Deeplearning Algorithms tutorial

谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ AI的开发离不开算法那我们就接下来开始学习算法吧！

深度卷积神经网络(Deep Convolutional Neural Networks)

深度卷积神经网络（DCNN）在特征识别相关任务中取得的效果，远比传统方法好。因此，DCNN常用于图像识别、语音识别等。但是，因为深度卷积神经网络结构庞大，一般都会包含几十个神经层，每一层，又有数百至数千个神经元；同时，DCNN任意两层之间神经元的相互影响错综复杂。这两个主要的因素，导致DCNN难以理解、分析。为此，用户很难从失败或成功的例子中学习到如何设计一个好的卷积神经网络。因此，设计一个效果好的神经网络，往往需要依靠大量的尝试。

而卷积神经网络（Convolutional Neural Network,CNN）是一种前馈神经网络，它的人工神经元可以响应一部分覆盖范围内的周围单元，对于大型图像处理有出色表现。 它包括卷积层(convolutional layer)和池化层(pooling layer)。

卷积神经网络是近年发展起来，并引起广泛重视的一种高效识别方法。20世纪60年代，Hubel和Wiesel在研究猫脑皮层中用于局部敏感和方向选择的神经元时发现其独特的网络结构可以有效地降低反馈神经网络的复杂性，继而提出了卷积神经网络（Convolutional Neural Networks-简称CNN）。现在，CNN已经成为众多科学领域的研究热点之一，特别是在模式分类领域，由于该网络避免了对图像的复杂前期预处理，可以直接输入原始图像，因而得到了更为广泛的应用。 K.Fukushima在1980年提出的新识别机是卷积神经网络的第一个实现网络。随后，更多的科研工作者对该网络进行了改进。其中，具有代表性的研究成果是Alexander和Taylor提出的“改进认知机”，该方法综合了各种改进方法的优点并避免了耗时的误差反向传播。

卷积神经网络的基本结构包括两层，其一为特征提取层，每个神经元的输入与前一层的局部接受域相连，并提取该局部的特征。一旦该局部特征被提取后，它与其它特征间的位置关系也随之确定下来；其二是特征映射层，网络的每个计算层由多个特征映射组成，每个特征映射是一个平面，平面上所有神经元的权值相等。特征映射结构采用影响函数核小的sigmoid函数作为卷积网络的激活函数，使得特征映射具有位移不变性。此外，由于一个映射面上的神经元共享权值，因而减少了网络自由参数的个数。卷积神经网络中的每一个卷积层都紧跟着一个用来求局部平均与二次提取的计算层，这种特有的两次特征提取结构减小了特征分辨率。

卷积神经网络主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习，所以在使用CNN时，避免了显式的特征抽取，而隐式地从训练数据中进行学习；再者由于同一特征映射面上的神经元权值相同，所以网络可以并行学习，这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性，其布局更接近于实际的生物神经网络，权值共享降低了网络的复杂性，特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。

深度卷积神经网络(Deep Convolutional Neural Networks) - 图1

一个典型的卷积神经网络包含两个卷积层（convolution layer），两个池化层（pooling layer）和一个全连接层（fully connected layer）。

深度卷积神经网络(Deep Convolutional Neural Networks) - 图2

卷积层，采用各种卷积核对输入图片进行卷积处理，基本卷积过程如图2所示。卷积操作具有平移不变性。因而，能够支持神经元学习到鲁棒性比较高的特征。

深度卷积神经网络(Deep Convolutional Neural Networks) - 图3

池化层的操作，是一种降采样操作。该操作是在一个小区域内，采取一个特定的值作为输出值。比如图3，在每个特定的小区域内，我们选取最大值作为输出值。池化层的操作可以达到一定的空间不变性效果。

卷积神经网络中的激励函数，根据一系列的输入值，神经元之间连接的权值以及激励规则，刺激神经元。

卷积神经网络中的损失函数，在训练阶段，用于评估网络输出结果与实际值的差异。然后用损失函数的值更新每个神经元之间的权重值。卷积神经网络的训练目的就是最小化损失函数值。

深度卷积神经网络在许多模式识别任务上较传统的方法而言已经展示了很大的提升，比如语音识别，图像分类和视频分类。

应用示例

  1. import argparse
  2. import os
  4. import matplotlib
  5. matplotlib.use('AGG')
  6. import matplotlib.pyplot as plt
  7. import numpy as np
  8. from keras.datasets import cifar10
  9. from keras.layers import (Activation, Conv3D, Dense, Dropout, Flatten,
  10.                           MaxPooling3D)
  11. from keras.layers.advanced_activations import LeakyReLU
  12. from keras.losses import categorical_crossentropy
  13. from keras.models import Sequential
  14. from keras.optimizers import Adam
  15. from keras.utils import np_utils
  16. from keras.utils.vis_utils import plot_model
  17. from sklearn.model_selection import train_test_split
  19. import videoto3d
  20. from tqdm import tqdm
  23. def plot_history(history, result_dir):
  24.     plt.plot(history.history['acc'], marker='.')
  25.     plt.plot(history.history['val_acc'], marker='.')
  26.     plt.title('model accuracy')
  27.     plt.xlabel('epoch')
  28.     plt.ylabel('accuracy')
  29.     plt.grid()
  30.     plt.legend(['acc', 'val_acc'], loc='lower right')
  31.     plt.savefig(os.path.join(result_dir, 'model_accuracy.png'))
  32.     plt.close()
  34.     plt.plot(history.history['loss'], marker='.')
  35.     plt.plot(history.history['val_loss'], marker='.')
  36.     plt.title('model loss')
  37.     plt.xlabel('epoch')
  38.     plt.ylabel('loss')
  39.     plt.grid()
  40.     plt.legend(['loss', 'val_loss'], loc='upper right')
  41.     plt.savefig(os.path.join(result_dir, 'model_loss.png'))
  42.     plt.close()
  45. def save_history(history, result_dir):
  46.     loss = history.history['loss']
  47.     acc = history.history['acc']
  48.     val_loss = history.history['val_loss']
  49.     val_acc = history.history['val_acc']
  50.     nb_epoch = len(acc)
  52.     with open(os.path.join(result_dir, 'result.txt'), 'w') as fp:
  53.         fp.write('epoch\tloss\tacc\tval_loss\tval_acc\n')
  54.         for i in range(nb_epoch):
  55.             fp.write('{}\t{}\t{}\t{}\t{}\n'.format(
  56.                 i, loss[i], acc[i], val_loss[i], val_acc[i]))
  59. def loaddata(video_dir, vid3d, nclass, result_dir, color=False, skip=True):
  60.     files = os.listdir(video_dir)
  61.     X = []
  62.     labels = []
  63.     labellist = []
  65.     pbar = tqdm(total=len(files))
  67.     for filename in files:
  68.         pbar.update(1)
  69.         if filename == '.DS_Store':
  70.             continue
  71.         name = os.path.join(video_dir, filename)
  72.         label = vid3d.get_UCF_classname(filename)
  73.         if label not in labellist:
  74.             if len(labellist) >= nclass:
  75.                 continue
  76.             labellist.append(label)
  77.         labels.append(label)
  78.         X.append(vid3d.video3d(name, color=color, skip=skip))
  80.     pbar.close()
  81.     with open(os.path.join(result_dir, 'classes.txt'), 'w') as fp:
  82.         for i in range(len(labellist)):
  83.             fp.write('{}\n'.format(labellist[i]))
  85.     for num, label in enumerate(labellist):
  86.         for i in range(len(labels)):
  87.             if label == labels[i]:
  88.                 labels[i] = num
  89.     if color:
  90.         return np.array(X).transpose((0, 2, 3, 4, 1)), labels
  91.     else:
  92.         return np.array(X).transpose((0, 2, 3, 1)), labels
  95. def main():
  96.     parser = argparse.ArgumentParser(
  97.         description='simple 3D convolution for action recognition')
  98.     parser.add_argument('--batch', type=int, default=128)
  99.     parser.add_argument('--epoch', type=int, default=100)
  100.     parser.add_argument('--videos', type=str, default='UCF101',
  101.                         help='directory where videos are stored')
  102.     parser.add_argument('--nclass', type=int, default=101)
  103.     parser.add_argument('--output', type=str, required=True)
  104.     parser.add_argument('--color', type=bool, default=False)
  105.     parser.add_argument('--skip', type=bool, default=True)
  106.     parser.add_argument('--depth', type=int, default=10)
  107.     args = parser.parse_args()
  109.     img_rows, img_cols, frames = 32, 32, args.depth
  110.     channel = 3 if args.color else 1
  111.     fname_npz = 'dataset_{}_{}_{}.npz'.format(
  112.         args.nclass, args.depth, args.skip)
  114.     vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
  115.     nb_classes = args.nclass
  116.     if os.path.exists(fname_npz):
  117.         loadeddata = np.load(fname_npz)
  118.         X, Y = loadeddata["X"], loadeddata["Y"]
  119.     else:
  120.         x, y = loaddata(args.videos, vid3d, args.nclass,
  121.                         args.output, args.color, args.skip)
  122.         X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
  123.         Y = np_utils.to_categorical(y, nb_classes)
  125.         X = X.astype('float32')
  126.         np.savez(fname_npz, X=X, Y=Y)
  127.         print('Saved dataset to dataset.npz.')
  128.     print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
  130.     # Define model
  131.     model = Sequential()
  132.     model.add(Conv3D(32, kernel_size=(3, 3, 3), input_shape=(
  133.         X.shape[1:]), border_mode='same'))
  134.     model.add(Activation('relu'))
  135.     model.add(Conv3D(32, kernel_size=(3, 3, 3), border_mode='same'))
  136.     model.add(Activation('softmax'))
  137.     model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
  138.     model.add(Dropout(0.25))
  140.     model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
  141.     model.add(Activation('relu'))
  142.     model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
  143.     model.add(Activation('softmax'))
  144.     model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
  145.     model.add(Dropout(0.25))
  147.     model.add(Flatten())
  148.     model.add(Dense(512, activation='sigmoid'))
  149.     model.add(Dropout(0.5))
  150.     model.add(Dense(nb_classes, activation='softmax'))
  152.     model.compile(loss=categorical_crossentropy,
  153.                   optimizer=Adam(), metrics=['accuracy'])
  154.     model.summary()
  155.     plot_model(model, show_shapes=True,
  156.                to_file=os.path.join(args.output, 'model.png'))
  158.     X_train, X_test, Y_train, Y_test = train_test_split(
  159.         X, Y, test_size=0.2, random_state=43)
  161.     history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), batch_size=args.batch,
  162.                         epochs=args.epoch, verbose=1, shuffle=True)
  163.     model.evaluate(X_test, Y_test, verbose=0)
  164.     model_json = model.to_json()
  165.     if not os.path.isdir(args.output):
  166.         os.makedirs(args.output)
  167.     with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'), 'w') as json_file:
  168.         json_file.write(model_json)
  169.     model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel.hd5'))
  171.     loss, acc = model.evaluate(X_test, Y_test, verbose=0)
  172.     print('Test loss:', loss)
  173.     print('Test accuracy:', acc)
  174.     plot_history(history, args.output)
  175.     save_history(history, args.output)
  178. if __name__ == '__main__':
  179.     main()