神经网络Keras

Keras

Keras 是一个Python深度学习框架，可以方便的定义和训练几乎所有类型的深度学习模型。Keras 最开始是为研究人员开发的，其目的在于快速实验。
Keras 重要特性
相同的代码可以在CPU或GPU上无缝切换运行。具有用户友好的API，便于快速开发深度学习模型的原理。内置支持卷积网络（用于计算机视觉）、循环网络（用于序列处理）以及二者的任意组合。
支持任意架构网络：多输入或多层输出模型、层共享、模型共享等。这也就是说，Keras能够构建任意深度学习模型。
Keras基于宽松的MIT许可证办法，这意味着可以在商业项目中免费使用它，它于所有的Python版本都兼容。

Keras的广泛度

Keras已有200 000多个用户。 Google, Netflix, Uber, CERN, Yelp, Square以及上百家创业公司都在用。
Keras还是机器学习竞赛网站Kaggle上的热门框架，最新的深度学习竞赛中，几乎所有的优胜者用的都是Keras模型。

Keras架构

Keras是一个模型级（model-level）的库，为开发深度学习模型提供了高层次的构建模块。
它依赖于一个专门的、高度优化的张量库来完成这些运算，这个张量库就是Keras的后端引擎（backend Engine）。
Keras没有选择单个张量库并将Keras实现与这个库绑定，而是以模块化的方式处理这个问题
目前，Keras有三个后端实现：Tensorflow，Theano和微软认知工具包（CNTK，Microsoft cognitive toolkit）

Keras工作流

（1）定义训练数据：输入张量和目标张量
（2）定义层组成的网络（或模型），将输入映射到目标
（3）配置学习过程：选择损失函数、优化器和需要监控的指标
（4）调用模型的fit方法在训练数据上进行迭代
定义模型有两种方法：
一种是使用Sequential类（仅用于层的线性堆叠，这是目前最常见的网络架构）
另一种是函数式API（functional API，用于层组成的有向无环图，让你可以构建任意形式的架构）

Keras的编译和训练

Keras的编译：也就是配置学习过程，这里你可以指定模型使用的优化器和损失函数，以及训练过程中想要监控的指标。
Keras的训练：通过 fit() 方法将输入数据的Numpy数组（和对应的目标数据）传入模型，这一做法和Scikit-Learn及其他机器学习库类似。

序列模型

序列模型的数学符号定义
x: 我一进门，就看见常威在打来福
Y: x<1> , x<2> , , , x<14>

什么是循环神经网络。

循环神经网络的前向传播的简化

循环神经网络的反向传播：穿越时间

如何用RNN构建语言模型和序列生成
语言模型做的基本工作就是，输入一个句子（或者叫文本序列），对语言模型来说，用y来表示这些序列，比用x来表示这些序列更好。然后语言模型会估计某个句子序列中各个单词出现的可能性。
（1）需要一个训练集，包含一个很大的（中文/英文）文本语料库
语料库：就是一个很长的，或者说数量众多的（中文/英文）句子组成的文本
（2）把语料库标记化：意思就是建立一个字典，然后将每个单词都转化成one-hot向量，也就是字典中的索引
注意：在每个句子最后都可以添加 <EOS>来表示每个句子的结尾，如果有未知的单词，我们把它替换成<UNK>

代码实现：

"""
Date: 2019--25 16:10
User: yz
Email: 1147570523@qq.com
Desc:
"""
import numpy as np

data_dir = './Data/jena_climate_2009_2016.csv'
f = open(data_dir)
data = f.read()
f.close()

lines = data.split('\n')
header = lines[0].split(',')
lines = lines[1:]

float_data = np.zeros((len(lines), len(header) - 1))

for i, line in enumerate(lines):
    values = [float(x) for x in line.split(',')[1:]]
    float_data[i, :] = values

print(float_data.shape[-1])

from matplotlib import pyplot as plt

temp = float_data[:, 1]
plt.plot(range(len(temp)), temp)

plt.plot(range(1440), temp[:1440])
plt.show()

mean = float_data[:200000].mean(axis=0)
float_data -= mean
std = float_data[:200000].std(axis=0)
float_data /= std

def generator(data, lookback, delay, min_index, max_index, shuffle=False, batch_size=128, step=6):
    if max_index is None:
        max_index = len(data) - delay - 1
    i = min_index + lookback
    while 1:
        if shuffle:
            rows = np.random.randint(min_index + lookback, max_index, size=batch_size)
        else:
            if i + batch_size >= max_index:
                i = min_index = lookback
            rows = np.arange(i, min(i + batch_size, max_index))
            i += len(rows)
        samples = np.zeros((len(rows), lookback // step, data.shape[-1]))
        targets = np.zeros((len(rows),))
        for j, row in enumerate(rows):
            indices = range(rows[j] - lookback, rows[j], step)
            samples[j] = data[indices]
            targets[j] = data[rows[j] + delay][1]
        yield samples, targets

lookback = 1440
step = 6
delay = 144
batch_size = 128

train_gen = generator(float_data, lookback=lookback, delay=delay, min_index=0, max_index=200000, shuffle=True,
                      batch_size=batch_size, step=step)
val_gen = generator(float_data, lookback=lookback, delay=delay, min_index=200001, max_index=300000,
                        batch_size=batch_size, step=step)
test_gen = generator(float_data, lookback=lookback, delay=delay, min_index=300001, max_index=None,
                     batch_size=batch_size, step=step)

val_steps = (300000 - 200001 - lookback) // batch_size
test_steps = (len(float_data) - 300001 - lookback) // batch_size

def evaluate_navie_method():
    batch_maes=[]
    for step in range(val_steps):
        samples,targets=next(val_gen)
        preds=samples[:,-1,1]
        mae=np.mean(np.abs(preds-targets))
        batch_maes.append(mae)
    print(np.mean(batch_maes))

evaluate_navie_method()

from keras.models import  Sequential
from keras import layers
from keras.optimizers import RMSprop
model =Sequential()
model.add(layers.GRU(32,input_shape=(None,float_data.shape[-1])))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(),loss='mae')

history=model.fit_generator(train_gen,steps_per_epoch=500,epochs=20,
                            validation_data=val_gen,validation_steps=val_steps)

import matplotlib.pyplot as plt

loss=history.history['loss']
val_loss=history.history['val_loss']

epochs=range(1,len(loss)+1)
plt.figure()

plt.plot(epochs,loss,'bo',lable='Training loss')
plt.plot(epochs,val_loss,'b',lable='Validation loss')

plt.title('Training ans validation loss')
plt.legend()
plt.show()

GRU（Gated Recurrent Unit）- 门控循环单元

代码实现：

"""
Date: 2019--25 15:53
User: yz
Email: 1147570523@qq.com
Desc:
"""
from keras.datasets import imdb
from keras.preprocessing import sequence

max_features=10000
maxlen=500
batch_size=32

(input_train,y_train),(input_test,y_test)=imdb.load_data(path='/home/kiosk/Linear/190727/day9/test_data_home/imdb.npz',num_words=max_features)

print('loading data......')
print(len(input_train),'train sequences')
print(len(input_test),'test sequences')
print(input_train[0])

print('Pad sequences (samples x time)')
input_train = sequence.pad_sequences(input_train, maxlen=maxlen)
input_test = sequence.pad_sequences(input_test, maxlen=maxlen)
print('input_train shape:', input_train.shape)
print('input_test shape:', input_test.shape)


from keras.layers import Embedding, Dense, SimpleRNN
from keras.models import Sequential


model = Sequential()
model.add(Embedding(max_features, 32))
model.add(SimpleRNN(32))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])
history = model.fit(input_train, y_train,
                    epochs=10,
                    batch_size=128,
                    validation_split=0.2)

import matplotlib.pyplot as plt
acc=history.history['acc']
val_acc=history.history['val_acc']
loss = history.history['loss']
val_loss= history.history['val_loss']

epochs = range(1, len(acc)+1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.show()

LSTM（Long short term memory）- 长短时记忆网络

代码实现：

"""
Date: 2019--25 15:53
User: yz
Email: 1147570523@qq.com
Desc:

"""
from keras.datasets import imdb
from keras.preprocessing import sequence

max_features=10000
maxlen=500
batch_size=32

(input_train,y_train),(input_test,y_test)=imdb.load_data(path='/home/kiosk/Linear/190727/day9/test_data_home/imdb.npz',num_words=max_features)

print('loading data......')
print(len(input_train),'train sequences')
print(len(input_test),'test sequences')
print(input_train[0])

print('Pad sequences (samples x time)')
input_train = sequence.pad_sequences(input_train, maxlen=maxlen)
input_test = sequence.pad_sequences(input_test, maxlen=maxlen)
print('input_train shape:', input_train.shape)
print('input_test shape:', input_test.shape)


from keras.layers import Embedding, Dense, SimpleRNN
from keras.models import Sequential


model = Sequential()
model.add(Embedding(max_features, 32))
model.add(SimpleRNN(32))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])
history = model.fit(input_train, y_train,
                    epochs=10,
                    batch_size=128,
                    validation_split=0.2)

import matplotlib.pyplot as plt
acc=history.history['acc']
val_acc=history.history['val_acc']
loss = history.history['loss']
val_loss= history.history['val_loss']

epochs = range(1, len(acc)+1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.show()