精华内容
下载资源
问答
  • 主要为大家详细介绍了TensorFlow实现MLP多层感知模型,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 基于多层感知器(MLP)模型的情感分类源码实现 一、 数据处理模块(utils文件夹下的MLPprocess.py) #词表隐射 from collections import defaultdict from platform import uname from torch.utils.data import ...

    基于多层感知器(MLP)模型的情感分类源码实现

    一、 数据处理模块(utils文件夹下的MLPprocess.py)

    #词表隐射
    from collections import defaultdict
    from platform import uname
    
    from torch.utils.data import Dataset, DataLoader, TensorDataset
    from nltk.corpus import sentence_polarity
    from torch.utils.data import DataLoader
    import torch
    
    class Vocab:
        def __init__(self, tokens=None):
            self.idx_to_token = list()
            self.token_to_idx = dict()
    
            if tokens is not None:
                if "<unk>" not in tokens:
                    tokens = tokens + ["<unk>"]
                for token in tokens:
                    self.idx_to_token.append(token)
                    self.token_to_idx[token] = len(self.idx_to_token) - 1
                self.unk = self.token_to_idx['<unk>']
    
        @classmethod
        def build(cls, text, min_freq=1, reserved_tokens=None):
            token_freqs = defaultdict(int)
            for sentence in text:
                for token in sentence:
                    token_freqs[token] += 1
            uniq_tokens = ["<unk>"] + (reserved_tokens if reserved_tokens else [])
            uniq_tokens += [token for token, freq in token_freqs.items() \
                            if freq >= min_freq and token != "<unk>"]
            return cls(uniq_tokens)
    
        def __len__(self):
            return len(self.idx_to_token)
    
        def __getitem__(self, token):
            return self.token_to_idx.get(token, self.unk)
    
        def convert_tokens_to_ids(self, tokens):
            return [self.token_to_idx.get(token, self.unk) for token in tokens]
    
        def convert_ids_to_tokens(self, indices):
            return [self.idx_to_token[index] for index in indices]
    
    def load_sentence_polarity():
        
        vocab = Vocab.build(sentence_polarity.sents())
        print('test---vocab:', len(vocab))
    
        train_data = [(vocab.convert_tokens_to_ids(sentence), 0) for sentence in sentence_polarity.sents(categories='pos')[:4000]]   \
                     + [(vocab.convert_tokens_to_ids(sentence), 1) for sentence in sentence_polarity.sents(categories='neg')[:4000]]
    
        #其余数据作为测试集
        test_data = [(vocab.convert_tokens_to_ids(sentence), 0) for sentence in sentence_polarity.sents(categories='pos')[4000:]]   \
                     + [(vocab.convert_tokens_to_ids(sentence), 1) for sentence in sentence_polarity.sents(categories='neg')[4000:]]
    
        return train_data, test_data, vocab
    
    class BowDataset(Dataset):
        def __init__(self, data):
            self.data = data
    
        def __len__(self):
            return len(self.data) #返回数据集中样例的数目
        def __getitem__(self, i):
            return self.data[i]  #返回下标为i的样例
    
    
    #collate_fn参数指向一个函数,用于对一个批次的样本进行整理,如将其转换成张量
    def collate_fn(examples):
        inputs = [torch.tensor(ex[0]) for ex in examples]
        #输出的目标targets为该批次中全部样例输出结果(0或者1)构成的张量
        targets = torch.tensor([ex[1] for ex in examples], dtype=torch.long)
        #获取一个批次中每个样例的序列长度
        offsets = [0] + [i.shape[0] for i in inputs]
        #根据序列的长度,转换为每个序列起始位置的偏移量(offsets)
        offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
        #将inputs 列表中的张量拼接成一个大的张量
        inputs = torch.cat(inputs)
        return inputs, offsets, targets
    
    

    二、MLP模型模块 (Models文件夹下的MLPModel.py)

    import torch.nn as nn
    import torch.nn.functional as F
    
    class MLP(nn.Module):
        def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class):
            super(MLP, self).__init__()
            self.embedding = nn.EmbeddingBag(vocab_size, embedding_dim)
            self.linear1 = nn.Linear(embedding_dim, hidden_dim)
            self.activate = F.relu
            self.linear2 = nn.Linear(hidden_dim, num_class)
    
        def forward(self, inputs, offsets):
            embedding = self.embedding(inputs, offsets)
            hidden = self.activate(self.linear1(embedding))
            outputs = self.linear2(hidden)
            log_probs = F.log_softmax(outputs, dim=1)
            return log_probs
    
    

    三、主函数(main.py)

    import sys
    sys.path.append("../") #此处是为了实现在本地运行时,调用同级文件夹下的函数/类
    
    import torch
    from torch import nn
    from torch.nn import functional as F
    from torch.utils.data import Dataset, DataLoader, TensorDataset
    from nltk.corpus import sentence_polarity
    from Models.MLPModel import MLP
    from utils.MLPprocess import (BowDataset, Vocab, collate_fn, load_sentence_polarity)
    
    from Models.CNNModel import CNN
    from utils.CNNprocess import BowDataset, Vocab, collate_fn, load_sentence_polarity
    
    import torch.optim as optim
    from tqdm.auto import tqdm  # tqdm是一个python模块,能以进度条的方式显示迭代的进度
    
    
    import nltk
    nltk.download('sentence_polarity')
    mlp = MLP(vocab_size=8,embedding_dim=3,hidden_dim=5,num_class=2)
    #输入为两个长度为4的整数序列S
    # inputs = torch.tensor([[0, 1, 2, 1], [4, 6, 6, 7]], dtype=torch.long)
    # outputs = mlp(inputs)
    # print(outputs)
    
    # print("\n")
    # print("Parameters: ")
    # for name, param in mlp.named_parameters():
    #     print(name,param.data)
    
    
    #超参数设置
    embedding_dim = 128
    hidden_dim = 256
    num_class = 2
    batch_size = 32
    num_epoch = 5
    filter_size = 3
    num_filter = 100
    
    # 加载数据
    train_data, test_data, vocab = load_sentence_polarity()
    train_dataset = BowDataset(train_data)
    test_data = BowDataset(test_data)
    
    train_data_loader = DataLoader(train_dataset, batch_size=batch_size, collate_fn=collate_fn, shuffle=True)
    test_data_loader = DataLoader(test_data, batch_size=batch_size, collate_fn= collate_fn, shuffle=False)
    
    #加载模型
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    print('vocab: ', vocab)
    model = MLP(len(vocab), embedding_dim, hidden_dim, num_class) #MLP
    model.to(device) #将模型加载到cpu或GPU设备
    
    #训练过程
    nll_loss = nn.NLLLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    model.train()
    for epoch in range(num_epoch):
        total_loss = 0
        for batch in tqdm(train_data_loader, desc=f"Training Epoch {epoch}"):
            inputs, offsets, targets = [x.to(device) for x in batch] #MLP
            log_probs = model(inputs, offsets) #MLP
            loss = nll_loss(log_probs, targets) #MLP
    
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
    
        print(f"Loss: {total_loss: .2f}")
    
    
    #测试过程
    acc = 0
    for batch in tqdm(test_data_loader, desc=f"Testing"):
        inputs, offsets, targets = [x.to(device) for x in batch]  #MLP
        with torch.no_grad():
            output = model(inputs, offsets) #MLP
            acc += (output.argmax(dim=1) == targets).sum().item()
    
    #输出在测试集上的准确率
    print(f"Acc: {acc /len(test_data_loader):.2f}")
    
    
    
    展开全文
  • 本实验旨在掌握Weka 多层感知模型实践操作;了解多层感知机算法在各领域的应用;掌握Matlab 神经网络工具箱实践操作;了解Matlab 神经网络工具箱在各领域的应用。
  • 多层感知器模型(MLP)

    万次阅读 2016-09-24 22:56:36
    需要训练的模型参数(parameters)num_hidden:隐藏层节点数目 activation func:隐藏层/输出层节点的激发函数 weights/biases:连接权重/偏置 * 构造成本函数 训练模型的目的就是降低C值的大小。由于每一层激发...

    需要训练的模型参数(parameters)

    num_hidden:隐藏层节点数目
    activation func:隐藏层/输出层节点的激发函数
    weights/biases:连接权重/偏置
    MLP
    * 构造成本函数cost function
    训练模型的目的就是降低C值的大小。由于每一层激发函数的输出a_j是权重(weight)和偏置(bias)的函数,因此C也是权重和偏置的函数。训练模型的过程就可以转化成寻找权重和偏置的最优组合,使得C的值降到最低。通常使用随机梯度下降算法(SGD)来寻找该最优组合。
    前向传播(forward propagation):将训练数据train_X输入到模型,并在输出层得到相应的输出output,此过程成为前向传播。
    后向传播(backward propagation):通过输出结果output和真实的结果y_true计算出成本函数值C,进而计算出C对每一层权重和偏置的偏导数值,并利用它们调整对应的权重和偏置使得调整后的权重/偏置组合更加接近最优。调整的方式为:
    这里写图片描述
    这里写图片描述
    sigmoid
    sigmoid_func

    展开全文
  • 神经网络基础神欢迎使用Markdown编辑新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    序言

    关于神经网络的内容已经学习了很多,也发现了一些问题,而这些问题是因为基础不牢靠引起的,所以在此从头总结一下,为方便过渡到CNN网络,此节内容将详细写一下MP模型、单层感知器、多层感知器(BP)。

    MP模型

    MP模型

    如上图所示MP模型,MP模型能够简单处理一些分类任务,其中激活函数比较简单,是一个简单的阈值例如:
    运算

    1、逻辑与:

    首先定义好权重:w1=w2=2; 偏置:b=0;阈值:h=3,结果如下:
    逻辑与
    在这里插入图片描述

    2、逻辑或:

    权重:w1=w2=2; 偏置:b=0;阈值:h=1,结果如下:
    在这里插入图片描述
    在这里插入图片描述

    3、逻辑异或:

    在这里插入图片描述
    能够发现没有一条直线能够将其分开,即是线性不可分的

    注:如果两类样本可以用直线、平面或超平面分开,称为线性可分,否则为线性不可分

    单层感知器

    本质上与MP模型没有太大的区别,区别主要有两点:
    1、输入可以不是离散型0/1
    2、激活函数可以不再是简单的阈值函数。
    单层感知器与前面的MP模型是一样的,都是只对线性可分问题具有分类能力。
    为了从细节上得以理解,下面给出一个具体实例:

    例:单层感知器训练分类
    如下
    优化器,这里的Y代表真实标签,y代表预测标签
    在这里插入图片描述
    激活函数:
    在这里插入图片描述
    初始权向量:
    在这里插入图片描述
    偏置:
    在这里插入图片描述
    学习率默认为
    在这里插入图片描述

    第一步:
    在这里插入图片描述
    在这里插入图片描述
    由于预测值不等于真实值,所以需要更新参数,这里用到了梯度下降,关于梯度下降见我的另一篇博客为什么模型训练要采用梯度下降
    更新权重:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    第二步:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    第三步:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    接着重复上述步骤直至y将所有类别正确分开。

    多层感知器(BP)

    多层感知器在单层感知器的基础上引入了隐含层,能够解决非线性分类的问题。
    下面是基于BP的三层前馈网络模型(为更加详细的理解我们对其中的误差反传进行了推导)
    在这里插入图片描述

    其中:
    输入向量: X=(x1,x2,…,xi,…,xn)T
    隐层输出向量: Y=(y1,y2,…,yj,…,ym)T
    输出层输出向量: O=(o1,o2,…,ok,…,ol)T
    期望输出向量:d=(d1, d2,…,dk,…,dl)T
    输入层到隐层之间的权值矩阵:V=(V1,V2,…,Vj,…,Vm)
    隐层到输出层之间的权值矩阵:W=(W1,W2,…,Wk,…,Wl)
    首先我们先看输出层:

    在这里插入图片描述
    Ok:经过激活函数的最终输出
    netk:最终输出
    隐层:
    在这里插入图片描述
    在这里插入图片描述
    yj:经过激活函数的隐含层输出
    netk:隐含层输出
    误差
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    之后的推导通过手写的形式介绍,如下:
    在这里插入图片描述
    在这里插入图片描述
    如上图所示,BP学习算法中,各层权值调整公式形式上是一样的,均有三个因素决定,即学习率,本层输出的误差信号,以及本层输入信号。这就是BP感知机学习算法,理解透彻这一部分对之后的神经网络学习是很重要的。

    展开全文
  • 而且上节学到了感知器神经元(阈值逻辑单元),对于单个的感知器神经元来说,尽管它能够实现线性可分数据的分类问题(如与、或问题),但是却无法解决非线性问题,如逻辑学里的异或(XOR)问题甚至

    转载出处:http://blog.csdn.net/eternity1118_。


     早前已经学习了感知器学习算法,主要通过对那些错分类的样本进行求和来表示对错分样本的惩罚,但明显的它是一个线性的判别函数;而且上节学到了感知器神经元(阈值逻辑单元),对于单个的感知器神经元来说,尽管它能够实现线性可分数据的分类问题(如与、或问题),但是却无法解决非线性问题,如逻辑学里的异或(XOR)问题甚至是高阶,那么这样的问题该如何利用简单学习机器来解决呢?

           回想下前面在非线性分类器中提到的分段线性判别,它的目的是为了将非线性函数拟合成多段线性函数的组合,同样,关于上述问题,我们也可以采用这一思想,对于任意复杂形状的分类区域,总可以用多个神经元组成一定的层次结构来实现,如图,也即多个感知器神经元的组合:

                         (1)             (这里依然指的是阶跃函数,用作传递函数)


           上图中的模型其实就是:前一层神经元的输出是后一层神经元的输入,最后一层只有一个神经元,它接收来自前一层的n个输入,给出作为决策的一个输出。

           尽管我们有了这种多层学习模型的惊喜发现,但是遗憾的是,之前在线性判别里学到的感知器学习算法并不能直接应用在这种多层学习模型的参数学习上(为什么呢,因为要使用梯度下降法训练更新权值,而在该模型,看公式(1),神经元的传递函数为阶跃函数,输出端的误差只能对最后一个神经元的权系数求梯度,无法对其他神经元的权系数求梯度,所以无法使用这种梯度下降算法学习其他神经元的权值;),因此上世纪60年代,多层学习模型的提出者Rosenblatt随即给出了解决方案:除了最后一个神经元外,预先固定其他所有神经元的权重,学习过程就变成只是用感知器学习算法来寻找最后一个神经元的权系数。事实上,这样做相当于通过第一层神经元把原始的特征空间变换到一个新的空间,且第一层的每个神经元构成这个新空间的每一维,其中每一维取值为二值,然后再在这个新空间里用感知器学习算法构造一个线性分类器;显然,由于第一层神经元的权重值由人为确定,因此该模型的性能好坏很大程度上直接取决于第一层神经元权重值的是否选取适当,即第一层怎样设计才最恰当,而这些又直接取决于输入的数据性质,但是不幸的是,在当时还没有人能给出针对任意问题求解第一层参数的方法,于是就这样仅仅因为无法对参数进行学习的瓶颈,导致了人们对感知器的研究就这样停滞了大约有25年之久,直道25年后一种全新且至今广为传用的学习算法‘BP’的出现(作为后续的学习),才打破了僵局。

           但是,不管神经网络模型的研究停滞不前了多久,多层感知器模型都是NN研究上的一个火光性的亮点,后续的一系列模型及学习算法(如当今火热的深度学习,还有经典的BP学习算法)都是基于此的,这么多年过去人们一提到NN,仍然会首先想到感知机模型,不仅是因为它简单,更因为它的历史贡献性无可替代。


    展开全文
  • 多层感知器

    千次阅读 2019-08-08 22:57:26
    很简单的一个分布,但事实上就是无法用直线进行分类,后来就出现了多层感知器,主要改变的地方是把第一层的感知器的输出作为第二层感知器的输入,即使只是简单添加一层感知器,也足以解决xor问题,关键的原因是,多...
  • 主要为大家详细介绍了python实现多层感知器MLP,基于双月数据集,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 多层感知模型讲解

    千次阅读 2020-01-13 12:44:16
    具有多层输出的感知机如下图所示: 图中节点上的符号表示的含义是: xk1x^1_kxk1​代表第1层上的第k个节点 Ok1O^1_kOk1​同样代表第1层上的第k个节点 若能求出∇E∇wjk\frac{\nabla E}{\nabla w_{jk}}∇wjk​∇E​...
  • 多层感知器 多层感知器的 C++ 实现。 应用程序接口 MultilayerPerceptron(int inputDimension, int outputDimension); 使用给定的输入和输出维度创建一个新的 MultilayerPerceptron。 void addHiddenLayer(int ...
  • 多层感知机python代码

    2018-04-26 12:41:55
    多层感知机python代码,属于深度网络学习中的内容,multilayer-perceptron,python代码
  • % 用两层感知器实现异或XOR % 第一层是随机层,即权重何偏差随机确定,以第一层的输出作为第二层的输入
  • keras多层感知器识别手写数字

    千次阅读 2018-11-14 17:33:16
    2.Keras建立多层感知器模型 2.1简单介绍多层感知器模型 注:以下模型及其说明来自于《TensorFlow+Keras深度学习人工智能实践应用》林大贵 著 以矩阵方式仿真多层感知器模型的工作方式(如下图所示) 建立输入与隐藏层...
  • 多层感知器(MLP) 问题引入: (1)根据检测数据x1、x2及其标签,判断x1=0.7、x2=0.6时所属类别 如果采用逻辑回归,因为边界函数并不是单一的直线或圆之类的函数,所以这个逻辑回归边界函数不很好找到,如果初始...
  • 多层感知器-原理

    2019-11-26 19:22:23
    深度学习之神经网络 神经网络的出现 神经网络的首次出现来美国神经生物学家沃伦·麦克洛克(Warren McCulloch)和数学家...感知器能够根据训练样本自动获取样本的组合 1.训练方式为有监督学习,即需要设定训练样...
  • 多层感知器的基本特征

    千次阅读 2018-04-22 18:06:33
    多层感知器的基本特征 Rosenblatt 感知器本质上是一个单层神经网络,这一网络局限于线性可分模式的分类问题。自适应滤波采用了 Widrow 和 Hoff 的 LMS 算法。这一算法也是基于权值可调的单个线性神经元,这也限制...
  • 多层感知器速成

    千次阅读 2020-07-07 09:38:29
    转载自《深度学习–基于Keras的Python实践》第四章 ...人工神经网络领域通常被称为神经网络或多层感知器(MLP,MultilayerPerceptron),多层感知器也许是最有用的神经网络类型。多层感知器是一种前馈.
  • 多层感知器(MLP)

    千次阅读 2018-06-05 21:50:53
    简述多层感知器(MLP)1. 深度前馈网络(deep feedforward network),也叫前馈神经网络(feedforward neuarl network)或者多层感知机(multilayer perceptron,MLP),是典型的深度学习模型。这种模型被称为前向...
  • 1.17.链式法则 x经过参数w1和b1得到y1,y1再...dy1_dw1 = torch.autograd.grad(y1, [w1], retain_graph=True) print(dy2_dy1[0] * dy1_dw1[0]) 结果: tensor(2.6400) tensor(2.6400) 1.18.MLP(多层感知器模型)反向传播
  • 多层感知器神经网络

    2019-01-03 20:40:20
    理解多层感知器用于分类的原理和方法,特别是解决非线性多类别分类问题,利用实际数据进行分类处理。
  • 文章目录前言一、随机森林模型二、SVR模型三、MLPRegressor模型总结 前言 本文将使用Python整理1927-2020年所有美国上市公司股票数据。根据历史收益以及交易量,使用随机森林,支持向量机以及神经网络等机器学习...
  • 多层感知器是最简单的神经网络模型,用于处理机器学习中的分在介绍单层感知器的时候,我们提到对于非线性可分问题,单层感知器是很难解决的,比如下面这个例子: 类与回归问题。 很简单的一个分布,但事实上就是...
  • Python语言,word2vec模型,词袋模型和TFIDF模型,使用MLP(多层感知机)进行情感分析,使用fasttext进行文档分类
  • 简化的广义多层感知模型及其学习算法_方宁.pdf
  • 深度学习-多层感知器

    千次阅读 2017-11-23 00:24:25
    多层感知器多层感知器(Multilayer Perceptron,缩写MLP)是一种前向结构的人工神经网络,映射一组输入向量到一组输出向量。MLP可以被看作是一个有向图,由多个的节点层所组成,每一层都全连接到下一层。除了输入节点...
  • keras 模型序列化 多层感知器进阶,代码有齐全的注释
  • 训练识别——MLP(多层感知器

    千次阅读 2019-04-15 14:00:26
    自己刚学习并总结的训练学习识别的整体思路记录下来,供对视觉训练学习感兴趣的同学参考。如大家有更通俗的思路也可以留言评价下,创百家争鸣的场面。...4、而划分不同的物体,就是使用分类完成的; 5、训...
  • 此代码使用基于反向传播的 NN 学习对鸢尾花数据集进行分类。
  • 一、定义和公式 1. 多层感知器 Multi Layer Perceptron MLP ...多层感知器MLP模型框架(多个逻辑回归模型叠加在一起): 数学表达式为: 逻辑回归模型与神经网络模型之间的关系: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,755
精华内容 9,102
关键字:

多层感知器模型