tensorflow和python操作中的笔记

　　前一段时间做了一些项目，把一些笔记放在了txt中，现分享出来，自己也能够时长预习。

1） 读取文件时，将固定的文件地址，采用数组或者字符串的形式，提前表示出来，后期使用时候采用拼接操作
2）    # 得到该目录下的文件
    file_list = os.listdir(base_path + '/data/cnn_train/')
    file_list
    Out[6]: ['finance', 'it', 'sports']
3） 打开一个文件
    f = open(base_path + '/data/cnn_train/' + c + '/' + files, 'r', encoding='gbk', errors='ignore')
4） 使用re.sub(pattern, repl, string),进行特定字符的替换，中间参数是要替换的字符，返回需要的字符串
5） 用list()将分词后的数据变成列表的形式，便于后期处理
6） 对于数据来说，数据集是一个列表，数据的标记也是一个列表，用于后期处理
    post_list(data)
    lebel_list(label)
7) .append()方法，在后面追加数据的时候是保持原来数据的形状的情况下实现的
    a = ['d', 'e', 'w', 'o', 'uo']
    b = b = ['d', 'e', 'w', 'o', 'uo']
    a.append(b)
    ['d', 'e', 'w', 'o', 'uo', ['d', 'e', 'w', 'o', 'uo']]
8)    itertools,python的内置模块
    一个重要的方法：chain(),给他一个list,tuple,iterables，将他们链接在一起;返回iterables对象
    a = ['deng', 'ye', 'xun']
    itertools.chain(a)
9）    Counter是实现的dict的一个子类，用来方便计数。from collections import Counter
    统计元素出现的个数：Counter(可迭代对象），返回是一个字典，放回字符的个数。例如：
    a = 'abcasddejioahnfus'
    Counter(a)
    Out[27]:
Counter({'a': 3,
         'b': 1,
         'c': 1,
         'd': 2,
         'e': 1,
         'f': 1,
         'h': 1,
         'i': 1,
         'j': 1,
         'n': 1,
         'o': 1,
         's': 2,
         'u': 1})

10）存到字典里面：{x:i for i,x in enumerate(XXX)}
    存到数组里面：[x for x in XXX]

    x = [ '的', '在', '了', '是', '和']
    d = {x:i for i,x in enumerate(x)}
    d:{'了': 2, '和': 4, '在': 1, '是': 3, '的': 0}
11) numpy.random.permutation      随机排列一个序列,返回一个排列的序列;
    函数shuffle与permutation都是对原来的数组进行重新洗牌（即随机打乱原来的元素顺序）；
    区别在于shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值。而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱顺序的数组，并不改变原来的数组
    np.random.permutation(np.arange(10))
    Out[48]: array([3, 8, 1, 2, 9, 4, 0, 7, 5, 6])

12) range()返回的是range object，而np.nrange()返回的是numpy.ndarray()  range尽可用于迭代，而np.nrange作用远不止于此，它是一个序列，可被当做向量使用。
    np.arange(10)
    Out[47]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
13) yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后开始
14)tf.truncated_normal(shape,mean,stdev):shape表示生成张量的维度，mean是均值，stddev是均值。用来生成随机数，随机数与均值的差距不会超过两倍的标准差，而其它的函数则会
15)loss,计算输出值和实际值的损失，这个损失通常采用交叉熵损失。
    tf.nn.softmax_cross_entropy_with_logits()函数是求交叉熵损失函数。功能：计算labels和logits之间的交叉熵。
    # API 说明
    tf.nn.softmax_cross_entropy_with_logits(
    _sentinel=None,
    labels=None,
    logits=None,
    dim=-1,
    name=None
    )
    解释：第一个参数基本不用；第二个参数是一个分类标签，不同的是这个分类标签labels是分类的概率，比如说[0.2,0.3,0.5],所以每一行必须为一个概率分布值
            对于第三个函数，logit本身是一个函数，他把每一个概率p从[0,1]映射到正负无穷区间，形式话表示为logit=ln(p/(1-p))。理解为：原生态的，未经缩放的，视为一种未归一化的log概率。所以softmax的作用是将其归一化到0-1之间，累积和为1，经过softmax加工过的数据可以当做概率来使用。也就是说logits作为softmax的输入。

16)机器学习的任务就是最小化损失，在损失已经确定的情况下，剩下的事情就交给优化器了。本质：梯度下降算法的优化
    常用的优化器：
    1）tf.train.GradientDescentOptimizer(learning_rate, use_looking=False, name='GradientDescent')
        功能：实现梯度下降算法的优化器，此处给一个学习速率就可以了
    2）tf.train.AdagradOptimizer()
        功能：实现Adagrad算法的优化器，此处给一个学习速率就可以了
    3) tf.train.AdamOptimizer()
        功能：实现Adam算法的优化器，默认有参数

17）np.linespace(开始，结束， 间隔),从matlab中学习得到的，构建一个等差数据
18）python 中的zip操作，可以理解成一个拉链，将两个list拉到一起来，组合后合并成一个list
    例子：
    x = zip(['a','b','c'],[1,2,3])
    list(x)
    Out[65]: [('a', 1), ('b', 2), ('c', 3)]
19）在python中，使用.dot()进行矩阵相乘
20）np.array()的强大功能已经体现出来了,切记一定要将数据转化成numpy array
        shuffle_index = np.random.permutation(np.arange(len(y)))
        y:[[0],
         [1],
         [2],
         [3],
         [4],
         [5],
         [6],
         [7],
         [8],
         [9],
         [10],
         [11],
         [12],
         [13],
         [14],
         [15],
         [16],
         [17],
         [18],
         [19]]
        如果不用np.array()就会出错，y[shuffle_index]
        必须使用：np.array(y)[shuffle_index]

21）# tf.reshape(tensor, shape, name=None)的使用.功能：张量变形。和原始张量具有相同的值，但是形状改变。如果shape的一个分量是特殊值-1，则计算该维度的大小，以使总大小保持不变。特别地情况为，一个[-1]维的shape变平成1维。
    # tf.random_normal()必须配合variable使用
    # tf.get_variable(name, shape, initializer) 创建变量。name：变量的名称；shape变量的维度；initializer：变量初始化的方式
    tf.constant_initializer：常量初始化函数

    tf.random_normal_initializer：正态分布

    tf.truncated_normal_initializer：截取的正态分布

    tf.random_uniform_initializer：均匀分布

    tf.zeros_initializer：全部是0

    tf.ones_initializer：全是1

    tf.uniform_unit_scaling_initializer：满足均匀分布，但不影响输出数量级的随机值

22）tf.Graph()函数非常重要
    1.可以通过Tensorboard图形化界面展示出流程结构
    2.整合一段代码为一个整体存在于图中
    声明情况有三种：1）通过张量本身直接给出Graph;2)通过声明一个默认的，然后定义张量内容，在后面可以调用或保存;3)通过多个声明，在后面通过变量名来分别调用
    对graph的操作主要有三种：1）保存；2）从pb文件中读取；3）穿插调用
23）tf.train.write_graph(一个图，保存路径，文件名， False),写一个图到一个文件中
24）加载图，tf.import_graph_def(graph_def, name='')
25）tf.nn.embedding_lookup：Looks up ids in a list of embedding tensors，在词嵌入张量中查找ids
    tf.nn.embedding_lookup(
    params,
    ids,
    partition_strategy='mod',
    name=None,
    validate_indices=True,
    max_norm=None
    )
26）tf.expand_dims(),在特定索引的位置上增加一个维度
    tf.expand_dims(
    input,
    axis=None,
    name=None,
    dim=None
    )
27）卷积操作：tf.nn.conv2d(input, filter, strides, padding)，给定一个4维输入和滤波器张量，计算2维卷积。输出，和输入具有相同的维度
    给定输入张量的形状：[batch, in_height, in_width, in_channels]，滤波器张量的形状：[filter_height, filter_width, in_channels, out_channels]
    对于strides=[1, stride, stride, 1], strides[0]=strides[3]=1,默认必须
28）tf.nn.bias_add(value, bias)，将偏差项bias加到value上。value是一个tensor，bias必须是1维的。value可以有不同的维度，bias要和values的最后1维度相同
29）tf.nn.max_pool(value, ksize, strides, padding, name=None);在输入张量上执行最大池化
    value:需要池化的输入数据，一般是接在卷积层后面，通常为feature，shape=[batch, height, width, channels],4维数据同输入数据一致
    ksize:池化窗口的大小，取一个4维向量，shape=[1, height, width, 1],不想在batch和channels做池化，这两个维度为1
    strides：窗口在每一个维度上滑动的步长，一般也是shape=[1, stride, stride, 1]
    padding:为'VALID''SAME'
30)tf.nn.relu(features):计算非线性值，即max(features, 0),features是卷积后加上偏置的值
31)tf.concat(values, axis):沿着一个维度拼接张量。axis=0,按照行，横着接，对接到后面。
32)tf.nn.dropout(x, keep_prob):防止过拟合。x:输入tensor；keep_prob:每个元素被保留下来的概率，float类型。根据给定的keep_prob,将tensor x按照比例输出
33)tf.contrib.layers.xavier_initializer():返回一个用于初始化权重的初始化程序Xavier，保持每一层的梯度大小都差不多相同。返回初始化权重矩阵
    tf.contrib.layers.xavier_initializer(
    uniform=True,
    seed=None,
    dtype=tf.float32
    )
34)tf.nn.l2_loss(tensor):利用L2范数计算张量的误差值，但是没有开方并且只取了L2范数的一半。output=sum(t**2)/2。在这里为什么要计算w的平方，这是一个正则化项，需要将这个损失添加到train_loss上，W的每一个数值都要计算机平方
35)tf.nn.xw_plus_b(x, weight, biases):计算机matmul(x, weight)+b
36)tf.reduce_mean(x, axis):根据输入张量的维度计算均值。axis=1是求行均值，axis=0是求列均值
    tf.reduce_mean(
    input_tensor,
    axis=None,
    keepdims=None,
    name=None,
    reduction_indices=None,
    keep_dims=None
    )
37)tf.argmax(input, axis):计算输入tensor的行或者列的最大值的索引。0表示按列，1表示按行。返回：一般是行或列的最大值下标向量
    tf.argmax(
        input,
        axis=None,
        name=None,
        dimension=None,
        output_type=tf.int64
    )
38)tf.equal(x,y):返回矩阵或者向量对应位置相等的元素真值。相等返回True，不等返回False
39)tf.cast(x, dtype):类型转换函数，将一个张量转换到其它类型。dtype目标类型
40)在整个session运行之前，图中的所有variable必须要被初始化。variable的值在sess.run(inti)之后就确定了，Tensor的值要在sess.run(x)之后确定
41)tf.summary.scalar(name, tensor) 对标量数据汇总和记录，一般在画loss和accuary时用到
42)global_step在优化器train的时候使用很方便，就是统计全局执行的步数，训练到多少轮了，类似于一个钟表。
    初始化：global_step = tf.Variable(0, trainalbe=False)
    train_op = optimizer.minimize(loss, global_step=global_step)

43)定义了词嵌入矩阵，将输入的词id转化成词向量，这里的词嵌入矩阵是可以训练的，最后将词向量结果增加了一个维度，为了匹配CNN的输入.然而研究证明，TextCnn在文本分类问题上有着更加卓越的表现

在工作用到TextCNN做query推荐，并结合先关的文献，谈几点经验：
1、TextCNN是一个n-gram特征提取器，对于训练集中没有的n-gram不能很好的提取。对于有些n-gram，可能过于强烈，反而会干扰模型，造成误分类。
2、TextCNN对词语的顺序不敏感，在query推荐中，我把正样本分词后得到的term做随机排序，正确率并没有降低太多，当然，其中一方面的原因短query本身对term的顺序要求不敏感。隔壁组有用textcnn做博彩网页识别，正确率接近95%，在对网页内容（长文本）做随机排序后，正确率大概是85%。
3、TextCNN擅长长本文分类，在这一方面可以做到很高正确率。
4、TextCNN在模型结构方面有很多参数可调，具体参看文末的文献。

44)tf.train.latest_checkpoint:发现最新保存的checkpoint文件
    tf.train.latest_checkpoint(
    checkpoint_dir,
    latest_filename=None
    )
45)tf.get_collection():使用默认图加载数据列表
    tf.get_collection(
    key,
    scope=None
)
46)当你使用tensorflow是你会定义一个图，然后给这个图feed数据和定义一些超参，注意当网络被保存时，placeholder()是不会被保存的
    在恢复网络的时候，不仅要恢复图好权重，也需要准备一个新的feed_dict，将新的训练数据喂给网络。我们可以使用graph.get_tensor_by_name('weights:0')获得已保存的operations和placeholder variables
47)np.load()和np.save()是numpy专用的二进制类型保存和加载数据，使用他读写数组很方便。
    np.save(filename, X)；第一个参数为存储的文件名，第二个参数为需要存储的数组(1维或者2维度)
    np.load(filename):将数据读出维array类型
48)含有yield函数不是一般的函数，他会把函数变成一个generator,调用此函数不会执行该函数，而是返回一个iterator对象。在for循环时，每次循环都会执行函数内部代码，执行到yield x时候，函数就返回一个迭代值，下次迭代时候就会从yield的下一条语句执行
    yield 的好处是显而易见的，把一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 的值，不仅代码简洁，而且执行流程异常清晰。
49)tf.summary.FileWriter
    ...create a graph...
    # Launch the graph in a session.
    sess = tf.Session()
    # Create a summary writer, add the 'graph' to the event file.
    writer = tf.summary.FileWriter(<some-directory>, sess.graph)
50)shutil模块中的rmtree移除整个目录，无论是否为空。shutil.rmtree(目录路径)
51)tf.assign():通过给value值来更新ref
    tf.assign(
        ref,
        value,
        validate_shape=None,
        use_locking=None,
        name=None
    )
52)记住，在写tensorflow网络的时候，对于每一个部分都要使用tf.name_sacope('name')明确定义域，这样在tensorboard查看时比较清晰；还有，对于每一个变量，每一个常量都要有name，这一点非常重要
53)tensorboard的可视化是一个好东西，summary是概要，保存变量。
    tf.summary.scalar('name', var);
    tf.summary.histogram('name', var);
    writer = tf.summary.FileWriter(logdir, sess.graph)
    merged = tf.summary.merge_all()
    summary = sess.run(merged)
    writer.add_summary(summary, i)
54)深度神经网络代码
def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
    # 定义大节点的名字
    with tf.name_scope(layer_name):
        with tf.name_scope('weight'):
            weights = tf.Variable(tf.truncated_normal([input_dim, output_dim]), dtype=tf.float32, name='weight')
            tf.summary.histogram('weights', weights)
        with tf.name_scope('bias'):
            biases = tf.Variable(tf.constant(0.1, dtype=tf.float32, shape=[output_dim]), name='bias')
            tf.summary.histogram('biases', biases)
        with tf.name_scope('wx_plus_b'):
            preactivate = tf.nn.bias_add(tf.matmul(input_tensor, weights), biases)
            tf.summary.histogram('preactivate', preactivate)
        activation = act(preactivate, name='activation')
        return activation
55)对于dropout和relu的两个操作，relu是包含在上一节点的操作中，是激活部分，不可缺少。所以，先relu之后再对结果dropout
    keep_prob是保留概率，即我们要保留的RELU的结果所占比例，tensorflow建议的语法是，让它作为一个placeholder，在run时传入
56)tf.placeholder(tf.float32, name='')
57)词频统计的最有效方式是：Counter()函数，和itertools组合使用时，必须要用*来指引
    sen = [['deng'],['ye','xun'],['meihao']]
    Counter(list(itertools.chain(*sen)))
58)tensorflow使用训练好的模型做测试。有两种方法，第一种方法：saver.save()和saver.restore()方法，不方便在于使用模型的时候必须把模型的结构重新定义一遍，然后载入对应名字的变量值，
    但是我们所希望的是能够读取一个文件然后就直接使用模型，而不是要把模型重新定义一遍；第二种方法，不需要重新定义网络结构，从文件中将保存的graph所有节点加载到当前的default中，并返回一个saver，这样在
    保存的时候除了将变量的值保存下来，还保存了对应graph中的各种节点，所以模型的结构同样被保存下来。
59)data = np.array([[1,2,3],[4,5,6]];data.shape结果:(2,3),那么data.shape[1]就是取出列数
60)模型越深越宽，就越复杂，也就很难训练。要有耐心，一定要等到收敛结束再看结果
61)tf.contrib.rnn.BasicRNNCell(num_units, forget_bias=1.0, stat_is_tuple=True)：最近本的RNN单元，num_units输入RNN单元的个数，隐含层神经元的个数;forget_bias=1.0不会遗忘，为0，就都忘记。stat_is_tuple默认是True，是说返回的状态用
一个元组表示，state=(c, h)。有一个状态初始化函数，zero_state(batch_size, dtype),batch_size是输入样本批次额数目.
    LSTM中有两个状态值，分别是c和h，对应想要的输出。其中h作为当前状态输出的同时，也是下一时间段的输入的一部分
62)例子，
    import tensorflow as tf

    batch_size = 4
    input = tf.random_normal(shape=[3, batch_size, 6], dtype=tf.float32)
    cell = tf.nn.rnn_cell.BasicaLSTMCell(10, forget_bias=1.0, state_is_tuple=True)
    init_state = cell.zero_state(batch_size, dtype=tf.float32)
    output, final_state = tf.nn.dynamic_rnn(cell, input, inittial_state=init_state, time_major=True)
    # time_major如果是True，就表示RNN的steps用第一个维度表示，建议用这个，运行速度块
    # 如果是True，output的维度是[steps, batch_size, depth], 反之就是[batch_size, max_time, depth],就是和输入一样的
    # final_state是整个LSTM输出的最终的状态，包含c和h，c和h的维度都是[batch_size, n_hidden]

63)搭建LSTM要点
# 把784个点的字符信息还原成 28 * 28 的图片
# 下面几个步骤是实现 RNN / LSTM 的关键
####################################################################
# **步骤1：RNN 的输入shape = (batch_size, timestep_size, input_size)
X = tf.reshape(_X, [-1, 28, 28])

# **步骤2：定义一层 LSTM_cell，只需要说明 hidden_size, 它会自动匹配输入的 X 的维度
lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)

# **步骤3：添加 dropout layer, 一般只设置 output_keep_prob
lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)

# **步骤4：调用 MultiRNNCell 来实现多层 LSTM
mlstm_cell = rnn.MultiRNNCell([lstm_cell] * layer_num, state_is_tuple=True)

# **步骤5：用全零来初始化state
init_state = mlstm_cell.zero_state(batch_size, dtype=tf.float32)

# **步骤6：方法一，调用 dynamic_rnn() 来让我们构建好的网络运行起来
# ** 当 time_major==False 时， outputs.shape = [batch_size, timestep_size, hidden_size]
# ** 所以，可以取 h_state = outputs[:, -1, :] 作为最后输出
# ** state.shape = [layer_num, 2, batch_size, hidden_size],
# ** 或者，可以取 h_state = state[-1][1] 作为最后输出
# ** 最后输出维度是 [batch_size, hidden_size]
# outputs, state = tf.nn.dynamic_rnn(mlstm_cell, inputs=X, initial_state=init_state, time_major=False)
# h_state = outputs[:, - 1, :]  # 或者 h_state = state[-1][1]

# *************** 为了更好的理解 LSTM 工作原理，我们把上面 步骤6 中的函数自己来实现 ***************
# 通过查看文档你会发现， RNNCell 都提供了一个 __call__()函数（见最后附），我们可以用它来展开实现LSTM按时间步迭代。
# **步骤6：方法二，按时间步展开计算
outputs = list()
state = init_state
with tf.variable_scope('RNN'):
    for timestep in range(timestep_size):
        if timestep > 0:
            tf.get_variable_scope().reuse_variables()
        # 这里的state保存了每一层 LSTM 的状态
        (cell_output, state) = mlstm_cell(X[:, timestep, :], state)
        outputs.append(cell_output)

64)tf.app.run()函数：用来处理flag解析，然后执行main函数。
    tf.app.flags.DEFINE_boolean('self_test', False, 'True is running a self test')
    tf.app.flags.DEFINE_boolean('use_fp16', False, 'whta is true')
    FLAGS = tf.flags.FALAGS
    执行过程：首先加载flags参数项，然后执行main()函数。参数是使用tf.app.flags.FLAGS中定义的
    例子：
    import tensorflow as tf

    FLAGS = tf.app.flags.FLAGS
    # 定义
    tf.app.flags.DEFINE_string('string', 'train', 'This is a string')
    tf.app.flags.DEFINE_float('learning_rate', 0.001, 'This is a learning_rate')
    tf.app.flags.DEFINE_boolean('boolean', True, 'This is a flag')

    def main():
        print('string', FLAGS.string)
        print('learning_rate', FLAGS.learning_rate)
        print('boolean', FLAGS.boolean)

    if __name__ == '__mian__':
        tf.app.run()

65)当网络达到收敛时，要懂得调参技巧，调整方法就是保持其它参数不变，只调整一个参数，需要调整的参数有：
    1)learning_rate
    2)minibatch size
    3)epoch
    4)filter size
    5)number of filter:奇数个
    网络调参的主方向：1.更深的网络，2.更加复杂的结构

66)os.listdir(str):获取字符串下目录下的所有子目录
67)os.path.join(str1, str2, str3):用于拼接文件路径，其中可以传入多个参数
68)codecs:读写中英文字符，编码转换。使用：codecs.open()
67)copy.copy(obj):属于浅拷贝
68)python数据存储于读取，pickle.dump(),pickel.load()
69)@property:为默认的属性生成getter和setter方法
70)numpy.squeeze(a, axis=None):删除数组中的单维度条目，shape=1的删除
71)numpy.argsort(a, axis=1):将矩阵a按照axis排序，axis=0，行固定，改变列；axis=1，列固定，改变行。返回排序后的下标值索引。
72)numpy.random.choice(a=x, size=3，p):随机等概率地从x中选取3个数据，p指定一个分布
73)tf.reset_default_graph:清除默认的图站，重置全局默认图
74)tf.one_hot(indices, depth)返回一个one_hot 张量，indices一维的索引，就是要存放one hot哪一个为1， depth表示one hot dimension.
75)tf.add_to_collection('list_name', element):将元素element添加到列表list_name中
76)tf.get_collection('list_name'):返回名称为list_name的列表。进行样本预测的时候使用。既然是list就可以通过下标索引的方式获取数值
77)tf.get_default_graph(),一个默认的图总是被注册了，就是会出现，调用该方法就是获得当前默认图
78)tf.Graph.get_operation_by_name(name):根据名称返回操作节点
79)tf.Graph.get_tensor_by_name(name):根据名称返回tensor数据
80)未登录词：没有被收录在分词词表中但必须切分出来的词，包括各类专有名词（人名，地名，企业名），缩写词、新增词汇等。
81)停用词：对预料建设没有作用的词，的，了，而且，等等
82)元组转化为数组形式，好东西：np.array()
83)Graph是一个就像一个大容器，OP,Tensor, Variable是这个大容器的组成部分
84)模型的使用，卡了很久的解决办法，现在贴出来
checkpoint_file=tf.train.latest_checkpoint(checkpoint_directory)
graph=tf.Graph()

 with graph.as_default():
     session_conf = tf.ConfigProto(allow_safe_placement=True, log_device_placement =False)
     sess = tf.Session(config = session_conf)
     with sess.as_default():
          saver =     tf.train.import_meta_graph("{}.meta".format(checkpoint_file))
          saver.restore(sess,checkpoint_file)
          input = graph.get_operation_by_name("input").outputs[0]
          prediction=graph.get_operation_by_name("prediction").outputs[0]
          #newdata=put your data here
          print sess.run(prediction,feed_dict={input:newdata})
85)收获：今早对新的样本进行了模型的结果预测。遇到的问题是，传递给feed_dict{}的x数据要和原始训练模型输入的数据维度保持一致。
    我们在查看一个矩阵的shape时候，显示的是矩阵的形状，如shape=[2,3],表示一个二维矩阵，第一个维度有2个元素，第二个维度有3个元素，只是代表形状，不代表具体矩阵
    当传递给feed里面的占位符时候，需要实际具体的矩阵而不是形状，如二维矩阵：x_data:[[1,2],[1,1]]，总之形状和具体矩阵不要混淆。
86)预测一个样本实例：
# 模型预测
with tf.Session() as sess:
    # 加载元数据,找到流程图
    new_saver = tf.train.import_meta_graph(model_path)
    # 加载ckpt
    new_saver.restore(sess, tf.train.latest_checkpoint(model_name))
    # 获取节点
    target = tf.get_collection('pred_network')[0]
    graph = tf.get_default_graph()
    # 获取placeholder,要注意，不同scope下的名字要一层一层的调用才能找到最终的操作.一定要使用获取该操作后的那个outputs的输出，然后取第一个
    # 必须要有outputs[0]，目前我还不知道这个是啥意思。
    input_x = graph.get_operation_by_name('inputs/inputs').outputs[0]
    keep_p = graph.get_operation_by_name('keep_prob/keep_prob').outputs[0]

    pred_result = sess.run(target, feed_dict={input_x: x1, keep_p: 1.0})
    print(pred_result)

87)tf.nn.conv1d();跟2维卷积相比，没有厚度的卷积。
tf.nn.conv1d(
    value,
    filters,
    stride,
    padding,
    use_cudnn_on_gpu=None,
    data_format=None,
    name=None
)

value: A 3D Tensor. Must be of type float16 or float32.
filters: A 3D Tensor. Must have the same type as value.
stride: An integer. The number of entries by which the filter is moved right at each step.
padding: 'SAME' or 'VALID'
use_cudnn_on_gpu: An optional bool. Defaults to True.
data_format: An optional string from "NWC", "NCW". Defaults to "NWC", the data is stored in the order of [batch, in_width, in_channels]. The "NCW" format stores data as [batch, in_channels, in_width].
name: A name for the operation (optional).

二维卷积：
tf.nn.conv2d():
tf.nn.conv2d(
    input,
    filter,
    strides,
    padding,
    use_cudnn_on_gpu=True,
    data_format='NHWC',
    dilations=[1, 1, 1, 1],
    name=None
)

input: A Tensor. Must be one of the following types: half, bfloat16, float32, float64. A 4-D tensor. The dimension order is interpreted according to the value of data_format, see below for details.
filter: A Tensor. Must have the same type as input. A 4-D tensor of shape [filter_height, filter_width, in_channels, out_channels]
strides: A list of ints. 1-D tensor of length 4. The stride of the sliding window for each dimension of input. The dimension order is determined by the value of data_format, see below for details.
padding: A string from: "SAME", "VALID". The type of padding algorithm to use.
use_cudnn_on_gpu: An optional bool. Defaults to True.
data_format: An optional string from: "NHWC", "NCHW". Defaults to "NHWC". Specify the data format of the input and output data. With the default format "NHWC", the data is stored in the order of: [batch, height, width, channels]. Alternatively, the format could be "NCHW", the data storage order of: [batch, channels, height, width].
dilations: An optional list of ints. Defaults to [1, 1, 1, 1]. 1-D tensor of length 4. The dilation factor for each dimension of input. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of data_format, see above for details. Dilations in the batch and depth dimensions must be 1.
name: A name for the operation (optional).

88)当出现：
UnicodeDecodeError: 'gbk' codec can't decode byte 0xab in position 11126: illegal multibyte sequence
解决：可以使用‘ignore’属性进行忽略，如：open(‘1.txt’,encoding=’gb18030’，errors=‘ignore’)
89)编码不正常：file_name = open('d:/a.txt', 'r', encoding='utf-8')。读取文件的时候要加上编码限制。
90)tf.ConfigProto()用来创建session的时候对session进行参数配置
    tf.ConfigProto(log_device_placement=True):记录设备指派情况，可以获取operations和Tensor被指派到哪个设备上运行，会在终端打印出任何操作
    tf.ConfigProto(allow_soft_placement=True):自动选择运行设备。在tf中，通过命令with tf.device('/cpu:0')，允许手动设置操作运行的设备，如果手动设置的设备不存在或者不可用，就会导致tf程序等待或异常，为了防止这种情况，可以设置tf.ConfigProto()中参数allow_soft_placement=True，允许tf自动选择一个存在并且可用的设备来运行操作。
    限制GPU资源的使用
    操作:session_conf = tf.ConfigProto(log_device_placement=True)
        sess = tf.Session(conf=session_conf)

91)采用枚举类型自动为list中的数据做索引，可以同时得到数据和索引
    例子：
    filter_sizes = [1,2,3]
    for i, filter_size in enumerate(filter_sizes)

92) 建立一个时间戳，独一无二的数据。建立一个绝对路径目录，在该处您能够存储自己的数据
    timestamp = str(int(time.time()))
    out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", timestamp))
    print("Writing to {}\n".format(out_dir))
93)检查目录是否存在。一般我们需要原来就有的目录进行数据操作，以下命令可以很好地服务于我们的工作
    if not os.path.exists(my_dir):
        os.makedirs(my_dir)
94)日期的快速格式：
    datetime.datetime.now().isocalendar()   格式：(2018, 31, 5)
    datetime.datetime.now().isoformat()        格式：'2018-08-03T15:43:30.793866'
    datetime.datetime.now().isoweekday()    格式： 5
95)自定义日期格式：
    datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    结果：'2018-08-03 15:51:15'
96)tf.train.global_step(sess, global_step):可以获取当前global_step的值
97)比较骚的一种关于存数据的方法：
    sessdict{}
    if not qid in sessdict:
        sessdict[qid] = []
    # 再往这个字典key=qid的值（为list）追加数据
    sessdict[qid].append(val_one, val_two)
98)遍历字典中的key和value
    d = {'a':1, 'b':2}
    d.items()
99)直接对列表进行排序：
    list.sort(func=None, key=None, reverse=False)
    当reverse=False时：为正向排序；当reverse=True时：为方向排序
    key:以什么来排序
    执行完后会改变原来的list，如果你不需要原来的list，这种效率稍微高点
100)operator.itmgetter()函数：operator模块提供的itemgetter函数用于获取对象的哪些维的数据，参数为一些序号。
    要注意，operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。
    例如：a = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]，根据第2个域和第3个域进行排序
    v.sort(key=operator.itemgetter(1,2))
101)把数字变成字符串，在打印输出的时候使用最为方便：str(28)
102)对于一个字符串，我们要处理这个字符串里面的每一个字符，那么，可以先用特殊的分隔符如'\t'或者' '，把他组成一个列表。如
    strings = 'I am very happy'
    words = strings.strip().split(' ')
103)读取文件，并进行操作的最佳方式
    for line in open('./folder/a.txt'):
        s = line.strip().split('\t')
    写入文件的最佳方式
    of = open('./folder/a.txt', 'w'):
        of.write('a b c')
        of.write('this is end! + '\n')
    of.close()

104)计算两句话的编辑距离，不用夹角余弦了。
    from nltk.metrics import distance
    distance.edit_distance('中国的首都', '中国的首都在哪')
105)SPARQL使用
from SPARQLWrapper import SPARQLWrapper, JSON

def QA():
    # 初始化，endpoint对外提供服务的链接，D2RQ默认的链接：http://localhost:2020/sparql
    sparql = SPARQLWrapper('http://localhost:2020/sparql')
    # 设置查询语句
    sparql.setQuery(
        """
            PREFIX : <http://www.kgdemo.com#>
            PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

            select ?n where{
                ?s rdf:type :Person.
                ?s :personName '巩俐'.
                ?s :hasActedIn ?o.
                ?o :movieTitle ?n.
                ?o :movieRating ?r.
            FILTER(?r >= 7)
            }
        """
    )
    # 设置返回个格式为JSON
    sparql.setReturnFormat(JSON)
    results = sparql.query().convert()

    # {'head': {'vars': ['n']},
    #  'results': {'bindings': [{'n': {'type': 'literal', 'value': '2046'}},
    #                           {'n': {'type': 'literal', 'value': 'Memoirs of a Geisha'}},
    #                           {'n': {'type': 'literal', 'value': '荆轲刺秦王'}},
    #                           {'n': {'type': 'literal', 'value': '大红灯笼高高挂'}},
    #                           {'n': {'type': 'literal', 'value': '霸王别姬'}},
    #                           {'n': {'type': 'literal', 'value': '活着'}},
    #                           {'n': {'type': 'literal', 'value': '唐伯虎点秋香'}},
    #                           {'n': {'type': 'literal', 'value': '秋菊打官司'}},
    #                           {'n': {'type': 'literal', 'value': '菊豆'}},
    #                           {'n': {'type': 'literal', 'value': 'Hong gao liang'}},
    #                           {'n': {'type': 'literal', 'value': '画魂'}},
    #                           {'n': {'type': 'literal', 'value': '风月'}},
    #                           {'n': {'type': 'literal', 'value': 'Piao Liang Ma Ma'}},
    #                           # {'n': {'type': 'literal', 'value': 'The Hand'}}]}}

    # 遍历找出value的值
    for result in results['results']['bindings']:
        print(result['n']['value'])

106)mysql免安装版设置步骤
    1.配置环境变量，把..\bin\下的文件都放入到Path中
    2.初始化mysql，打开cmd，执行命令：mysqld --initialize；
    3.打开mysql服务，打开cmd，执行：mysqld --install；
    4.启动mysql
    5.是因为无法找到MySQL执行文件，需要我们配置注册表，Win+R运行输入regedit来启动注册表，找到HKEY_LOCAL_MECHINE---SYSTEM---CurrentControlSet---services:
    6.设置root密码，先执行：mysqld --skip-grant-tables
    7.再开启一个命令提示符，执行：mysql。之后，更改root密码：update mysql.user set password=password(“root”) where user = “root”;
    8.刷新权限：flush privileges;
    9.退出：quit
107)mysqldb是python便于同数据库连接的工具类，使用方便，是mysqldb的一个高级版本，兼容python2和python3
108)mysql数据库操作
    查看数据库的编码格式：show variables like 'character_set_database';
    查看表的的编码格式：show create table entity_relation_info;
    可以使用nvaicat数据库管理软件方便地编辑字符编码，也要不断探索其它的功能
109)mysqladmin -u root -p shutdown
再net start mysql就没有这个错误提示了~
110)使用python编写一个类，方便使用.在一个文件中可以建立一个类，使用一个类，也就是说这个类在哪个文件夹中都行，只要导入即可
    class DataSet(object):
        def __init__(self, data_size):
            self.a = 10
            self.b = 11
            self.c = 12
        def get_batch(self):
            x = self.a
            y = self.b

        def get_info(self):
            q = self.a
            z = self.b
    # 使用这个类,构建一个对象
    trainds = DataSet(100);
    one = trains.get_batch()

111)进行单元测试的总结
    1.导入unittest包
    2.定义一个Test类，继承自unittest.TestCase
    3.在类中定义各种测试方法，进行测试使用
    4.在主函数中使用:unittest.main()执行单元测试
112)数据库中存储的数据都是字符串
113)argpares是一个好东西，可以在执行训练函数的时候选择参数，
    如：python train.py --hiden_size=200 --num_step = 35
114)SDK软件工具开发包，由第三方服务商提供的实现软件产品某项功能的工具包。通常以集合KPI和文档、范例、工具的形式出现。
    SDK是专业性质的公司提供专业服务的集合。开发者不需要对产品每个功能进行开发，选择合适、稳定的SDK服务并花费很少的精力即可在
    产品中
115)这个数据结构用的比较好
    result = list['row_index'], list['start_index'], list['end_index']
    通过查找result的下标索引找到这3个数据
    result[0],result[1],result[2]
    其中，r是元组
116)repr(object):将对象转化为供解释器读取的形式，str是面向用户的，repr是面向程序员的
    返回：一个对象的string形式
117)插入对c++的学习：
    C++中会常用到.和::和:和->,在此整理一下常用函数的区别
    1.当出现A.B，那么A为结构体或者对象；
    2.当出现A->B，则A为指针，->为成员提取，A->B是提取A中的成员B，A只能是指向类、结构和联合的指针
    3.但出现::，那么为域运算符，A::B指作用域A中的名称B，A可以是命名空间、类、结构
    4.当出现:，一般表示继承
118)C++中的结构体：属于聚合数据类型的一类，它将不同的数据类型整合在一起构成一个新的类型，相当于数据库中的一条记录。和类具有相似的作用，类就是由结构体发展而来。
119)C++中，&引用的一个重要作用就是作为函数的参数
    如：void swap(int &p1, int &p2){}
    常引用，既要引用提高程序的执行效率，又要保护传递给函数的数据不在函数中被改变，就应该使用常引用
    声明格式：const 类型标识符 &引用名=目标变量名；
    不能够通过引用对目标变量的值进行修改，从而使引用的目标成为const，达到了引用的安全性
    例如：
    int a;
    const int &ra = a;
    ra=1;// 错误
    a=1;// 正确
120)pandas将读取的数据转换为列表，方便操作，df.values.tolist()