2. 程式人生 > >lua，torch，nn模組入門筆記

lua，torch，nn模組入門筆記

阿新 • • 發佈：2019-01-11

最近看到好多論文的神經網路都是用lua基於torch實現的，於是迫不得已學學lua和torch以及nn模組，才能看懂人家的程式碼。

首先看教程和文件：

nn模組

簡單操作

nn.Narrow()

這是nn標準庫中的提取矩陣中對應子塊的函式，官方定義如下：
module = nn.Narrow(dimension, offset, length)
用法如下：

> x = torch.rand(4, 5)
> x
 0.3695  0.2017  0.4485  0.4638  0.0513
 0.9222  0.1877  0.3388  0.6265  0.5659
 

 0.8785  0.7394  0.8265  0.9212  0.0129
 0.2290  0.7971  0.2113  0.1097  0.3166
[torch.DoubleTensor of size 4x5]

> nn.Narrow(1, 2, 3):forward(x)
 0.9222  0.1877  0.3388  0.6265  0.5659
 0.8785  0.7394  0.8265  0.9212  0.0129
 0.2290  0.7971  0.2113  0.1097  0.3166
[torch.DoubleTensor of size 3x5]

> nn.Narrow(1, 2, -1):forward(x)
 0.9222
 
  0.1877  0.3388  0.6265  0.5659
 0.8785  0.7394  0.8265  0.9212  0.0129
 0.2290  0.7971  0.2113  0.1097  0.3166
[torch.DoubleTensor of size 3x5]

> nn.Narrow(1, 2, 2):forward(x)
 0.9222  0.1877  0.3388  0.6265  0.5659
 0.8785  0.7394  0.8265  0.9212  0.0129
[torch.DoubleTensor of size 2x5]

> nn.Narrow(1, 2, -2):forward(x)
 0.9222
 
  0.1877  0.3388  0.6265  0.5659
 0.8785  0.7394  0.8265  0.9212  0.0129
[torch.DoubleTensor of size 2x5]

> nn.Narrow(2, 2, 3):forward(x)
 0.2017  0.4485  0.4638
 0.1877  0.3388  0.6265
 0.7394  0.8265  0.9212
 0.7971  0.2113  0.1097
[torch.DoubleTensor of size 4x3]

> nn.Narrow(2, 2, -2):forward(x)
 0.2017  0.4485  0.4638
 0.1877  0.3388  0.6265
 0.7394  0.8265  0.9212
 0.7971  0.2113  0.1097
[torch.DoubleTensor of size 4x3]

可以看到，dimension=1時為按行取(1為起始序號),dimension=2時為按列取。length為正數時表示取多少行或者列，為負數是表示取到倒數第幾行或者列，其中-1表示最後。

注意，在Lua中進行擷取或分片時，是包含開始和結束這兩個元素的。如上面所示，從第2行開始取是包含第二行的，取到-2行是包含倒數第二行的，這一點與python不同

nn.CMulTable()

這個函式的輸入為幾個向量的table（在lua裡所有列表、陣列、矩陣都是table），輸出這個table裡各個向量component-wise的乘積。用法如下：

ii = {torch.ones(5)*2, torch.ones(5)*3, torch.ones(5)*4}
m = nn.CMulTable()
=m:forward(ii)
 24
 24
 24
 24
 24
[torch.DoubleTensor of dimension 5]

nn.CAddTable()用於幾個矩陣相加，也同樣是component-wise的

nn.Identity()

這個函式建立一個輸入模組，什麼都不做，通常用在神經網路的輸入層。用法如下：

mlp = nn.Identity()
print(mlp:forward(torch.ones(5, 2)))

輸出：

 1  1
 1  1
 1  1
 1  1
 1  1
[torch.Tensor of dimension 5x2]

這個官網上的例子可能令人費解。再看一下一個LSTM中的例子：

local inputs = {}
table.insert(inputs, nn.Identity()())   -- network input
table.insert(inputs, nn.Identity()())   -- c at time t-1
table.insert(inputs, nn.Identity()())   -- h at time t-1
local input = inputs[1]
local prev_c = inputs[2]
local prev_h = inputs[3]

在這裡，用nn.Identity()作為輸入模組，存到inputs中，暫時為空。在程式中呼叫時，分別輸入3個向量，即對應到模組中的3個Indentity。如下中的forward.

th>LSTM = require'LSTM.lua'                                                                                [0.0224s]
th> layer = LSTM.create(3, 2)
                                             [0.0019s]
th> layer:forward({torch.randn(1,3), torch.randn(1,2), torch.randn(1,2)})
{
  1 : DoubleTensor - size: 1x2
  2 : DoubleTensor - size: 1x2
}                                                    
                                             [0.0005s]

nn.View()

module = nn.View(sizes)

這個函式使用指定的size建立了一個view(這是一個物件). 這個size引數既可以是一個數字，也可以是一個LongStorage(陣列樣子的物件). 它自己有個 setNumInputDims() 函式可以指定輸入的維數.如果使用longstorage,當其中一個維度引數為-1時就是使用minibatch. 另外一個方法resetSize(sizes) 可以在初始化之後重置view的輸入大小。

這個函式的大概作用就是把輸入變成指定大小的矩陣。我就是在一個conv網路中看到這個函式的：

-- input is batch_size x length x input_size
nn.View(1, -1, input_size):setNumInputDims(2)(input)

上面的程式碼把input變成了3維的，第一維是大小為1，第二維大小沒有指定，最後一維為input_size。推斷可知，第二維的大小為 batch_size * length。由於指定了輸入維數是2，可想而知batch_size為1
不是很明白？那看看官網的例子：

> x = torch.Tensor(4, 4)
> for i = 1, 4 do
>    for j = 1, 4 do
>       x[i][j] = (i-1)*4+j
>    end
> end
> print(x)

  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16
[torch.Tensor of dimension 4x4]

> print(nn.View(2, 8):forward(x))

  1   2   3   4   5   6   7   8
  9  10  11  12  13  14  15  16
[torch.DoubleTensor of dimension 2x8]

> print(nn.View(torch.LongStorage{8,2}):forward(x))

  1   2
  3   4
  5   6
  7   8
  9  10
 11  12
 13  14
 15  16
[torch.DoubleTensor of dimension 8x2]

nn.Squeeze()

module=nn.squeeze([dim, numInputDims])
or torch.squeeze([dim])

這個函式和torch.squeeze([dim])一樣，將高維陣列中單層的陣列去掉，壓縮陣列。如果給出了dim，那麼只會在dim維度上進行該操作。看一下官網的例子：

x=torch.rand(2,1,2,1,2)
> x
(1,1,1,.,.) =
  0.6020  0.8897

(2,1,1,.,.) =
  0.4713  0.2645

(1,1,2,.,.) =
  0.4441  0.9792

(2,1,2,.,.) =
  0.5467  0.8648
[torch.DoubleTensor of dimension 2x1x2x1x2]

這時，x 的形狀是這樣的：

+-------------------------------+
| +---------------------------+ |
| | +-----------------------+ | |
| | |   0.6020  0.8897      | | |
| | +-----------------------+ | |
| | +-----------------------+ | |
| | |   0.4441  0.9792      | | |
| | +-----------------------+ | |
| +---------------------------+ |
|                               |
| +---------------------------+ |
| | +-----------------------+ | |
| | |   0.4713  0.2645      | | |
| | +-----------------------+ | |
| | +-----------------------+ | |
| | |   0.5467  0.8648      | | |
| | +-----------------------+ | |
| +---------------------------+ |
+-------------------------------+

然後進行squeeze:

> torch.squeeze(x)
(1,.,.) =
  0.6020  0.8897
  0.4441  0.9792

(2,.,.) =
  0.4713  0.2645
  0.5467  0.8648
[torch.DoubleTensor of dimension 2x2x2]

這時，形狀變成了這樣的：

+-------------------------------+
|       0.6020  0.8897          |
|       0.4441  0.9792          |
+-------------------------------+
+-------------------------------+
|       0.4713  0.2645          |
|       0.5467  0.8648          |
+-------------------------------+

nn.JoinTable()

module = JoinTable(dimension, nInputDims)

這個函式建立了一個模組，將輸入的張量陣列在dimension維度上進行合併並輸出。可選的引數nInputDims表示接收的輸入的維數，這樣可以使得minibatch 或者非batch的輸入同樣可以通過這個模組。下面是dimension=1（按列）時的圖示：

+----------+             +-----------+
| {input1, +-------------> output[1] |
|          |           +-----------+-+
|  input2, +-----------> output[2] |
|          |         +-----------+-+
|  input3} +---------> output[3] |
+----------+         +-----------+

例子如下：

x = torch.randn(5, 1)
y = torch.randn(5, 1)
z = torch.randn(2, 1)

print(nn.JoinTable(1):forward{x, y})
print(nn.JoinTable(2):forward{x, y})
print(nn.JoinTable(1):forward{x, z})

>1.3965
 0.5146
-1.5244
-0.9540
 0.4256
 0.1575
 0.4491
 0.6580
 0.1784
-1.7362
[torch.DoubleTensor of dimension 10x1]

 1.3965  0.1575
 0.5146  0.4491
-1.5244  0.6580
-0.9540  0.1784
 0.4256 -1.7362
[torch.DoubleTensor of dimension 5x2]

 1.3965
 0.5146
-1.5244
-0.9540
 0.4256
-1.2660
 1.0869
[torch.Tensor of dimension 7x1]

nn.BatchNormalization()

module = nn.BatchNormalization(N [, eps] [, momentum] [,affine])

N是輸入的維數，eps是一個很小的值加在標準差上來避免分母為0，預設值是1e-5。affine是布林值，當為false時，仿射變換不可被學習，預設值為true。momentum 的預設值為0.1。

訓練時，這個層會動態計算它的均值和標準差，測試時這個均值和標準差用來歸一化。

歸一化之後的值為：

              x - mean(x)
y =  ----------------------------- * gamma + beta
      standard-deviation(x) + eps

nn.gModel()

nngraph(nn) 是一個基於有向無環圖的模組，所有的節點建立完後，需要使用nn.gModel()組成一個圖。

module=nn.gModule(input,output)

這裡的input 和output既可以是元素，也可以是列表。這個函式會生成一個從input到output的圖。其中此前的每一個模組後面加上該模組輸入，成為這個圖中的節點。
給出一個簡單的例子：

 x1 = nn.Identity()()
 x2 = nn.Identity()()
 a = nn.CAddTable()({x1, x2})
 m = nn.gModule({x1, x2}, {a})

這裡只是對兩個輸入進行了合併，然後進行輸出，一個有3個模組，對應3個圖節點，其中兩個是輸入節點。這樣會生成一個如下圖的計算圖，這樣在呼叫m的時候會根據這個圖進行計算，輸出a的值。

__|__   __|__
|    |  |    |
|____|  |____|
| x1    | x2
 \     /
  \z  /
  _\ /_
 |    |
 |____|
    |a

卷積

先說說時序卷積模組：
不算第一維batch維，時序卷積的輸入是一個2維的矩陣。第一維是輸入序列的數目(e.g.nInputFrame), 第二維是每個輸入序列包含的特徵維數 (e.g.inputFrameSize). 這個模組通常用來處理聲學訊號或者是單詞序列,例如用在Natural Language Processing.

nn.TemporalConvolution()

module = nn.TemporalConvolution(inputFrameSize, outputFrameSize, kW, [dW])

回到這個函式，這個函式對一個輸入序列進行一個維度上的卷積，這個輸入由nInputFrame個定長序列（Frame）組成。這個輸入向量在前饋過程中是一個二維的(nInputFrame* inputFrameSize)或者三維的(nBatchFrame*nInputFrame*inputFrameSize)張量。

引數的意義如下：

  • inputFrameSize: The input frame size expected in sequences given into forward().
  • outputFrameSize: The output frame size the convolution layer will produce.
  • kW: The kernel width of the convolution
  • dW: The step of the convolution. Default is 1.

注意：根據我們定的卷積核的大小，輸入序列中最後的一些Frame會不夠核的大小，這時我們需要進行一些補齊或者丟棄。

如果我們輸入的是一個二維的張量(nInputFrame*inputFrameSize) ，那麼經過卷積之後，輸出序列的大小為nOutputFrame *outputFrameSize，而nOutputFrame為

nOutputFrame = (nInputFrame - kW) / dW + 1

如果輸入序列是一個3維的張量nBatchFrame x nInputFrame x inputFrameSize, 那麼輸出的張量大小為 nBatchFrame x nOutputFrame x outputFrameSize.
下面是一個簡單的例子：

inp=5;  -- dimensionality of one sequence element
outp=1; -- number of derived features for one sequence element
kw=1;   -- kernel only operates on one sequence element per step
dw=1;   -- we step once and go on to the next sequence element

mlp=nn.TemporalConvolution(inp,outp,kw,dw)

x=torch.rand(7,inp) -- a sequence of 7 elements
print(mlp:forward(x))
>
-0.9109
-0.9872
-0.6808
-0.9403
-0.9680
-0.6901
-0.6387
[torch.Tensor of dimension 7x1]

nn.TemporalMaxPooling()

module = nn.TemporalMaxPooling(kW, [dW])

顧名思義，這個函式是進行maxpooling的，對輸入序列進行一個維度上的操作。每次pooling的區域大小為kW, 步長為dW。
如果我們輸入的是一個二維的張量(nInputFrame*inputFrameSize) ，那麼經過卷積之後，輸出序列的大小為nOutputFrame *inputFrameSize，而nOutputFrame為

nOutputFrame = (nInputFrame - kW) / dW + 1

nn.SpatialConvolution()

module = nn.SpatialConvolution(nInputPlane, nOutputPlane, kW, kH, [dW], [dH], [padW], [padH])
or  cudnn.SpatialConvolution(nInputPlane, nOutputPlane, width, height, [dW = 1], [dH = 1], [padW = 0], [padH = 0],[groups=1])

對多個輸入平面在空間上進行2維卷積，期待的出入大小為 (nInputPlane x height x width).
下面是各個引數：

  • nInputPlane: The number of expected input planes in the image given into forward().
  • nOutputPlane: The number of output planes the convolution layer will produce.
  • kW: The kernel width of the convolution
  • kH: The kernel height of the convolution
  • dW: The step of the convolution in the width dimension. Default is 1.
  • dH: The step of the convolution in the height dimension. Default is 1.
  • padW: The additional zeros added per width to the input planes. Default is 0, a good number is (kW-1)/2.
  • padH: The additional zeros added per height to the input planes. Default is padW, a good number is (kH-1)/2.

如果輸入是一個3維的張量(nInputPlane * height * width), 那麼輸出大小就是 nOutputPlane * oheight * owidth，其中

owidth  = floor((width  + 2*padW - kW) / dW + 1)
oheight = floor((height + 2*padH - kH) / dH + 1)

所以，這個和時序的卷積的區別就是，可以對多個平面進行卷積。通常為了加快速度，使用cudnn庫的卷積，因為可以GPU加速

同樣有cudnn.SpatialMaxPooling()，但是引數跟空間卷積一樣，作用和時序的maxpooling一樣，就不詳細說了。

nn.LookupTable()

module = nn.LookupTable(nIndex, size, [paddingValue], [maxNorm], [normType])

這個層的作用就是根據輸入的序號找都應的向量。當呼叫forward(input),它假設輸入是一個1維的或者2維的張量，裡面的元素都是序號。如果輸入是一個矩陣，那麼每一行被看作是給定batch的一個輸入樣本。序號從1開始，到nIndex。對每一個序號，輸出一個對應的大小為size的向量（矩陣）。

如果某些輸入跟其他輸入相比很頻繁的話，LookupTable 會很慢。這種情況在輸入補零時經常發生。在BP的時候，每個輸入會建立一個程序，這樣在生成n x size1 x size2 x … x sizeN形成瓶頸。n是一維輸入的維數。
看看例子：

-- a lookup table containing 10 tensors of size 3
 module = nn.LookupTable(10, 3)

 input = torch.Tensor{1,2,1,10}
 print(module:forward(input))
>
-1.4415 -0.1001 -0.1708
-0.6945 -0.4350  0.7977
-1.4415 -0.1001 -0.1708
-0.0745  1.9275  1.0915
[torch.DoubleTensor of dimension 4x3]

如果輸入是二維的話，每一個集合被看成一個batch：

-- a batch of 2 samples of 4 indices each
 input = torch.Tensor({{1,2,4,5},{4,3,2,10}})
 print(module:forward(input))
 >
 (1,.,.) =
 -0.0570 -1.5354  1.8555
 -0.9067  1.3392  0.6275
  1.9662  0.4645 -0.8111
  0.1103  1.7811  1.5969

(2,.,.) =
  1.9662  0.4645 -0.8111
  0.0026 -1.4547 -0.5154
 -0.9067  1.3392  0.6275
 -0.0193 -0.8641  0.7396
[torch.DoubleTensor of dimension 2x4x3]

Criterion

這個模組包含了各式各樣的訓練時的代價函式。最常用的是交叉熵，Negative log-likelihood 等。

nn.ClassNLLCriterion()

在分類問題中，這個Negative log-likelihood準則很常用。

criterion = nn.ClassNLLCriterion([weights])

通常這個函式用於n分類問題的log-softmax之後，即假定輸入都是log處理後的值。如果不想加一個log-softmax層，可以使用後面的CrossEntropyCriterion。如果指定了weight向量，則每個類別的值將乘以對應權重。代價函式可以描述為:

loss(x, class) = -x[class]

如果指定了權重，則代價函式為：

loss(x, class) = -weights[class] * x[class]

訓練一個簡單的模型

以這個準則為例，下面的程式碼告訴我們怎麼訓練一個mlp網路，並更新引數。輸入是x，輸出是pred，期望的輸出是y：

function gradUpdate(mlp, x, y, learningRate)
   local criterion = nn.ClassNLLCriterion()
   local pred = mlp:forward(x)
   local err = criterion:forward(pred, y)
   mlp:zeroGradParameters()
   local t = criterion:backward(pred, y)
   mlp:backward(x, t)
   mlp:updateParameters(learningRate)
end

通常，一個網路在torch中被稱為一個模組Module.裡面主要有4個函式：forward(),backward(),zeroGradParameters()和updateParameters()。這些函式的使用方法如下：

  • forward(input) 給定輸入，計算這個網路模組的輸出
  • backward(input, gradOutput)給定輸入和當前的引數，計算這個網路中引數的梯度.
  • zeroGradParameters()將網路模組中的引數的梯度置0
  • updateParameters(learningRate) 在執行完backward之後用它返回的梯度更新引數

總結上面的訓練過程，就是先進行mlp:forward()計算結果pred,然後使用criterion:forward(pred,y)計算誤差(這一步可以沒有),再使用criterion:backward(pred,y)計算輸出層梯度t，利用mlp:backward(x,t)計算整個網路的梯度，最後mlp:updateParameters()更新整個網路的引數~

**注意:在掉用backward()之前必須先呼叫forward()，否則計算出來的梯度是錯誤的！**

nn.CrossEntropyCriterion()

這個交叉熵準則結合了LogSoftMax 和ClassNLLCriterion.

criterion = nn.CrossEntropyCriterion([weights])

weights的作用與上面的ClassNLLCriterion 相同，不同的是代價函式：

loss(x, class) = -log(exp(x[class]) / (\sum_j exp(x[j])))
               = -x[class] + log(\sum_j exp(x[j]))

相關推薦

lua，torch，nn模組入門筆記

最近看到好多論文的神經網路都是用lua基於torch實現的，於是迫不得已學學lua和torch以及nn模組，才能看懂人家的程式碼。 首先看教程和文件： nn模組 簡單操作 nn.Narrow() 這是nn標準庫中的提取矩陣中對應子

Python入門學習筆記————16(模組，包，名稱空間)

模組 一個模組就是一個包含Python程式碼的檔案，字尾名為.py。 模組 程式太大，編寫維護非常不方便，需要拆分 模組可以增加模組的複用 當做名稱空間使用，避免命名衝突 模組的定義 模組就是普通檔案，任何程式碼

JS入門筆記+基本操作（剛接觸JS，很多筆記就是看到啥寫啥的，希望多多包涵）。

外部 friend mage fff pen scrip 表示 num 很好 1.註釋： html的註釋:<!--我是註釋--> CSS的註釋:/*我是註釋*/ JS的註釋://我是註釋 2.變量： 變量要先聲明再賦值，如下： var mychar; myc

Oracle-4 - ：超級適合初學者的入門級筆記：plsql，基本語法，記錄類型，循環，遊標，異常處理，存儲過程，存儲函數，觸發器

個人 就會 逗號 n) 循環結構 less 寫上 所有 targe 初學者可以從查詢到現在的pl/sql的內容都可以在我這裏的筆記中找到，希望能幫到大家，視頻資源在 資源， 我自己的全套筆記在 筆記 在pl/sql中可以繼續使用的sql關鍵字有：update delet

Android圖片載入框架最全解析（六），探究Glide的自定義模組功能(筆記)

參考原文：Android圖片載入框架最全解析（六），探究Glide的自定義模組功能 自定義模組的基本用法 自定義模組功能可以將更改Glide配置，替換Glide元件等操作獨立出來，使得我們能輕鬆地對Glide的各種配置進行自定義，並且又和Glide的圖片載入邏輯沒有任何交集，

Python零基礎，從草根到大神的入門筆記，學習效果非常不錯！

正所謂“人生苦短，我用Python”，而Python的設計哲學就是“優雅”、“明確”、“簡單”。 image 基礎（變數和字串） image image image 在這裡還是要推薦下我自己建的Python開發學習群:943752371，群裡都是學Py

Python入門學習筆記————09(元組，集合，字典)

關於元組的函式 以下看程式碼 In [5]:   #len:獲取元組長度1 t = (1,2,3,4,4) len(t) Out[5]: 5 In [6]:   #max,min:最大值，最小值 #如果

騰訊十年Python開發經驗寫的Python入門筆記，是否對你有幫助？

啟動python 從IDLE啟動Python IDLE是一個Python Shell。Shell的意思是“外殼”，是一個通過 鍵入文字與程式互動的途徑 （類似windows中的cmd。Visual Studio 也是一種Shell） >>>是指Python

torch和lua學習常見問題（重點是nn模組編譯和torch編譯）

x = torch.Tensor(5):zero() 這個時候輸出長度為5的全部為0的Tensor x = torch.Tensor(5).zero() [string "x = torch.Tensor(5).zero()"]:1: inva

Python入門筆記（2）_ 資料型別及取整運算 round，floor，ceil

資料型別 1.  資料型別包括整數、浮點、字串，這些大家都很清楚，關於定義這裡不多說。 不過，關於整數浮點計算要多說兩句。先看如下計算 11 / 4 # ==> 2 11.0 / 4

ECMAScript 6 入門筆記（八）Proxy，Reflect

Proxy proxy用於修改某些操作的預設行為，等同於在語言層面作出修改，屬於”超程式設計”。可以理解成架設一層“攔截”，外界對該物件訪問都必須通過這層攔截。 var obj = new Proxy({},{ get: function

SQL入門筆記2——子查詢，JOIN,GROUP BY

一、SELECT 子查詢 例1.SQLZOO:SELECT within SELECT T7、在每一個州中找出最大面積的國家，列出洲份 continent, 國家名字 name 及面積 area。 (有

學術寫作利器——LaTeX入門筆記整理（不定期更新，附加使用心得）

LaTeX入門教程（上）比Word更適合學術寫作的編纂語言Credit：講座是敝系的幾個技術宅辦的，作者只負責記錄和整理。後面的更新是個人心得。寫這篇日誌的初衷是小圈子分享和個人心得記錄，適合完全不瞭解tex的入門者閱讀，我的水平有限所以肯定有所疏漏，歡迎提出建議。具體使用

IPFS 怎麼挖礦，IPFS入門筆記

IPFS一直被稱為取代HTTP的下一代網際網路，具體優化解決了什麼問題？1.IPFS讓網際網路變得不再中心化，而是去中心化，讓儲存分佈在所有的節點上面，讓網路從所有的節點上面去下載。它能夠給我們節省60%的頻寬，這是什麼概念？ IPFS共享了所有的頻寬，它的共享來自於什麼地方

500多頁的機器學習入門筆記，下載超5萬次，都講了些什麼？

導讀：今年 4 月，樑勁在百度雲盤上傳了一份自己整理的學習筆記——《機器學習——從入門到放棄》。

python3-tkinter模組錯誤筆記-text，entry等找不到相應方法

錯誤日誌：     file_path = f_name.get() AttributeError: 'NoneType' object has no attribute 'get' 程式碼： f_name = tkinter.Entry().pack(side='le

最近時間空閑，整理的一些Python入門級筆記分享給大家！

-o str 最新 函數式編程 python cas 類型 text sha 過完年了，那份愉悅輕松的氣氛又開始緊張起來啦，該上班的上班，改上學的上學。趁著還有幾天假期，這不年間一些小夥伴說開年了要學python，問我有沒有入門級的筆記啥的，我昨晚正好整理了最近用到的pyt

ETL-Kettle學習筆記（入門，簡介，簡單操作）

KETTLE Kettle:簡介 ETL:簡介 ETL（Extract-Transform-Load的縮寫，即資料抽取、轉換、裝載的過程），對於企業或行業應用來說，我們經常會遇到各種資料的處理，轉換，遷移，所以瞭解並掌握一種etl工具的使用，必不可少的，Kettle就是強大的ETL工具。 Kettle:概念

隨機生成數，摘自算法競賽入門經典P120-P123測試STL。

space urn algo std ace ear str stream stl //#include<bits/stdc++.h> #include<cstring> #include<iostream> #include<c

13.django入門01（django入門初探視圖，模板，路由）

python django 一、django的基本使用流程。pip install django #安裝django創建一個project： django-admin startproject mysite---mysite ---settings.py ---ur