深度学习入门（一），从Keras开始

import tensorflow as tf
import keras
print(tf.__version__)
print(keras.__version__)

Using TensorFlow backend.
1.2.1
2.1.6

    目前主要有两种方式来表示张量：
    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的位置不一样。

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

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

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

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

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

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

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

完整代码：
#1. 导入相关的Python和Keras的模块（module）
import numpy as np
np.random.seed(1337)
from keras.models import Sequential
from keras.layers import Dense


import matplotlib.pyplot as plt



# 1.Build the trainning data
X=np.linspace(-1,1,200)
np.random.shuffle(X)
np.random.normal()
Y=0.5*X+2+np.random.normal(0,0.05,(200,))
plt.scatter(X,Y)
plt.show()
X_train,Y_train=X[:160],Y[:160]
X_test,Y_test=X[160:],Y[160:]
print(X)
print("*******************************************")
print(Y)
# 2.Build a neural network from the 1st layer to the last layer
model=Sequential()
model.add(Dense(output_dim=1,input_dim=1))

#3. Choose loss function and optimzing method
model.compile(loss='mse',optimizer='sgd')


#4. Trainning
print("Training......")
for step in range(1400):
        cost=model.train_on_batch(X_train,Y_train)
        if step % 100 ==0:
                print('train cost',cost)


#5.Test
print("\n Testing...........")
cost=model.evaluate(X_test,Y_test,batch_size=40)
print("Test cost:",cost)
W,b=model.layers[0].get_weights()
print('Weight=',W,"\nbiases=",b)

#6.Plotting the prediction
Y_pred=model.predict(X_test)
plt.scatter(X_test,Y_test)
plt.plot(X_test,Y_pred)
plt.show()

train cost 4.0281153
train cost 0.080740646
train cost 0.0058854916
train cost 0.0031687208
train cost 0.002764651
train cost 0.0026669714
train cost 0.00264223
train cost 0.0026359423
train cost 0.0026343435
train cost 0.002633939
train cost 0.0026338336
train cost 0.002633807
train cost 0.002633801
train cost 0.0026337993

 Testing...........

40/40 [==============================] - 0s 175us/step
Test cost: 0.0033766974229365587
Weight= [[0.5063296]] 
biases= [2.0042796]

# 1.Build the trainning data  
X=np.linspace(-1,1,200)  
np.random.shuffle(X)  
np.random.normal()  
Y=0.5*X+2+np.random.normal(0,0.05,(200,))  
plt.scatter(X,Y)  
plt.show()  
X_train,Y_train=X[:160],Y[:160]  
X_test,Y_test=X[160:],Y[160:]  
print(X)  
print("*******************************************")  
print(Y)  

# 2.Build a neural network from the 1st layer to the last layer  
model=Sequential()  
model.add(Dense(output_dim=1,input_dim=1))  

#3. Choose loss function and optimzing method  
model.compile(loss='mse',optimizer='sgd')  

mean_squared_error
mean_absolute_error
mean_absolute_percentage_error
mean_squared_logarithmic_error
squared_hinge
hinge
logcosh
categorical_crossentropy
sparse_categorical_crossentropy
binary_crossentropy
kullback_leibler_divergence
poisson
cosine_proximity

RMSprop
Adagrad
Adadelta
Adam
Adamax
Nadam
TFOptimizer

#4. Trainning  
print("Training......")  
for step in range(1400):  
        cost=model.train_on_batch(X_train,Y_train)  
        if step % 100 ==0:  
                print('train cost',cost)  

#5.Test  
print("\n Testing...........")  
cost=model.evaluate(X_test,Y_test,batch_size=40)  
print("Test cost:",cost)  
W,b=model.layers[0].get_weights()  
print('Weight=',W,"\nbiases=",b)  

#6.Plotting the prediction  
Y_pred=model.predict(X_test)  
plt.scatter(X_test,Y_test)  
plt.plot(X_test,Y_pred)  
plt.show()  

"""
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)))