So Tired !_! 逆水行舟, 不进则退!

15May/19

格力空调红外遥控器编码详解

Posted by Nick Xu

可以用于制作格力红外遥控器,这里边有它的编码定义。
格力小王子

一、基本信息:
型号:YB0F2
采用脉冲间距调制。

 

图1:示波器获取波形

 

报头脉冲:9ms
报头间距:4.5ms
载波频率:37.9KHz(38KHz)
码段1与码段2间距:20ms
“1”:脉宽,656us。间距,1640us。
“0”:脉宽,656us。间距,544us。

 

二、编码信息:
1-3位:模式
  • 送风:
图标:风扇。代码:110
  • 自动:
图标:循环箭头。代码:000
  • 除湿:
图标:水滴。代码:010
  • 制冷:
图标:雪花。代码:100
  • 制热:
图标:太阳。代码:001
4位(加68位):开机关机
开机:1
关机:068位取反。
5-6位:风速
一级:10
二级:01
三级:11
自动:00
73741(加65位):扫风
上下扫风110。第65位取反
左右扫风:101
上下左右:111
无扫风:000
8位:睡眠
睡眠:1
不睡眠:0
9-12位与65-68位:温度
制冷模式下:
温度
9-12位
65-68位
30
0111
1000
29
1011
0000
28
0011
1111
27
1101
0111
26
0101
1011
25
1001
0011
24
0001
1101
23
1110
0101
22
0110
1001
21
1010
0001
20
0010
1110
19
1100
0110
18
0100
1010
17
1000
0010
16
0000
1100
制热模式:
温度
9-12位
65-68位
30
0111
0010
29
1011
1100
28
1101
0100
27
1101
1000
26
0101
0000
25
1001
1111
24
0001
0111
23
1110
1011
22
0110
0011
21
1010
1101
20
0010
0101
19
1100
1001
18
0100
0001
17
1000
1110
16
0000
0110
吸湿模式:
温度
9-12位
65-68位
30
0111
0100
29
1011
1000
28
0011
0000
27
1101
1111
26
0101
0111
25
1001
1011
24
0001
0011
23
1110
1101
22
0110
0101
21
1010
1001
20
0010
0001
19
1100
1110
18
0100
0110
17
1000
1010
16
0000
0010
送风模式:
温度
9-12位
65-68位
30
0111
1100
29
1011
0100
28
0011
1000
27
1101
0000
26
0101
1111
25
1001
0111
24
0001
1011
23
1110
0011
22
0110
1101
21
1010
0101
20
0010
1001
19
1100
0001
18
0100
1110
17
1000
0110
16
0000
1010
13-20位:睡眠定时
时间
13-20位
0.5
10010000
1
00011000
1.5
10011000
2
00010100
2.5
10010100
3
00011100
3.5
10011100
4
00010010
4.5
10010010
5
00011010
5.5
10011010
6
00010110
6.5
10010110
7
00011110
7.5
10011110
8
00010001
8.5
10010001
9
00011001
9.5
10011001
10
01010000
10.5
11010000
11
01011000
11.5
11011000
12
01010100
12.5
11010100
13
01011100
13.5
11011100
14
01010010
14.5
11010010
15
01011010
15.5
11011010
16
01010110
16.5
11010110
17
01011110
17.5
11011110
18
01010001
18.5
11010001
19
01011001
19.5
11011001
20
00110000
20.5
10110000
21
00111000
21.5
10111000
22
00110100
22.5
10110100
23
00111100
23.5
10111100
24
00110010
0
00000000
21位:超强
超强:1
普通:0
22位:灯光
亮:1
灭:0
23位与25位:健康,换气
健康:10
换气:01
健康+换气:11
普通:00
24位:制冷模式下-干燥;制热模式下-辅热;
干燥:1
普通:0
45-46位:显示温度
不显示:00
显示:10
显示室内温度:01
显示室外温度:11
其他位:
除了293134位为“1”外,均为“0。其他位功能不详(遥控器无对应项)。
36位和69位分别是码段1和码段2的最后一位,无所谓“0”“1”。
三、其他说明
自动模式下只可以设置的项目有:风速123级、自动;上上下左右扫风;显示温度;灯光;睡眠定时(非睡眠)。其他项均不可以设置。此时温度不可设置,温度段的代码为:10011101

 

关机状态下,可以设置定时开机,代码与睡眠定时关机一样。也可以设置灯光。
制冷模式下,可以设置的项有:温度;扫风;健康换气,节能(仅在此状态下可以设置);风速;定时;超强;睡眠;灯光;温度显示。
除湿模式下,可以设置的项有:温度;扫风;健康换气;干燥;温度显示;定时;睡;灯光。
送风模式下,可以设置的项有:温度;风速;健康换气;扫风;温度显示;定时;灯光。
制热模式下,可以设置的项有:温度;风速;扫风;辅热;温度显示;定时;超强;睡眠;灯光。

 


MGQ 2012-04-14
1、 格力YB0F2红外信号命令格式

红外信号主要包括CMD1和CMD2两部分,其中CMD1包括35 位的命令 和一位停止位,CMD2包括32位的命令和一位停止位。
表格 1 CMD1
Bit:1~3
4
5~6
7
8
模式
开关机(CMD2 32bit取反)
风速
是否扫风
是否睡眠
9~12
13~16
温度
睡眠1
17~20
21
22
23
24
睡眠2
超强
灯光
健康
干燥/辅热
25
26
27
28
29
30
31
32
换气
0
0
0
1
0
1
0
33
34
35
0
1
0

 

表格 2 CMD2
Bit:1
2
3
4
5
6
7
8
上下扫风
0
0
0
左右扫风
0
0
0
9~10
11
12
13
14
15
16
显示温度
0
0
0
0
0
0
17
18
19
20
21
22
23
24
0
0
0
0
0
0
0
0
25
26
27
28
29~32
0
0
0
0
温度

 

Filed under: 单片机 Comments Off
10May/19

深度学习:Keras入门(一)之基础篇

Posted by Nick Xu

1.关于Keras

1)简介

Keras是由纯python编写的基于theano/tensorflow的深度学习框架。

Keras是一个高层神经网络API,支持快速实验,能够把你的idea迅速转换为结果,如果有如下需求,可以优先选择Keras:

a)简易和快速的原型设计(keras具有高度模块化,极简,和可扩充特性)

b)支持CNN和RNN,或二者的结合

                c)无缝CPU和GPU切换

2)设计原则

a)用户友好:Keras是为人类而不是天顶星人设计的API。用户的使用体验始终是我们考虑的首要和中心内容。Keras遵循减少认知困难的最佳实践:Keras提供一致而简洁的API, 能够极大减少一般应用下用户的工作量,同时,Keras提供清晰和具有实践意义的bug反馈。

b)模块性:模型可理解为一个层的序列或数据的运算图,完全可配置的模块可以用最少的代价自由组合在一起。具体而言,网络层、损失函数、优化器、初始化策略、激活函数、正则化方法都是独立的模块,你可以使用它们来构建自己的模型。

c)易扩展性:添加新模块超级容易,只需要仿照现有的模块编写新的类或函数即可。创建新模块的便利性使得Keras更适合于先进的研究工作。

d)与Python协作:Keras没有单独的模型配置文件类型(作为对比,caffe有),模型由python代码描述,使其更紧凑和更易debug,并提供了扩展的便利性。

 

2.Keras的模块结构

 

3.使用Keras搭建一个神经网络

 

4.主要概念

1)符号计算

Keras的底层库使用Theano或TensorFlow,这两个库也称为Keras的后端。无论是Theano还是TensorFlow,都是一个“符号式”的库。符号计算首先定义各种变量,然后建立一个“计算图”,计算图规定了各个变量之间的计算关系。

符号计算也叫数据流图,其过程如下(gif图不好打开,所以用了静态图,数据是按图中黑色带箭头的线流动的):

2)张量

张量(tensor),可以看作是向量、矩阵的自然推广,用来表示广泛的数据类型。张量的阶数也叫维度。

0阶张量,即标量,是一个数。

1阶张量,即向量,一组有序排列的数

2阶张量,即矩阵,一组向量有序的排列起来

3阶张量,即立方体,一组矩阵上下排列起来

4阶张量......
依次类推

重点:关于维度的理解

假如有一个10长度的列表,那么我们横向看有10个数字,也可以叫做10维度,纵向看只能看到1个数字,那么就叫1维度。注意这个区别有助于理解Keras或者神经网络中计算时出现的维度问题。

3)数据格式(data_format)

目前主要有两种方式来表示张量:
a) th模式或channels_first模式,Theano和caffe使用此模式。
b)tf模式或channels_last模式,TensorFlow使用此模式。
下面举例说明两种模式的区别:
对于100张RGB3通道的16×32(高为16宽为32)彩色图,
th表示方式:(100,3,16,32)
tf表示方式:(100,16,32,3)
唯一的区别就是表示通道个数3的位置不一样。

4)模型

Keras有两种类型的模型,序贯模型(Sequential)和函数式模型(Model),函数式模型应用更为广泛,序贯模型是函数式模型的一种特殊情况。
a)序贯模型(Sequential):单输入单输出,一条路通到底,层与层之间只有相邻关系,没有跨层连接。这种模型编译速度快,操作也比较简单
b)函数式模型(Model):多输入多输出,层与层之间任意连接。这种模型编译速度慢。

 

5.第一个示例

这里也采用介绍神经网络时常用的一个例子:手写数字的识别。

在写代码之前,基于这个例子介绍一些概念,方便大家理解。

PS:可能是版本差异的问题,官网中的参数和示例中的参数是不一样的,官网中给出的参数少,并且有些参数支持,有些不支持。所以此例子去掉了不支持的参数,并且只介绍本例中用到的参数。

1)Dense(500,input_shape=(784,))

a)Dense层属于网络层-->常用层中的一个层

b) 500表示输出的维度,完整的输出表示:(*,500):即输出任意个500维的数据流。但是在参数中只写维度就可以了,比较具体输出多少个是有输入确定的。换个说法,Dense的输出其实是个N×500的矩阵。

c)input_shape(784,) 表示输入维度是784(28×28,后面具体介绍为什么),完整的输入表示:(*,784):即输入N个784维度的数据

2)Activation('tanh')

a)Activation:激活层

b)'tanh' :激活函数

3)Dropout(0.5)

在训练过程中每次更新参数时随机断开一定百分比(rate)的输入神经元,防止过拟合。

4)数据集

数据集包括60000张28×28的训练集和10000张28×28的测试集及其对应的目标数字。如果完全按照上述数据格式表述,以tensorflow作为后端应该是(60000,28,28,3),因为示例中采用了mnist.load_data()获取数据集,所以已经判断使用了tensorflow作为后端,因此数据集就变成了(60000,28,28),那么input_shape(784,)应该是input_shape(28,28,)才对,但是在这个示例中这么写是不对的,需要转换成(60000,784),才可以。为什么需要转换呢?

如上图,训练集(60000,28,28)作为输入,就相当于一个立方体,而输入层从当前角度看就是一个平面,立方体的数据流怎么进入平面的输入层进行计算呢?所以需要进行黄色箭头所示的变换,然后才进入输入层进行后续计算。至于从28*28变换成784之后输入层如何处理,就不需要我们关心了。(喜欢钻研的同学可以去研究下源代码)。

并且,Keras中输入多为(nb_samples, input_dim)的形式:即(样本数量,输入维度)。

5)示例代码

from keras.models import Sequential  
from keras.layers.core import Dense, Dropout, Activation  
from keras.optimizers import SGD  
from keras.datasets import mnist  
import numpy 
'''
    第一步:选择模型
'''
model = Sequential()
'''
   第二步:构建网络层
'''
model.add(Dense(500,input_shape=(784,))) # 输入层,28*28=784  
model.add(Activation('tanh')) # 激活函数是tanh  
model.add(Dropout(0.5)) # 采用50%的dropout

model.add(Dense(500)) # 隐藏层节点500个  
model.add(Activation('tanh'))  
model.add(Dropout(0.5))

model.add(Dense(10)) # 输出结果是10个类别,所以维度是10  
model.add(Activation('softmax')) # 最后一层用softmax作为激活函数

'''
   第三步:编译
'''
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # 优化函数,设定学习率(lr)等参数  
model.compile(loss='categorical_crossentropy', optimizer=sgd, class_mode='categorical') # 使用交叉熵作为loss函数

'''
   第四步:训练
   .fit的一些参数
   batch_size:对总的样本数进行分组,每组包含的样本数量
   epochs :训练次数
   shuffle:是否把数据随机打乱之后再进行训练
   validation_split:拿出百分之多少用来做交叉验证
   verbose:屏显模式 0:不输出  1:输出进度  2:输出每次的训练结果
'''
(X_train, y_train), (X_test, y_test) = mnist.load_data() # 使用Keras自带的mnist工具读取数据(第一次需要联网)
# 由于mist的输入数据维度是(num, 28, 28),这里需要把后面的维度直接拼起来变成784维  
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1] * X_train.shape[2]) 
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1] * X_test.shape[2])  
Y_train = (numpy.arange(10) == y_train[:, None]).astype(int) 
Y_test = (numpy.arange(10) == y_test[:, None]).astype(int)

model.fit(X_train,Y_train,batch_size=200,epochs=50,shuffle=True,verbose=0,validation_split=0.3)
model.evaluate(X_test, Y_test, batch_size=200, verbose=0)

'''
    第五步:输出
'''
print("test set")
scores = model.evaluate(X_test,Y_test,batch_size=200,verbose=0)
print("")
print("The test loss is %f" % scores)
result = model.predict(X_test,batch_size=200,verbose=0)

result_max = numpy.argmax(result, axis = 1)
test_max = numpy.argmax(Y_test, axis = 1)

result_bool = numpy.equal(result_max, test_max)
true_num = numpy.sum(result_bool)
print("")
print("The accuracy of the model is %f" % (true_num/len(result_bool)))

 

Tagged as: Comments Off
8May/19

小白学CNN以及Keras的速成

Posted by Nick Xu

一、为何要用Keras

如今在深度学习大火的时候,第三方工具也层出不穷,比较出名的有Tensorflow,Caffe,Theano,MXNet,在如此多的第三方框架中频繁的更换无疑是很低效的,只要你能够好好掌握其中一个框架,熟悉其原理,那么之后因为各种要求你想要更换框架也是很容易的。

那么sherlock用的是哪个框架呢?sherlock使用的是Google的开源框架Tensorflow,因为Google开源了tensorflow之后其社区非常活跃,而且版本更新也非常稳定,所以我就选择了这个框架。对于框架之争,在知乎上已经有很多人在撕逼了,这个就好比哪种编程语言好这个问题一样。对于我们来讲,选择一个稳定的框架,好好的学习deep learning才是重中之重,对于哪种框架更好的问题,我们学好之后自然有自己的见解,所以前期切忌在刷知乎听完大神撕逼之后频繁更换框架。

对于Tensorflow的安装,以及CPU和GPU版本,各种系统的安装网上已经有很多人详细的写过攻略了,可以自己去网上搜一搜,很容易就可以安装成功。

选择了Tensorflow之后,我们就可以愉快的开始我们的深度学习之旅了。去Tensorflow的中文社区,可以看到有一些新手教程,网上也有很多学习材料,推荐看看stanford大学cs224d的课件,http://cs224d.stanford.edu/lectures/CS224d-Lecture7.pdf, 很详细的介绍了tensorflow。然后你就可以写tensorflow的程序了。虽然说tensorflow已经是一个封装好的框架,但是你发现你写一个简单的神经网络也需要很多行才能够写完,这个时候,就有很多的第三方插架来帮助你写网络,也就是说你用tensorflow要写10行,第三方插架帮你封装了一个函数,就是把这10行集合在这个函数里面,那么你用1行,传入相同的参数,就能够达到10行相同的效果,如此简便并且节约时间,可以帮助很快的实现我们的想法。

Keras Documentation 就是Keras的官方文档,里面可以查阅所有的函数,并且可以在github上看他的开源代码,非常方便。安装也很简单,打开终端,输入pip install keras 就可以等待安装了。

下面就给一个简单的例子,来看一看Keras到底有多简单。

from keras.models import Sequential
model = Sequential()

引入sequential,这个就是一个空的网络结构,并且这个结构是一个顺序的序列,所以叫Sequential,Keras里面还有一些其他的网络结构。

from keras.layers import Dense, Activation

model.add(Dense(units=64, input_dim=100))

model.add(Activation('relu'))

model.add(Dense(units=10))

model.add(Activation('softmax'))

可以看到加入层很简单,只需要写.add,后面是要加的层的类型。

model.compile(loss='categorical_crossentropy',

optimizer='sgd',

metrics=['accuracy'])

一旦你写好了网络之后,就可以用compile编译整个网络,看参数设置有没有问题

model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

你也可以自定义其中的优化函数,就像上面这样,’sgd’是Keras已经写好了一些默认参数的优化函数,你可以自己重新定义参数,得到一个优化函数。

model.fit(x_train,y_train,epochs=5,batch_size=32)

这个就像scikit-learn一样训练模型。

loss_and_metrics=model.evaluate(x_test,y_test,batch_size=128)

这个就是评估训练结果。

classes=model.predict(x_test,batch_size=128)

或者是通过predict进行预测。

看了上面的代码,相信很多熟悉scikit-learn的同学都很亲切,因为确实很简便,跟scikit-learn也有着类似的语法。

二、开始学习CNN

在理解CNN之前,我们有必要先理解一下什么是神经网络,这样才能开始了解更高级的卷积神经网络。

要学习神经网络当然有很多途径,网上不少的大牛写了很多攻略,有的推崇从理论到工程完成深度学习,有的希望从工程出发发现问题,解决问题。各种各样的方式都有不同的人去尝试,攻略也是一大推,这使得不少的小白直接倒在了选择材料的路上,一直在补先修知识,待到热情结束就放弃了学习,连卷积网络都不知道是什么,大大地打击了大家的学习热情。今天,sherlock在这里给大家推荐一个学习材料,保证你能够快速入门cnn,出去装逼也能够和别人聊几句。

这个材料是什么呢,就是大名鼎鼎的standford的cs231n这门课程。 CS231n Convolutional Neural Networks for Visual Recognition  stanford大学确实算是深度学习和人工智能领域非常牛逼的学校。

神经网络

废话不多说,开始学习我们的神经网络。

小白学CNN以及Keras的速成

这是一张脑神经的图片,神经网络的发明也是由此开始的,这就是所谓的一个神经元,上面有各种接受突触,然后通过一个脑神经来接受,最后得到输出的结果。

那么由这张脑神经图能够抽象出来的神经网络是什么呢?就是下面这个神经网络模型。

小白学CNN以及Keras的速成

这个怎么理解呢?就是输入一个向量,然后给向量的每一个元素分配一个权重,然后通过权重求和得到一个结果,然后将这个结果输入一个激活函数,得到最后的输出结果。

激活函数又是什么鬼?激活函数的出现是因为人脑的构造,人脑里面接受信息得到结果这个过程是非线性的,比如你看到一样东西,你不可能保留这个东西的全部特征,你会重点观察你感兴趣的地方,这就是非线性的,也就是说需要一个非线性变化将输入的结果变换为非线性的结果。现在常用的非线性函数就是Relu(x) = max(x, 0),就是将小于0的部分去掉,只保留大于0的部分。

这就是单元的输入和输出,将这些单元合在一起就是一个神经网络。

小白学CNN以及Keras的速成

这就是简单的一层网络,也可以由多层网络

小白学CNN以及Keras的速成

这里面的input layer就是所谓的单个训练集的维数,将所有的训练集输入就可以开始训练一个神经网络。

Keras实现简单的神经网络

知道了神经网络的基本结构和原理,我们就可以开始使用keras去实现一个简单的神经网络。

import keras

from keras.models import Sequential

from keras.layers import Dense

import numpy as np

导入必要的package

x=np.array([[0,1,0],[0,0,1],[1,3,2],[3,2,1]])

y=np.array([0,0,1,1]).T

设定输入的x和y

simple_model=Sequential()

simple_model.add(Dense(5,input_shape=(x.shape[1],),activation='relu',name='layer1'))

simple_model.add(Dense(4,activation='relu',name='layer2'))

simple_model.add(Dense(1,activation='sigmoid',name='layer3'))

输入一个三层的神经网络,中间的hidden layer的元素个数是5和4,最后一层输出一个结果

simple_model.compile(optimizer='sgd',loss='mean_squared_error')

complie这个简单的模型

simple_model.fit(x,y,epochs=20000)

训练20000次模型

simple_model.predict(x[0:1])

可以预测一下第一个输入的x的结果与实际的是否相符。

上面就是一个简单三层网络的keras实现,接下来我们将正式进入Convolutional Neural Network

三、Convolutional Neural Network

前面给大家推荐了一门好课cs231n,本篇文章也是按照这个思路来的。

基本结构

首先解释一下什么是卷积,这个卷积当然不是数学上的卷积,这里的卷积其实表示的是一个三维的权重,这么解释起来可能不太理解,我们先看看卷积网络的基本结构。

小白学CNN以及Keras的速成

通过上面的图我们清楚地了解到卷积网络和一般网络结构上面的差别,也可以理解为卷积网络是立体的,而一般的网络结构是平面的。

卷积层

了解完了基本的结构之后,我们就要了解cnn最重要的一个部分,也是最为创新的一个部分,卷积层。首先用一张图片来比较一下卷积网络到底创新在什么地方。

小白学CNN以及Keras的速成

我们通过这个结构就可以清晰地看到卷积网络到底是怎么实现的。首先右边是传统的网络结构,在前面我们已经详细的解释过了。而左边的图片,我们首先看看图中最左边的结构,你肯定会好奇为什么是32x32x3的一块立体方块。这个32x32代表的是像素点,说白了也就是图片的大小,这个大小是你可以设置的,你可以设置为50x50,也可以是256x256,这都取决与图片的大小,那么3表示什么呢?3其实表示的是RGB的三个通道,RGB也是什么?RGB表示red,green,blue,这三种颜色的各种组合叠加可以形成各种各样的颜色,所以任何一张照片都可以用左边这种图形来表示。

那么中间这个小方块又表示什么呢?这个就是我们要重点讲的卷积。所谓的卷积,就是这种小方块,我们设置一个小方块的大小,但是这个小方块的厚度必须和左边的这个大方块的厚度是一样的,大方块每一个像素点由一个0到255的数字表示,这样我们就可以赋予小方块权重,比如我们取小方块的大小是3x3,我们要求厚度必须要和左边的大方块厚度一样,那么小方块的的大小就为3x3x3,我们就可以赋予其3x3x3个权重,然后我们就可以开始计算卷积的结果,将小方块从大方块的左上角开始,一个卷积小方块所覆盖的范围是3x3x3,然后我们将大方块中3x3x3的数字和小方块中的权重分别相乘相加,再加上一个偏差,就可以得到一个卷积的结果,可以抽象的写成Wx+b这种形式,这就是图上所显示的结果,然后我们可以设置小方块的滑动距离,每次滑动就可以形成一个卷积的计算结果,然后将整张大图片滑动覆盖之后就可以形成一层卷积的结果,我们看到图中的卷积结果是很厚的,也就是设置了很多层卷积。总结来说,每层卷积就是一个卷积核在图片上滑动求值,然后设置多个卷积核就可以形成多层的卷积层。

池化层

讲完卷积层,接下来就要讲一下池化层。为什么会有池化层的出现呢?是因为不断的做卷积,得到的中间结果会越来越厚,卷积就相当于提取图片中的特征,所以卷积层一般会设置得越来越厚,不然你就无法从前面的结果来提取更多的特征。这样就会导致中间的结果会越来越大,计算会越来越慢,所以提出了池化层。

所谓的池化层,就是将图片的大小缩小的一种处理方式。我们可以先看看下面的图片。

小白学CNN以及Keras的速成

通过这个图片,我们可以清楚地看到池化层是怎么处理的。池化层也是需要先设置一个窗口,但是这个小窗口的厚度是1,而不再是前一层输出的结果的厚度。然后有两种处理方式,一种是取这个小窗口里面所有元素的最大值来代表这个小窗口,一种是取平均值,然后将小窗口滑动,在第二的位置再做同样的处理,上层网络输出方块的每一层做完之后就进入这个大方块的下一层做同样的操作,这个处理办法就可以让整个大方块的大小变小,可以看看上面的图片的左边。右边是一个简单的一层厚度,取最大值的例子。

实现Lenet

讲完了卷积网络的基本结构之后,你是不是已经迫不及待希望能够实现一个简单的神经网络了呢?卷积网络发展的特别迅速,最早是由Lecun提出来的,Lenet成为cnn的鼻祖,接下来他的学生Alex提出了层数更深的Alexnet,然后2013年又提出了VGGnet,有16层和19层两种,这些都只是在层数上面的加深,并没有什么其他的创新,而之后google提出了inception net在网络结构上实现了创新,提出了一种inception的机构,facebook ai 实验室又提出了resnet,残差网络,实现了150层的网络结构可训练化,这些我们之后会慢慢讲到。

接下来我们就来实现一下最简单的Lenet,使用mnist手写子体作为训练集。

import keras

from keras.datasets import mnist

(x_train, y_train), (x_test,y_test) =mnist.load_data()

导入必要的库和数据集

x_train=x_train.reshape(-1,28,28,1)

x_test=x_test.reshape(-1,28,28,1)

x_train=x_train/255.

x_test=x_test/255.

y_train=keras.utils.to_categorical(y_train)

y_test=keras.utils.to_categorical(y_test)

处理数据,让数据的shape是(28, 28, 1),然后label做一个one-hot encoding处理,比如类别是3,那么变成[0, 0, 1 ,0, 0, 0, 0, 0, 0, 0]。

from keras.layers import Conv2D,MaxPool2D,Dense,Flatten

from keras.models import Sequential

lenet=Sequential()

lenet.add(Conv2D(6,kernel_size=3,strides=1,padding='same',input_shape=(28, 28, 1)))

lenet.add(MaxPool2D(pool_size=2,strides=2))

lenet.add(Conv2D(16,kernel_size=5,strides=1,padding='valid'))

lenet.add(MaxPool2D(pool_size=2,strides=2))

lenet.add(Flatten())

lenet.add(Dense(120))

lenet.add(Dense(84))

lenet.add(Dense(10,activation='softmax'))

构建lenet

小白学CNN以及Keras的速成

lenet.compile('sgd',loss='categorical_crossentropy',metrics=['accuracy'])

编译

lenet.fit(x_train,y_train,batch_size=64,epochs=50,validation_data=[x_test,y_test])

训练50次,得到结果如下

小白学CNN以及Keras的速成

lenet.save('myletnet.h5')

可以保存训练好的模型

总结

OK, 这就是我们写的一个超级简单的Lenet,训练50次得到的训练准确率已经达到0.9939,测试准确率达到0.9852。

欢迎关注我的知乎专栏,深度炼丹

欢迎关注我的github主页

欢迎访问我的博客

这篇文章的代码都已传到了github上
SherlockLiao/lenet

Tagged as: , Comments Off
   
site
site