2. 程式人生 > >轉：TensorFlow入門（六） 雙端 LSTM 實現序列標註（分詞）

轉：TensorFlow入門（六） 雙端 LSTM 實現序列標註（分詞）

阿新 • • 發佈：2018-01-13
vsm max poc 代碼 單詞 arch 大致 雙端 fun

http://blog.csdn.net/Jerr__y/article/details/70471066

歡迎轉載，但請務必註明原文出處及作者信息。

@author: huangyongye
@creat_date: 2017-04-19

前言
本例子主要介紹如何使用 TensorFlow 來一步一步構建雙端 LSTM 網絡（聽名字就感覺好膩害的樣子），並完成序列標註的問題。先聲明一下，本文中采用的方法主要參考了【中文分詞系列】 4. 基於雙向LSTM的seq2seq字標註這篇文章。該文章用 keras 框架來實現的雙端 LSTM，在本例中，實現思路和該文章基本上一樣，但是用 TensorFlow 來實現的。這個例子中涉及到的知識點比較多，包括 word embedding, Viterbi 算法等，但是就算你對這些不是非常了解，依然能夠很好地理解本文。

本例的主要目的是講清楚基於 TensorFlow 如何來實現雙端 LSTM。通過本例的學習，你可以知道 Bi-directional LSTM 是怎麽樣一步一步計算的。

為了講清楚這個，我把封裝好的 static_bidirectional_rnn 接口進行展開，自己手寫實現了一遍。如果你只是想急著用一下看看效果的話，我也提供了static_bidirectional_rnn 接口的用法（其實網上多了去）。但是既然用這個東西，當然還是希望把細節也理解透更好。否則的話，還不如直接用 keras 幾行就把模型建好了，中間的變量維度也不需要你過多地考慮，keras 框架已經寫好了自動匹配的功能。但是你用 keras 跑了幾個網絡以後，一問你細節，你啥也不知道。所以，抱著學習的心態，從 TensorFlow 這一比較底層的框架上手還是能有不少收獲的。另外，因為比較底層，我們可以比較靈活的進行模型修改（假設已經到了要改模型這一步…）

由於這個例子的代碼比較長，本文主要就網絡結構部分進行分析。其余的比如數據處理這些在這裏只是簡單介紹，想理解具體內容的歡迎移步 鄙人 GitHub，代碼，數據 什麽的全都放上去了。

如果你還不知道什麽是 LSTM 的話，建議先看一下 （譯）理解 LSTM 網絡 （Understanding LSTM Networks by colah） 這篇文章。在理解 LSTM 的基礎上，再去理解 雙端 LSTM （Bi-directional LSTM）還是非常容易的。關於雙端 LSTM 的原理，這裏不做詳細解釋，下面這張圖顯示了 雙端 RNN 的結構。

技術分享圖片
fig.1 Bi-RNN 按時間展開的結構

Bi-LSTM大致的思路是這樣的，看圖中最下方的輸入層，假設一個樣本（句子）有10個 timestep （字）的輸入 x1,x2,...,x10。 現在有兩個相互分離的 LSTMCell：

  1. 對於前向 fw_cell ，樣本按照x1,x2,...,x10 的順序輸入 cell 中，得到第一組狀態輸出 {h1,h2,...,h10} ;
  2. 對於反向 bw_cell ，樣本按照 x10,x9,...,x1 的反序輸入 cell 中，得到第二組狀態輸出 {h10,h9,...,h1 };
  3. 得到的兩組狀態輸出的每個元素是一個長度為 hidden_size 的向量（一般情況下，h1和h1長度相等）。現在按照下面的形式把兩組狀態變量拼起來{[h1,h1], [h2,h2], … , [h10,h10]}。
  4. 最後對於每個 timestep 的輸入 xt, 都得到一個長度為 2*hidden_size 的狀態輸出 Ht= [ht,ht]。然後呢，後面處理方式和單向 LSTM 一樣。

1. 數據說明

下面大概說一下數據處理，但是這不影響對模型的理解，可以直接跳到

1.1 原始語料在txt文件中，長的下面這個樣子

人/b  們/e  常/s  說/s  生/b  活/e  是/s  一/s  部/s  教/b  科/m  書/e  ，/s  而/s  血/s  與/s  火/s  的/s  戰/b  爭/e  更/s  是/s  不/b  可/m  多/m  得/e  的/s  教/b  科/m  書/e  ，/s  她/s  確/b  實/e  是/s  名/b  副/m  其/m  實/e  的/s  ‘/s  我/s  的/s  大/b  學/e  ’/s  。/s   心/s  靜/s  漸/s  知/s  春/s  似/s  海/s  ，/s  花/s  深/s  每/s  覺/s  影/s
  • 1
  • 2

1.2 根據標點符號進行切分，下面是一個 sample

 人/b  們/e  常/s  說/s  生/b  活/e  是/s  一/s  部/s  教/b  科/m  書/e
  • 1
  • 2

1.3 把每個字和對應的tag轉為一一對應的 id

在轉為 id 之前，跟下表這樣。這樣的東西我們沒辦法塞到模型裏去訓練呀，必須先轉為數值才行呀。

wordstagssentence_len
[人, 們, 常, 說, 生, 活, 是, 一, 部, 教, 科, 書] [b, e, s, s, b, e, s, s, s, b, m, e] 12
[而, 血, 與, 火, 的, 戰, 爭, 更, 是, 不, 可, 多, 得, 的, 教, …] [s, s, s, s, s, b, e, s, s, b, m, m, e, s, b, …] 17

Table.1 按標點切分後的片段

因為一般情況下，我們訓練網絡的時候都喜歡把輸入 padding 到固定的長度，這樣子計算更快。可是切分之後的句子長短不一，因此我們取 32 作為句子長度，超過 32 個字的將把多余的字去掉，少於 32 個字的將用特殊字符填充。處理之前，每個字 word <-> tag，處理完後變成 X <-> y。長度不足 32 的補0填充。(下面編碼問題顯示就這樣，湊合著看吧。)

words:  [u‘\u4eba‘ u‘\u4eec‘ u‘\u5e38‘ u‘\u8bf4‘ u‘\u751f‘ u‘\u6d3b‘ u‘\u662f‘  u‘\u4e00‘ u‘\u90e8‘ u‘\u6559‘ u‘\u79d1‘ u‘\u4e66‘]
tags:  [u‘b‘ u‘e‘ u‘s‘ u‘s‘ u‘b‘ u‘e‘ u‘s‘ u‘s‘ u‘s‘ u‘b‘ u‘m‘ u‘e‘]
X:  [  8  43 320  88  36 198   7   2  41 163 124 245   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0]
y:  [2 4 1 1 2 4 1 1 1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
  • 1
  • 2
  • 3
  • 4
  • 5
跳到這裏！！！

總之，上面這些都不重要，重要的是我們模型的輸入 shape 是下面這樣子的。第一維表示樣本個數，第二維是 timestep_size。其實還有個第三維大小是 1， 因為每個時刻就只輸入一個字，確切地說就是一個數字，因為我們已經把它轉為數值 id 的形式了。

X_train.shape=(205780, 32), y_train.shape=(205780, 32); 
X_valid.shape=(51446, 32), y_valid.shape=(51446, 32);
X_test.shape=(64307, 32), y_test.shape=(64307, 32)
  • 1
  • 2
  • 3
  • 4

2. Bi-directional lstm 模型

2.1 模型分析

import tensorflow as tf
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
from tensorflow.contrib import rnn
import numpy as np

‘‘‘
For Chinese word segmentation.
‘‘‘
# ##################### config ######################
decay = 0.85
max_epoch = 5
max_max_epoch = 10
timestep_size = max_len = 32           # 句子長度
vocab_size = 5159    # 樣本中不同字的個數，根據處理數據的時候得到
input_size = embedding_size = 64       # 字向量長度
class_num = 5
hidden_size = 128    # 隱含層節點數
layer_num = 2        # bi-lstm 層數
max_grad_norm = 5.0  # 最大梯度（超過此值的梯度將被裁剪）

lr = tf.placeholder(tf.float32)
keep_prob = tf.placeholder(tf.float32)
batch_size = tf.placeholder(tf.int32)  # 註意類型必須為 tf.int32
model_save_path = ‘ckpt/bi-lstm.ckpt‘  # 模型保存位置


def weight_variable(shape):
    """Create a weight variable with appropriate initialization."""
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)


def bias_variable(shape):
    """Create a bias variable with appropriate initialization."""
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)


X_inputs = tf.placeholder(tf.int32, [None, timestep_size], name=‘X_input‘)
y_inputs = tf.placeholder(tf.int32, [None, timestep_size], name=‘y_input‘)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

如果你看過我上一篇文章 TensorFlow入門（五）多層 LSTM 通俗易懂版 的話，應該已經知道 LSTM 是怎麽實現的了（如果不懂的話請先把上篇文章看懂再繼續往下看了）。

下面重點終於來啦!!!
在這裏，為了那些不懂 embedding 的朋友能夠看懂下面的代碼，我必須啰嗦幾句說明一下什麽是 word embedding。這是自然語言處理的一個大殺器，我們平時口口聲聲說的詞向量就是這東西。在這個例子中我們指的是字向量，原理完全是一樣的。剛才我們已經說過，每個 timestep 輸入的是一個字對應的 id, 也就是一個整數。經過 embedding 操作之後，就變成了一個長度為 embedding_size（我們可以自己指定字向量的長度） 的實數向量。具體它是怎麽做的呢？如果你是做自然語言處理的應該已經知道了，如果你不是做自然語言處理的呢，那就不用管了。反正，真正輸入到 LSTMCell 中的數據 shape 長這樣 [ batchsize, timestep_size, input_size ]。 input_size 是每個 timestep 輸入樣本的特征維度，如上個例子中就是MNIST字符每行的28個點，那麽就應該 input_size=28。把你要處理的數據整理成這樣的 shape 就可以了，管它什麽 embedding。


def bi_lstm(X_inputs):
    """build the bi-LSTMs network. Return the y_pred"""
    # ** 0.char embedding，請自行理解 embedding 的原理！！做 NLP 的朋友必須理解這個
    embedding = tf.get_variable("embedding", [vocab_size, embedding_size], dtype=tf.float32)
    # X_inputs.shape = [batchsize, timestep_size]  ->  inputs.shape = [batchsize, timestep_size, embedding_size]
    inputs = tf.nn.embedding_lookup(embedding, X_inputs)  
    # ** 1.LSTM 層
    lstm_fw_cell = rnn.BasicLSTMCell(hidden_size, forget_bias=1.0, state_is_tuple=True)
    lstm_bw_cell = rnn.BasicLSTMCell(hidden_size, forget_bias=1.0, state_is_tuple=True)
    # ** 2.dropout
    lstm_fw_cell = rnn.DropoutWrapper(cell=lstm_fw_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    lstm_bw_cell = rnn.DropoutWrapper(cell=lstm_bw_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    # ** 3.多層 LSTM
    cell_fw = rnn.MultiRNNCell([lstm_fw_cell]*layer_num, state_is_tuple=True)
    cell_bw = rnn.MultiRNNCell([lstm_bw_cell]*layer_num, state_is_tuple=True)
    # ** 4.初始狀態
    initial_state_fw = cell_fw.zero_state(batch_size, tf.float32)
    initial_state_bw = cell_bw.zero_state(batch_size, tf.float32)  

    # 下面兩部分是等價的
    # **************************************************************
    # ** 把 inputs 處理成 rnn.static_bidirectional_rnn 的要求形式
    # ** 文檔說明
    # inputs: A length T list of inputs, each a tensor of shape
    # [batch_size, input_size], or a nested tuple of such elements.
    # *************************************************************
    # Unstack to get a list of ‘n_steps‘ tensors of shape (batch_size, n_input)
    # inputs.shape = [batchsize, timestep_size, embedding_size]  ->  timestep_size tensor, each_tensor.shape = [batchsize, embedding_size]
    # inputs = tf.unstack(inputs, timestep_size, 1)
    # ** 5.bi-lstm 計算（tf封裝）  一般采用下面 static_bidirectional_rnn 函數調用。
    #   但是為了理解計算的細節，所以把後面的這段代碼進行展開自己實現了一遍。
#     try:
#         outputs, _, _ = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, 
#                         initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)
#     except Exception: # Old TensorFlow version only returns outputs not states
#         outputs = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, 
#                         initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)
#     output = tf.reshape(tf.concat(outputs, 1), [-1, hidden_size * 2])
    # ***********************************************************

    # ***********************************************************
    # ** 5. bi-lstm 計算（展開）
    with tf.variable_scope(‘bidirectional_rnn‘):
        # *** 下面，兩個網絡是分別計算 output 和 state 
        # Forward direction
        outputs_fw = list()
        state_fw = initial_state_fw
        with tf.variable_scope(‘fw‘):
            for timestep in range(timestep_size):
                if timestep > 0:
                    tf.get_variable_scope().reuse_variables()
                (output_fw, state_fw) = cell_fw(inputs[:, timestep, :], state_fw)
                outputs_fw.append(output_fw)

        # backward direction
        outputs_bw = list()
        state_bw = initial_state_bw
        with tf.variable_scope(‘bw‘) as bw_scope:
            inputs = tf.reverse(inputs, [1])
            for timestep in range(timestep_size):
                if timestep > 0:
                    tf.get_variable_scope().reuse_variables()
                (output_bw, state_bw) = cell_bw(inputs[:, timestep, :], state_bw)
                outputs_bw.append(output_bw)
        # *** 然後把 output_bw 在 timestep 維度進行翻轉
        # outputs_bw.shape = [timestep_size, batch_size, hidden_size]
        outputs_bw = tf.reverse(outputs_bw, [0])
        # 把兩個oupputs 拼成 [timestep_size, batch_size, hidden_size*2]
        output = tf.concat([outputs_fw, outputs_bw], 2)  
        # output.shape 必須和 y_input.shape=[batch_size,timestep_size] 對齊
        output = tf.transpose(output, perm=[1,0,2])
        output = tf.reshape(output, [-1, hidden_size*2])
    # ***********************************************************

    softmax_w = weight_variable([hidden_size * 2, class_num]) 
    softmax_b = bias_variable([class_num]) 
    logits = tf.matmul(output, softmax_w) + softmax_b
    return logits


y_pred = bi_lstm(X_inputs)
# adding extra statistics to monitor
# y_inputs.shape = [batch_size, timestep_size]
correct_prediction = tf.equal(tf.cast(tf.argmax(y_pred, 1), tf.int32), tf.reshape(y_inputs, [-1]))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels = tf.reshape(y_inputs, [-1]), logits = y_pred))

# ***** 優化求解 *******
# 獲取模型的所有參數
tvars = tf.trainable_variables()
# 獲取損失函數對於每個參數的梯度
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)
# 優化器
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
# 梯度下降計算
train_op = optimizer.apply_gradients( zip(grads, tvars),
    global_step=tf.contrib.framework.get_or_create_global_step())
print ‘Finished creating the bi-lstm model.‘
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99

過多的解釋也沒有了，都在上面的代碼中！但還是得說一聲，在這個雙端 LSTM 模型中，重點要理解兩點：

1. 兩個 LSTM （cell_fw, cell_bw）的計算是各自獨立的，只是最後輸出的時候把二者的狀態向量結合起來。
2. 本例中每個 timestep 都有結果輸出，而上篇的分類問題中我們只拿最後一個 h_state 來計算最後的輸出（註意這不是 Bi-LSTM 和 單向 LSTM 的區別， 單向的也可以每個 timestep 都輸出）。註意本例中的 y_input 也對應的每個 timestep 對應一個 tag(id)。
  • 1
  • 2
  • 3

2.2 實驗結果

看一下結果吧，不放結果都是耍流氓 :
（1） 先是分類準確率

**Test 64307, acc=0.948665, cost=0.139884
  • 1
  • 2

（2）實際分詞

人們 / 思考 / 問題 / 往往 / 不是 / 從 / 零開始 / 的 / 。 / 就 / 好 / 像 / 你 / 現在 / 閱讀 / 這 / 篇 / 文章 / 一樣 / ， / 你 / 對 / 每個 / 詞 / 的 / 理解 / 都會 / 依賴 / 於 / 你 / 前面 / 看到 / 的 / 一些 / 詞 / ， /        / 而 / 不是 / 把 / 你 / 前面 / 看 / 的 / 內容 / 全部 / 拋棄 / 了 / ， / 忘記 / 了 / ， / 再去 / 理解 / 這個 / 單詞 / 。 / 也 / 就 / 是 / 說 / ， / 人們 / 的 / 思維 / 總是 / 會 / 有 / 延續 / 性 / 的 / 。 /
  • 1
  • 2

結論：本例子使用 Bi-directional LSTM 來完成了序列標註的問題。本例中展示的是一個分詞任務，但是還有其他的序列標註問題都是可以通過這樣一個架構來實現的，比如 POS（詞性標註）、NER（命名實體識別）等。在本例中，單從分類準確率來看的話差不多到 95% 了，還是可以的。可是最後的分詞效果還不是非常好，但也勉強能達到實用的水平 （詳細請看全部代碼及說明： https://github.com/yongyehuang/Tensorflow-Tutorial/blob/master/Tutorial_6%20-%20Bi-directional%20LSTM%20for%20sequence%20labeling%20(Chinese%20segmentation).ipynb），而且模型也只是粗略地跑了一遍，還沒有進行任何的參數優化。最後的維特比譯碼中轉移概率只是簡單的用了等概分布，如果能根據訓練語料以統計結果作為概率分布的話相信結果能夠進一步提高。

3.reference

[1] 【中文分詞系列】 4. 基於雙向LSTM的seq2seq字標註 http://spaces.ac.cn/archives/3924/
[2] https://github.com/yongyehuang/TensorFlow-Examples/blob/master/examples/3_NeuralNetworks/bidirectional_rnn.py
[3] https://github.com/yongyehuang/deepnlp/blob/master/deepnlp/pos/pos_model_bilstm.py

轉：TensorFlow入門（六） 雙端 LSTM 實現序列標註（分詞）

相關推薦

轉：TensorFlow入門（六） 雙端 LSTM 實現序列標註（分詞）

vsm max poc 代碼 單詞 arch 大致 雙端 fun http://blog.csdn.net/Jerr__y/article/details/70471066 歡迎轉載，但請務必註明原文出處及作者信息。 @author: huangyongye @creat_

TensorFlow入門（六） 雙端 LSTM 實現序列標註（分詞）

歡迎轉載，但請務必註明原文出處及作者資訊。 @author: huangyongye @creat_date: 2017-04-19 前言 本例子主要介紹如何使用 TensorFlow 來一步一步構建雙端 LSTM 網路（聽名字就感覺好膩害的樣子），

自然語言處理（NLP）- HMM+VITERBI演算法實現詞性標註（解碼問題）（動態規劃）（Python實現）

NLP- HMM+維特比演算法進行詞性標註（Python實現）     維特比演算法針對HMM解碼問題，即解碼或者預測問題（下面的第二個問題），尋找最可能的隱藏狀態序列：對於一個特殊的隱馬爾可夫模型(HMM)及一個相應的觀察序列，找到生成此序列最可能的隱藏狀態序列。也就是說

Python編程：從入門到實踐——【作業】——第十一章（測試代碼）

stc 增加 收集 得到 width .com ast 接受 ted 第十一章 11-1 城市和國家 ： 編寫一個函數， 它接受兩個形參： 一個城市名和一個國家名。 這個函數返回一個格式為City, Country 的字符串， 如Santiago, Chile 。 將這個函

Python編程：從入門到實踐——【作業】——第十四章（記分）

wid ont elif pac rom ext splay 添加 能夠 第十四章 14-1 按P開始新遊戲 ： 鑒於遊戲《外星人入侵》 使用鍵盤來控制飛船， 最好讓玩家也能夠通過按鍵來開始遊戲。 請添加讓玩家在按P時開始遊戲的代碼。 也許這樣做會有所幫助： 將check_

基於雙端堆實現的優先順序佇列（3）：外觀

   本文講述雙端堆的5個公開泛型操作演算法：make_dheap（原位構造雙端堆）、push_dheap（插入元素）、pop_max_dheap（刪除最大元素）、pop_min_dheap（刪除最小元素），is_dheap（堆驗證），每個演算法都提供<小於運算子和仿函式比較2個版本，要注意

基於雙端堆實現的優先順序佇列（1）：原理

前言    眾所周知，stl中的優先順序佇列是基於最大堆實現的，能夠在對數時間內插入元素和獲取優先順序最高的元素，但如果要求在對數時間內還能獲取優先順序最低的元素，而不只是獲取優先順序最高的元素，該怎麼實現呢？可以用最大堆-最小堆或雙端堆資料結構來實現，最大堆-最小堆和雙端堆都是支援雙端優先佇列

基於雙端堆實現的優先順序佇列（2）：內幕

   在《基於雙端堆實現的優先順序佇列（1）：原理》一文中講述了雙端堆的相關原理，本文則詳細講述具體的內部實現，便於區分，內部函式名稱都以雙下劃線作為字首，在這裡，有幾個關鍵問題需要說明    1）怎麼求一個結點的對稱結點：如果完全二叉樹根結點從索引1開始但不儲存元素，那麼最小堆根結點則在索引2

轉：CentOS 7使用nmcli配置雙網卡聚合LACP

lob ifconf centos7 運行程序 edge 鏈路聚合 網關 最長 ref 進入CentOS 7以後，網絡方面變化比較大，例如eth0不見了，ifconfig不見了，其原因是網絡服務全部都由NetworkManager管理了，下面記錄下今天下午用nmcli配置的

Python第三方庫jieba（結巴-中文分詞）入門與進階（官方文檔）

修改 demo 特點 pypi nlp CA 動態修改 tag 官方文檔 jieba “結巴”中文分詞：做最好的 Python 中文分詞組件。下載地址：https://github.com/fxsjy/jieba 特點 支持三種分詞模式： 精確模式，試圖將句子最精確地

excel oracle欄位命名（大寫下劃線分詞）轉 駝峰命名

  （帕斯卡） =LEFT(C251,1)&MID(SUBSTITUTE(PROPER(C251),"_",""),2,100) （駝峰） =LOWER(LEFT(A:A,1))&MID(SUBSTITUTE(PROPER(A:A),"_",""),2,10

（六）springboot + mybatis plus實現多表聯查分頁3.X版本

註明 ： 上兩篇文章我們講解了springboot+mybatis-plus對於單表的CRUD和條件構造器的使用方法，但是對於我們的實戰專案中多表聯查也是經常會出現的。今天我們就來說下怎麼在springboot+MP模式下實現多表聯查並分頁。 MP推薦使用的是

【資料結構】棧的儲存結構（二）雙端棧

雙端棧 雙端棧是為了更有效的利用棧的空間而產生的。 雙端棧是一種特殊的順序棧。 雙端棧適用於一組互補的資料。 雙端棧兩端為底，2個整形表示棧頂指標。 程式碼收穫 主要還是弄清雙端棧的結構。 棧的歸檔 #include <stdio.h> #

深度學習筆記：tensorflow 入門 變數初始化

# 變數op # 1、變數能夠持久化儲存，普通的張量op是不行的 # 2、當定義一個變數op的時候，一定要在會話當中去執行初始化 a = tf.constant([1, 2, 3, 4, 5]) var = tf.Variable(tf.random_no

深度學習：tensorflow入門：tf讀入資料

同步讀取資料 import tensorflow as tf # 模擬一下同步先處理資料，然後才能取訓練資料 # tensorflow中，執行操作有依賴性 # 1、首先定義佇列 Q = tf.FIFOQueue(3, tf.float32) # 放入一些資

深度學習：tensorflow入門：卷積神經網路實現MNIST手寫字型識別

程式碼中./data/mnist/input_data/為真實MNIST資料集的路徑 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # 定義

自己動手實現java資料結構（四）雙端佇列

自己動手實現java資料結構（四）雙端佇列 1.雙端佇列介紹 　　在介紹雙端佇列之前，我們需要先介紹佇列的概念。和棧相對應，在許多演算法設計中，需要一種"先進先出(First Input First Output)"的資料結構，因而一種被稱為"佇列(Queue)"的資料結構被抽象了出來(因為

Python：Python 中 jieba 庫的使用（中文分詞）

==================================================================一、說明：    1、支援三種分詞模式：             精確模式，試圖將句子最精確地切開，適合文字分析             全模式

觸發器（六、instead of觸發器實現檢視增刪改）

場景描述 開發中遇到一個情況：前臺頁面是一個角色對使用者的批量授權，其中使用者是多選，多選的結果是控制元件裡會填入逗號分隔的使用者ID字串，比如“TOM,JERRY”，最終要分別插入2張一對多的主從表中。 --主表 CREATE TABLE T_MAIN (

架構之路：nginx與IIS服務器搭建集群實現負載均衡（二）

原創 not c盤 鏈接 發布 原創文章 hang 實戰 負載均衡 【前言】 在《架構之路：nginx與IIS服務器搭建集群實現負載均衡（一）》中小編簡單的講解了Nginx的原理！俗話說：光說不練假把式。接下來，小編就和大家一起來做個小Demo來體會一下Nginx的