tensorflow API 参数记录

一、x_train处理流程：文本->jieba分词->->去除停用词->learn.preprocessing.VocabularyProcessor（将句子中的词用数字id映射）-->word_embedding;

1)cnn模型之前的word_embedding输入处理：

word_vectors = tf.contrib.layers.embed_sequence(         features, vocab_size=n_words, embed_dim=EMBEDDING_SIZE, scope='words')     word_vectors = tf.expand_dims(word_vectors, 3)

2）词袋模型之前的word_embedding输入处理：

features = encoders.bow_encoder(             features, vocab_size = n_words, embed_dim=EMBEDDING_SIZE)

3）gru模型之前的wording_embedding输入处理：

word_vectors = tf.contrib.layers.embed_sequence(             features, vocab_size=n_words, embed_dim=EMBEDDING_SIZE, scope='words') #返回 [batch_size, sequence_length, embed_dim]      word_list = tf.unstack(word_vectors, axis=1)

二、y_label处理流程：将list类别map成id--->one_hot编码

cate_dic = {'technology':1, 'car':2, 'entertainment':3, 'military':4, 'sports':5} train_target = map(lambda x:cate_dic[x], train_target) test_target = map(lambda x:cate_dic[x], test_target) y_train = pandas.Series(train_target) y_test = pandas.Series(test_target)

三、API

1)tf.contrib.layers.embed_sequence(features, vocab_size, embed_dim): 输入[batch_size, sequence_length]的tensor，返回[batch_size, sequence_length, embed_dim]的tensor，相当于初始化每个词向量. features: 形状为[batch_size, doc_length]的int32或int64张量; vocab_size：输入数据的总词汇量，指的是总共有多少泪词汇，不是总个数； embed_dim：想要得到的嵌入矩阵的维度。

2)learn.preprocessing.VocabularyProcessor(max_document_length,min_frequency=0,vocabulary=None, tokenizer_fn=None)

创建一个词汇表，将每个词map一个数字id，然后对每个句子，将其表示成数字id；

max_document_length：文档最大长度，如果文本的长度小于最大长度，它会被剪切，反之则用0填充； min_frequency：词频的最小值，出现次数>最小词频的词才会被收录到词表中； tokenizer_fn ：分词函数

global n_words vocab_processor = learn.preprocessing.VocabularyProcessor(MAX_DOCUMENT_LENGTH, min_frequency=MIN_WORD_FREQUENCE) x_train = np.array(list(vocab_processor.fit_transform(train_data))) #fit：给每个词编一个唯一的id号,对每个句子，将它的词map为id编号； x_test = np.array(list(vocab_processor.transform(test_data))) n_words = len(vocab_processor.vocabulary_)

3) tensorflow的二维卷积有三种，分别是tf.nn.conv2d, tf.layers.conv2d, tf.contrib.layers.conv2d，相比而言, tf.layers.conv2d使用起来更为方便简单，它不需要对权重初始化设置，只需要填写卷积核的数量和大小即可。

3.1）res = tf.layers.conv2d(x,filters=32,kernel_size=[3,3],strides=1,padding='SAME') #即用32个3*3的卷积核对x进行卷积操作。

与tf.nn.conv2d不同的是，tf.nn.conv2d不仅需要对权重初始化，还需要定义卷积核的维度，例如，如果我们要用64个3*3的卷积核对大小为256*256*32的图像进行卷积的话，卷积核需要设置为[3,3,32,64]，这样就太麻烦了。
3.2) tf.nn.conv2d:卷积操作

tf.nn.conv2d(     input, # [batch,in_height,in_width,in_channels]的输入图像，分别是图片数量，高度，宽度，通道数     filter, #  [filter_height,filter_width,in_channels,out_channels]，滤波器高度，宽度，图像通道数，滤波器个数     strides, #卷积在每一维的步长,[1,stride,stride,1]     padding,     use_cudnn_on_gpu=True,     data_format='NHWC',     dilations=[1, 1, 1, 1],     name=None )

3.3) tf.contrib.layers.convolution2d：做了大量的设置，不必再写全部

inputs:输入张量，维度是：[batch, in_height, in_width, in_channels]

tf.nn.max_pool(                        h,    #需要池化的输入，依旧是[batch_size, height, width, channels]这样的shape                     ksize=[1, height, width, 1],   #池化窗口的大小                     strides=[1, 1, 1, 1],  #窗口在每个维度上滑动的步长，一般是[1, stride,stride, 1]                     padding='VALID', #填充的方法，SAME或VALID，SAME表示添加全0填充，VALID表示不添加                     name="pool") 最终得到的pool的shape为： [batch_size, height_1-height_2+1, width_1-width_2+1，channels]

4）tf.contrib.layers.fully_connected()：增加一个全连接层，自动化初始w和b，激活函数默认为relu，输出个数由num_outputs指定

tf.contrib.layers.fully_connected( inputs, num_outputs, activation_fn=tf.nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=tf.zeros_initializer(), biases_regularizer=None, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, scope=None )

5） tf.contrib.rnn.LSTMCell(rnn_size,initializer=tf.random_uniform_initializer(-0.1,0.1,seed=2))

#rnn_size:LSTM网络单元的个数，即隐藏层的节点数或者说LSTM的units大小，也就是说你要讲embeding_size维度的特征映射成多少维度的新特征，embedding_size和这个输出维度共同决定了LSTM的参数大小。

至于cell这个概念，其实我觉得一个rnn后者lstm层就称为一个cell。属于整体结构的一个叫法。比如TF里面有个multiRNNCell其实就是多层rnn连接在一起。

6） tf.contrib.rnn.static_rnn(cell, inputs, initial_state=None, dtype=None, sequence_length=None, scope=None)

cell: 用于神经网络的RNN神经元,如BasicRNNCell,BasicLSTMCell

inputs: 一个长度为T的list，list中的每一个元素为一个Tensor，Tensor形如[batch_size, input_size]

输出：[n_steps,batch,n_hidden] 

构建GRU网络： cell = tf.contrib.rnn.GRUCell(EMBEDDING_SIZE) #    _, encoding = tf.contrib.rnn.static_rnn(cell, word_list, dtype=tf.float32) logits = tf.contrib.layers.fully_connected(encoding, 5, activation_fn=None) #全连接

7) tf.squeeze(input, squeeze_dims=None, name=None)：删掉所有维度为1的那些维度

squeeze_dims：删掉特定为1的维度列表

8) tf.one_hot(
    indices,#输入，这里是一维的
    depth,# one hot dimension.
    on_value=None,#output 默认1
    off_value=None,#output 默认0
    axis=None,
    dtype=None,
    name=None
)

9)  tf.expand_dims：用于给函数增加维度

tf.expand_dims( input, axis=None, name=None, dim=None )： input是输入张量； axis：指定扩大输入张量形状的维度索引值；

10） tf.unstack(   #对矩阵进行分解
          value,  #待分解的矩阵变量，就是一个多维数组
         num=None, 
        axis=0,   #指明对矩阵的哪个维度进行分解
        name='unstack' )

11) seq2seq

encoder: lstm_cell = tf.contrib.rnn.LSTMCell(rnn_size,initializer=tf.random_uniform_initializer(-0.1,0.1,seed=2))  cell =  tf.contrib.rnn.MultiRNNCell([get_lstm_cell(rnn_size) for _ in range(num_layers)]) #将多个BasicLSTMCell单元汇总为一个，多层LSTM  encoder_output , encoder_state = tf.nn.dynamic_rnn(cell,encoder_embed_input,sequence_length=source_sequence_length,dtype=tf.float32) return encoder_output,encoder_state

12) tf.nn.dynamic_rnn(
    cell,  
    inputs,
    sequence_length=None,
    initial_state=None,
    dtype=None,
    parallel_iterations=None,
    swap_memory=False,
    time_major=False,
    scope=None)

输出outputs:是一个tensor， 如果time_major==True, outputs形状为[max_time, batch_size, cell.output_size](要求rnn输入与输出形状保持一致); 如果time_major==False, outputs形状为[batch_size, max_time, cell.output_size]

states:是一个tensor，state是最终的转改，也就是序列中最厚一个cell输出的状态，一般情况下state的形状为[bach_size, cell.output_size], 但当输入的cell为BasicLSTMCell时，state的形状为[2, batch_size, cell.output_size]，因为LSTM的state是由Ct和ht组成的，其中2对应着LSTM中的cell state和hidden state。其实state就是ht，state==outputs[-1]，即ht与outputs中的最后一时刻的输出相等。