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推薦，並結合先關的文獻，談幾點經驗： 
一、TextCNN是一個n-gram特徵提取器，對於訓練集中沒有的n-gram不能很好的提取。對於有些n-gram，可能過於強烈，反而會干擾模型，形成誤分類。 
二、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()