Tensorflownode
一、使用圖(graphs)來表示計算任務python
二、使用會話(session)的上下文(context)中執行任務git
三、使用tensor表示數據,張量是幾階的能夠經過張量右邊的方括號數來判斷。例如 t = [ [ [ ] ] ],顯然這個爲3階。web
0階張量稱爲標量,表示單獨的一個數[1]
算法
1階張量稱爲向量, 表示一個一維數組[1, 2, 3]
數組
2階張量稱爲矩陣,表示一個二維數組[[1, 2, 3],[4, 5, 6],[7, 8, 9]]
網絡
四、經過變量(variable)維護狀態session
五、用feed和fetch可爲任意的操做賦值或從中獲取數據數據結構
圖中的節點叫op(operation),一個op得到0個或多個Tensor,產生0個或多個Tensor,tensor看做一個n維的數組或列表。圖必須在會話裏被啓動。app
1、會話
變量初始化後,仍是沒有被激活,須要再在 sess
裏, sess.run(init)
, 激活 init
這一步.
直接 print(state)
不起做用!!必定要把 sess
的指針指向 state
再進行 print
才能獲得想要的結果!
1 import tensorflow as tf 2 3 #建立一個常量 4 m1 = tf.constant([[3,3]])#一行兩列 5 m2 = tf.constant([[2],[3]])#兩行一列 6 7 #矩陣乘法 8 product = tf.matmul(m1,m2) 9 print(product) 10 11 #定義一個會話,啓動默認圖 12 sess = tf.Session() 13 result = sess.run(product)# 調用run方法執行圖,這個觸發了三個op(操做),兩個常量的創建,矩陣的乘法 14 print(result) 15 sess.close() 16 17 #無需關閉會話 # with as的這種結構會自動關閉會話 18 with tf.Session() as sess: 19 result = sess.run(product) 20 print(result)
輸出:
運行會獲得顯示結果,其中MatMul爲節點名,0表明第0個輸出;shape是維度,(1,1)表明一行一列的張量,長度爲1;dtype指數據類型爲整型。
Tensor("MatMul:0", shape=(1, 1), dtype=int32)
[[15]]
[[15]]
2、變量
上文常量使用tf.constant()表示,變量是用tf.Variable()表示,要初始化!!!init=tf.global_variables_initializer()
1 import tensorflow as tf 2 3 x=tf.Variable([1,2]) # 定義一個變量,這裏是張量的加減法,因此一維數組便可 4 a=tf.constant([3,3]) # 定義一個常量 5 6 sub=tf.subtract(x,a) # 增長一個減法op 7 add=tf.add(x,sub) # 增長一個加法op 8 9 init=tf.global_variables_initializer() # 在tensorflow中使用變量要初始化,此條語句也能夠初始化多個變量,這句代碼提示沒有(),多加練習 10 #沒有第13行會FailedPreconditionError: Attempting to use uninitialized value Variable_1 試圖使用未初始化的值Variable_1 11 with tf.Session() as sess: 12 sess.run(init) # 變量初始化,也要放在會話中,才能執行 13 print(sess.run(sub)) 14 print(sess.run(add))
[-2 -1]
[-1 1]
上述代碼展現了變量的定義和初始化,但尚未體現變量的本質,下面一段代碼實現變量a進行5次+1的操做
值得一提的是,在打印常量和變量時,不能像python中的直接print(a),而是也須要放在sess.run()中。
1 a=tf.Variable(0,name='counter') # 建立一個變量初始化爲0,並命名爲counter。(此段代碼中命名無做用) 2 new_value = tf.add(a,1) # 建立一個加法op,做用是使state加1 3 update=tf.assign(a,new_value) # 此句話是賦值op,在tensorflow中,賦值也須要對應的op 4 init=tf.global_variables_initializer() # 變量初始化 5 with tf.Session() as sess: 6 sess.run(init) 7 print(sess.run(a)) 8 for i in range(5): 9 sess.run(update) 10 print(sess.run(a))
0
1
2
3
4
5
注意:初始化時,pycharm會代碼提示 tf.global_variables_initializer,但每每會把括號漏掉,需注意
經常使用的op如今除了加減乘除,還多了個assign()的賦值op
3、Fetch
sess.run([fetch1,fetch2]) 進行多個op,注意格式
1 import tensorflow as tf 2 3 input1 = tf.constant(3.0) 4 input2 = tf.constant(2.0) 5 input3 = tf.constant(5.0) 6 7 add = tf.add(input2,input3) 8 mul = tf.multiply(input1,add) 9 10 with tf.Session() as sess: 11 result = sess.run([mul,add]) # 執行了兩個op,要注意格式 12 print(result)
[21.0,7.0]
這裏須要提一下tf.matmul()是用於矩陣乘法,tf.multiply是用於點乘。正如上面這段代碼的multiply
4、佔位 feed的數據格式以字典的形式傳入
先不輸入具體數值,先佔位,在會話中調用op時,再輸入具體值
1 import tensorflow as tf 2 3 input1 = tf.placeholder(tf.float32) # 使用placeholder()佔位,須要提供類型 4 input2 = tf.placeholder(tf.float32) 5 output = tf.multiply(input1,input2) 6 7 with tf.Session() as sess: 8 print(sess.run(output,feed_dict={input1:8.0,input2:2.0})) # 以字典形式輸入feed_dict
16.0
小案例
import tensorflow as tf import numpy as np #使用numpy生成100個隨機點 x_data = np.random.rand(100) y_data=x_data * 0.1 +0.2 #構造一個線性模型 b = tf.Variable(1.5)#隨機取一個數,最後結果接近0.2 k = tf.Variable(3.2)#隨機取一個數,最後結果接近0.1 #二次代價函數(損失函數) loss = tf.reduce_mean(tf.square(y_data-y)) #定義一個梯度降低法來訓練的優化器 optimizer = tf.train.GrandientDescentOptimizer(0.2) #最小化代價函數 train = optimizer.minimize(loss) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for step in range(300): sess.run(train) if step%20==0 print(step,sess.run([k,b]
4、Tensorflow解決非線性迴歸問題
使用反斜傳播算法對神經網絡(全鏈接)的權值進行訓練,使用梯度降低法(交叉熵)對損失函數進行優化
非線性迴歸
import tensorflow as tf import numpy as np import matplotlib.pyplot as plt #使用numpy在[-0.5,0.5]生成200個數(200行1列)---樣本 x_data = np.linspace(-0.5,0.5,200)[:,np.newaxis]#增長一個維度 noise = np.random.normal(0,0.02,x_data.shape) y_data = np.square(x_data) + noise #定義兩個佔位符 x = tf.placeholder(tf.float32,[None,1]) y = tf.placeholder(tf.float32,[None,1]) #定義神經網絡的中間層 weights_L1 = tf.Variable(tf.random_normal([1,10]))#一行十列 biases_L1 = tf.Variable(tf.zeros([1,10]))#定義只有一個神經元在輸入層 Wx_plus_b_L1 = tf.matmul(x,weights_L1) + biases_L1 #矩陣相乘(輸入和中間層權重) L1 = tf.nn.tanh(Wx_plus_b_L1)#tanh爲激活函數 #定義神經網絡的輸出層 weights_L2 = tf.Variable(tf.random_normal([10,1])) biases_L2 = tf.Variable(tf.zeros([1,1]))#定義只有一個神經元在輸入層 Wx_plus_b_L2 = tf.matmul(L1,weights_L2) + biases_L2 #矩陣相乘(輸入和中間層權重) prediction = tf.nn.tanh(Wx_plus_b_L2)#tanh爲激活函數 #定義損失函數 loss = tf.reduce_mean(tf.square(y - prediction)) #計算張量tensor沿着某一維度的平均值,用於降維 #使用梯度降低法(0.35爲學習率) train_step = tf.train.GradientDescentOptimizer(0.35).minimize(loss)#loss的值和bias和weight有關,不停地回調他們 #其中 minimize() 實際上包含了兩個步驟,即 compute_gradients 和 apply_gradients, #前者用於計算梯度,後者用於使用計算獲得的梯度來更新對應的variable。下面對這兩個函數作具體介紹。 print(sess.run(train_step)) with tf.Session() as sess: #初始化變量 sess.run(tf.global_variables_initializer()) for _ in range(1000): sess.run(train_step,feed_dict={x:x_data,y:y_data}) #得到預測值 prediction_value = sess.run(prediction,feed_dict={x:x_data}) #畫圖 plt.figure() plt.scatter(x_data,y_data)#散點出樣本分佈 plt.plot(x_data,prediction_value,'r-',lw=5)#紅色實線,線寬爲5 plt.show()
5、Tensorflow解決簡單分類問題
MNIST數據集
有兩部分:60000行的訓練數據集和10000行的測試數據集
每一張圖片包含28*28個像素,咱們把這個數組展開成一個向量,長度是28*28=784.在MNIST數據集在mnist.yrain.images是一個形狀爲[60000,784]的張量,第一個維度數字用來索引每張圖片中的像素點。圖片中某個像素的強度值介於0-1之間。
數據集標籤是介於0-9的數字,把標籤轉換成獨熱向量,除了某一位是1,其餘維度都是0.標籤0表示成([1,0,0,0,0,0,0,0,0,0]),所以,mnist.train.label是個[60000,10]的數字矩陣。
神經網絡構成:
784個輸入神經元===>10個輸出神經元
Softmax函數
咱們的模型測出來有十個機率,和爲1。sorfmax迴歸函數用來給不一樣的對象分配機率。
將n維向量映射到另外一個n維向量。採用指數函數,拉大了向量中大小份量的差距
手寫數字識別基於非線性迴歸
1 import tensorflow as tf 2 import tensorflow.example.tutorials.mnist import input_data 3 4 #載入數據集 5 print("--"*36) 6 mnist = input_data.read_data_set("MNIST_data",one_hot=True) 7 #one_hot是一位是1 8 9 #每一個批次的大小(以矩陣的形式放進去訓練) 10 batch_size = 50 11 #計算有多少個批次 12 n_batch = mnist.train.num_examples//batch_size #整除 13 14 #定義兩個佔位符 15 x = tf.placeholder(tf.float32,[None,28*28])#None的賦值與批次有關 16 y = tf.placeholder(tf.float32,[None,10])#標籤:10個數字 17 18 #建立有關簡單的神經網絡(隱藏層爲10個神經元) 19 w = tf.Variable(tf.zero([784,10])) 20 b = tf.Variable(tf.zero([10])) 21 prediction = tf.nn.softmax(tf.matmul(x,w)+b)#softmax:輸出值轉換成機率 22 23 #損失函數 24 loss = tf.reduce_mean(tf.square(y-prediction)) 25 26 #梯度降低法 27 train_step = tf.train.GradientDesentOptimizer(0.4)minimize(loss) 28 29 #比較equal()函數內參數是否一致,一致返回「true」 30 #argmax函數返回一維張量中最大值所在位置 31 correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) 32 #求準確率cast()將布爾型轉換成浮點型(true轉換成1.0,false轉換成0) 33 34 accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) 35 36 with tf.Session() as sess: 37 sess.run(tf.global_variables_initializer()) 38 for iter in range(25): 39 for batch in range(n_batch): 40 #next_batch()第二次執行獲取第二個批次的數據 41 batch_xs,batch_ys = mnist.train.next_batch(batch_size) 42 sess.run(train_step,feed={x:batch_x,y:batch_y}) 43 ac=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels}) 44 print("--"*36) 45 print(">>>Iter:" +str(iter)+ ",>>>Testing Accuracy"" +str(ac))
能夠經過修改批次大小/優化方式/學習率/損失函數類型/訓練次數等來提升訓練準確度
6、損失函數、優化器、過擬合
(一)損失函數
損失函數(loss function),量化了分類器輸出的結果(預測值)和咱們指望的結果(標籤)之間的差距,這和分類器結構自己一樣重要。改良損失函數可使得分類器的結果最優。
A、內置的損失函數(對數似然損失函數)
1.Tensor=tf.nn.softmax_cross_entropy_with_logits(logits= Network.out, labels= Labels_onehot)
面是softmax交叉熵loss,參數爲網絡最後一層的輸出和onehot形式的標籤。切記輸入必定不要通過softmax,由於在函數中內置了softmax操做,若是再作就是重複使用了。在計算loss的時候,輸出Tensor要加上tf.reduce_mean(Tensor)或者tf.reduce_sum(Tensor),做爲tensorflow優化器(optimizer)的輸入。
2. Tensor=tf.nn.sparse_softmax_cross_entropy_with_logits (logits=Network.out, labels= Labels)
這個函數和上面的區別就是labels參數應該是沒有通過onehot的標籤,其他的都是同樣的。另外加了sparse的loss還有一個特性就是標籤能夠出現-1,若是標籤是-1表明這個數據再也不進行梯度回傳。
3. Tensor=tf.nn. sigmoid_cross_entropy_with_logits (logits= Network.out, labels= Labels_onehot)
sigmoid交叉熵loss,與softmax不一樣的是,該函數首先進行sigmoid操做以後計算交叉熵的損失函數,其他的特性與tf.nn.softmax_cross_entropy_with_logits一致。
4. Tensor=tf.nn.weighted_cross_entropy_with_logits (logits=Network.out, labels=Labels_onehot, pos_weight=decimal_number)
這個loss不同凡響的地方就是加入了一個權重的係數,其他的地方與tf.nn. sigmoid_cross_entropy_with_logits這個損失函數是一致的,加入的pos_weight函數能夠適當的增大或者縮小正樣本的loss,能夠必定程度上解決正負樣本數量差距過大的問題。
對於普通的sigmoid來講計算的形式以下:
targets * -log(sigmoid(logits)) + (1 - targets) * -log(1 - sigmoid(logits))
加入了pos_weight以後的計算形式以下:
targets * -log(sigmoid(logits)) * pos_weight + (1 - targets) * -log(1 - sigmoid(logits))
B、自定義損失函數
常見的函數
(二)優化器
若是數據是稀疏的,用自適用方法,Adagrad,Adadelta,RMSprop,Adam。
RMSprop,Adadelta,Adam在不少狀況下是類似的
Adam就算在RMSprop的基礎上加了bias-correction和momentum,
隨着梯度變稀疏,Adam比RMSprop效果好。
總體來說,Adam是最好的選擇。
不少論文用SGD,沒有momentum等。SGD雖然能達到極小值,可是時間長,可能被困住鞍點
若是是複雜的神經網絡,要一種自適應的算法。
(三)過擬合
都是經過限制權限的大小。
L1:讓參數變得更稀疏,即便更多的參數變爲0,相似特徵提取。
L2:弱參數平方後變的更小,模型優化中幾乎能夠忽略,好比0.0001的平方。
根據須要能夠結合L1和L2一塊兒使用。
#L1,L2demo w = tf.constant([[1.0,2.],[-2.,4.]]) with tf.Session() as sess: print(sess.run(tf.contrib.layers.l1_regularizer(0.5)(w))) print(sess.run(tf.contrib.layers.l2_regularizer(0.5)(w))) print(sess.run(tf.contrib.layers.l1_l2_regularizer(scale_l1=0.5,scale_l2=0.5)(w))) out: 4.5 #1+2+2+4=9 9*0.5=4.5 6.25 #1+4+4+16=25 25/2=12.5 12.5*0.5=6.25 10.75 #9*0.5+12.5*0.5=10.75
L3_drop=tf.nn.dropout(L3,keep_prob)#keep_prob表明百分之多少的神經元在工做
後續工做用L3_drop代替L3
(四)激活函數
tensorflow-->python-->ops-->nn.py在這個文件裏面
經常使用的激活函數有sigmoid、tanh、relu
tf.nn.激活函數(變量名)
1.sigmoid映射到(0,1)區間
2.log_sigmoid映射到了(負無窮,0)
3.tanh映射到(-1,1)
4.relu最受歡迎,relu函數的定義:f(x)=max(x,0)
5.relu6取值區間被限定在了[0,6]之間,min(max(features,0),6)
7、tensorflow可視化
log_dir = '' # 輸出日誌保存的路徑
(1)首先確定是先創建一個graph,你想從這個graph中獲取某些數據的信息
(2)肯定要在graph中的哪些節點放置summary operations以記錄信息
使用tf.summary.scalar記錄標量
使用tf.summary.histogram記錄數據的直方圖
使用tf.summary.distribution記錄數據的分佈圖
使用tf.summary.image記錄圖像數據
函數('名稱',變量名)
(3)operations並不會去真的執行計算,除非你告訴他們須要去run,或者它被其餘的須要run的operation所依賴。而咱們上一步建立的這些summary operations其實並不被其餘節點依賴,所以,咱們須要特意去運行全部的summary節點。可是呢,一份程序下來可能有超多這樣的summary 節點,要手動一個一個去啓動天然是及其繁瑣的,所以咱們可使用tf.summary.merge_all去將全部summary節點合併成一個節點,只要運行這個節點,就能產生全部咱們以前設置的summary data。
(4)使用tf.summary.FileWriter將運行後輸出的數據都保存到本地磁盤中
(5)運行整個程序,並在命令行輸入運行tensorboard的指令,以後打開web端可查看可視化的結果
運行整個程序,在程序中定義的summary node就會將要記錄的信息所有保存在指定的logdir路徑中了,訓練的記錄會存一份文件,測試的記錄會存一份文件。進入命令行,運行如下代碼,等號後面加上summary日誌保存的路徑(在程序第一步中就事先自定義了)
tensorboard --logdir=
有一條信息出來,打開網址就能夠看到可視化信息
Starting TensorBoard 41 on port 6006
(You can navigate to http://127.0.1.1:6006)
模型的保存
1 # 以前是各類構建模型graph的操做(矩陣相乘,sigmoid等等....) 2 3 saver = tf.train.Saver() # 生成saver 4 5 with tf.Session() as sess: 6 sess.run(tf.global_variables_initializer()) # 先對模型初始化 7 8 # 而後將數據丟入模型進行訓練blablabla 9 10 # 訓練完之後,使用saver.save 來保存 11 saver.save(sess, "save_path/file_name") #file_name若是不存在的話,會自動建立
模型的載入
1 saver = tf.train.Saver() 2 3 with tf.Session() as sess: 4 #參數能夠進行初始化,也可不進行初始化。即便初始化了,初始化的值也會被restore的值給覆蓋 5 sess.run(tf.global_variables_initializer()) 6 saver.restore(sess, "save_path/file_name") #會將已經保存的變量值resotre到 變量中。
8、卷積神經網絡
(一)數據結構
mnist原始圖片輸入,原始圖片的尺寸爲28×28,導入後會自動展開爲28×28=784的list
tensor : shape=[784]
卷積層輸入input_image: shape=[batch, height, width, channels]
bacth : 取樣數
height, width : 圖片的尺寸
channels : 圖片的深度;若是是灰度圖像,則爲1,rgb圖像,則爲3
卷積核filter: shape=[height, width, in_channels, out_channels]
height, width: 圖片的尺寸
in_channels: 圖片的深度
out_channels: 卷積核的數量
(二)函數
卷積函數[tf.nn.conv2d(x, filter, strides=[1,1,1,1], padding=’SAME’)]
def conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None,
data_format=None, name=None):
x: 卷積層輸入 shape=[batch, height, width, channels]
filter: 卷積核 shape=[height, width, in_channels, out_channels]
stride: 卷積步長 shape=[batch_stride, height_stride, width_stride, channels_stride]
padding: 控有SAME和VALID兩種選項,表示是否要保留圖像邊上那一圈不徹底卷積的部分。若是是SAME,則保留。
use_cudnn_on_gpu :是否使用cudnn加速。默認是True
池化函數tf.nn.max_pool(x, k_size=[1,2,2,1], strides=[1,2,2,1], padding=’SAME’)
ave_pool是平均池化
def max_pool(value, ksize, strides, padding, data_format="NHWC", name=None):
x: 池化輸入input_image: shape=[batch, height, width, channels]
ksize: 池化窗口的尺寸
strides: 池化步長
padding: 處理邊界策略
卷積核filter初始化weight_variable(shape)
def weight_variable(shape):
initial=tf.truncated_normal(shape, mean=0.0, stddev=0.1)
return tf.Variable(inital)
偏置初始化bias_variable(shape)
def bias_variable(shape):
initial=tf.constant(0,1,shape=shape)
return tf.Vatiable(initial)
手寫字體的識別
1 import tensorflow as tf 2 from tensorflow.examples.tutorials.mnist import input_data 3 4 #獲取mnist訓練集 5 mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 6 7 #交互式session 8 sess = tf.InteractiveSession() 9 10 #已將32×32的圖片展開成行向量,None表明該維度上數量不肯定,程序中指的是取樣的圖像數量不肯定 11 x=tf.placeholder(tf.float32, shape=[None,784]) 12 #圖片的標籤 13 y_label=tf.placeholder(tf.float32, shape=[None,10]) 14 ------------------------------------------------------------------------- 15 #第一層網絡 16 #reshape()將按照設定的shape=[-1,28,28,1]對x:shape=[None,784]的結構進行從新構建 17 #參數-1表明該維度上數量不肯定,由系統自動計算 18 x_image = tf.reshape(x, shape=[-1,28,28,1]) 19 #32個卷積核,卷積核大小5×5 20 W_conv1 = weight_variable([5,5,1,32]) 21 #32個前置,對應32個卷積核輸出 22 b_conv1 = bias_varibale([32]) 23 24 #卷積操做 25 layer_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 26 #池化操做 27 layer_pool1 = tf.nn.max_pool(layer_conv1) 28 ------------------------------------------------------------------------- 29 #第二層網絡 30 #64個卷積核,卷積核大小5×5,32個channel 31 W_conv2 = weight_variable([5,5,32,64]) 32 #64個前置,對應64個卷積核輸出 33 b_conv2 = bias_varibale([64]) 34 35 #卷積操做 36 layer_conv2 = tf.nn.relu(conv2d(layer_pool1, W_conv2) + b_conv2) 37 #池化操做 38 layer_pool2 = tf.nn.max_pool(layer_conv2) 39 ------------------------------------------------------------------------- 40 #full-connected網絡 41 #圖片尺寸變化28×28-->14×14-->7×7 42 #該層設定1024個神經元 43 layer_pool2_flat = tf.reshape(layer_pool2,[-1,7*7*64]) 44 45 W_fc1 = weight_variable([7*7*64,1024]) 46 b_fc1 = bias_variable([1024]) 47 48 h_fc1 = tf.nn.relu(tf.matmul(layer_pool2_flat, W_fc1) + b_fc1) 49 ------------------------------------------------------------------------- 50 #droput網絡 51 keep_prob = tf.placeholder(tf.float32) 52 h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) 53 ------------------------------------------------------------------------- 54 #輸出層 55 W_fc2 = weight_variable([1024,10]) 56 b_fc2 = bias_variable([10]) 57 58 y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2) 59 ------------------------------------------------------------------------- 60 #loss-function 61 cross_entropy = -tf.reduce_sum(y_lable*tf.log(y_conv)) 62 #梯度降低 63 train = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) 64 #tf.argmax(x,1)表示從x的第二維度選取最大值 65 correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_lable,1)) 66 accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) 67 sess.run(tf.global_variables_initializer()) 68 ------------------------------------------------------------------------- 69 #訓練train 70 #訓練3000次 71 for i in range(3000) 72 #每次選取50訓練集 73 batch = mnist.train.next_batch(50) 74 75 if i%100 == 0: 76 train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_labe: batch[1], keep_prob: 1.0}) 77 print ("step %d, training accuracy %g"%(i, train_accuracy)) 78 79 train.run(feed_dict={x: batch[0], y_label: batch[1], keep_prob: 0.5}) 80 print ("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_label: mnist.test.labels, keep_prob: 1.0}))
9、矩陣生成
1.矩陣生成(全0矩陣,全1矩陣,隨機矩陣,常數矩陣)
tf.ones(shape,type=tf.float32,name=None)
tf.zeros([2, 3], int32)
產生尺寸爲shape的張量,全1/0
tf.ones_like(tensor,dype=None,name=None)
tf.zeros_like(tensor,dype=None,name=None)
新建一個與給定的tensor類型大小一致的tensor,其全部元素爲1/0
tf.fill(shape,value,name=None)
建立一個形狀大小爲shape的tensor,其初始值爲value
tf.constant(value,dtype=None,shape=None,name=’Const’)
建立一個常量tensor,按照給出value來賦值,能夠用shape來指定其形狀。value能夠是一個數,也能夠是一個list。
若是是一個數,那麼這個常亮中全部值的按該數來賦值。
若是是list,那麼len(value)必定要小於等於shape展開後的長度。賦值時,先將value中的值逐個存入。不夠的部分,則所有存入value的最後一個值。
tf.random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32,seed=None,name=None)
tf.truncated_normal(shape, mean=0.0, stddev=1.0,dtype=tf.float32,seed=None, name=None)
tf.random_uniform(shape,minval=0,maxval=None,dtype=tf.float32,seed=None,name=None)
這幾個都是用於生成隨機數tensor的。尺寸是shape
random_normal: 正太分佈隨機數,均值mean,標準差stddev
truncated_normal:截斷正態分佈隨機數,均值mean,標準差stddev,不過只保留[mean-2*stddev,mean+2*stddev]範圍內的隨機數
random_uniform:均勻分佈隨機數,範圍爲[minval,maxval]
tf.get_variable
get_variable(name, shape=None, dtype=dtypes.float32, initializer=None, regularizer=None, trainable=True, collections=None, caching_device=None, partitioner=None, validate_shape=True, custom_getter=None):
name: 這個不用說了,變量的名字
shape: 變量的形狀,[]表示一個數,[3]表示長爲3的向量,[2,3]表示矩陣或者張量(tensor)
dtype: 變量的數據格式,主要有tf.int32, tf.float32, tf.float64等等
initializer: 初始化工具,有tf.zero_initializer, tf.ones_initializer, tf.constant_initializer, tf.random_uniform_initializer, tf.random_normal_initializer, tf.truncated_normal_initializer等
2.矩陣變換
tf.shape(Tensor)
Returns the shape of a tensor.返回張量的形狀。可是注意,tf.shape函數自己也是返回一個張量。而在tf中,張量是須要用sess.run(Tensor)
來獲得具體的值的。
labels = [1,2,3] shape = tf.shape(labels) print(shape) sess = tf.InteractiveSession() print(sess.run(shape)) # >>>Tensor("Shape:0", shape=(1,), dtype=int32) # >>>[3]
tf.expand_dims(Tensor, dim)
爲張量+1維。官網的例子:’t’ is a tensor of shape [2]
shape(expand_dims(t, 0)) ==> [1, 2]
shape(expand_dims(t, 1)) ==> [2, 1]
shape(expand_dims(t, -1)) ==> [2, 1]
import tensorflow as tf import numpy as np import matplotlib.pyplot as plt sess = tf.InteractiveSession() labels = [[1,2,3],[2,2,2]] x = tf.expand_dims(labels, 0) print(sess.run(x)) x = tf.expand_dims(labels, -1) print(sess.run(x)) x = tf.expand_dims(labels, 1) print(sess.run(x)) [[[1 2 3] [2 2 2]]] [[[1] [2] [3]] [[2] [2] [2]]] [[[1 2 3]] [[2 2 2]]]
tf.pack
tf.pack(values, axis=0, name=」pack」)
Packs a list of rank-R
tensors into one rank-(R+1)
tensor
將一個R維張量列表沿着axis軸組合成一個R+1維的張量
# 'x' is [1, 4] # 'y' is [2, 5] # 'z' is [3, 6] pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]] # Pack along first dim. pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
tf.concat(concat_dim, values, name=」concat」)
Concatenates tensors along one dimension.
將張量沿着指定維數拼接起來。我的感受跟前面的pack用法相似
t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] tf.concat(0, [t1, t2]) #==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] tf.concat(1, [t1, t2]) #==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]
tf.sparse_to_dense
稀疏矩陣轉密集矩陣
def sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value=0, validate_indices=True, name=None):
sparse_indices: 元素的座標[[0,0],[1,2]] 表示(0,0),和(1,2)處有值
output_shape: 獲得的密集矩陣的shape
sparse_values: sparse_indices座標表示的點的值,能夠是0D或者1D張量。若0D,則全部稀疏值都同樣。如果1D,則len(sparse_values)應該等於len(sparse_indices)
default_values: 缺省點的默認值
tf.random_shuffle(value,seed=None,name=None)
沿着value的第一維進行隨機從新排列
sess = tf.InteractiveSession() a=[[1,2],[3,4],[5,6]] x = tf.random_shuffle(a) print(sess.run(x)) #===>[[3 4],[5 6],[1 2]
tf.argmax(input=tensor,dimention=axis)
找到給定的張量tensor中在指定軸axis上的最大值/最小值的位置。
argmin找最小值
tf.equal(x, y, name=None):
判斷兩個tensor是否每一個元素都相等。返回一個格式爲bool的tensor
tf.cast(x, dtype, name=None) 將x的數據格式轉化成dtype.例如,原來x的數據格式是bool,那麼將其轉化成float之後,就可以將其轉化成0和1的序列。反之也能夠