基于 KERAS 深度学习开发快速感性认知

• 机器学习按大功能来区分包含两类

  • 监督学习，需要有经过标注的结果，说明入参对应的结果，用于解决分类、拟合等问题。
  • 无监督学习，无需经过标注的结果，用于分析数据间的聚合关联关系，

• 在监督学习算法按实现的功能有两大类型

  • 分类算法（用于给定参数推定所属的坆举分类）
  • 回归算法（拟合曲线方程，并根据入参算出曲线入参的结果，回归能得出连续的结果）

• 一些监督算法

  • 线性回归，可以有多个入参，但是入参对应的幂指数都是1

    • 非线性回归可以转化成线性回归处理

  • Logistic回归，其基于Sigmoid函数，该函数结果介于0-1之间，其结合线性/非线性回归，可用于判断一件事情发生的概率。其是神经网络的基础，神经网络由多个该年该层组成

  • 神经网络（深度学习属于神经网络，后面的算法若不感兴趣可以直接跳过，本节仅仅用于说明监督算法有很多分类，下面会详细一点的介绍神经网络）

  • kNN算法，根据代数最短距离挑出最近的k个已知学习样本,并以样本的平均值（或者分类结果）作为推断值

  • 朴素贝叶斯算法，有很多个对结果有影响的参数，并假设这些参数都是独立发生，没有相互关联的，然后统计这些参数在某个结论中出现的概率，根据这些概率推断特定入参对应最可能的结果是什么

  • 决策树算法，根据训练样本的入参及结果，结合各个参数信息增熵的信息构造一个高效的分类树

• 神经网络

  • 所谓神经网络学习的过程可以想象成解方程的过程，例如 y=ax+b,如果我们知道了 y 和 x的2个值，那么我们就可以求得a跟b的值。求得a跟b的值就是整个训练的最终目的
  • 但是实际情况下训练过程会复杂很多，我们之前有将到，神经网络的基础是Logistic回归,一个Logistic回归函数可对应为一个神经元，其函数形式可为 y = sigmoid(a0 + a1*x1 + a2 * x2 + ......)。我们实际上是不知道x的实际有效个数，也不知道其对应的合适幂等次数，所以我们很难像解方程一样解出各个a的值，通常求a的值是利用现有的所有训练样例，求得针对所有样例能获得一个最小化误差的a的值。求a值通常会用梯度下降及其相关优化的算法。具体感兴趣可以自行学习。
  • 而神经网络由多个神经元堆叠而成，以下第一个图为单个神经元，第二个图为神经网络

• 深度学习

  • 所谓深度学习就是计算由很多个层次（见上图的Layer）的神经网络的各个a（权重）的值，并没有什么玄乎的东西，其是一个商业概念
  • 但从上图可以看出，深度神经网络的计算量非常的大，这也是为什么在之前深度学习没有火起来的原因，为了减轻计算量提高效率，神经网络有针对不同场景的优化分支，有以下几类
  • 卷积神经网络
    • 卷积神经网络，会局部的抽取计算小特征，并在高层的layer根据小特征计算大特征，最终得到推论结果。其多用于图像处理
  • 循环神经网络
    • 其用于不能一次获得所有输入的场景，其能记录之前输入数据的状态，并以此加以训练。例如语音转文字处理场景，其能根据新的语音输入，以及之前转出来的文字统一作为入参，推断出下一个要转换的语音对应的文字

• 基于KERAS的深度学习开发

  • 实际上基于KERAS的开发特别简单，我们要做的仅仅是搭积木
  • 根据我们现有的场景，选择组合特定适合的神经网络，就是工作的最主要部分，当然，前提就是我们需要熟悉各种神经网络的有缺点
  • 因此深度学习开发，可以说作出基本成果是难度不的，难度大的是，如何选择出合适的神经网络，拼凑出合适的模型，使得在足量的训练样本的情况下，训练出准确率高，计算复杂度小模型。

• 以下是一个训练从图片转HTML/CSS的全部开发代码，大家可以感受下其代码量

  from numpy import array
    from keras.preprocessing.text import Tokenizer, one_hot
    from keras.preprocessing.sequence import pad_sequences
    from keras.models import Model, Sequential, model_from_json
    from keras.utils import to_categorical
    from keras.layers.core import Dense, Dropout, Flatten
    from keras.optimizers import RMSprop
    from keras.layers.convolutional import Conv2D
    from keras.callbacks import ModelCheckpoint
    from keras.layers import Embedding, TimeDistributed, RepeatVector, LSTM, concatenate , Input, Reshape, Dense
    from keras.preprocessing.image import array_to_img, img_to_array, load_img
    import numpy as np
    Using TensorFlow backend.
    # In [2]:
    dir_name = '/data/train/'
  # Read a file and return a string
  
  def load_doc(filename):
  
  file = open(filename, 'r')
  
  text = file.read()
  
  file.close()
  
  return text
  def load_data(data_dir):
  
  text = []
  
  images = []
  
  # Load all the files and order them
  
  all_filenames = listdir(data_dir)
  
  all_filenames.sort()
  
  for filename in (all_filenames):
  
  if filename[-3:] == "npz":
  
  # Load the images already prepared in arrays
  
  image = np.load(data_dir+filename)
  
  images.append(image['features'])
  
  else:
  
  # Load the boostrap tokens and rap them in a start and end tag
  
  syntax = '<START> ' + load_doc(data_dir+filename) + ' <END>'
  
  # Seperate all the words with a single space
  
  syntax = ' '.join(syntax.split())
  
  # Add a space after each comma
  
  syntax = syntax.replace(',', ' ,')
  
  text.append(syntax)
  
  images = np.array(images, dtype=float)
  
  return images, text
  train_features, texts = load_data(dir_name)
  
  # In [4]:
  
  # Initialize the function to create the vocabulary 
  
  tokenizer = Tokenizer(filters='', split=" ", lower=False)
  
  # Create the vocabulary 
  
  tokenizer.fit_on_texts([load_doc('bootstrap.vocab')])
  # Add one spot for the empty word in the vocabulary 
  
  vocab_size = len(tokenizer.word_index) + 1
  
  # Map the  input sentences into the vocabulary indexes
  
  train_sequences = tokenizer.texts_to_sequences(texts)
  
  # The longest set of boostrap tokens
  
  max_sequence = max(len(s) for s in train_sequences)
  
  # Specify how many tokens to have in each input sentence
  
  max_length = 48
  def preprocess_data(sequences, features):
  
  X, y, image_data = list(), list(), list()
  
  for img_no, seq in enumerate(sequences):
  
  for i in range(1, len(seq)):
  
  # Add the sentence until the current count(i) and add the current count to the output
  
  in_seq, out_seq = seq[:i], seq[i]
  
  # Pad all the input token sentences to max_sequence
  
  in_seq = pad_sequences([in_seq], maxlen=max_sequence)[0]
  
  # Turn the output into one-hot encoding
  
  out_seq = to_categorical([out_seq], num_classes=vocab_size)[0]
  
  # Add the corresponding image to the boostrap token file
  
  image_data.append(features[img_no])
  
  # Cap the input sentence to 48 tokens and add it
  
  X.append(in_seq[-48:])
  
  y.append(out_seq)
  
  return np.array(X), np.array(y), np.array(image_data)
  X, y, image_data = preprocess_data(train_sequences, train_features)
  In [ ]:
  
  #Create the encoder
  
  image_model = Sequential()
  
  image_model.add(Conv2D(16, (3, 3), padding='valid', activation='relu', input_shape=(256, 256, 3,)))
  
  image_model.add(Conv2D(16, (3,3), activation='relu', padding='same', strides=2))
  
  image_model.add(Conv2D(32, (3,3), activation='relu', padding='same'))
  
  image_model.add(Conv2D(32, (3,3), activation='relu', padding='same', strides=2))
  
  image_model.add(Conv2D(64, (3,3), activation='relu', padding='same'))
  
  image_model.add(Conv2D(64, (3,3), activation='relu', padding='same', strides=2))
  
  image_model.add(Conv2D(128, (3,3), activation='relu', padding='same'))
  image_model.add(Flatten())
  
  image_model.add(Dense(1024, activation='relu'))
  
  image_model.add(Dropout(0.3))
  
  image_model.add(Dense(1024, activation='relu'))
  
  image_model.add(Dropout(0.3))
  image_model.add(RepeatVector(max_length))
  visual_input = Input(shape=(256, 256, 3,))
  
  encoded_image = image_model(visual_input)
  language_input = Input(shape=(max_length,))
  
  language_model = Embedding(vocab_size, 50, input_length=max_length, mask_zero=True)(language_input)
  
  language_model = LSTM(128, return_sequences=True)(language_model)
  
  language_model = LSTM(128, return_sequences=True)(language_model)
  #Create the decoder
  
  decoder = concatenate([encoded_image, language_model])
  
  decoder = LSTM(512, return_sequences=True)(decoder)
  
  decoder = LSTM(512, return_sequences=False)(decoder)
  
  decoder = Dense(vocab_size, activation='softmax')(decoder)
  # Compile the model
  
  model = Model(inputs=[visual_input, language_input], outputs=decoder)
  
  optimizer = RMSprop(lr=0.0001, clipvalue=1.0)
  
  model.compile(loss='categorical_crossentropy', optimizer=optimizer)
  
  In [ ]:
  
  #Save the model for every 2nd epoch
  
  filepath="org-weights-epoch-{epoch:04d}--val_loss-{val_loss:.4f}--loss-{loss :.4f}.hdf5"
  
  checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_weights_only=True, period=2)
  
  callbacks_list = [checkpoint]
  
  In [ ]:
  
  # Train the model
  
  model.fit([image_data, X], y, batch_size=64, shuffle=False, validation_split=0.1, callbacks=callbacks_list, verbose=1, epochs=50)

以上仅为大家提供一个深度学习开发的一个初步概念，本人也在学习中，有错误或者不完善请斧整～