TensorFlow高层API Custom Estimator建立CNN+RNN的演示

作者:YJango

链接:https://zhuanlan.zhihu.com/p/33681224

来源:知乎

目录

前言

机器学习

  • 两大模块:数据、模型
  • 三个阶段:训练、评估、预测

优势

实现

  • 数据集:TFRecord+Dataset
  • 定义input_fn
  • 定义model_fn

    • 正向传播

      • CNN:二维卷积层
      • RNN:循环层(双向循环层)
      • CNN+RNN:一维卷积层+循环层
    • 预测分支
    • 训练分支
    • 评估分支
  • 创建estimator
  • 训练
  • 评估
  • 预测
  • 可视化

前言

该文是YJango:TensorFlow中层API Datasets+TFRecord的数据导入的后续。

知道了如何用中层API:Dataset来导入数据后,下面介绍如何接着用高层API:Estimator来用下面四个网络结构来完成mnist手写数字识别。

  • 卷积神经网络
  • 循环神经网络
  • 双向循环神经网络
  • 卷积+循环网络

机器学习

人们常说深度学习是黑箱,我们同样也希望使用深度学习可以像使用黑箱工具那样简单。可事实却并非如此。以监督学习为例:

我们的最终目标是:希望获得一个可以输入问题就能获得答案的算法。

可为了获得该算法,要先搜集数据,然后将数据处理成适应计算机或模型的形式。根据目的分成训练集、验证集、测试集。经过反复的选择、训练、调参、评估后确定最终投入应用的模型。

上述流程可分为训练评估预测三个阶段。不同阶段:

  • 使用的模型数据处理记录操作是相同的。
  • 使用的数据集模型操作不同。

一、训练:

  • 模型操作:正向传播+反向传播。遍历整个训练集若干次,用于更新模型权重
  • 数据集:训练集。

二、评估:

  • 模型操作:正向传播。遍历每个数据集一次,算出评估指标来衡量模型表现。
  • 数据集:会使用多个数据集进行评估,但意义不同。

    • 训练集:评估模型能力是否足够,判断是否欠拟合。
    • 验证集:其本质也属于训练集的一部分。评估模型的普遍性,和训练集的评估结果一起来判断是否过拟合。因为会根据验证集的结果来调整模型参数 (hyper-parameters),所以模型间接的“见过”验证集的数据。
    • 测试集:模型从未见过的数据,用于评估模型的最终表现,决定是否选择新模型。

注:训练集和验证集都无法作为最终表现的考核标准。评估模型的最终表现一定要用模型从未见过的数据。就如同考核高考解题能力的方法是考核我们从没做过的题目一样,因为我们可以记住做过题目的答案。

三、预测:

  • 模型操作:正向传播。用训练好的模型算出所有预测值即可。
  • 数据集:只有输入的实际应用数据。

优势

一、为什么用Estimator API?

正如先前所说机器学习可分为训练、评估、预测三个阶段,每个阶段又都会用到相同的模型和数据处理方法。

Tensorflow的高层API:Estimator正是对共用部分使用通用方法,而在不同的阶段实现具体的控制。

共用部分:

  • model_fn:构建模型
  • input_fn:导入数据 + 数据集的处理(结合中层API:Dataset)
  • 其他:帮助控制sessions、graphs、loops、logging

三个阶段:通过调用对应的train(), evaluate(), predict()方法来执行不同的阶段。

优势

  • 学习流程:Estimator 封装了对机器学习不同阶段的控制,用户无需不断的为新机器学习任务重复编写训练、评估、预测的代码。可以专注于对网络结构的控制。
  • 网络结构:Estimator 的网络结构是在 model_fn 中独立定义的,用户创建的任何网络结构都可以在 Estimator 的控制下进行机器学习。这可以允许用户很方便的使用别人定义好的 model_fn。
  • 数据导入:Estimator 的数据导入也是由 input_fn 独立定义的。例如,用户可以非常方便的只通过改变 input_fn 的定义,来使用相同的网络结构学习不同的数据。

实现

一、数据集

这里直接使用上篇文章中所描述的方法(没看过的先看上一篇),将MNIST数据集先写成tfrecord文件,再用dataset API导入,进行batch,shuffle,padding等操作。需要文件:tfrecorder.py

1. 制作TFrecord文件

# 所需库包 
import pandas as pd 
import numpy as np 
import tensorflow as tf 
# 需要从我给的github上获得tfrecorder
from tfrecorder import TFrecorder 
from matplotlib import pyplot as plt 
import matplotlib.image as mpimg 
%pylab inline 

# mnist数据 
mnist = tf.contrib.learn.datasets.load_dataset("mnist") 

# 指定如何写成tfrecord文件的信息
# 每一个row是一个feature 
df = pd.DataFrame({'name':['image','label'],                 
                  'type':['float32','int64'],                  
                  'shape':[(784,),()],                  
                  'isbyte':[False,False],                  
                  "length_type":['fixed','fixed'],                  
                  "default":[np.NaN,np.NaN]}) 
# 实例化该类 
tfr = TFrecorder() 

# 写训练集和测试集的位置 
mkdir mnist_tfrecord mnist_tfrecord/train mnist_tfrecord/test

使用tfr.feature_writer方法创建样本写入字典,一个样本一个样本的写入TFRecord file中。

由于使用tfrecord时往往是拥有大量数据的情况,需要一点点写入。

1.1. 训练集 

# 用该方法写训练集的tfrecord文件 
dataset = mnist.train 
path = 'mnist_tfrecord/train/train' 
# 每个tfrecord文件写多少个样本 
num_examples_per_file = 1000 
# 当前写的样本数 
num_so_far = 0 
# 要写入的文件 
writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, num_examples_per_file)) 
# 写多个样本 
for i in np.arange(dataset.num_examples):    
    # 要写到tfrecord文件中的字典   
    features = {}    
    # 写一个样本的图片信息存到字典features中   
    tfr.feature_writer(df.iloc[0], dataset.images[i], features)    
    # 写一个样本的标签信息存到字典features中    
    tfr.feature_writer(df.iloc[1], dataset.labels[i], features)       
    tf_features = tf.train.Features(feature= features)    
    tf_example = tf.train.Example(features = tf_features)    
    tf_serialized = tf_example.SerializeToString()    
    writer.write(tf_serialized)    
    # 每写了num_examples_per_file个样本就令生成一个tfrecord文件    
    if i%num_examples_per_file ==0 and i!=0:        
       writer.close()        
       num_so_far = i        
       writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file))        
       print('saved %s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file)) 
writer.close() 
# 把指定如何写成tfrecord文件的信息保存起来 
data_info_path = 'mnist_tfrecord/data_info.csv' 
df.to_csv(data_info_path,index=False)

1.2. 测试集 

# 用该方法写测试集的tfrecord文件
dataset = mnist.test 
path = 'mnist_tfrecord/test/test' 
# 每个tfrecord文件写多少个样本 
num_examples_per_file = 1000 
# 当前写的样本数 
num_so_far = 0 
# 要写入的文件 
writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, num_examples_per_file)) 
# 写多个样本 
for i in np.arange(dataset.num_examples):    
    # 要写到tfrecord文件中的字典    
    features = {}    
    # 写一个样本的图片信息存到字典features中    
    tfr.feature_writer(df.iloc[0], dataset.images[i], features)    
    # 写一个样本的标签信息存到字典features中    

    tfr.feature_writer(df.iloc[1], dataset.labels[i], features)        
    tf_features = tf.train.Features(feature= features)    
    tf_example = tf.train.Example(features = tf_features)    
    tf_serialized = tf_example.SerializeToString()    
    writer.write(tf_serialized)    
    # 每写了num_examples_per_file个样本就令生成一个tfrecord文件    
    if i%num_examples_per_file ==0 and i!=0:        
       writer.close()        
       num_so_far = i        
       writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file))        
       print('saved %s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file)) 
writer.close() 
# 把指定如何写成tfrecord文件的信息保存起来 
data_info_path = 'mnist_tfrecord/data_info.csv' 
df.to_csv(data_info_path,index=False)

二、生成input_fn

送入到Estimator中的input_fn需要是一个函数,而不是具体的数据。

所以这里用input_fn_maker来控制如何生成不同的input_fn函数。

tfr = TFrecorder() 
def input_fn_maker(path, data_info_path, shuffle=False, batch_size = 1, epoch = 1, padding = None):    
    def input_fn():        
        # tfr.get_filenames会返回包含path下的所有tfrecord文件的list        
        # shuffle会让这些文件的顺序打乱        
        filenames = tfr.get_filenames(path=path, shuffle=shuffle)        
        dataset=tfr.get_dataset(paths=filenames, data_info=data_info_path, shuffle = shuffle,                             
                            batch_size = batch_size, epoch = epoch, padding =padding)        
        iterator = dataset.make_one_shot_iterator()        
        return iterator.get_next()    
    return input_fn 
padding_info = ({'image':[784,],'label':[]}) 
# 生成3个input_fn 
test_input_fn = input_fn_maker('mnist_tfrecord/test/',  'mnist_tfrecord/data_info.csv',                               
                               padding = padding_info) 
train_input_fn = input_fn_maker('mnist_tfrecord/train/',  'mnist_tfrecord/data_info.csv', shuffle=True, batch_size = 512,                                                            padding = padding_info) 
# 用来评估训练集用,不想要shuffle train_eval_fn = input_fn_maker('mnist_tfrecord/train/',  'mnist_tfrecord/data_info.csv', batch_size = 512,                                          padding = padding_info) 
# input_fn在执行时会返回一个字典,里面的key对应着不同的feature(包括label在内)

完整代码可以在MNIST TFrecord.ipynb找到。

三、model_fn

模型函数必须要有features, mode两个参数,可自己选择加入labels(YJango习惯把label也放进features中)。最后要返回特定的tf.estimator.EstimatorSpec()。

模型有三个阶段都共用的正向传播部分,和由mode值来控制返回不同tf.estimator.EstimatorSpec的三个分支。

def model_fn(features, mode):    
    # reshape 784维的图片到28x28的平面表达,1为channel数    
    features['image'] = tf.reshape(features['image'],[-1,28,28,1])

1. 正向传播

这里使用tf.layers来搭建模型,

要点:

  • 记住tensor在每层前后的shape
  • 记住shape上每个dimension上的意义
  • 给每一层都赋予name,用于debug和方便后续操作。

注:虽然我循序罗列了不同结构,但请一次只拿一个使用

注:关于下面网络的搭建,不明白的细节可以问我。

1.1. 二维卷积层

定义LeNet模型。

# shape: [None,28,28,1]    
    conv1 = tf.layers.conv2d(        
        inputs=features['image'],        
        filters=32,        
        kernel_size=[5, 5],        
        padding="same",        
        activation=tf.nn.relu,        
        name = 'conv1')    
# shape: [None,28,28,32]    
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2, name= 'pool1')    
# shape: [None,14,14,32]    
conv2 = tf.layers.conv2d(        
    inputs=pool1,        
    filters=64,        
    kernel_size=[5, 5],        
    padding="same",        
    activation=tf.nn.relu,        
    name = 'conv2')    
# shape: [None,14,14,64]    
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2, name= 'pool2')    
# shape: [None,7,7,64]   
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64], name= 'pool2_flat')    
# shape: [None,3136]    
dense1 = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu, name= 'dense1')    
# dropout只在当mode为tf.estimator.ModeKeys.TRAIN时才使用    
dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)    
# shape: [None,1024]    
logits = tf.layers.dense(inputs=dropout, units=10, name= 'output')    
# shape: [None,10]

1.2. 循环层

定义两层循环层模型。

# shape: [None,28,28,1]    
    # create RNN cells:    
    rnn_cells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]    
    # stack cells for multi-layers RNN    
    multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_cells)    
    # create RNN layers    
    outputs, last_state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,                                   
                                   inputs=tf.reshape(features['image'],[-1,28,28]),                                   
                                   dtype=tf.float32)    
# shape: outputs: [None,28,256]    
# shape: last_state: [None,256]    
dense1 = tf.layers.dense(inputs=last_state[1], units=1024, activation=tf.nn.relu, name= 'dense1')    
# shape: [None,1024]    
dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)    
logits = tf.layers.dense(inputs=dense1, units=10, name= 'output')    
# shape: [None,10]

1.3. 双向循环层

定义两个双向循环层模型。

# shape: [None,28,28,1]    
    # create RNN cells:    
    rnn_fcells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]    
    rnn_bcells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]    
    # stack cells for multi-layers RNN    
    multi_rnn_fcell = tf.nn.rnn_cell.MultiRNNCell(rnn_fcells)    
    multi_rnn_bcell = tf.nn.rnn_cell.MultiRNNCell(rnn_bcells)    
    # create RNN layers    
    ((outputs_fw, outputs_bw),(last_state_fw, last_state_bw)) = tf.nn.bidirectional_dynamic_rnn(   
                                   cell_fw=multi_rnn_fcell,                                   
                                   cell_bw=multi_rnn_bcell,                                   
                                   inputs=tf.reshape(features['image'],[-1,28,28]),                                   
                                   dtype=tf.float32)    
# shape: outputs: [None,28,256]    
# shape: last_state: [None,256]    
dense1 = tf.layers.dense(inputs=last_state_fw[1]+last_state_bw[1], units=1024, activation=tf.nn.relu, name= 'dense1')    
# shape: [None,1024]    
dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)    
logits = tf.layers.dense(inputs=dense1, units=10, name= 'output')    
# shape: [None,10]

1.4. 一维卷积层+循环层模型

定义一维卷基层+一维maxpool+循环层模型。

# shape: [None,28,28,1]    
    conv1 = tf.layers.conv1d(            
            inputs = tf.reshape(features['image'],[-1,28,28]),            
            filters = 32,            
            kernel_size = 5,            
            padding="same",            
            activation=tf.nn.relu,            
            name = 'conv1')    
# shape: [None,28,32]    
pool1 = tf.layers.max_pooling1d(inputs = conv1,                           
                      pool_size=2,                          
                      strides=2,                          
                      name = 'pool1')    
# shape: [None,14,32]    
# create RNN cells:    
rnn_cells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]    
# stack cells for multi-layers RNN    
multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_cells)    
# create RNN layers    
outputs, last_state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,                                   
                               inputs=pool1,                                   
                               dtype=tf.float32)    
# shape: outputs: [None,14,256]    
# shape: last_state: [None,256]    
dense1 = tf.layers.dense(inputs=last_state[1], units=1024, activation=tf.nn.relu, name= 'dense1')    
# shape: [None,1024]    
dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)    
logits = tf.layers.dense(inputs=dense1, units=10, name= 'output')    
# shape: [None,10]
想要换成不同的模型,只需改变正向传播部分的代码即可。

注:不同网络结构训练1epoch+评估的结构可以在CNN.ipynbRNN.ipynbbiRNN.ipynbCNN_RNN.ipynb中找到。

注:CNN之后的模型并不意味着更好,这里只是为了展示你可以使用任何模型结构来进行学习。还有残差网络的跳层链接,batchnorm层,注意力机制等,至于如何选择,主要是在于你的任务是否具有符合这些特殊层的结构特点。详细的请参考:

YJango:深层神经网络设计理念(在线+视频+幻灯片)

2. 预测分支

# 创建predictions字典,里面写进所有你想要在预测值输出的数值    
    # 隐藏层的数值也可以,这里演示了输出所有隐藏层层结果。    
    # 字典的key是模型,value给的是对应的tensor    
    predictions = {        
        "image":features['image'],        
        "conv1_out":conv1,        
        "pool1_out":pool1,        
        "conv2_out":conv2,        
        "pool2_out":pool2,        
        "pool2_flat_out":pool2_flat,        
        "dense1_out":dense1,        
        "logits":logits,        
        "classes": tf.argmax(input=logits, axis=1),        
        "labels": features['label'],        
        "probabilities": tf.nn.softmax(logits, name="softmax_tensor")        
        }   
   # 当mode为tf.estimator.ModeKeys.PREDICT时,我们就让模型返回预测的操作    
   if mode == tf.estimator.ModeKeys.PREDICT:        
       return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

3. 训练分支

# 训练和评估时都会用到loss    
    loss = tf.losses.sparse_softmax_cross_entropy(labels=features['label'], logits=logits)    
    # 训练分支    
    if mode == tf.estimator.ModeKeys.TRAIN:        
        optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)        
        train_op = optimizer.minimize(        
        loss=loss,        
        # global_step用于记录训练了多少步        
        global_step=tf.train.get_global_step())        
        # 返回的tf.estimator.EstimatorSpec根据        
        return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

4. 评估分支

# 注意评估的时候,模型和训练时一样,是一个循环的loop,不断累积计算评估指标。    
    # 其中有两个局部变量total和count来控制    
    # 把网络中的某个tensor结果直接作为字典的value是不好用的    
    # loss的值是始终做记录的,eval_metric_ops中是额外想要知道的评估指标    
    eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=features['label'], predictions=predictions["classes"])}    
    # 不好用:eval_metric_ops = {"probabilities": predictions["probabilities"]}    
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

四、创建estimator

注意:送入的model_fn和input_fn一样是一个函数,不可以是model_fn()返回结果

# model_dir 表示模型要存到哪里 
mnist_classifier = tf.estimator.Estimator(    
     model_fn=model_fn, model_dir="mnist_model_cnn")

训练后的模型参数会保存在model_dir中,随着训练在目录下生成拥有类似下面内容的checkpoint文件。

model_checkpoint_path: "model.ckpt-860" 
all_model_checkpoint_paths: "model.ckpt-1" 
all_model_checkpoint_paths: "model.ckpt-430" 
all_model_checkpoint_paths: "model.ckpt-431" 
all_model_checkpoint_paths: "model.ckpt-860"

当你再次运行相同model_dir的Estimator时,它默认会读取model_checkpoint_path: "model.ckpt-860"的模型权重

如果想要改变读取的检查点到之前的某个时刻,可以改变:

model_checkpoint_path: "model.ckpt-431" 
all_model_checkpoint_paths: "model.ckpt-1" 
all_model_checkpoint_paths: "model.ckpt-430" 
all_model_checkpoint_paths: "model.ckpt-431" 
all_model_checkpoint_paths: "model.ckpt-860"

五、训练

1. 日志

# 在训练或评估的循环中,每50次print出一次字典中的数值 
tensors_to_log = {"probabilities": "softmax_tensor"} 
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

2. 训练

  • hooks:如果不送值,则训练过程中不会显示字典中的数值
  • steps:指定了训练多少次,如果不送值,则训练到dataset API遍历完数据集为止
  • max_steps:指定了最大训练次数
mnist_classifier.train(input_fn=train_input_fn, hooks=[logging_hook])

如果再次运行,同时没有限制最大训练次数,那么网络会从最后一个checkpoint读取模型权重接着训练。


六、评估

# 训练集 
eval_results = mnist_classifier.evaluate(input_fn=train_eval_fn, checkpoint_path=None) 
print('train set') 
print(eval_results) 
# 测试集 
# checkpoint_path是可以指定选择那个时刻保存的权重进行评估 
eval_results = mnist_classifier.evaluate(input_fn=test_input_fn, checkpoint_path=None) 
print('test set') 
print(eval_results)

七、预测

predicts =list(mnist_classifier.predict(input_fn=test_input_fn))

predicts是一个list,list中的元素是dictionary

predicts[0].keys() 
# 输出为: 
dict_keys(['image', 'conv1_out', 'pool1_out', 'conv2_out', 'pool2_out', 'pool2_flat_out', 'dense1_out', 'logits', 'classes', 'labels', 'probabilities'])

如果想要输出4个第一个卷基层的输出,可以

plt.figure(num=4,figsize=(28,28)) 
for i in range(4):    
    plt.subplot(1,4,i+1)    
    plt.imshow(predicts[0]['conv1_out'][:,:,i],cmap = plt.cm.gray) 
plt.savefig('conv1_out.png')

八、可视化

tensorboard --logdir=mnist_model_cnn 
打开http://localhost:6006 

分享简单易懂深度学习知识。

入门TensorFlow
1
相关数据
注意力机制技术
Attention mechanism

我们可以粗略地把神经注意机制类比成一个可以专注于输入内容的某一子集(或特征)的神经网络. 注意力机制最早是由 DeepMind 为图像分类提出的,这让「神经网络在执行预测任务时可以更多关注输入中的相关部分,更少关注不相关的部分」。当解码器生成一个用于构成目标句子的词时,源句子中仅有少部分是相关的;因此,可以应用一个基于内容的注意力机制来根据源句子动态地生成一个(加权的)语境向量(context vector), 然后网络会根据这个语境向量而不是某个固定长度的向量来预测词。

神经网络技术
Neural Network

(人工)神经网络是一种起源于 20 世纪 50 年代的监督式机器学习模型,那时候研究者构想了「感知器(perceptron)」的想法。这一领域的研究者通常被称为「联结主义者(Connectionist)」,因为这种模型模拟了人脑的功能。神经网络模型通常是通过反向传播算法应用梯度下降训练的。目前神经网络有两大主要类型,它们都是前馈神经网络:卷积神经网络(CNN)和循环神经网络(RNN),其中 RNN 又包含长短期记忆(LSTM)、门控循环单元(GRU)等等。深度学习是一种主要应用于神经网络帮助其取得更好结果的技术。尽管神经网络主要用于监督学习,但也有一些为无监督学习设计的变体,比如自动编码器和生成对抗网络(GAN)。

卷积神经网络技术
Convolutional neural network

卷积神经网路(Convolutional Neural Network, CNN)是一种前馈神经网络,它的人工神经元可以响应一部分覆盖范围内的周围单元,对于大型图像处理有出色表现。卷积神经网路由一个或多个卷积层和顶端的全连通层(对应经典的神经网路)组成,同时也包括关联权重和池化层(pooling layer)。这一结构使得卷积神经网路能够利用输入数据的二维结构。与其他深度学习结构相比,卷积神经网路在图像和语音识别方面能够给出更好的结果。这一模型也可以使用反向传播算法进行训练。相比较其他深度、前馈神经网路,卷积神经网路需要考量的参数更少,使之成为一种颇具吸引力的深度学习结构。 卷积网络是一种专门用于处理具有已知的、网格状拓扑的数据的神经网络。例如时间序列数据,它可以被认为是以一定时间间隔采样的一维网格,又如图像数据,其可以被认为是二维像素网格。

超参数技术
Hyperparameter

在机器学习中,超参数是在学习过程开始之前设置其值的参数。 相反,其他参数的值是通过训练得出的。 不同的模型训练算法需要不同的超参数,一些简单的算法(如普通最小二乘回归)不需要。 给定这些超参数,训练算法从数据中学习参数。相同种类的机器学习模型可能需要不同的超参数来适应不同的数据模式,并且必须对其进行调整以便模型能够最优地解决机器学习问题。 在实际应用中一般需要对超参数进行优化,以找到一个超参数元组(tuple),由这些超参数元组形成一个最优化模型,该模型可以将在给定的独立数据上预定义的损失函数最小化。

LeNet技术
LeNet

LeNet 诞生于 1994 年,是最早的卷积神经网络之一,并且推动了深度学习领域的发展。自从 1988 年开始,在许多次成功的迭代后,这项由 Yann LeCun 完成的开拓性成果被命名为 LeNet5。LeNet5 的架构基于这样的观点:(尤其是)图像的特征分布在整张图像上,以及带有可学习参数的卷积是一种用少量参数在多个位置上提取相似特征的有效方式。在那时候,没有 GPU 帮助训练,甚至 CPU 的速度也很慢。因此,能够保存参数以及计算过程是一个关键进展。这和将每个像素用作一个大型多层神经网络的单独输入相反。LeNet5 阐述了那些像素不应该被使用在第一层,因为图像具有很强的空间相关性,而使用图像中独立的像素作为不同的输入特征则利用不到这些相关性。

机器学习技术
Machine Learning

机器学习是人工智能的一个分支,是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸分析、计算复杂性理论等多门学科。机器学习理论主要是设计和分析一些让计算机可以自动“学习”的算法。因为学习算法中涉及了大量的统计学理论,机器学习与推断统计学联系尤为密切,也被称为统计学习理论。算法设计方面,机器学习理论关注可以实现的,行之有效的学习算法。

过拟合技术
Overfitting

过拟合是指为了得到一致假设而使假设变得过度严格。避免过拟合是分类器设计中的一个核心任务。通常采用增大数据量和测试样本集的方法对分类器性能进行评价。

优化器技术
Optimizer

优化器基类提供了计算梯度loss的方法,并可以将梯度应用于变量。优化器里包含了实现了经典的优化算法,如梯度下降和Adagrad。 优化器是提供了一个可以使用各种优化算法的接口,可以让用户直接调用一些经典的优化算法,如梯度下降法等等。优化器(optimizers)类的基类。这个类定义了在训练模型的时候添加一个操作的API。用户基本上不会直接使用这个类,但是你会用到他的子类比如GradientDescentOptimizer, AdagradOptimizer, MomentumOptimizer(tensorflow下的优化器包)等等这些算法。

参数技术
parameter

在数学和统计学裡,参数(英语:parameter)是使用通用变量来建立函数和变量之间关系(当这种关系很难用方程来阐述时)的一个数量。

结构学习技术
Structure learning

结构化预测是监督学习,分类和回归的标准范式的一种推广。 所有这些可以被认为是找到一个能最大限度减少训练集损失的函数。

监督学习技术
Supervised learning

监督式学习(Supervised learning),是机器学习中的一个方法,可以由标记好的训练集中学到或建立一个模式(函数 / learning model),并依此模式推测新的实例。训练集是由一系列的训练范例组成,每个训练范例则由输入对象(通常是向量)和预期输出所组成。函数的输出可以是一个连续的值(称为回归分析),或是预测一个分类标签(称作分类)。

验证集技术
Validation set

验证数据集是用于调整分类器超参数(即模型结构)的一组数据集,它有时也被称为开发集(dev set)。

权重技术
Weight

线性模型中特征的系数,或深度网络中的边。训练线性模型的目标是确定每个特征的理想权重。如果权重为 0,则相应的特征对模型来说没有任何贡献。

深度学习技术
Deep learning

深度学习(deep learning)是机器学习的分支,是一种试图使用包含复杂结构或由多重非线性变换构成的多个处理层对数据进行高层抽象的算法。 深度学习是机器学习中一种基于对数据进行表征学习的算法,至今已有数种深度学习框架,如卷积神经网络和深度置信网络和递归神经网络等已被应用在计算机视觉、语音识别、自然语言处理、音频识别与生物信息学等领域并获取了极好的效果。

张量技术
Tensor

张量是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数,这些线性关系的基本例子有内积、外积、线性映射以及笛卡儿积。其坐标在 维空间内,有 个分量的一种量,其中每个分量都是坐标的函数,而在坐标变换时,这些分量也依照某些规则作线性变换。称为该张量的秩或阶(与矩阵的秩和阶均无关系)。 在数学里,张量是一种几何实体,或者说广义上的“数量”。张量概念包括标量、矢量和线性算子。张量可以用坐标系统来表达,记作标量的数组,但它是定义为“不依赖于参照系的选择的”。张量在物理和工程学中很重要。例如在扩散张量成像中,表达器官对于水的在各个方向的微分透性的张量可以用来产生大脑的扫描图。工程上最重要的例子可能就是应力张量和应变张量了,它们都是二阶张量,对于一般线性材料他们之间的关系由一个四阶弹性张量来决定。

TensorFlow技术
TensorFlow

TensorFlow是一个开源软件库,用于各种感知和语言理解任务的机器学习。目前被50个团队用于研究和生产许多Google商业产品,如语音识别、Gmail、Google 相册和搜索,其中许多产品曾使用过其前任软件DistBelief。

推荐文章