ApacheCN_深度学习_感知器

写在前面

1.关于深度学习。目前自己的水平是项目需求在Ubuntu 中搭建Keras，完成了图像的分类使用基础的VGG16,CFAR,ResNet，得到的效果是很惊人的，相对于常规的算法，优势很明显

2.关于ApacheCN。一帮有热情的年轻人组织的知识交流社区，很多人入门都是从这里开始的，安利一下组织的大门ApacheCN

3.关于参与组织活动。严格自律，时间安排更加合理，抱紧组织大腿。

废话不多说，开怼。

深度学习

我记得有这样一道面试题，用最快的时间给你的家人解释什么是深度学习?看着简答说着难，个人想法是说清楚深度学习的几个要素。

1.举个例子。让机器从经验中学习，就像堆积木，不同的层数构建，通过让电脑学习人的神经元传递方式，去完成层次很多的知识，就是一种深度学习；

2.深度学习是机器学习的子集；

3.深度学习是学的很深，学到不是原来的知识形状。

感知器 or 感知机

刚刚拿到这个词，我想到的是感知机是不是一个概念。。。

西瓜书对感知机的定义是由两层神经元组成，输入层接收外界输入信息后传递给输出层，输出层是M-P神经元，亦称“阈值逻辑单元”。

感知器是就是单个的神经元。一个感知器由3部分组成输入权值，激活函数，输出三部分组成。所以两者在描述的就是这样的结构。百度百科也表示这就是一个概念。感知器也是人工神经网络的第一个里程碑，它的核心功能是做决策的，一个感知机其实是对神经元的最基本概念模拟。

比如说你要决定今天出不出去看电影，你要考虑3个因素，一个是女朋友在不在，一个是电影好不好看，另一个是今天有没有工作，这三个因素每个人的权重都不同，有的人看重女朋友，有的人看重工作，所以权重就不等， 最后每个人根据自己的权重做出0或1，去或不去，to be or not to be的决策。那么你怎么做呢？你把三个要素按照它们需要的权重加和在一起， 在把这个分数送到一个叫sigmoid的门面前得到去或不去的决定， 工作原理如上图。

比单层感知机更复杂的多层感知机-或者我们常说的深度网络，是进行数据处理和模式识别的利器。 深度神经网络之所以能够处理这些数据类型，主要是因为这些数据本身具有的复杂结构很适合被NN识别，而人类不需要预先设计识别这些结构的函数而是任由网络学习， D-CNN 深度卷积网络能够同时看到一个图像从细节到抽象的结构，所以能够抓住一些我们人类都说不出的细节。

感知机的作用

在蓝皮书上，感知机是根据输入示例的特征向量x对其进行二分类的线性分类模型：

    

感知机模对应输入空间中的分离超平面w·x+b=0

感知机的学习的策略是极小化损失函数：

损失函数对应于误分类点到分离超平面的总距离。

感知机学习算法实际图随机梯度下降的对损失函数最优化算法，有原始形式和对偶形式。算法比较容易实现。

1.首先任意选取一个超平面

2.用梯度下降法不断极小化目标函数，随机选一个误分类点使其梯度下降。

感知器的作用

从最基础的说起，感知器是一个'Yes' or 'No'的工具，可以用来拟合任意线性函数，这样就可以用来处理分类和回归问题。但是感知器不能实现异或的功能。核心是记住在目标平面的权重项w和便置项b的迭代规则

wi是与输入xi对应的权重项，b是偏置项。事实上，可以b看作是值永远为1的输入xb所对应的权重。t是训练样本的实际值，一般称之为label。而y是感知器的输出值，也就是感知器觉得是对的值，它是根据公式(1)计算得出。eta是一个称为学习速率的常数，其作用是控制每一步调整权的幅度。

每次从训练数据中取出一个样本的输入向量x，使用感知器计算其对应y，再根据上面的规则来调整权重。每处理一个样本就调整一次权重。经过多轮迭代后，就可以训练出感知器的权重，使之实现目标函数。

实现代码

代码来自hatemath大佬，博客很优秀，代码很优秀，以下部分为大佬的代码内容自己实现了一遍，很清爽。hatemath

# -*- coding: utf-8 -*-
"""
Created on Fri Mar 23 15:36:21 2018

@author: EWilsen
"""
#coding=utf-8

from functools import reduce  # for py3

class Perceptron(object):
    def __init__(self, input_num, activator):
        '''
        初始化感知器，设置输入参数的个数，以及激活函数。
        激活函数的类型为double -> double
        '''
        self.activator = activator
        # 权重向量初始化为0
        self.weights = [0.0 for _ in range(input_num)]
        # 偏置项初始化为0
        self.bias = 0.0
    def __str__(self):
        '''
        打印学习到的权重、偏置项
        '''
        return 'weights\t:%s\nbias\t:%f\n' % (self.weights, self.bias)


    def predict(self, input_vec):
        '''
        输入向量，输出感知器的计算结果
        '''
        # 把input_vec[x1,x2,x3...]和weights[w1,w2,w3,...]打包在一起
        # 变成[(x1,w1),(x2,w2),(x3,w3),...]
        # 然后利用map函数计算[x1*w1, x2*w2, x3*w3]
        # 最后利用reduce求和

        #list1 = list(self.weights)
        #print ("predict self.weights:", list1)

        
        return self.activator(
            reduce(lambda a, b: a + b,
                   list(map(lambda tp: tp[0] * tp[1],   # HateMath修改
                       zip(input_vec, self.weights)))
                , 0.0) + self.bias)
    def train(self, input_vecs, labels, iteration, rate):
        '''
        输入训练数据：一组向量、与每个向量对应的label；以及训练轮数、学习率
        '''
        for i in range(iteration):
            self._one_iteration(input_vecs, labels, rate)

    def _one_iteration(self, input_vecs, labels, rate):
        '''
        一次迭代，把所有的训练数据过一遍
        '''
        # 把输入和输出打包在一起，成为样本的列表[(input_vec, label), ...]
        # 而每个训练样本是(input_vec, label)
        samples = zip(input_vecs, labels)
        # 对每个样本，按照感知器规则更新权重
        for (input_vec, label) in samples:
            # 计算感知器在当前权重下的输出
            output = self.predict(input_vec)
            # 更新权重
            self._update_weights(input_vec, output, label, rate)

    def _update_weights(self, input_vec, output, label, rate):
        '''
        按照感知器规则更新权重
        '''
        # 把input_vec[x1,x2,x3,...]和weights[w1,w2,w3,...]打包在一起
        # 变成[(x1,w1),(x2,w2),(x3,w3),...]
        # 然后利用感知器规则更新权重
        delta = label - output
        self.weights = list(map( lambda tp: tp[1] + rate * delta * tp[0], zip(input_vec, self.weights)) ) # HateMath修改

        # 更新bias
        self.bias += rate * delta

        print("_update_weights() -------------")
        print("label - output = delta:" ,label, output, delta)
        print("weights ", self.weights)
        print("bias", self.bias)
 




def f(x):
    '''
    定义激活函数f
    '''
    return 1 if x > 0 else 0

def get_training_dataset():
    '''
    基于and真值表构建训练数据
    '''
    # 构建训练数据
    # 输入向量列表
    input_vecs = [[1,1], [0,0], [1,0], [0,1]]
    # 期望的输出列表，注意要与输入一一对应
    # [1,1] -> 1, [0,0] -> 0, [1,0] -> 0, [0,1] -> 0
    labels = [1, 0, 0, 0]
    return input_vecs, labels 
    
def train_and_perceptron():
    '''
    使用and真值表训练感知器
    '''
    # 创建感知器，输入参数个数为2（因为and是二元函数），激活函数为f
    p = Perceptron(2, f)
    # 训练，迭代10轮, 学习速率为0.1
    input_vecs, labels = get_training_dataset()
    p.train(input_vecs, labels, 10, 0.1)
    #返回训练好的感知器
    return p

if __name__ == '__main__': 
    # 训练and感知器
    and_perception = train_and_perceptron()
    # 打印训练获得的权重

    # 测试
    print (and_perception)
    print ('1 and 1 = %d' % and_perception.predict([1, 1]))
    print ('0 and 0 = %d' % and_perception.predict([0, 0]))
    print ('1 and 0 = %d' % and_perception.predict([1, 0]))
    print ('0 and 1 = %d' % and_perception.predict([0, 1]))

从py2改成py3的调试经过：

1. lambda表达式的使用

第38和第70行中，原适用于Python2.7的代码无法正常运行，提示 invalid syntax。貌似是Python3中，在lambda表达式中使用元组的方式和Python2.7不一样。

我改了一下代码，语法问题没有了，可是预测结果不正常。于是就打印map()函数的返回值，试图调试。

 

2. 打印map()函数返回的对象

参见 https://www.cnblogs.com/lyy-totoro/p/7018597.html 的代码，先转为list再打印。

 list1 = list(data)

print(list1)

 打印输出表明，训练的值明显不对，到底是哪里的问题？

 

3. 真相【小】白

https://segmentfault.com/a/1190000000322433

关键句：在Python3中，如果不在map函数前加上list，lambda函数根本就不会执行。

于是加上list，就变成了最终的代码，工作正常。

只是“lambda函数根本就不会执行”这句，我没考证过，所以说真相小白。