精华内容
下载资源
问答
  • 感知机线性分类器.zip

    2021-05-22 15:23:09
    模式识别感知机线性分类器,单样本修正方法
  • 6. 多层感知机分类器逻辑回归交叉熵 逻辑回归 对于逻辑回归我们不能直接最大化 accuracy。 • acc.= I(pred i ==y i ) len(Y ) • grad 出现等于零的情况。 • grad 不连续。 为什么叫 regression。 • MSE−− &...

    逻辑回归

    1. 对于逻辑回归我们不能直接最大化 accuracy。
      • acc.= I ( p r e d i = = y i ) l e n ( Y ) \frac{I(pred_i==y_i)}{len(Y)} len(Y)I(predi==yi)
      • grad 出现等于零的情况。
      • grad 不连续。
    2. 为什么叫 regression。
      • MSE−− >regression.
      • cross entropy−− >classification.
    3. 多类:
      • 实现多个二分类器。
      • softmax。

    交叉熵

    1. Entropy

      1. uncertain 不确定度
      2. measure of surprise 惊喜程度
      3. higher entropy = less info
        e n t r o p y = − ∑ i P ( i ) l o g P ( i ) entropy = -\sum_{i}P(i)logP(i) entropy=iP(i)logP(i)
    2. Cross Entropy
      H ( p , q ) = ∑ p ( x ) l o g q ( x ) H(p,q) = \sum p(x)log q(x) H(p,q)=p(x)logq(x)
      H ( p , q ) = H ( p ) + D K L ( p ∣ q ) H(p,q) = H(p)+D_{KL}(p|q) H(p,q)=H(p)+DKL(pq)
      p = q ,     C r o s s   e n t r o p y = e n t r o p y p=q, ~~~Cross~entropy=entropy p=q,   Cross entropy=entropy
      H ( P , Q ) = − ( y l o g p + ( 1 − y ) l o g ( 1 − p ) ) H(P,Q)=-(ylogp+(1-y)log(1-p)) H(P,Q)=(ylogp+(1y)log(1p))

    对于分类什么不用MSE :

    1. sigmoid+MSE(梯度弥散)。
    2. 收敛非常慢。
    3. 但是有时可以试试MSE,求导简单。

    小结
    l o g i t − − > s o f t m a x − − > c r o s s   e n t r o p y logit-->softmax-->cross~entropy logit>softmax>cross entropy
    一般不建议自己单独使用 softmax 与 cross entropy。使用 pytorch 组合的框架。

    import torch
    from torch.nn import functional as F
    x = torch.randn(1,784)
    w = torch.randn(10,784)
    logits = x@w.t()
    pred = F.softmax(logits, dim=1)
    pred_log = torch.log(pred)
    F.nll_loss(pred_log, torch.tensor([1]))
    #F.cross_entropy=F.softmax+log+F.nll_loss
    F.cross_entropy(logits, torch.tensor([1]))
    

    多分类实战-Minst

    在这里插入图片描述
    建立网络 :

    w1, b1 = torch.randn(200, 784, requires_grad=True), torch.zeros(200,
    requires_grad=True)
    w2, b2 = torch.randn(200, 200, requires_grad=True), torch.zeros(200,
    requires_grad=True)
    w3, b3 = torch.randn(10, 200, requires_grad=True), torch.zeros(10,
    requires_grad=True)
    #向前传播
    def forward(x):
    	x = x@w1.t()+b1
    	x = F.relu(x)
    	x = x@w2.t()+b2
    	x = F.relu(x)
    	x = x@w3.t()+b3
    	x = F.relu(x)
    return x
    

    训练 :

    optimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)
    criteon = nn.CrossEntropyLoss()
    for epoch in range(epochs):
    #训练
    for batch_idx, (data, target) in enumerate(train_loader):
    data = data.reshape(-1, 28*28) #torch.Size([200, 784])
    logits = forward(data) #torch.Size([200, 10])
    loss = criteon(logits, target)
    optimizer.zero_grad() #梯度清零
    loss.backward() #反向回传
    # print(w1.grad.norm(), w2.grad.norm())
    optimizer.step() #更新梯度值
    

    通过打印 weight.grad.norm(),得知常常陷入局部极小值。解决这个问题可以利用何
    凯明的初始化方法。

    torch.nn.init.kaiming_normal_(w1)
    torch.nn.init.kaiming_normal_(w2)
    torch.nn.init.kaiming_normal_(w3)
    

    全连接层

    在上节中,我们未用 PyTorch 封装的 API 去建立神经网络,这节来使用 PyTorch
    封装的 API。

    1. 继承 nn.module 类
    2. 用 init 来初始化
    3. 应用向前传播
    class MLP(nn.Module):
    def __init__(self):
    	super(MLP, self).__init__()
    	
    	self.model = nn.Sequential(
    		nn.Linear(784, 200),
    		nn.ReLU(inplace=True),
    		nn.Linear(200, 200),
    		nn.ReLU(inplace=True),
    		nn.Linear(200, 10),
    		nn.ReLU(inplace=True),
    )
    
    def forward(self, x):
    	x = self.model(x)
    	return x
    

    PyTorch 两 种 风 格 的API

    1. class-style API (nn.***)
    2. function-style API (F.***)

    没有遇到上节遇到的初始化问题,参数未暴露给用户,拥有自己的初始化体系,一
    般来说够用,否则自己必须编写相应的初始化代码。

    激活函数与GPU加速

    常用激活函数

    1. Sigmoid
    2. ReLu
    3. tanh
    4. Leaky ReLu
    5. SELU
    6. softplus

    一键部署 GPU 加速

    device = torch.device(cuda)
    net = MLP().to(device)
    optimizer = optim.SGD(net.parameters(), lr=learning_rate)
    criteon = nn.CrossEntropyLoss().to(device)
    time1 = time.time()
    for epoch in range(epochs):
    for batch_idx, (data, target) in enumerate(train_loader):
    data = data.view(-1, 28*28)
    data, target = data.to(device), target.cuda()
    logits = net(data)
    loss = criteon(logits, target)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    

    测试与可视化

    测试

    神经网络的表达能力非 强,容易过拟合,所以要测试 。不能单一观测测Loss 的大小判断模型的好坏,还要观测测试集的准确度,确保模型的泛化能力。

    test_loss = 0
    correct = 0
    for data, target in test_loader:
    	data = data.view(-1, 28 * 28)
    	data, target = data.to(device), target.cuda()
    	logits = net(data)
    	test_loss += criteon(logits, target).item()
    	pred = logits.argmax(1)
    	correct += pred.eq(target.data).sum()
    	
    test_loss /= len(test_loader.dataset)
    

    可视化

    通过pip install visdom等方式成功安装完之后,开启服务

    python -m visdom.server
    

    出现了Mnist图片 viz.images() 全黑故障,是由于样本 normalization 引起的,要进行反归一化才可正常显示。

    展开全文
  • 4.1 多层感知机分类) 这篇文章开始就是深度学习了。多层感知机的架构是这样: 输入层除了提供数据之外,不干任何事情。隐层和输出层的每个节点都计算一次线性变换,并应用非线性激活函数。隐层的激活函数是压缩...

    4.1 多层感知机(分类)

    这篇文章开始就是深度学习了。多层感知机的架构是这样:

    输入层除了提供数据之外,不干任何事情。隐层和输出层的每个节点都计算一次线性变换,并应用非线性激活函数。隐层的激活函数是压缩性质的函数。输出层的激活函数取决于标签的取值范围。

    其本质上相当于广义线性回归模型的集成。

    操作步骤

    导入所需的包。

    import tensorflow as tf
    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    import sklearn.datasets as ds
    import sklearn.model_selection as ms
    

    导入数据,并进行预处理。我们使用鸢尾花数据集所有样本。根据萼片长度和花瓣长度预测样本是不是杂色鸢尾(第二种)。要注意杂色鸢尾在另外两种之间,所以它不是线性问题。

    iris = ds.load_iris()
    
    x_ = iris.data[:, [0, 2]]
    y_ = (iris.target == 1).astype(int)
    y_ = np.expand_dims(y_ , 1)
    
    
    x_train, x_test, y_train, y_test = \
        ms.train_test_split(x_, y_, train_size=0.7, test_size=0.3)
    

    定义超参数。

    变量含义
    n_input样本特征数
    n_epoch迭代数
    n_hidden1隐层 1 的单元数
    n_hidden2隐层 2 的单元数
    lr学习率
    threshold如果输出超过这个概率,将样本判定为正样本
    n_input = 2
    n_hidden1 = 4
    n_hidden2 = 4
    n_epoch = 2000
    lr = 0.05
    threshold = 0.5
    

    搭建模型。要注意隐层的激活函数使用了目前暂时最优的 ELU。由于这个是二分类问题,输出层激活函数只能是 Sigmoid。

    变量含义
    x输入
    y真实标签
    w_l{1,2,3}{1,2,3}层的权重
    b_l{1,2,3}{1,2,3}层的偏置
    z_l{1,2,3}{1,2,3}层的中间变量,前一层输出的线性变换
    a_l{1,2,3}{1,2,3}层的输出,其中a_l3样本是正样本的概率
    x = tf.placeholder(tf.float64, [None, n_input])
    y = tf.placeholder(tf.float64, [None, 1])
    w_l1 = tf.Variable(np.random.rand(n_input, n_hidden1))
    b_l1 = tf.Variable(np.random.rand(1, n_hidden1))
    w_l2 = tf.Variable(np.random.rand(n_hidden1, n_hidden2))
    b_l2 = tf.Variable(np.random.rand(1, n_hidden2))
    w_l3 = tf.Variable(np.random.rand(n_hidden2, 1))
    b_l3 = tf.Variable(np.random.rand(1, 1))
    z_l1 = x @ w_l1 + b_l1
    a_l1 = tf.nn.elu(z_l1)
    z_l2 = a_l1 @ w_l2 + b_l2
    a_l2 = tf.nn.elu(z_l2)
    z_l3 = a_l2 @ w_l3 + b_l3
    a_l3 = tf.sigmoid(z_l3)
    

    定义交叉熵损失、优化操作、和准确率度量指标。

    变量含义
    loss损失
    op优化操作
    y_hat标签的预测值
    acc准确率
    loss = - tf.reduce_mean(y * tf.log(a_l3) + (1 - y) * tf.log(1 - a_l3))
    op = tf.train.AdamOptimizer(lr).minimize(loss)
    
    y_hat = tf.to_double(a_l3 > threshold)
    acc = tf.reduce_mean(tf.to_double(tf.equal(y_hat, y)))
    

    使用训练集训练模型。

    losses = []
    accs = []
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        
        for e in range(n_epoch):
            _, loss_ = sess.run([op, loss], feed_dict={x: x_train, y: y_train})
            losses.append(loss_)
    

    使用测试集计算准确率。

            acc_ = sess.run(acc, feed_dict={x: x_test, y: y_test})
            accs.append(acc_)
    

    每一百步打印损失和度量值。

            if e % 100 == 0:
                print(f'epoch: {e}, loss: {loss_}, acc: {acc_}')
    

    得到决策边界:

        x_plt = x_[:, 0]
        y_plt = x_[:, 1]
        c_plt = y_.ravel()
        x_min = x_plt.min() - 1
        x_max = x_plt.max() + 1
        y_min = y_plt.min() - 1
        y_max = y_plt.max() + 1
        x_rng = np.arange(x_min, x_max, 0.05)
        y_rng = np.arange(y_min, y_max, 0.05)
        x_rng, y_rng = np.meshgrid(x_rng, y_rng)
        model_input = np.asarray([x_rng.ravel(), y_rng.ravel()]).T
        model_output = sess.run(y_hat, feed_dict={x: model_input}).astype(int)
        c_rng = model_output.reshape(x_rng.shape)
    

    输出:

    epoch: 0, loss: 8.951598255929909, acc: 0.28888888888888886
    epoch: 100, loss: 0.5002945631529941, acc: 0.7333333333333333
    epoch: 200, loss: 0.10712651780120697, acc: 0.9333333333333333
    epoch: 300, loss: 0.08321807852608396, acc: 0.9333333333333333
    epoch: 400, loss: 0.08013835031876741, acc: 0.9333333333333333
    epoch: 500, loss: 0.07905186419367002, acc: 0.9333333333333333
    epoch: 600, loss: 0.07850865683940819, acc: 0.9333333333333333
    epoch: 700, loss: 0.07808251016428093, acc: 0.9333333333333333
    epoch: 800, loss: 0.07780712763974691, acc: 0.9333333333333333
    epoch: 900, loss: 0.07759866398922599, acc: 0.9333333333333333
    epoch: 1000, loss: 0.07744327666591566, acc: 0.9333333333333333
    epoch: 1100, loss: 0.07731295774932465, acc: 0.9333333333333333
    epoch: 1200, loss: 0.07721162022836371, acc: 0.9333333333333333
    epoch: 1300, loss: 0.07712807776857629, acc: 0.9333333333333333
    epoch: 1400, loss: 0.07735547120278226, acc: 0.9333333333333333
    epoch: 1500, loss: 0.07700215794853897, acc: 0.9333333333333333
    epoch: 1600, loss: 0.07695230759382654, acc: 0.9333333333333333
    epoch: 1700, loss: 0.07690933782097598, acc: 0.9333333333333333
    epoch: 1800, loss: 0.07687191279304387, acc: 0.9333333333333333
    epoch: 1900, loss: 0.07683911419647445, acc: 0.9333333333333333
    

    绘制整个数据集以及决策边界。

    plt.figure()
    cmap = mpl.colors.ListedColormap(['r', 'b'])
    plt.scatter(x_plt, y_plt, c=c_plt, cmap=cmap)
    plt.contourf(x_rng, y_rng, c_rng, alpha=0.2, linewidth=5, cmap=cmap)
    plt.title('Data and Model')
    plt.xlabel('Petal Length (cm)')
    plt.ylabel('Sepal Length (cm)')
    plt.show()
    

    绘制训练集上的损失。

    plt.figure()
    plt.plot(losses)
    plt.title('Loss on Training Set')
    plt.xlabel('#epoch')
    plt.ylabel('Cross Entropy')
    plt.show()
    

    绘制测试集上的准确率。

    plt.figure()
    plt.plot(accs)
    plt.title('Accurary on Testing Set')
    plt.xlabel('#epoch')
    plt.ylabel('Accurary')
    plt.show()
    

    扩展阅读

    展开全文
  • 设有两个模式样本集合,用感知机算法设计两个模式类的分类判决函数G(x)
  • 本节为大家介绍实现感知机实现的具体原理代码: 运 行结果如图所示: 总结 以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对软件开发网的支持。 您可能感...
  • 编写感知机实践2.1 数据处理2.2 编写感知机类2.3 参数组合运行3. sklearn 感知机实践4. 附完整代码 本文将使用感知机模型,对鸢尾花进行分类,并调整参数,对比分类效率。 1. 感知机简介 感知机(perceptron)是...
  • \quad \quad多层感知机(MLP,Multilayer Perceptron)也叫人工神经网络(ANN,Artificial Neural Network),除了输入输出层,它中间可以有个隐层,最简单的MLP只含一个隐层,即三层的结构,如下图: \quad \...

    1、概述

    \quad \quad 多层感知机(MLP,Multilayer Perceptron)也叫人工神经网络(ANN,Artificial Neural Network),除了输入输出层,它中间可以有多个隐层,最简单的MLP只含一个隐层,即三层的结构,如下图:

    在这里插入图片描述
    \quad \quad 从上图可以看到,多层感知机层与层之间是全连接的。多层感知机最底层是输入层,中间是隐藏层,最后是输出层。

    \quad \quad 隐藏层的神经元怎么得来?首先它与输入层是全连接的,假设输入层用向量X表示,则隐藏层的输出就是 f ( W 1 X + b 1 ) f (W_1X+b_1) f(W1X+b1) W 1 W_1 W1是权重(也叫连接系数), b 1 b_1 b1是偏置,函数f 可以是激活函数,比如常用的sigmoid函数或者tanh函数。常见激活函数

    2、原理

    \quad \quad 多层感知机就是含有至少一个隐藏层的由全连接层组成的神经网络,且每个隐藏层的输出通过激活函数进行变换。多层感知机的层数和各隐藏层中隐藏单元个数都是超参数。

    \quad \quad 具体来说,给定一个小批量样本 X ∈ R n × d \boldsymbol{X} \in \mathbb{R}^{n \times d} XRn×d,其批量大小为 n n n,输入个数为 d d d。假设多层感知机只有一个隐藏层,其中隐藏单元个数为 h h h。记隐藏层的输出(也称为隐藏层变量或隐藏变量)为 H \boldsymbol{H} H,有 H ∈ R n × h \boldsymbol{H} \in \mathbb{R}^{n \times h} HRn×h。因为隐藏层和输出层均是全连接层,可以设隐藏层的权重参数和偏差参数分别为 W h ∈ R d × h \boldsymbol{W}_h \in \mathbb{R}^{d \times h} WhRd×h b h ∈ R 1 × h \boldsymbol{b}_h \in \mathbb{R}^{1 \times h} bhR1×h,输出层的权重和偏差参数分别为 W o ∈ R h × q \boldsymbol{W}_o \in \mathbb{R}^{h \times q} WoRh×q b o ∈ R 1 × q \boldsymbol{b}_o \in \mathbb{R}^{1 \times q} boR1×q

    \quad \quad 以单隐藏层为例并沿用本节之前定义的符号,多层感知机隐藏层按以下方式计算输出:

    H = ϕ ( X W h + b h ) , O = H W o + b o , \begin{aligned} \boldsymbol{H} &= \phi(\boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h),\\ \boldsymbol{O} &= \boldsymbol{H} \boldsymbol{W}_o + \boldsymbol{b}_o, \end{aligned} HO=ϕ(XWh+bh),=HWo+bo,

    其中 ϕ \phi ϕ表示激活函数。在分类问题中,我们可以对输出 O \boldsymbol{O} O做softmax运算,并使用softmax回归中的交叉熵损失函数。
    在回归问题中,我们将输出层的输出个数设为1,并将输出 O \boldsymbol{O} O直接提供给线性回归中使用的平方损失函数。

    3、多层感知机(MLP)代码详细解读(基于python+PyTorch)

    使用多层感知机对fashion_mnist数据集数据集简介进行图像分类

    1、导入库

    #使用多层感知机对fashion_mnist分类
    #导入库
    import torch 
    import numpy as np 
    import sys
    from torch import nn
    from torch.nn import init
    import torchvision
    import torchvision.transforms as transforms
    

    2.导入fashion_mnist数据集及类别标签

    #继续使用fashion_mnist数据集
    mnist_train = torchvision.datasets.FashionMNIST(root='~/Desktop/OpenCV_demo/Datasets/FashionMNIST', train=True, download=True, transform=transforms.ToTensor())
    mnist_test = torchvision.datasets.FashionMNIST(root='~/Desktop/OpenCV_demo/Datasets/FashionMNIST', train=False, download=True, transform=transforms.ToTensor())
    
    #数据集中的10个类别
    def get_fashion_mnist_labels(labels):
        text_labels = ['t-shirt','trouser','pullover','dress','coat',
                      'sandal','shirt','sneaker','bag','ankle boot']
        return [text_labels[int(i)]for i in labels]
    

    3.设置batch_size,小批量读取数据

    #batch_size的设置
    batch_size = 256
    if sys.platform.startswith('win'):
        num_workers = 0
    else:
        num_workers = 4
    train_iter = torch.utils.data.DataLoader(
        mnist_train,batch_size = batch_size,shuffle = True,num_workers =  num_workers)
    test_iter = torch.utils.data.DataLoader(
        mnist_test,batch_size = batch_size,shuffle = True,num_workers =  num_workers)
      
    
    

    4.初始换参数 w1,w2,b1,b2 ,此时添加了一层隐藏层

    Fashion-MNIST数据集中图像形状为 28 × 28 28 \times 28 28×28,类别数为10。本节中我们依然使用长度为 28 × 28 = 784 28 \times 28 = 784 28×28=784的向量表示每一张图像。因此,输入个数为784,输出个数为10。实验中,我们设超参数隐藏单元个数为256。

    #设置输入28*28=784 输出设置为10(类别) 隐藏单元个数设置为256 两层的神经网络
    num_inputs, num_outputs, num_hiddens = 784, 10, 256
    
    W1 = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_hiddens)), dtype=torch.float)
    b1 = torch.zeros(num_hiddens, dtype=torch.float)
    W2 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_outputs)), dtype=torch.float)
    b2 = torch.zeros(num_outputs, dtype=torch.float)
    
    params = [W1, b1, W2, b2]
    for param in params:
        param.requires_grad_(requires_grad=True)
    

    5.定义激活函数,损失函数,优化函数

    #定义激活函数RELU
    def relu(X):
        return torch.max(input=X,other = torch.tensor(0.0))
    #定义损失函数:交叉熵损失函数
    loss = torch.nn.CrossEntropyLoss()
    
    #优化算法  小批量随机梯度下降算法
    def sgd(params,lr,batch_size):
        for param in params:
            param.data -= lr*param.grad/batch_size
    #也可以由一句话代替
    #loss = torch.nn.CrossEntropyLoss()
    #optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
    
    
    
    

    6.定义网络模型 双层网络,经过激活函数传递到下一层

    #定义模型  torch.matmul表示当 两者维度不一致时会自动填充到相应的维度进行点称
    #定义模型  torch.matmul表示当 两者维度不一致时会自动填充到相应的维度进行点称
    def net(X):
        X = X.view((-1,num_inputs))
        H = relu(torch.matmul(X,W1)+b1)
        return torch.matmul(H,W2)+b2
    '''
    网络模型的简洁搭建方法
    class FlattenLayer(nn.Module):
        def __init__(self):
            super(FlattenLayer,self).__init__()
        def forward(self,x):
            return x.view(x.shape[0],-1)
    net = nn.Sequential(
            d2l.FlattenLayer(),
            nn.Linear(num_inputs, num_hiddens),
            nn.ReLU(),
            nn.Linear(num_hiddens, num_outputs), 
            )
    
    for params in net.parameters():
        init.normal_(params, mean=0, std=0.01)
    '''
    
    

    7.定义模型参数精度函数

    #在模型上评价数据集的准确率  .item()将Tensor转换为number
    def evaluate_accuracy(data_iter,net):
        acc_sum,n = 0.0,0
        for X,y in data_iter:
            #计算判断准确的元素
            acc_sum += (net(X).argmax(dim=1)==y).float().sum().item()
            #通过shape 获得y的列元素
            n += y.shape[0]
        return acc_sum/n
    
    

    8.训练模型

    #训练模型 
    #由于这里定义的损失函数已经除了batch_size 且SGD函数也除l了batch_size(不需要的)
    #因此这里的学习率设置的大一些 
    num_epochs,lr= 5,100
    
    def train_softmax(net,train_iter,test_iter,loss,num_epochs,batch_size,
                      params=None, lr=None, optimizer=None):
        for epoch in range(num_epochs):
            #损失值、正确数量、总数 初始化
            train_l_sum,train_acc_sum,n = 0.0,0.0,0
            
            for X,y in train_iter:
                y_hat = net(X)
                l = loss(y_hat,y).sum()
                
                 # 梯度清零 损失函数和优化函数梯度清零
                if optimizer is not None:
                    optimizer.zero_grad()
                elif params is not None and params[0].grad is not None:
                    for param in params:
                        param.grad.data.zero_()
                        
                l.backward()
                if optimizer is None:
                    sgd(params, lr, batch_size)
                else:
                    optimizer.step() 
                
                train_l_sum += l.item()
                train_acc_sum +=(y_hat.argmax(dim=1)==y).sum().item()
                n += y.shape[0]
                
            test_acc = evaluate_accuracy(test_iter,net)
            print('epoch %d, loss %.4f, train acc %.3f,test acc %.3f'
                  %(epoch+1,train_l_sum/n,train_acc_sum/n,test_acc))
    #如果使用简洁网络,则需要修改 params和lr改成 optimizer        
    train_softmax(net,train_iter,test_iter,loss,num_epochs,batch_size,params,lr)
    
    

    epoch 1, loss 0.0031, train acc 0.710,test acc 0.756
    epoch 2, loss 0.0019, train acc 0.822,test acc 0.824
    epoch 3, loss 0.0017, train acc 0.844,test acc 0.838
    epoch 4, loss 0.0015, train acc 0.856,test acc 0.780
    epoch 5, loss 0.0015, train acc 0.863,test acc 0.843

    【完整代码】

    #使用多层感知机对fashion_mnist分类
    #导入库
    import torch 
    import numpy as np 
    import sys
    from torch import nn
    from torch.nn import init
    import torchvision
    import torchvision.transforms as transforms
    
    #继续使用fashion_mnist数据集
    mnist_train = torchvision.datasets.FashionMNIST(root='~/Desktop/OpenCV_demo/Datasets/FashionMNIST', train=True, download=True, transform=transforms.ToTensor())
    mnist_test = torchvision.datasets.FashionMNIST(root='~/Desktop/OpenCV_demo/Datasets/FashionMNIST', train=False, download=True, transform=transforms.ToTensor())
    
    #数据集中的10个类别
    def get_fashion_mnist_labels(labels):
        text_labels = ['t-shirt','trouser','pullover','dress','coat',
                      'sandal','shirt','sneaker','bag','ankle boot']
        return [text_labels[int(i)]for i in labels]
    
    #batch_size的设置
    batch_size = 256
    if sys.platform.startswith('win'):
        num_workers = 0
    else:
        num_workers = 4
    train_iter = torch.utils.data.DataLoader(
        mnist_train,batch_size = batch_size,shuffle = True,num_workers =  num_workers)
    test_iter = torch.utils.data.DataLoader(
        mnist_test,batch_size = batch_size,shuffle = True,num_workers =  num_workers)
      
    #设置输入28*28=784 输出设置为10(类别) 隐藏单元个数设置为256 两层的神经网络
    num_inputs,num_outputs,num_hiddens = 784,10,256
    
    W1 = torch.tensor(np.random.normal(0,0.01,(num_inputs,num_hiddens)),dtype = torch.float)
    b1 = torch.zeros(num_hiddens,dtype = torch.float)
    W2 = torch.tensor(np.random.normal(0,0.01,(num_hiddens,num_outputs)),dtype = torch.float)
    b2 = torch.zeros(num_outputs,dtype = torch.float)
    
    params = [W1,b1,W2,b2]
    for param in params:
        param.requires_grad_(requires_grad = True)
    #定义激活函数RELU
    def relu(X):
        return torch.max(input=X,other = torch.tensor(0.0))
    
    #定义模型  torch.matmul表示当 两者维度不一致时会自动填充到相应的维度进行点称
    def net(X):
        X = X.view((-1,num_inputs))
        H = relu(torch.matmul(X,W1)+b1)
        return torch.matmul(H,W2)+b2
    
    #定义损失函数
    loss = torch.nn.CrossEntropyLoss()
    
    #优化算法  小批量随机梯度下降算法
    def sgd(params,lr,batch_size):
        for param in params:
            param.data -= lr*param.grad/batch_size
    
    #在模型上评价数据集的准确率  .item()将Tensor转换为number
    def evaluate_accuracy(data_iter,net):
        acc_sum,n = 0.0,0
        for X,y in data_iter:
            #计算判断准确的元素
            acc_sum += (net(X).argmax(dim=1)==y).float().sum().item()
            #通过shape 获得y的列元素
            n += y.shape[0]
        return acc_sum/n
    
    #训练模型 
    #由于这里定义的损失函数已经除了batch_size 且SGD函数也除l了batch_size(不需要的)
    #因此这里的学习率设置的大一些 
    num_epochs,lr= 5,100
    
    def train_softmax(net,train_iter,test_iter,loss,num_epochs,batch_size,
                      params=None, lr=None, optimizer=None):
        for epoch in range(num_epochs):
            #损失值、正确数量、总数 初始化
            train_l_sum,train_acc_sum,n = 0.0,0.0,0
            
            for X,y in train_iter:
                y_hat = net(X)
                l = loss(y_hat,y).sum()
                
                 # 梯度清零 损失函数和优化函数梯度清零
                if optimizer is not None:
                    optimizer.zero_grad()
                elif params is not None and params[0].grad is not None:
                    for param in params:
                        param.grad.data.zero_()
                        
                l.backward()
                if optimizer is None:
                    sgd(params, lr, batch_size)
                else:
                    optimizer.step() 
                
                train_l_sum += l.item()
                train_acc_sum +=(y_hat.argmax(dim=1)==y).sum().item()
                n += y.shape[0]
                
            test_acc = evaluate_accuracy(test_iter,net)
            print('epoch %d, loss %.4f, train acc %.3f,test acc %.3f'
                  %(epoch+1,train_l_sum/n,train_acc_sum/n,test_acc))
            
    train_softmax(net,train_iter,test_iter,loss,num_epochs,batch_size,params,lr)
    
    

    参考资料:
    动手学深度学习

    展开全文
  • 行业分类-物理装置-基于多层感知机的新闻推荐方法.zip
  • 多层感知机

    千次阅读 2016-01-14 20:07:42
    1、单输出多层感知机 在单层感知机的基础上增加若干个(本文增加一个)隐层,得到多层感知机(Multi Perceptron Machine,MLP)。结构如图所示: (单输出多层感知机) 图中各变量满足公式:

    1、单输出多层感知机

    在单层感知机的基础上增加若干个(本文增加一个)隐层,得到多层感知机(Multi Perceptron Machine,MLP)。结构如图所示:

    (单输出多层感知机)


    图中各变量满足公式:



      


    假如现在有一个样本[(x1x2),T],用该样本训练网络时,网络优化的目标为lossFun最小。lossFun是一个关于变量w和v多元函数。网络的训练又变成多元函数求极值的问题。

    v1的梯度:

      

    同理可得vi的梯度:


    w11的梯度:

     

    同理,可得wij的梯度:


    通过上述方法算得单输出多层感知机的各连接权重w和v的梯度,只要按照w和v的梯度下降方向更新网络就能完成网络训练。


    2、多输出多层感知机

    在前面介绍的神经网络输出节点都是一个,如果遇到多分类问题,我们便需要多输出的神经网络。下图为一个多输出多层感知机。


                                                                                                              (多输出多层感知机)

    在上图的网络中,各变量满足公式:

     

    通过数学求导,得到lossFun对vjk的梯度:



    求导得到lossFun对wij的梯度:

    在求出权重梯度之后,只要按照梯度下降的方向更新连接权重就可以完成网络的训练。

    我们总结出:对于末层神经元,输出错误定义为:

     

    对于非末层神经元,输出错误如Err(y)由与其相连的后层神经元的输入错误Err(Z)加权求和得到,如下公式所示:



    一个神经元的输入错误Err(Y)与输出错误Err(y)满足公式:


      

    一条连接权重的更新量为该条连接前层神经元的输出乘以后层神经元的输入错误信号,如下公式所示。

      

    展开全文
  • JAVA感知机的动态分类实现

    千次阅读 2018-08-10 11:48:35
    网上的很博客在讲解感知机的时候提及了非常的专业知识,涉及的知识面较广,对小白不是很友好,容易把人给吓跑。因此,今天就想通俗地讲一下感知机的模型,并动手写一个简单的感知机。 一、感知机的基本概念 在...
  • 基于谱聚类和成对数据表示的多层感知机分类算法.pdf
  • 多层感知机的基本知识 深度学习主要关注多层模型。在这里,我们将以多层感知机(multilayer perceptron,MLP)为例,介绍多层神经网络的概念。
  • 感知机分类学习

    千次阅读 2013-11-26 22:59:49
    感知机(perceptron)是一种二类分类的线性分类模型,也就是说,使用于将数据分成两类的,并且数据要线性可分。线性可分是指存在一个超平面能够将空间分成两部分,每一部分为一类,感知机的目的就在于找这样的一个超...
  • 多分类问题与感知机算法

    千次阅读 2013-05-06 12:50:00
    本节延续线上节感知机算法,继续探讨多分类的线性感知机算法。  多分类问题首先可以看成是二元分类的一个拓展,具体的有两种方法:1.one vs rest;2.one vs one。  1.one vs rest  对于K(k>=3),我们可以用K...
  • 多层感知机(multi-layer perceptron)实现手写体分类(TensorFlow)
  • tensorflow 多层感知机 分类mnist

    千次阅读 2017-01-02 10:17:02
    from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("/root/data/", one_hot=True) import tensorflow as tf learning_rate = 0.001 training_epochs = 25 ...
  • Multilayer Perceptron (MLP) for multi-class softmax classification: from keras.models import Sequential from keras.layers import Dense, Dropout, ...更教程: http://www.tensorflownews.com/
  • 感知机算法,采用感知机算法设计分类器,并用其中的数据来验证测试分类器性能
  • 感知机

    千次阅读 2019-06-19 07:59:46
    感知机是二分类的线性分类模型,输入为实例的特征向量,输出为实例的类别(取+1和-1)。感知机对应于输入空间中将实例划分为两类的分离超平面。感知机旨在求出该超平面,为求得超平面导入了基于误分类的损失函数,...
  • 一种用于模式分类的多层感知机模型和学习算法,本文给出一种用于模式分类的多层感知器。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,945
精华内容 20,778
关键字:

感知机多分类