精华内容
下载资源
问答
  • MLP分类模型
    2021-07-13 20:31:57

    @Author:Runsen

    分类任务的MLP

    • 当目标(y)是离散的(分类的)
    • 对于损失函数,使用交叉熵;对于评估指标,通常使用accuracy

    数据集描述

    • CIFAR-10数据集包含10个类中的60000个图像—50000个用于培训,10000个用于测试
    • 有关更多信息,请参阅官方文档
    from tensorflow.keras.datasets import cifar10
    from tensorflow.keras.utils import to_categorical
    # load data and flatten X data to fit into MLP
    (x_train
    更多相关内容
  • 本文将会介绍如何使用PyTorch来搭建简单的MLP(Multi-layer Perceptron,多层感知机)模型,来实现二分类及多分类任务。

      本文是PyTorch入门的第二篇文章,后续将会持续更新,作为PyTorch系列文章。
      本文将会介绍如何使用PyTorch来搭建简单的MLP(Multi-layer Perceptron,多层感知机)模型,来实现二分类及多分类任务。

    数据集介绍

       二分类数据集为ionosphere.csv(电离层数据集),是UCI机器学习数据集中的经典二分类数据集。它一共有351个观测值,34个自变量,1个因变量(类别),类别取值为g(good)和b(bad)。在ionosphere.csv文件中,共351行,前34列作为自变量(输入的X),最后一列作为类别值(输出的y)。
    电离层数据
    ​ 多分类数据集为iris.csv(鸢尾花数据集),是UCI机器学习数据集中的经典多分类数据集。它一共有150个观测值,4个自变量(萼片长度,萼片宽度,花瓣长度,花瓣宽度),1个因变量(类别),类别取值为Iris-setosa,Iris-versicolour,Iris-virginica。在iris.csv文件中,共150行,前4列作为自变量(输入的X),最后一列作为类别值(输出的y)。前几行数据如下图:
    鸢尾花数据集

    分类模型流程

      使用PyTorch构建神经网络模型来解决分类问题的基本流程如下:

    加载数据集
    划分数据集
    构建模型
    选择损失函数及优化器
    模型训练
    模型预测

    其中加载数据集划分数据集为数据处理部分,构建模型选择损失函数及优化器为创建模型部分,模型训练的目标是选择合适的优化器及训练步长使得损失函数的值很小,模型预测是在模型测试集或新数据上的预测。

    二分类模型

      使用PyTorch构建MLP模型来实现二分类任务,模型结果图如下:

    MLP模型示意图
    实现MLP模型的Python代码如下:

    # -*- coding: utf-8 -*-
    # pytorch mlp for binary classification
    from numpy import vstack
    from pandas import read_csv
    from sklearn.preprocessing import LabelEncoder
    from sklearn.metrics import accuracy_score
    from torch import Tensor
    from torch.optim import SGD
    from torch.utils.data import Dataset, DataLoader, random_split
    from torch.nn import Linear, ReLU, Sigmoid, Module, BCELoss
    from torch.nn.init import kaiming_uniform_, xavier_uniform_
    
    
    # dataset definition
    class CSVDataset(Dataset):
        # load the dataset
        def __init__(self, path):
            # load the csv file as a dataframe
            df = read_csv(path, header=None)
            # store the inputs and outputs
            self.X = df.values[:, :-1]
            self.y = df.values[:, -1]
            # ensure input data is floats
            self.X = self.X.astype('float32')
            # label encode target and ensure the values are floats
            self.y = LabelEncoder().fit_transform(self.y)
            self.y = self.y.astype('float32')
            self.y = self.y.reshape((len(self.y), 1))
    
        # number of rows in the dataset
        def __len__(self):
            return len(self.X)
    
        # get a row at an index
        def __getitem__(self, idx):
            return [self.X[idx], self.y[idx]]
    
        # get indexes for train and test rows
        def get_splits(self, n_test=0.3):
            # determine sizes
            test_size = round(n_test * len(self.X))
            train_size = len(self.X) - test_size
            # calculate the split
            return random_split(self, [train_size, test_size])
    
    
    # model definition
    class MLP(Module):
        # define model elements
        def __init__(self, n_inputs):
            super(MLP, self).__init__()
            # input to first hidden layer
            self.hidden1 = Linear(n_inputs, 10)
            kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
            self.act1 = ReLU()
            # second hidden layer
            self.hidden2 = Linear(10, 8)
            kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
            self.act2 = ReLU()
            # third hidden layer and output
            self.hidden3 = Linear(8, 1)
            xavier_uniform_(self.hidden3.weight)
            self.act3 = Sigmoid()
    
        # forward propagate input
        def forward(self, X):
            # input to first hidden layer
            X = self.hidden1(X)
            X = self.act1(X)
            # second hidden layer
            X = self.hidden2(X)
            X = self.act2(X)
            # third hidden layer and output
            X = self.hidden3(X)
            X = self.act3(X)
            return X
    
    
    # prepare the dataset
    def prepare_data(path):
        # load the dataset
        dataset = CSVDataset(path)
        # calculate split
        train, test = dataset.get_splits()
        # prepare data loaders
        train_dl = DataLoader(train, batch_size=32, shuffle=True)
        test_dl = DataLoader(test, batch_size=1024, shuffle=False)
        return train_dl, test_dl
    
    
    # train the model
    def train_model(train_dl, model):
        # define the optimization
        criterion = BCELoss()
        optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
        # enumerate epochs
        for epoch in range(100):
            # enumerate mini batches
            for i, (inputs, targets) in enumerate(train_dl):
                # clear the gradients
                optimizer.zero_grad()
                # compute the model output
                yhat = model(inputs)
                # calculate loss
                loss = criterion(yhat, targets)
                # credit assignment
                loss.backward()
                print("epoch: {}, batch: {}, loss: {}".format(epoch, i, loss.data))
                # update model weights
                optimizer.step()
    
    
    # evaluate the model
    def evaluate_model(test_dl, model):
        predictions, actuals = [], []
        for i, (inputs, targets) in enumerate(test_dl):
            # evaluate the model on the test set
            yhat = model(inputs)
            # retrieve numpy array
            yhat = yhat.detach().numpy()
            actual = targets.numpy()
            actual = actual.reshape((len(actual), 1))
            # round to class values
            yhat = yhat.round()
            # store
            predictions.append(yhat)
            actuals.append(actual)
        predictions, actuals = vstack(predictions), vstack(actuals)
        # calculate accuracy
        acc = accuracy_score(actuals, predictions)
        return acc
    
    
    # make a class prediction for one row of data
    def predict(row, model):
        # convert row to data
        row = Tensor([row])
        # make prediction
        yhat = model(row)
        # retrieve numpy array
        yhat = yhat.detach().numpy()
        return yhat
    
    
    # prepare the data
    path = './data/ionosphere.csv'
    train_dl, test_dl = prepare_data(path)
    print(len(train_dl.dataset), len(test_dl.dataset))
    # define the network
    model = MLP(34)
    print(model)
    # train the model
    train_model(train_dl, model)
    # evaluate the model
    acc = evaluate_model(test_dl, model)
    print('Accuracy: %.3f' % acc)
    # make a single prediction (expect class=1)
    row = [1, 0, 0.99539, -0.05889, 0.85243, 0.02306, 0.83398, -0.37708, 1, 0.03760, 0.85243, -0.17755, 0.59755, -0.44945,
           0.60536, -0.38223, 0.84356, -0.38542, 0.58212, -0.32192, 0.56971, -0.29674, 0.36946, -0.47357, 0.56811, -0.51171,
           0.41078, -0.46168, 0.21266, -0.34090, 0.42267, -0.54487, 0.18641, -0.45300]
    yhat = predict(row, model)
    print('Predicted: %.3f (class=%d)' % (yhat, yhat.round()))
    

    在上面代码中,CSVDataset类为csv数据集加载类,处理成模型适合的数据格式,并划分训练集和测试集比例为7:3。MLP类为MLP模型,模型输出层采用Sigmoid函数,损失函数采用BCELoss,优化器采用SGD,共训练100次。evaluate_model函数是模型在测试集上的表现,predict函数为在新数据上的预测结果。MLP模型的PyTorch输出如下:

    MLP(
      (hidden1): Linear(in_features=34, out_features=10, bias=True)
      (act1): ReLU()
      (hidden2): Linear(in_features=10, out_features=8, bias=True)
      (act2): ReLU()
      (hidden3): Linear(in_features=8, out_features=1, bias=True)
      (act3): Sigmoid()
    )
    

    ​ 运行上述代码,输出结果如下:

    epoch: 0, batch: 0, loss: 0.7491992712020874
    epoch: 0, batch: 1, loss: 0.750106692314148
    epoch: 0, batch: 2, loss: 0.7033759355545044
    ......
    epoch: 99, batch: 5, loss: 0.020291464403271675
    epoch: 99, batch: 6, loss: 0.02309396117925644
    epoch: 99, batch: 7, loss: 0.0278386902064085
    Accuracy: 0.924
    Predicted: 0.989 (class=1)
    

    可以看到,该MLP模型的最终训练loss值为0.02784,在测试集上的Accuracy为0.924,在新数据上预测完全正确。

    多分类模型

    ​ 接着我们来创建MLP模型实现iris数据集的三分类任务,Python代码如下:

    # -*- coding: utf-8 -*-
    # pytorch mlp for multiclass classification
    from numpy import vstack
    from numpy import argmax
    from pandas import read_csv
    from sklearn.preprocessing import LabelEncoder, LabelBinarizer
    from sklearn.metrics import accuracy_score
    from torch import Tensor
    from torch.optim import SGD, Adam
    from torch.utils.data import Dataset, DataLoader, random_split
    from torch.nn import Linear, ReLU, Softmax, Module, CrossEntropyLoss
    from torch.nn.init import kaiming_uniform_, xavier_uniform_
    
    
    # dataset definition
    class CSVDataset(Dataset):
        # load the dataset
        def __init__(self, path):
            # load the csv file as a dataframe
            df = read_csv(path, header=None)
            # store the inputs and outputs
            self.X = df.values[:, :-1]
            self.y = df.values[:, -1]
            # ensure input data is floats
            self.X = self.X.astype('float32')
            # label encode target and ensure the values are floats
            self.y = LabelEncoder().fit_transform(self.y)
            # self.y = LabelBinarizer().fit_transform(self.y)
    
        # number of rows in the dataset
        def __len__(self):
            return len(self.X)
    
        # get a row at an index
        def __getitem__(self, idx):
            return [self.X[idx], self.y[idx]]
    
        # get indexes for train and test rows
        def get_splits(self, n_test=0.3):
            # determine sizes
            test_size = round(n_test * len(self.X))
            train_size = len(self.X) - test_size
            # calculate the split
            return random_split(self, [train_size, test_size])
    
    
    # model definition
    class MLP(Module):
        # define model elements
        def __init__(self, n_inputs):
            super(MLP, self).__init__()
            # input to first hidden layer
            self.hidden1 = Linear(n_inputs, 5)
            kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
            self.act1 = ReLU()
            # second hidden layer
            self.hidden2 = Linear(5, 6)
            kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
            self.act2 = ReLU()
            # third hidden layer and output
            self.hidden3 = Linear(6, 3)
            xavier_uniform_(self.hidden3.weight)
            self.act3 = Softmax(dim=1)
    
        # forward propagate input
        def forward(self, X):
            # input to first hidden layer
            X = self.hidden1(X)
            X = self.act1(X)
            # second hidden layer
            X = self.hidden2(X)
            X = self.act2(X)
            # output layer
            X = self.hidden3(X)
            X = self.act3(X)
            return X
    
    
    # prepare the dataset
    def prepare_data(path):
        # load the dataset
        dataset = CSVDataset(path)
        # calculate split
        train, test = dataset.get_splits()
        # prepare data loaders
        train_dl = DataLoader(train, batch_size=1, shuffle=True)
        test_dl = DataLoader(test, batch_size=1024, shuffle=False)
        return train_dl, test_dl
    
    
    # train the model
    def train_model(train_dl, model):
        # define the optimization
        criterion = CrossEntropyLoss()
        # optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
        optimizer = Adam(model.parameters())
        # enumerate epochs
        for epoch in range(100):
            # enumerate mini batches
            for i, (inputs, targets) in enumerate(train_dl):
                targets = targets.long()
                # clear the gradients
                optimizer.zero_grad()
                # compute the model output
                yhat = model(inputs)
                # calculate loss
                loss = criterion(yhat, targets)
                # credit assignment
                loss.backward()
                print("epoch: {}, batch: {}, loss: {}".format(epoch, i, loss.data))
                # update model weights
                optimizer.step()
    
    
    # evaluate the model
    def evaluate_model(test_dl, model):
        predictions, actuals = [], []
        for i, (inputs, targets) in enumerate(test_dl):
            # evaluate the model on the test set
            yhat = model(inputs)
            # retrieve numpy array
            yhat = yhat.detach().numpy()
            actual = targets.numpy()
            # convert to class labels
            yhat = argmax(yhat, axis=1)
            # reshape for stacking
            actual = actual.reshape((len(actual), 1))
            yhat = yhat.reshape((len(yhat), 1))
            # store
            predictions.append(yhat)
            actuals.append(actual)
        predictions, actuals = vstack(predictions), vstack(actuals)
        # calculate accuracy
        acc = accuracy_score(actuals, predictions)
        return acc
    
    
    # make a class prediction for one row of data
    def predict(row, model):
        # convert row to data
        row = Tensor([row])
        # make prediction
        yhat = model(row)
        # retrieve numpy array
        yhat = yhat.detach().numpy()
        return yhat
    
    
    # prepare the data
    path = './data/iris.csv'
    train_dl, test_dl = prepare_data(path)
    print(len(train_dl.dataset), len(test_dl.dataset))
    # define the network
    model = MLP(4)
    print(model)
    # train the model
    train_model(train_dl, model)
    # evaluate the model
    acc = evaluate_model(test_dl, model)
    print('Accuracy: %.3f' % acc)
    # make a single prediction
    row = [5.1, 3.5, 1.4, 0.2]
    yhat = predict(row, model)
    print('Predicted: %s (class=%d)' % (yhat, argmax(yhat)))
    

    可以看到,多分类代码与二分类代码大同小异,在加载数据集、模型结构、模型训练(训练batch值取1)代码上略有不同。运行上述代码,输出结果如下:

    105 45
    MLP(
      (hidden1): Linear(in_features=4, out_features=5, bias=True)
      (act1): ReLU()
      (hidden2): Linear(in_features=5, out_features=6, bias=True)
      (act2): ReLU()
      (hidden3): Linear(in_features=6, out_features=3, bias=True)
      (act3): Softmax(dim=1)
    )
    epoch: 0, batch: 0, loss: 1.4808106422424316
    epoch: 0, batch: 1, loss: 1.4769641160964966
    epoch: 0, batch: 2, loss: 0.654313325881958
    ......
    epoch: 99, batch: 102, loss: 0.5514447093009949
    epoch: 99, batch: 103, loss: 0.620153546333313
    epoch: 99, batch: 104, loss: 0.5514482855796814
    Accuracy: 0.933
    Predicted: [[9.9999809e-01 1.8837408e-06 2.4509615e-19]] (class=0)
    

    可以看到,该MLP模型的最终训练loss值为0.5514,在测试集上的Accuracy为0.933,在新数据上预测完全正确。

    总结

      本文介绍的模型代码已开源,Github地址为:https://github.com/percent4/PyTorch_Learning。后续将持续介绍PyTorch内容,欢迎大家关注~

    展开全文
  • 卷积神经网络(CNN)是计算机视觉的常用模型。最近,基于注意力的网络,如Vision Transformer,也变得很流行。在本文中,我们表明,虽然卷积和注意力都足以获得良好的性能,但它们都不是必需的。我们提出了MLPMixer...

    全MLP结构模型学习笔记

    MLP-Mixer: An all-MLP Architecture for Vision

    代码:GitHub - google-research/vision_transformer

    Abstract

    卷积神经网络(CNN)是计算机视觉的常用模型。最近,基于注意力的网络,如Vision Transformer,也变得很流行。在本文中,我们表明,虽然卷积和注意力都足以获得良好的性能,但它们都不是必需的。我们提出了MLPMixer,一种专门基于多层感知器(MLP)的体系结构。MLP混合器包含两种类型的层一种是将MLP独立应用于图像patches的层(即“混合”每个位置的特征),另一种是跨patches应用MLP的层(即“混合”空间信息)。当在大型数据集上或使用现代正则化方案进行训练时,MLP混合器在图像分类基准上获得了有竞争力的分数,预训练和推理成本与最先进的模型相当。我们希望这些结果能够激发出成熟的CNN和变压器领域之外的进一步研究。

    1 Introduction

    正如计算机视觉的历史所证明的那样,更大数据集的可用性加上计算能力的增加往往会导致范式的转变。虽然卷积神经网络(CNN)已经成为计算机视觉的事实标准,但最近,基于自我注意层的另一种视觉转换器(ViT)获得了最先进的性能。ViT延续了从模型中去除手工制作的视觉特征和归纳偏见的长期趋势,并进一步依赖于从原始数据中学习。

    我们提出了MLP-Mixer体系结构(简称“Mixer”),这是一种具有竞争力但在概念和技术上都很简单的替代方案,它不使用卷积或自我关注。相反,Mixer的体系结构完全基于多层感知器(MLP),这些感知器在空间位置或特征通道上重复应用。混合器仅依赖于基本矩阵乘法例程、数据布局的更改(重塑和换位)以及标量非线性

    图1描述了混合器的宏观结构。它接受一系列线性投影的图像patches(也称为标记),形状为“patches×通道”表,作为输入,并保持此维度。混合器使用两种类型的MLP层:信道混合MLP和令牌混合MLP信道混合MLP允许不同信道之间的通信; 他们独立地对每个令牌进行操作,并将表中的各行作为输入。令牌混合MLP允许不同空间位置(令牌)之间的通信;它们独立地对每个通道进行操作,并将表中的各个列作为输入。这两种类型的层是交错的,以实现两个输入维度的交互

    极端情况下,我们的体系结构可以看作是一种非常特殊的CNN,它使用1×1卷积进行信道混合,使用全感受野的单信道深度卷积和参数共享进行令牌混合。然而,情况并非如此,因为典型的CNN不是混合器的特例。此外,在MLP中,卷积比普通矩阵乘法更复杂,因为它需要对矩阵乘法和/或专用实现进行额外的代价降低。

    尽管它很简单,Mixer还是取得了有竞争力的效果。在对大型数据集进行预培训时(即。,∼100万张图像),在精确度/成本权衡方面达到了CNNs和Transformers之前声称的接近最先进的性能。这包括ILSVRC2012“ImageNet”上87.94%的top-1验证准确率【13】。当对更适度规模的数据进行预培训时(即。,∼1–10M图像),再加上现代正则化技术[49,54],Mixer也实现了强大的性能。然而,与ViT类似,它略低于专门的CNN架构。

    2 Mixer Architecture

    现代深度视觉体系结构由以下各层组成:(i)在给定的空间位置,(ii)在不同的空间位置之间,或同时在两者之间混合特征。在CNN中,(ii)使用N×N卷积(对于N>1)和池来实现。更深层次的神经元有更大的感受野[1,28]。同时,1×1卷积也执行(i),较大的核同时执行(i)和(ii)。在视觉转换器和其他基于注意的架构中,自我注意层允许(i)和(ii),MLP块执行(i)。混频器体系结构背后的思想是明确区分每位置(信道混合)操作(i)和跨位置(令牌混合)操作(ii)。这两种操作都是通过MLP实现的。图1总结了体系结构。

    Mixer将S个不重叠的图像面片序列作为输入,每个面片投影到所需的隐藏维度C。这将生成一个二维实值输入表X∈ R^{S×C}。如果原始输入图像具有分辨率(H,W),并且每个面片具有分辨率(P,P),则面片数为S=HW/P^2。所有面片都使用相同的投影矩阵进行线性投影。混合器由多个尺寸相同的层组成,每层由两个MLP块组成。第一个是令牌混合MLP:它作用于X的列(即,它应用于转置的输入表X^T),映射R^S → R^S,并在所有列中共享。第二个是通道混合MLP:它作用于X行,映射R^C→ R^C,并在所有行中共享。每个MLP块包含两个完全连接的层和非线性独立应用于其输入数据张量的每一行。混合器层可编写如下(省略层索引):

    这里σ是元素非线性(GELU【16】)。D_S和D_C分别是令牌混合和信道混合mlp中的可调隐藏宽度。请注意,D_S的选择与输入面片的数量无关。因此,网络的计算复杂度在输入面片的数量上是线性的,不像ViT的复杂度是二次的。由于D_C与面片大小无关,因此与典型的CNN一样,图像中像素数的总体复杂性是线性的

    如上所述,相同的信道混合MLP(令牌混合MLP)应用于X的每一行(列)。绑定信道混合MLP的参数(在每一层内)是一种自然选择,它提供了位置不变性,这是卷积的一个显著特征。然而,跨通道绑定参数的情况要少得多。例如,在一些CNN中使用的可分离卷积(9,40)将卷积独立于其他信道应用于每个信道。然而,在可分离卷积中,不同的卷积核应用于每个信道,这与混合器中的令牌混合MLP不同,混合器中的令牌混合MLP对所有信道共享相同的核全感受野)。当增加隐藏维度C或序列长度S时,参数绑定可以防止体系结构增长过快,并导致显著的内存节省。令人惊讶的是,这种选择并不影响实证绩效,见补充A.1。

    混合器中的每一层(初始面片投影层除外)都接受相同大小的输入。这种“各向同性”设计最类似于变压器,或其他领域的深RNN,也使用固定宽度。这与大多数具有金字塔结构的CNN不同:更深的层具有更低的分辨率输入,但有更多的通道。请注意,虽然这些是典型的设计,但也存在其他组合,如各向同性网状结构[38]和棱锥状VIT[52]

    除了MLP层之外,Mixer还使用其他标准体系结构组件:跳过连接[15]和层规范化[2]。与VIT不同,Mixer不使用位置嵌入,因为令牌混合MLP对输入令牌的顺序很敏感。最后,混合器使用一个标准的分类头,该分类头具有全局平均池层,后跟一个线性分类器。总体而言,该体系结构可以用JAX/Flax紧凑地编写,代码在补充E中给出。

    3 Experiments

    我们在一系列中小型下游分类任务中,评估了使用中大型数据集预先训练的MLP混合器模型的性能。我们对三个主要数量感兴趣:(1)下游任务的准确性;(2)预训练的总计算成本,这在上游数据集上从头开始训练模型时很重要;(3) 测试时间吞吐量,这对从业者很重要。我们的目标不是展示最先进的结果,而是要表明,值得注意的是,一个简单的基于MLP的模型与当今最好的卷积模型和基于注意力的模型具有竞争力。

    Downstream tasks

    我们使用流行的下游任务,如ILSVRC2012“ImageNet”(1.3M训练示例,1k类),带有原始验证标签[13]和清理过的真实标签[5],CIFAR-10/100(50k示例,10/100类)[23],Oxford IIIT Pets(3.7k示例,36类)[32],以及Oxford Flowers-102(2k示例,102类)[31]。我们还使用了视觉任务适应基准(VTAB-1k),该基准由19个不同的数据集组成,每个数据集都有1k个训练示例【58】。

    Pre-training

    我们遵循标准的迁移学习设置:先进行预培训,然后对下游任务进行微调。我们在两个公共数据集上对模型进行预训练:ILSVRC2021 ImageNet和ImageNet-21k,这是ILSVRC2012的超集,包含21k类和1400万图像[13]。为了更大规模地评估性能,我们还对JFT-300M进行了培训,这是一个拥有300M示例和18k类的专有数据集[44]。正如Dosovitskiy等人【14】、Kolesnikov等人【22】所做的那样,我们针对下游任务的测试集消除了所有预训练数据集。我们使用Adam对所有模型进行分辨率为224的预训练,其中β1=0.9,β2=0.999,线性学习率预热10k步,线性衰减,batch size为4096,重量衰减,梯度裁剪为全局范数1。对于JFT-300M,除了随机水平翻转外,我们还通过应用Szegedy等人的裁剪技术对图像进行预处理。对于ImageNet和ImageNet-21k,我们采用了额外的数据增强和正则化技术。特别是,我们使用RandAugment[12]、mixup[60],dropout【43】和随机深度【19】。这套技术的灵感来自timm library【54】和Touvron等人【48】。补充B中提供了有关这些超参数的更多详细信息。

    Fine-tuning

    我们使用动量SGD、批次大小512、全局范数1下的梯度剪裁和具有线性预热的余弦学习速率计划进行微调。微调时不使用权重衰减。按照常见做法【22,48】,我们也会对训练前使用的分辨率进行微调,以获得更高的分辨率。由于我们保持面片分辨率不变,这会增加输入面片的数量(例如从S到S0),因此需要修改混合器的令牌混合MLP块的形状。形式上,等式(1)中的输入左乘以权重矩阵W_1∈ R^{D_S×S},在更改输入维度S时,必须调整此操作。为此,我们将隐藏层宽度从D^S增加到D^{S^{'}},与面片数成比例,并初始化(现在更大的)权重矩阵\mathbf{W}_{2}^{\prime} \in \mathbb{R}^{D_{S^{\prime}} \times S^{\prime}},具有块对角矩阵,其对角线上包含W_2的副本。该特定方案仅允许S^{'}=K^2S和K∈N、有关更多详细信息,请参见补充C。在VTAB-1k基准上,我们分别在具有小输入图像和大输入图像的数据集上遵循位超规则[22]和分辨率为224和448的微调混频器模型。

    Metrics

    我们评估了模型计算成本和质量之间的权衡。对于前者,我们计算了两个指标:(1)TPU-v3加速器上的总预训练时间,它结合了三个相关因素:每个训练设置的理论失败率、相关训练硬件上的计算效率和数据效率。(2) TPU-v3上的吞吐量(以映像/秒/核心为单位)。由于不同大小的模型可能受益于不同的批次大小,我们将扫描批次大小,并报告每个模型的最高吞吐量。对于模型质量,我们关注微调后的top-1下游精度。在两种情况下(图3,右图和图4),微调所有模型的成本太高,我们报告了通过解决图像和标签的冻结学习表示之间的“2-正则化线性回归问题”获得的少数镜头精度。

     

    Models

    我们将表1中总结的混合器的各种配置与最新的、最先进的、CNN和基于注意的模型进行了比较。在所有的图和表中,基于MLP的Mixer模型用粉红色标记,基于卷积的模型用黄色标记,基于注意力的模型用蓝色标记。视觉变换器(VIT)具有与混合器相似的模型比例和面片分辨率。HaloNets是一种基于注意力的模型,它使用一种类似ResNet的结构,具有局部自我注意层,而不是3×3卷积[51]。我们专注于特别有效的“HaloNet-H4(base 128,Conv-12)”模型,该模型是更广泛的HaloNet-H4架构的混合变体,其中一些自我注意层被卷积所取代。注意,我们用蓝色标记了带有注意力和卷积的HaloNets。Big Transfer(BiT)[22]模型是为迁移学习而优化的网络。NFNets【7】是无规范化器的RESNET,具有针对ImageNet分类的若干优化。我们考虑NFNet-F4+型号变体。我们考虑MPL[34]和ALIGN[21]来实现高效的网络体系结构。MPL是在JFT-300M图像上进行大规模预训练的,使用ImageNet的元伪标签代替原始标签。我们将其与EfficientNetB6宽模型变体进行比较。在有噪声的web图像-文本对上以对比方式对齐预训练图像编码器和语言编码器。我们将其与效率最高的ET-L2图像编码器进行比较。

    3.1 Main results

    表2给出了最大混合器模型与文献中最先进模型的比较。“ImNet”和“ReaL”列指原始ImageNet验证[13]和清理过的ReaL[5]标签。“Avg.5”代表所有五个下游任务(ImageNet、CIFAR-10、CIFAR-100、Pets、Flowers)的平均性能。图2(左)显示了精度计算边界。当在ImageNet-21k上进行预训练并进行额外的正则化时,混频器实现了整体强大的性能(在ImageNet上排名前1的84.15%),尽管略低于其他模型2。在这种情况下,正则化是必要的,没有正则化,混频器会过度拟合,这与ViT的类似观察结果一致【14】。当从ImageNet上的随机初始化训练混合器时,同样的结论成立(见第3.2节):混合器-B/16在分辨率224时达到76.4%的合理分数,但往往过度拟合。该分数与香草ResNet50相似,但落后于ImageNet“从头开始”设置的最先进CNN/混合网络,例如84.7%的僵尸网络[42]和86.5%的NFNet[7]。

    当上游数据集的大小增加时,混合器的性能会显著提高。特别是,Mixer-H/14在ImageNet上实现了87.94%的top-1精度,比BiTResNet152x4高0.5%,比ViT-H/14低0.5%。值得注意的是,Mixer-H/14的运行速度是ViT-H/14的2.5倍,几乎是BiT的两倍。总的来说,图2(左)支持我们的主要主张,即在精度方面,计算折衷混合器与更传统的神经网络架构具有竞争力。该图还显示了培训前总成本与下游精度之间的明显相关性,即使是跨架构类的。

    表中的BiT-ResNet152x4是使用SGD进行预训练的,具有动量和长的时间表。由于Adam趋向于更快地收敛,我们使用Dosovitskiy等人的BiT-R200x3模型完成了图2(左)中的图片。[14]使用Adam对JFT-300M进行了预训练。该ResNet的精确度略低,但训练前计算量要低得多。最后,图中还报告了较小ViT-L/16和Mixer-L/16模型的结果。

    3.2 The role of the model scale

    上一节概述的结果侧重于计算谱上端的(大型)模型。我们现在将注意力转向更小的Mixer型号。

    我们可以通过两种独立的方式缩放模型:(1)在预训练时增加模型大小(层数、隐藏维度、MLP宽度);(2) 在以下情况下提高输入图像分辨率微调,前者影响训练前计算和测试时吞吐量,后者只影响吞吐量。除非另有说明,我们对第224号决议进行微调。

    我们将混频器的各种配置(见表1)与类似规模的ViT模型和Adam预先训练的BiT模型进行了比较。结果总结在表3和图3中。当在ImageNet上从头开始训练时,Mixer-B/16达到了76.44%的合理top-1精度。这比ViT-B/16型号落后3%。训练曲线(未报告)表明,两个模型的训练损失值非常相似。换句话说,Mixer-B/16比ViT-B/16更适合。对于Mixer-L/16和ViT-L/16型号,这种差异更为明显。

    随着预训练数据集的增长,Mixer的性能稳步提高。值得注意的是,Mixer-H/14在JFT-300M上预先训练并在224分辨率下微调,仅比ImageNet上的ViT-H/14慢0.3%,同时运行速度快2.2倍。图3清楚地表明,尽管混合器在模型比例尺的低端略低于前沿,但它自信地位于高端的前沿。

    3.3 The role of the pre-training dataset size

    迄今为止的结果表明,在较大数据集上进行预训练可以显著提高混音器的性能。在这里,我们将更详细地研究这种效应。

    为了研究Mixer利用越来越多的训练示例的能力,我们在JFT-300M的随机子集上对Mixer-B/32、Mixer-L/32和Mixer-L/16模型进行预训练,其中包含233、70、23和7个时期所有训练示例的3%、10%、30%和100%。因此,每个模型都针对相同数量的总步骤进行预训练。我们还在一个更大的JFT-3B数据集[59]上预训练Mixer-L/16模型,该数据集包含大约3B个图像,30k个类,总步长相同。

    虽然没有严格的可比性,但这使我们能够进一步推断规模的影响。我们使用ImageNet上的线性5拍top-1精度作为传输质量的代理。对于每次训练前的跑步,我们都会根据最佳的上游验证性能提前停止。结果如图2(右)所示,其中我们还包括ViT-B/32、ViT-L/32、ViT-L/16和BiT-R152x2模型。

    当在JFT-300M的最小子集上进行预训练时,所有混频器模型都严重过拟合。BiT模型也过拟合,但程度较小,可能是由于与卷积相关的强感应偏差。随着数据集的增加,Mixer-L/32和Mixer-L/16的性能增长速度都快于BiT;Mixer-L/16不断改进,而BiT模型停滞不前。

    同样的结论也适用于ViT,与Dosovitskiy等人的结论一致。然而,大型混频器模型的相对改进更为明显。Mixer-L/16和ViT-L/16之间的性能差距随着数据规模的缩小而缩小。Mixer似乎比ViT更能从不断增长的数据集大小中获益。人们可以通过归纳偏差的不同来推测和解释它:ViT中的自我注意层导致学习功能的某些特性,这些特性与真实的底层分布不太兼容,而与混音器结构中发现的特性相比。

    3.4 Invariance to input permutations

    在本节中,我们将研究混频器和CNN结构的电感偏置之间的差异。具体而言,我们在预培训后在JFT-300M上培训Mixer-B/16和ResNet50x1型号设置如第3节所述,并使用两种不同的输入变换之一:(1)将16×16面片的顺序和每个面片内的像素置换为共享置换;(2) 在整个图像中全局排列像素。所有图像都使用相同的排列。我们在图4(下图)中报告了ImageNet上经过训练的模型的线性5拍top-1精度。图4(顶部)显示了一些原始图像及其两个转换版本。正如所料,混合器对面片和面片内像素的顺序保持不变(蓝色和绿色曲线完美匹配)。另一方面,ResNet的强感应偏差依赖于图像中特定顺序的像素,当面片排列时,其性能会显著下降。值得注意的是,当全局排列像素时,混频器的性能下降幅度要小得多(∼与ResNet相比,下降了45%(∼下降75%)。

    3.5 Visualization

    通常可以观察到,CNN的第一层倾向于学习作用于图像局部区域像素的类Gabor检测器。相反,Mixer允许在令牌混合MLP中进行全局信息交换,这回避了它是否以类似方式处理信息的问题。图5显示了在JFT-300M上训练的混合器前三个令牌混合MLP的隐藏单元。回想一下,令牌混合MLP允许不同空间位置之间的全局通信。一些学习到的特征操作于整个图像,而其他特征操作于较小的区域。深层似乎没有明确可识别的结构。与CNN类似,我们观察到许多相位相反的特征检测器对【39】。学习单元的结构取决于超参数。第一个嵌入层的图如补充D的图7所示。

    4 Related work

    MLP混频器是一种新的计算机视觉体系结构,它不同于以前成功的体系结构,因为它既不使用卷积层,也不使用自我注意层。然而,设计选择可以追溯到CNN【24、25】和变压器【50】文献中的想法。

    自从AlexNet模型【24】超越了基于手工图像特征的主流方法【35】以来,CNN已经成为计算机视觉的事实标准。许多工作集中于改进CNN的设计。Simonyan和Zisserman【41】证明,仅使用具有小3×3核的卷积就可以训练最先进的模型。he等人【15】引入了跳跃连接和批量归一化【20】,这使得能够训练非常深入的神经网络并进一步提高性能。一项重要的研究已经调查了使用稀疏卷积的好处,例如分组(57)或深度(9,17)变体。本着与我们的标记混合MLP类似的精神,Wu等人[55]在自然语言处理的深度卷积中共享参数。Hu et al.(18)和Wang et al.(53)建议使用非局部操作增强卷积网络,以部分缓解CNN的局部处理限制。Mixer将使用小核卷积的想法发挥到极致:通过将核大小减小到1×1,它将卷积转换为独立应用于每个空间位置的标准密集矩阵乘法(信道混合MLP)。仅此一点不允许空间信息的聚合,为了进行补偿,我们将密集矩阵乘法应用于所有空间位置的每个特征(令牌混合MLP)。在Mixer中,矩阵乘法在“patches×features”输入表上按行或列进行,这也与稀疏卷积的工作密切相关。混合器使用跳过连接[15]和规范化层[2,20]。

    在计算机视觉中,基于自我注意的变压器架构最初用于生成建模[8,33]。它们对图像识别的价值后来得到了证实,尽管是与卷积式局部偏差相结合[37],或是在低分辨率图像上[10]。Dosovitskiy等人【14】介绍了ViT,这是一种纯变压器模型,具有较少的局部性偏差,但可以很好地扩展到大数据。ViT在流行的视觉基准上实现了最先进的性能,同时保持了CNN的健壮性[6]。Touvron等人[49]使用广泛的正则化在较小的数据集上有效地训练ViT。Mixer借鉴了最近基于transformer的架构的设计选择。混合器MLP块的设计源于V aswani等人【50】。将图像转换为一系列补丁并直接处理这些补丁的嵌入源于Dosovitskiy等人【14】。

    最近的许多工作都致力于为vision设计更有效的体系结构。Srinivas等人[42]用自我注意层取代了resnet中的3×3卷积。Ramachandran等人【37】、Tay等人【47】、Li等人【26】和Bello【3】设计了具有新的注意力样机制的网络。混合器可以看作是正交方向上的一个步骤,不依赖于位置偏差和注意机制。

    Lin等人的工作密切相关。它在CIFAR-10上通过使用全连接网络、大量数据扩充和使用自动编码器进行预训练获得了合理的性能。Neyshabur【30】设计了定制的正则化和优化算法,并训练了一个完全连接的网络,在小规模任务中获得了令人印象深刻的性能。相反,我们依赖令牌和信道混合MLP,使用标准的正则化和优化技术,并有效地扩展到大数据

    传统上,在ImageNet上评估的网络【13】是使用初始风格的预处理从随机初始化中训练出来的【46】。对于较小的数据集,ImageNet模型的传输很流行。然而,现代最先进的模型通常使用在更大数据集上预先训练的权重,或者使用更新的数据扩充和训练策略。例如,Dosovitskiy等人【14】、Kolesnikov等人【22】、Mahajan等人【29】、Pham等人【34】、Xie等人【56】都利用大规模预训练提升了图像分类的技术水平。增强或正则化变化带来的改进示例包括Cubuk等人【11】,他们通过学习数据增强获得了优异的分类性能,以及Bello等人【4】,他们表明,如果使用最新的训练和增强策略,规范重新网仍然接近最先进水平。

    5 Conclusions

    我们描述了一个非常简单的vision架构。我们的实验表明,就训练和推理所需的准确性和计算资源之间的权衡而言,它与现有的最先进的方法一样好。我们认为,这些结果引发了许多问题。在实践方面,研究模型学习到的特征并确定主要与CNN和Transformers学习到的差异(如有)。在理论方面,我们想了解隐藏在这些不同特征中的归纳偏差,以及它们在推广中的作用。最重要的是,我们希望我们的结果能够激发进一步的研究,超越基于卷积和自我注意的已建立模型的领域。看看这样的设计是否适用于NLP或其他领域,这将是非常有趣的。

    展开全文
  • 模型介绍-----MLP

    千次阅读 2022-06-11 10:10:26
    M-P 模型是一个神经元结构,但是没有参数学习的过程;感知机将训练数据进行线性划分的分离超平面,引入损失函数,利用梯度下降法对损失函数进行极小化,求感知机模型,在此并提出了学习的概念,但无法解决异或运算;...

    导读:M-P 模型是一个神经元结构,但是没有参数学习的过程;感知机将训练数据进行线性划分的分离超平面,引入损失函数,利用梯度下降法对损失函数进行极小化,求感知机模型,在此并提出了学习的概念,但无法解决异或运算;多层感知机通过增加层数解决非线性问题,直到1986年Hinton提出了反向传播算法,使得训练多层网络成为可能。

    参考文献:《西瓜书》、《统计学习方法》、以及知乎或 CSDN 部分博客

    M-P 模型

    1943年,McCulloch 将生物神经网络中的神经元模型抽象为" M-P 神经元模型", n个输入( x 1 , ⋯ x n x_1, \cdots x_n x1,xn),通过带权重的连接( w 1 , ⋯   , w n w_1,\cdots, w_n w1,,wn)进行传递,神经元接收的总输入( ∑ w i ∗ x i \sum w_i * x_i wixi)与阈值 θ \theta θ 比较,然后通过激活函数处理以产生神经元的输出。激活函数包括:跃阶函数(0,1,不连续、不光滑),Sigmoid 函数((0,1)挤压函数)

    在这里插入图片描述

    感知机 (perceptron)(判别模型)----神经网络和支持向量机的基础

    在1957年,美国学者Frank Rosenblatt 提出感知机,一种二值分类的线性分类模型,(特征向量)->实例类别(+1,-1),旨在将训练数据进行线性划分的分离超平面,导入基于误分类的损失函数,利用梯度下降法对损失函数进行极小化,求感知机模型。

    在这里插入图片描述

    以线性为例,由两层神经元组成 x 1 x_1 x1, x 2 x_2 x2为两个神经元,可以实现与、或、非运算。( x 1 ∧ x 2 x_1 \land x_2 x1x2),( x 1 ∨ x 2 x_1 \vee x_2 x1x2),( x 1 ¬ x 2 x_1 \neg x_2 x1¬x2

    在这里插入图片描述

    在这里插入图片描述
    其中 w w w b b b 为感知机模型参数, w ∈ R n w \in R^n wRn 表示权值(weight)或权值向量(weight vector), b ∈ R b\in R bR 叫作偏置(bias), w ⋅ x w\cdot x wx 表示 w w w x x x 的内积。sign 是符号函数,即:

    在这里插入图片描述
    在这里插入图片描述
    超平面 S S S,其中 w w w 超平面的法向量, b b b 是超平面的截距。超平面将特征空间划分为两个部分。位于两部分的点(特征向量)分别被分为正、负两类。

    数据集的线性可分性

    如果存在这样一个超平面,可以将数据集的正负实例点完全正确地划分到超平面的两侧。

    1969 Minsky 证明若两类模式是线性可分的,即存在一个线性超平面将他们分开,则感知机的学习过程一定会收敛,否则会震荡,不能求得合适的解。

    在这里插入图片描述

    感知机学习策略

    1. 确定超平面( w w w/ b b b), 定义一个损失函数,并极小化。

      损失函数:(1)误分类点的总数,不是参数 w w w/ b b b的连续可导函数,不易优化;(2)用距离来测量,误分类点到超平面的总距离。(点到直线的距离)
      在这里插入图片描述

    2. 对于误分类的数据( 将1误分类为-1,或者将-1误分类为1 ), − y i ( w ∗ x i + b ) > 0 -y_i(w*x_i+b)>0 yi(wxi+b)>0, 当 w ∗ x i + b > 0 w*x_i+b>0 wxi+b>0, y i < 1 y_i <1 yi<1, 误分类的集合为M, 误分类点到超平面 S S S的总距离为
      在这里插入图片描述

    3. 损失函数为:
      在这里插入图片描述

    感知机学习算法

    感知机学习问题转化为求解损失函数的最优化问题,最优化方法随机梯度下降。

    首先,任意选取一个超平面 w 0 w_0 w0, b 0 b_0 b0 ,然后用梯度下降法不断地极小化目标函数。极小化过程中不是一次使 M M M中所有误分类点的梯度下降,而是一次随机选取一个误分类点使其梯度下降。

    在这里插入图片描述
    在这里插入图片描述

    w w w, b b b更新:
    在这里插入图片描述
    在这里插入图片描述
    算法:

    输入: 训练数据集

    输出: w, b; 感知机模型 f ( x ) = s i g n ( w ∗ x + b ) f(x)=sign(w*x+b) f(x)=sign(wx+b)

    (1) 选取初值 w 0 , b 0 w_0,b_0 w0,b0

    (2) 在训练集中选取数据 (x_i,y_i)

    (3) 如果 y i ( w ∗ x i + b ) ≤ 0 y_i(w*x_i+b)\leq0 yi(wxi+b)0

                          (2.6),(2.7)
    

    (4) 转至(2),直至训练集中没有误分类点。

    当一个实例点被误分类,及位于分离超平面的错误一侧时,则调整 w , b w, b w,b 的值,使分离超平面向该误分类点的一侧移动,以减少该误分类点与超平面的距离,直至超平面越过该误分类点使其被正确分类。(与、或、非门都支持)

    算法收敛性

    误分类的次数k是有上界的,经过有限次搜索可以找到将训练数据完全分开的分离超平面,也就是说,当训练数据集线性可分时,感知机学习算法原始形式迭代是收敛的。

    对偶形式

    w w w b b b 表示为实例 x i x_i xi y i y_i yi的线性组合的形式,通过求解其系数而求得 w 和 b 。

    在这里插入图片描述
    在这里插入图片描述
    逐步修改 w w w b b b,设修改 n n n 次,则w , b 关于 ( x i , y i x_i,y_i xi,yi) 的增量分别是 α i y i x i \alpha_i y_i x_i αiyixi 和 $\alpha_i y_i $,这里 α i = n i η \alpha_i = n_i \eta αi=niη , 最后的 w , b 可以分别表示为
    在这里插入图片描述
    在这里插入图片描述

    表示第 i i i 个实例点由于误分而进行更新的次数,实例点更新次数越多,意味着它距离分离超平面越近,也就越难正确分类, 这样的实例对学习结果影响最大。

    多层感知机

    解决非线性可分问题,使用多层功能神经元,使用两层感知机解决异或问题。神经元不存在同层相连,也不存在跨层连接。

    特点:

    1. 参数量大,层数多
    2. 丢失像素间空间信息,只接受向量输入

    在这里插入图片描述

    单隐层的多层网络
    在这里插入图片描述

    学习策略–误差逆传播算法(BP Back-propagation)

    具体公式在西瓜书上,我的理解还是利用链式法则,从输入到输出的你过程。

    训练集 D = ( x i , y i ) D=(x_i,y_i) D=(xi,yi), x i ∈ R d , y i ∈ R l x_i\in R^d, y_i \in R^l xiRd,yiRl, 输入为d维,输出为l维, 隐藏层的第h个神经元阈值为 γ h \gamma_h γh, 输出层的第j个神经元阈值为 θ j \theta_j θj

    BP算法目标的最小化训练集D上的累积误差

    E = 1 m ∑ k = 1 m E k E = \frac{1}{m}\sum^m_{k=1}E_k E=m1k=1mEk

    在这里插入图片描述

    三种激活函数:ReLU函数,Sigmoid函数,tanh函数

    R e L U ( x ) = m a x ( x , 0 ) ReLU(x)=max(x,0) ReLU(x)=max(x,0), 只保留正数元素,并将负数元素清零

    Sigmoid 函数可以将元素的值变换到0和1之间, s i g m o i d ( x ) = 1 / ( 1 + e x p ( − x ) ) sigmoid(x)=1/(1+exp(−x)) sigmoid(x)=1/(1+exp(x))

    tanh函数是将元素值变换到-1和1之间, t a n h ( x ) = ( 1 − e x p ( − 2 x ) ) / ( 1 + e x p ( − 2 x ) ) tanh(x)=(1−exp(−2x))/(1+exp(−2x)) tanh(x)=(1exp(2x))/(1+exp(2x))

    用于分类器时,Sigmoid 函数及其组合通常效果更好。由于梯度消失问题,有时要避免使用 Sigmoid 和 tanh 函数。
    在神经网络层数较多的时候,最好使用 ReLu 函数,ReLu函数比较简单计算量少,而 Sigmoid 和 Tanh 函数计算量大很多。

    三种
    这幅图引自博客(https://blog.csdn.net/u011848397/article/details/102733351

    缓解BP网络的过拟合

    1. “早停”, 数据分为训练集和验证集,训练集计算梯度、更新连接权和阈值,验证集估计误差,若训练集误差下降,而验证集误差升高,则停止训练
    2. 正则化,在误差目标函数中增加一个用于描述网络复杂度的部分,

    E = 1 m ∑ k = 1 m E k + ( 1 − λ ) ∑ i w i 2 E = \frac{1}{m}\sum^m_{k=1}E_k + (1-\lambda)\sum_i w^2_i E=m1k=1mEk+(1λ)iwi2

    全局最优与局部最优

    1. 以多组不同参数值初始化多个神经网络
    2. 利用模拟退火技术,以一定的概率接收比此次结果更差的结果
    3. 随机梯度下降
    展开全文
  • matlab开发-使用MLP进行IRISFlowerClassification。虹膜花分类的多层感知器
  • 使用全连接神经网络(MLP)解决垃圾邮件分类问题
  • 1.拍四张不同方位的标准照片,falg 0 1 2 3。 2.选择了多层感知机分类器。 4.图片预处理(crop,sobel、emphasize),选取合适点的特征表征(这步比较关键,特征的选取根据图片来分析,分类...6.读取模型,映射分类。`
  • MLP简单分类任务 VS2015

    2018-12-12 15:20:14
    基于MLP的简单分类任务 平台:VS2015 语言:C++ 固定大小输入
  • 基于pytorch框架,设计MLP网络实现wine分类
  • 主要为大家详细介绍了TensorFlow实现MLP多层感知机模型,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 4、MLP简单的二分类代码案例 1、神经网络:(Artifical Neural Network) 全程为人工神经网络,是一种模仿生物神经网络(大脑)的结构和功能的数学模型或计算机模型 生物神经细胞; 神经细胞是构成神经系统的基本...
  • halcon MLP分类

    2021-09-22 11:22:34
    halcon代码 *关闭当前窗口 dev_close_window() *创建新窗口 dev_open_window (0, 0, 512, 512, 'black', WindowHandle) ...*创建MLP分类器,输出方法选择softmax,用于分类 create_class_mlp (1, 1, 2, 'softmax', 'no
  • Halcon 图像分类-MLP分类器使用

    千次阅读 2021-06-24 10:54:29
    Halcon 图像分类 学习内容: (1)基于神经网络的多层感知器MLP分类器 (2)基于支持向量机的SVM分类器 (3)基于高斯混合模型的GMM分类器 (4)基于K-NN分类器 本章学习目标: 1.了解图像分类的一般流程: (1)...
  • 基于MLP神经网络算法的中医肥胖体质分类模型研究.pdf
  • 基于MLP进行文本分类

    千次阅读 2021-10-14 19:27:38
    最近学习了基于Pytorch框架下的MLP、CNN、RNN网络模型,利用在GitHub上获取的商品评论数据进行文本分类实验。本文介绍了如何在Pytorch框架下建立MLP对数据进行二分类,数据集大致如下: 1、导入模块 import pandas ...
  • 网上商店:使用MLP分类器创建了一个预测模型,以预测在线客户是否会购物
  • 基于MLP分类器的Python实现

    千次阅读 2021-04-02 16:13:09
    MLP分类器-Python sklearn.neural_network.MLPClassifier 前提警告: MLP实现不适用于大规模应用程序。特别是,scikit-learn不提供GPU支持。关于更快的,基于gpu的实现,以及提供更多灵活性来构建深度学习架构的框架...
  • 此代码使用基于反向传播的 NN 学习对鸢尾花数据集进行分类
  • Halcon-MLP分类

    千次阅读 2019-12-18 10:07:52
    步骤: 1、创建分类器create_class_mlp() 2、获取各个类别的特征向量 gen_...4、训练模型,生成gmc文件 train_class_mlp(),write_class_mlp() 5、获取待分类图像的特征向量 6、通过分类器计算特征向量的类 class...
  • 每个MLP模型由一个输入层、几个隐藏层和一个输出层组成 每层神经元的数目不受限制 具有一个隐藏层的MLP - 输入神经元数:3 - 隐藏神经元数:4 - 输出神经元数:2 回归任务的MLP 当目标(y)连续时 对于损失函数和...
  • MLP分类——MNIST(手写数字识别) 目录MLP分类——MNIST(手写数字识别)数据集model+predicted 数据集 #导入数据 X_train = load_data("train-images-idx3-ubyte.gz") / 255.0 X_test = load_data("t10k-images-...
  • 基于MLP和SepCNN神经网络模型的藏文文本分类研究.pdf
  • MLP实现图像多分类

    千次阅读 2021-12-12 01:32:45
    MLP实现图像多分类
  • 利用MLP进行分类

    千次阅读 2021-02-07 21:06:56
    文章目录一、MLP是什么?二、实例演示1.引入库2.分类图形可视化3.分离数据4.建立模型5.训练模型6.对数据进行预测并计算精确度 一、MLP是什么? 示例:MLP是多层感知器,是深度学习中的重要内容。 二、实例演示 1....
  • MLP做电影评论二分类

    千次阅读 2019-01-20 19:43:22
    2、带有 relu 激活的 Dense 层堆叠,可以解决很多种问题(包括情感分类),你可能会经常用到这种模型。 3、对于二分类问题(两个输出类别),网络的最后一层应该是只有一个单元并使用 sigmoid激活的 Dense 层,网络...
  • 利用Keras实现多层感知器(MLP模型和卷积神经网络(CNN)模型并对手写数字图像分类
  • 针对传统的DTBSVM算法中判断类间的可分的难易程度时可能造成的错误判断,提出了基于空间重叠度的DTSVM多类分类方法。该方法通过计算已知的类别样本在空间中的重叠度,合并有重叠的类,组合为一个新的类,再基于一种...
  • MLP实现非线性二分类 keras简单应用

    千次阅读 2020-07-23 23:52:06
    data = pd.read_csv("MLP_test_data.csv") data.head() 数据自己用excel生成的… 再处理一下输出: print(type(data),type(data.loc[:,'x'])) data_x = [] data_y = [] data_lable = [] for index, row in data....
  • Python语言,word2vec模型,词袋模型和TFIDF模型,使用MLP(多层感知机)进行情感分析,使用fasttext进行文档分类

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,082
精华内容 6,432
关键字:

MLP分类模型