[Deep Learning]——感知机Perceptron (PyTorch)

 1) 感知机的定义是什么？ 

感知机(perceptron)是二分类的线性分类模型，其输入为实例的特征向量，输出为实例的类别。

2) 感知机的取值是什么？

取+1和-1二值。

3) 感知机对应于输入空间(特征空间)中的什么？

感知机对应于输入空间中将实例划分为正负两类的分离超平面，属于判别模型。

4) 感知机学习的目的是什么？

感知机学习旨在求出将训练数据进行线性划分的分离超平面，为此，导入基于误分类的损失函数，利用梯度下降法对损失函数进行极小化，求得感知机模型。

5) 感知机学习算法有什么特点？

感知机学习算法具有简单，并且易于实现的特点，分为原始形式和对偶形式。

6) 什么是感知机预测？

感知机预测是用学习得到的感知机模型对新的输入实例进行分类。它是神经网络与支持向量机的基础。

基础感知机的实现：

1、与门方式实现

该方式主要是模拟与门的逻辑去实现，设置一个阈值，小于阈值则为0， 大于则为1

import torch

#与门思路设计
def AND(x1, x2):
    w1, w2, theta = 0.5, 0.5, 0.7
    temp = x1*w1 + x2*w2
    if temp <= theta:
        return 0
    elif temp > theta:
        return 1

if __name__ == '__main__':
    print(AND(0, 0))
    print(AND(0, 1))
    print(AND(1, 1))

2、导入权重和偏置

此时需满足： 1：w1*x1+w2*x2+b <=0，0：w1*x1+w2*x2+b >0

• 其中，b是偏置，也即调整神经元被激活的容易程度的参数
• w1和w2是权重 ，也即控制输入信号的重要性的参数

import torch
import numpy as np

#与门思路设计,加入偏置
def AND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([.5, .5])
    b = -0.7
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    elif tmp > 0:
        return 1

if __name__ == '__main__':
    print(AND(0, 0))
    print(AND(0, 1))
    print(AND(1, 1))

3、与非门、或门实现方式

import torch
import numpy as np

#与非门实现感知机
# 1 1为0，其余均为1
def NAND(x1, x2):
    x = np.array([x1, x2])
    w = np.array(([-0.5, -0.5])) #仅偏执和权重不一样
    b = 0.7
    temp = np.sum(w*x) + b
    if temp <= 0:
        return 0
    elif temp > 0:
        return 1

#或门实现感知机
def OR(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.2
    #np.sum()对序列进行求和
    temp = np.sum(w*x) + b
    if temp <= 0:
        return 0
    elif temp > 0:
        return 1


if __name__ == '__main__':
    print(NAND(0, 0))
    print(NAND(1, 1))
    print(OR(1, 1))

 

一、单层感知机

import torch
from torch.nn import functional as F

#单层感知机
#10维度
def test():
    x = torch.randn(1, 10)
    w = torch.randn(1, 10, requires_grad=True)
    o = torch.sigmoid([email protected]())
    print(o.shape)

    #loss
    loss = F.mse_loss(torch.ones(1, 1), o)
    print(loss.shape)
    loss.backward()
    print(w.grad)

if __name__ == '__main__':
    test()

 二、多层感知机（Multi-output Perceptron）

求导：

只与对应的输入节点和 O有关系

import torch
from torch.nn import functional as F

#多层感知机
#10dim -> 2dim
def test():
    x = torch.randn(1, 10)
    w = torch.randn(2, 10, requires_grad=True)
    o = torch.sigmoid([email protected]())
    print(o.shape)

    #loss
    loss = F.mse_loss(torch.ones(1, 2), o)
    print(loss)
    #get gradient
    loss.backward()
    print(w.grad)

if __name__ == '__main__':
    test()

 三、链式法则

import torch
from torch.nn import functional as F

#链式求导
def test():
    x = torch.tensor(1.)
    w1 = torch.tensor(2., requires_grad=True)
    b1 = torch.tensor(1.)
    w2 = torch.tensor(2., requires_grad=True)
    b2 = torch.tensor(1.)

    #定义函数
    y1 = x*w1 + b1
    y2 = y1*w2 + b2
    #y2对y1求导
    dy2_dy1 = torch.autograd.grad(y2, [y1], retain_graph=True)[0]
    print(torch.autograd.grad(y2, [y1], retain_graph=True))
    dy1_dw1 = torch.autograd.grad(y1, [w1], retain_graph=True)[0]
    #直接使用自动求导工具算 y2对w1求导
    dy2_dw1 = torch.autograd.grad(y2, [w1], retain_graph=True)[0]
    print("autograd dy2 / dw1： {0}".format(dy2_dw1))

    #使用公式法求解
    print("manual dy2 / dw1： {0}".format(dy2_dy1*dy1_dw1))


if __name__ == '__main__':
    test()