TF高級別API TF.Learn? ? http://tflearn.org/
從零開始學TF-Learn?
https://blog.csdn.net/u013745804/article/details/78285166
https://blog.csdn.net/u013745804/article/details/78291425
TensorFlow入門
TensorFlow是Google公司2015年11月開源的第二代深度學習框架,是第一代框架DistBelief的改進版本.
TensorFlow支持python和c/c++語言, 可以在cpu或gpu上進行運算, 支持使用virtualenv或docker打包發布.
TensorFlow并不是一個純粹的神經網絡框架, 而是使用數據流圖進行數值分析的框架.
TensorFlow使用有向圖(graph)表示一個計算任務.圖的節點稱為ops(operations)表示對數據的處理,圖的邊flow 描述數據的流向.
該框架計算過程就是處理tensor組成的流. 這也是TensorFlow名稱的來源.
TensorFlow使用tensor表示數據. tensor意為張量即高維數組,在python中使用numpy.ndarray表示.
TensorFlow使用Session執行圖, 使用Variable維護狀態.tf.constant是只能輸出的ops, 常用作數據源.
在TensorFlow的世界里，變量的定義和初始化是分開的，所有關于圖變量的賦值和計算都要通過tf.Session的run來進行。想要將所有圖變量進行集體初始化時應該使用tf.global_variables_initializer
用TensorFlow實現一個簡單神經網絡
Neural Network Demo powered by tensorflow
import tensorflow as tf
import numpy as np
def make_layer(inputs, in_size, out_size,activate=None):
? weights = tf.Variable(tf.random_normal([in_size, out_size]))
? ? basis= tf.Variable(tf.zeros([1, out_size]) + 0.1)
? result = tf.matmul(inputs, weights) + basis
? ? ifactivate is None:
? ? ? return result
? ? else:
? ? ? return activate(result)
class BPNeuralNetwork:
? ? def__init__(self):
? ? ? self.input_layer = None
? ? ? self.label_layer = None
? ? ? self.loss = None
? ? ? self.optimizer = None
? ? ? self.layers = []
? ? def train(self, cases, labels, limit=100, learn_rate=0.05):
? ? ? ? #build network
? ? ? self.input_layer = tf.placeholder(tf.float32, [None, 2])
? ? ? self.label_layer = tf.placeholder(tf.float32, [None, 1])
? ? ? self.layers.append(make_layer(self.input_layer, 2, 10,activate=tf.nn.relu))
? ? ? self.layers.append(make_layer(self.layers[0], 10, 2, activate=None))
? ? ? self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer -self.layers[1])), reduction_indices=[1]))
? ? ? self.optimizer =tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)
? ? ? ? # do training
? ? ? self.session.run(tf.initialize_all_variables())
? ? ? for i in range(limit):
? ? ? ? ? self.session.run(self.optimizer, feed_dict={self.input_layer: cases,self.label_layer: labels})
? ? defpredict(self, case):
? ? ? return self.session.run(self.layers[-1], feed_dict={self.input_layer:case})
? ? deftest(self):
? ? ? x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
? ? ? y_data = np.array([[0, 1, 1, 0]]).transpose()
? ? ? test_data = np.array([[0, 1]])
? ? ? self.train(x_data, y_data)
? ? ? print self.predict(test_data)
def main():
? ? withtf.Session() as session:
? ? ? model = BPNeuralNetwork()
? ? ? model.session = session
? ? ? model.test()
調用reduce_sum(arg1, arg2)時，參數arg1即為要求和的數據，arg2有兩個取值分別為0和1，通常用reduction_indices=[0]或reduction_indices=[1]來傳遞參數。從上圖可以看出，當arg2 = 0時，是縱向對矩陣求和，原來矩陣有幾列就得到幾個值；相似地，當arg2 = 1時，是橫向對矩陣求和；當省略arg2參數時，默認對矩陣所有元素進行求和。
看到這里，函數名的前綴為什么是reduce_其實也就很容易理解了，reduce就是“對矩陣降維”的含義，下劃線后面的部分就是降維的方式，在reduce_sum()中就是按照求和的方式對矩陣降維。那么其他reduce前綴的函數也舉一反三了，比如reduce_mean()就是按照某個維度求平均值，等等。
E:\Anaconda3\lib\site-packages\h5py\__init__.py:36:FutureWarning: Conversion of the second argument of issubdtype from `float` to`np.floating` is deprecated. In future, it will be treated as `np.float64 ==np.dtype(float).type`. from ._conv import register_converters as_register_converters
anaconda指的是一個開源的Python發行版本，其包含了conda、Python等180多個科學包及其依賴項。因為包含了大量的科學包，Anaconda的下載文件比較大（約515 MB），如果只需要某些包，或者需要節省帶寬或存儲空間，也可以使用Miniconda這個較小的發行版（僅包含conda和 Python）。
安裝TensorFlow
基于 Anaconda 的安裝
Anaconda 是一個集成許多第三方科學計算庫的Python 科學計算環境,Anaconda使用 conda 作為自己的包管理工具,同時具有自己的計算環境,類似Virtualenv.
和Virtualenv 一樣,不同 Python 工程需要的依賴包,conda 將他們存儲在不同的地方。 TensorFlow 上安裝的 Anaconda 不會對之前安裝的 Python 包進行覆蓋.
- 安裝Anaconda
- 建立一個 conda 計算環境
- 激活環境,使用conda 安裝TensorFlow
- 安裝成功后,每次使用TensorFlow 的時候需要激活conda 環境
安裝Anaconda :
參考 Anaconda 的下載頁面的指導
建立一個 conda 計算環境名字叫tensorflow：
激活tensorflow環境，然后使用其中的 pip 安裝 TensorFlow. 當使用easy_install使用--ignore-installed標記防止錯誤的產生。
ValueError: Cannot feed value of shape (200,)
for Tensor 'Placeholder_32:0', which has shape '(?, 1)'
I am new to tensorflow. This code isjust for a simple neural network. I think the problem maybe is from:
x_data =np.linspace(-0.5,0.5,200)[:np..newaxis]
I tried to write without [:np.newaxis], but it looks like the same.
1 Answer
x_data = x_data.reshape([-1,1])
y_data = y_data.reshape([-1,1])
Tensorflow: You must feed a value for placeholder tensor'inputs/y_input' with dtype float and shape
從字面理解是：你必須給占位符y_input喂入一個向量值即賦值
交叉熵（Cross Entropy）是Shannon信息論中一個重要概念，主要用于度量兩個概率分布間的差異性信息，將交叉熵引入計算語言學消岐領域，采用語句的真實語義作為交叉熵的訓練集的先驗信息，將機器翻譯的語義作為測試集后驗信息。計算兩者的交叉熵，并以交叉熵指導對歧義的辨識和消除。實例表明，該方法簡潔有效
tf.reduce_mean
一，tensorflow中有一類在tensor的某一維度上求值的函數。如：
求最大值tf.reduce_max(input_tensor, reduction_indices=None,keep_dims=False, name=None)
求平均值tf.reduce_mean(input_tensor, reduction_indices=None,keep_dims=False, name=None)
舉例說明：
# 'x' is [[1., 2.]
? ? ? ? ? [3., 4.]]
x是一個2維數組，分別調用reduce_*函數如下：
首先求平均值：
tf.reduce_mean(x) ==> 2.5 #如果不指定第二個參數，那么就在所有的元素中取平均值
tf.reduce_mean(x, 0) ==> [2., 3.]
#指定第二個參數為0，則第一維的元素取平均值，即每一列求平均值
tf.reduce_mean(x, 1) ==> [1.5,3.5]? #指定第二個參數為1，則第二維的元素取平均值，即每一行求平均值? 同理，還可用tf.reduce_max()求最大值等。
tf.argmax 返回張量在某一維度上最大值的索引值
Colaboratory可以讓你在瀏覽器中運行 TensorFlow 程序
Colaboratory是一種數據分析工具，可將文字、代碼和代碼輸出內容合并到一個協作文檔中。
借助 Colaboratory，您只需點擊一下鼠標，即可在瀏覽器中執行 TensorFlow 代碼。
Colaboratory 包含很多已被廣泛使用的庫（例如 matplotlib），因而能夠簡化數據的可視化過程。
Colaboratory 可與 Google Cloud BigQuery 結合使用。
要運行此程序，請執行以下操作
點擊代碼塊中的任意位置（例如，點擊字詞 import）。
點擊代碼塊左上角的右向三角圖標，或按 ?/Ctrl+Enter 鍵。
程序需要幾秒鐘才會運行。
整個程序僅包含一個代碼塊。不過，大部分練習都會包含多個代碼塊，在這種情況下，您應按從上到下的順序逐個運行代碼塊。
不按順序運行代碼塊通常會導致錯誤。
實用的鍵盤快捷鍵
?/Ctrl+m、b：在當前選擇的單元格下方創建一個空白代碼單元格
?/Ctrl+m、i：中斷單元格的運行
?/Ctrl+m、h：顯示所有鍵盤快捷鍵列表
要查看關于任何 TensorFlow API 方法的文檔，請將光標放置在其左括號的正后方，然后按Tab鍵：
廣播
在數學中，您只能對形狀相同的張量執行元素級運算（例如，相加和等于）。不過，在 TensorFlow 中，您可以對張量執行傳統意義上不可行的運算。TensorFlow支持廣播（一種借鑒自 Numpy 的概念）。利用廣播，元素級運算中的較小數組會增大到與較大數組具有相同的形狀。
張量變形
由于張量加法和矩陣乘法均對運算數施加了限制條件，TensorFlow編程者肯定會頻繁改變張量的形狀。
您可以使用 tf.reshape 方法改變張量的形狀。 例如，您可以將 8x2 張量變形為 2x8 張量或 4x4 張量
變量、初始化和賦值
到目前為止，我們執行的所有運算都是針對靜態值(tf.constant)進行的；調用 eval() 始終返回同一結果。在TensorFlow 中可以定義 Variable 對象，它的值是可以更改的。
創建變量時，您可以明確設置一個初始值，也可以使用初始化程序
張量處理器（英語：tensor processing unit，縮寫：TPU）是Google為機器學習定制的專用芯片（ASIC），專為Google的深度學習框架TensorFlow而設計。
與圖形處理器（GPU）相比，TPU采用低精度（8位）計算，以降低每步操作使用的晶體管數量。降低精度對于深度學習的準確度影響很小，但卻可以大幅降低功耗、加快運算速度。同時，TPU使用了脈動陣列（英語：Systolic array）的設計，用來優化矩陣乘法與卷積運算，減少I/O操作。此外，TPU還采用了更大的片上內存，以此減少對DRAM的訪問，從而更大程度地提升性能。
Google在2016年的Google I/O年會上首次公布了TPU。不過在此之前TPU已在Google內部的一些項目中使用了一年多，如Google街景服務、RankBrain（英語：RankBrain）以及其旗下DeepMind公司的圍棋軟件AlphaGo等都用到了TPU。[2][3]而在2017年的Google
I/O年會上，Google又公布了第二代TPU，并將其部署在Google云平臺之上。第二代TPU的浮點運算能力高達每秒180萬億次。
第一代
第一代的TPU使用8-bit矩陣乘法引擎，透過PCIe 3.0與CISC指令操作。晶片為28nm制程，die ≤ 331 mm2，700 Mhz，功耗在28至40瓦。
第二代
第二代于2017年五月發表。
第三代
第三代于2018年五月發表。
TensorFlow DNN for regression
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from tensorflow.contrib import learn
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn import datasets, linear_model
from sklearn import cross_validation
import numpy as np
boston = learn.datasets.load_dataset('boston')
x, y = boston.data, boston.target
X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(
x, y, test_size=0.2, random_state=42)
total_len = X_train.shape[0]
# Parameters
learning_rate = 0.001
training_epochs = 500
batch_size = 10
display_step = 1
dropout_rate = 0.9
# Network Parameters
n_hidden_1 = 32 # 1st layer number of features
n_hidden_2 = 200 # 2nd layer number of features
n_hidden_3 = 200
n_hidden_4 = 256
n_input = X_train.shape[1]
n_classes = 1
# tf Graph input
x = tf.placeholder("float", [None,13])
y = tf.placeholder("float", [None])
# Create model
def multilayer_perceptron(x, weights, biases):
? ? #Hidden layer with RELU activation
? layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
? layer_1 = tf.nn.relu(layer_1)
? ? #Hidden layer with RELU activation
? layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
? layer_2 = tf.nn.relu(layer_2)
? ? #Hidden layer with RELU activation
? layer_3 = tf.add(tf.matmul(layer_2, weights['h3']), biases['b3'])
? layer_3 = tf.nn.relu(layer_3)
? ? #Hidden layer with RELU activation
? layer_4 = tf.add(tf.matmul(layer_3, weights['h4']), biases['b4'])
? layer_4 = tf.nn.relu(layer_4)
? ? #Output layer with linear activation
? out_layer = tf.matmul(layer_4, weights['out']) + biases['out']
? return out_layer
# Store layers weight & bias
weights = {
? ? 'h1':tf.Variable(tf.random_normal([n_input, n_hidden_1], 0, 0.1)),
? ? 'h2':tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], 0, 0.1)),
? ? 'h3':tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3], 0, 0.1)),
? ? 'h4':tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4], 0, 0.1)),
? 'out': tf.Variable(tf.random_normal([n_hidden_4, n_classes], 0, 0.1))
}
biases = {
? ? 'b1':tf.Variable(tf.random_normal([n_hidden_1], 0, 0.1)),
? ? 'b2':tf.Variable(tf.random_normal([n_hidden_2], 0, 0.1)),
? ? 'b3':tf.Variable(tf.random_normal([n_hidden_3], 0, 0.1)),
? ? 'b4':tf.Variable(tf.random_normal([n_hidden_4], 0, 0.1)),
? 'out': tf.Variable(tf.random_normal([n_classes], 0, 0.1))
}
# Construct model
pred = multilayer_perceptron(x, weights,biases)
# Define loss and optimizer
cost = tf.reduce_mean(tf.square(pred-y))
optimizer =tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Launch the graph
with tf.Session() as sess:
? sess.run(tf.initialize_all_variables())
? ? #Training cycle
? ? forepoch in range(training_epochs):
? ? ? avg_cost = 0.
? ? ? total_batch = int(total_len/batch_size)
? ? ? ? #Loop over all batches
? ? ? for i in range(total_batch-1):
? ? ? ? ? batch_x = X_train[i*batch_size:(i+1)*batch_size]
? ? ? ? ? batch_y = Y_train[i*batch_size:(i+1)*batch_size]
? ? ? ? ? # Run optimization op (backprop) and cost op (to get loss value)
? ? ? ? ? _, c, p = sess.run([optimizer, cost, pred], feed_dict={x: batch_x,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? y:batch_y})
? ? ? ? ? # Compute average loss
? ? ? ? ? avg_cost += c / total_batch
? ? ? ? #sample prediction
? ? ? label_value = batch_y
? ? ? estimate = p
? ? ? err = label_value-estimate
? ? ? ? print ("num batch:", total_batch)
? ? ? ? #Display logs per epoch step
? ? ? if epoch % display_step == 0:
? ? ? ? ? print ("Epoch:", '%04d' % (epoch+1), "cost=", \
? ? ? ? ? ? ? "{:.9f}".format(avg_cost))
? ? ? ? ? print ("[*]----------------------------")
? ? ? ? ? for i in xrange(3):
? ? ? ? ? ? ? print ("label value:", label_value[i], \
? ? ? ? ? ? ? ? ? ? "estimatedvalue:", estimate[i])
? ? ? ? ? print ("[*]============================")
? ? print("Optimization Finished!")
? ? #Test model
? correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
? ? #Calculate accuracy
? accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
? ? print("Accuracy:", accuracy.eval({x: X_test, y: Y_test}))
TensorFlow回歸
在運行到 loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output,Y))
時，報錯：
ValueError: Only call sigmoid_cross_entropy_with_logitswith named arguments (labels=…, logits=…, …)
應該改為
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=output,logits=Y))
tensorflow中tf.random_normal和tf.truncated_normal的區別
1、tf.truncated_normal使用方法
tf.truncated_normal(shape, mean=0.0, stddev=1.0,dtype=tf.float32, seed=None, name=None)
從截斷的正態分布中輸出隨機值。生成的值服從具有指定平均值和標準偏差的正態分布，如果生成的值大于平均值2個標準偏差的值則丟棄重新選擇。
在正態分布的曲線中，橫軸區間（μ-σ，μ+σ）內的面積為68.268949%。橫軸區間（μ-2σ，μ+2σ）內的面積為95.449974%。橫軸區間（μ-3σ，μ+3σ）內的面積為99.730020%。
X落在（μ-3σ，μ+3σ）以外的概率小于千分之三，在實際問題中常認為相應的事件是不會發生的，基本上可以把區間（μ-3σ，μ+3σ）看作是隨機變量X實際可能的取值區間，這稱之為正態分布的“3σ”原則。在tf.truncated_normal中如果x的取值在區間（μ-2σ，μ+2σ）之外則重新進行選擇。這樣保證了生成的值都在均值附近。
參數:
shape:一維的張量，也是輸出的張量。
mean:正態分布的均值。
stddev:正態分布的標準差。
dtype:輸出的類型。
seed:一個整數，當設置之后，每次生成的隨機數都一樣。
name:操作的名字
2、tf.random_normal使用方法
tf.random_normal(shape, mean=0.0, stddev=1.0,
dtype=tf.float32, seed=None, name=None)
從正態分布中輸出隨機值。參數:
shape:一維的張量，也是輸出的張量。
mean:正態分布的均值。
stddev:正態分布的標準差。
dtype:輸出的類型。
seed:一個整數，當設置之后，每次生成的隨機數都一樣。
name:操作的名字。
代碼
a = tf.Variable(tf.random_normal([2,2],seed=1))
b = tf.Variable(tf.truncated_normal([2,2],seed=2))
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print(sess.run(a))
print(sess.run(b))
輸出：
[[-0.81131822? 1.48459876]
[ 0.06532937 -2.44270396]]
[[-0.85811085 -0.19662298]
[ 0.13895047 -1.22127688]]
tf.cast TensorFlow中的類型轉換函數 cast(x, dtype, name=None) #將x的數據格式轉換成dtype
tensorflow中的圖上的節點稱之為operations或者ops。我們可以使用 graph.get_operations()命令來獲取圖中的operations.
tf.matrix_solve(matrix, rhs, adjoint=None, name=None)
求解tf.matrix_solve(matrix,rhs, adjoint=None, name=None) matrix為方陣 shape為[M,M], rhs的shape為[M,K]，output為[M,K]
Tensorflow:AttributeError: 'module' object has no attribute 'mul'
tensorflow 版本為1.0.1后，
將tf.mul替換為tf.multiply后，錯誤問題解決。
Tensorflow中隨機數生成種子tf.set_random_seed()
Tensorflow中的隨機數生成種子是在數據流圖資源上運作的。每一個數據流圖中，我們可以執行針對隨機數生成種子應用不同的操作（operation）。事實上，隨機數生成種子作為random系列函數的參數之一，可在相應的參數列表進行設置，這就是op-level的操作。與之對應的是graph-level的操作tf.set_random_seed()，它管理著同一數據流圖下的資源。
tensorflow中設置隨機種子，可分為兩類，圖級seed和操作級seed, 情況1：當沒有設置圖級seed和操作級seed時，生成的隨機數是隨機的 情況2：當設置操作級seed時，生成的隨機數是同一組隨機數，沒有設置操作級seed的操作，生成的隨機數是隨機的 情況3：當設置圖級seed,將會生成同一組隨機數，如果設置操作級seed又和情況2相同
tf.random_normal()函數
用于從服從指定正太分布的數值中取出指定個數的值。
tf.random_normal(shape,mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
? shape: 輸出張量的形狀，必選
? mean: 正態分布的均值，默認為0
? stddev: 正態分布的標準差，默認為1.0
? dtype: 輸出的類型，默認為tf.float32
? seed: 隨機數種子，是一個整數，當設置之后，每次生成的隨機數都一樣
? name: 操作的名稱
tf.random_uniform 函數
從均勻分布中輸出隨機值。
生成的值在該 [minval,
maxval) 范圍內遵循均勻分布。下限 minval 包含在范圍內，而上限 maxval 被排除在外。
對于浮點數，默認范圍是 [0, 1)。對于整數，至少 maxval 必須明確地指定。
在整數情況下，隨機整數稍有偏差，除非 maxval -
minval 是 2 的精確冪。對于maxval - minval的值，偏差很小，明顯小于輸出（2**32 或者 2**64）的范圍。
參數：
shape：一維整數張量或 Python 數組。輸出張量的形狀。
minval：dtype 類型的 0-D 張量或 Python 值；生成的隨機值范圍的下限；默認為0。
maxval：dtype 類型的 0-D 張量或 Python 值。要生成的隨機值范圍的上限。如果 dtype 是浮點，則默認為1 。
dtype：輸出的類型：float16、float32、float64、int32、orint64。
seed：一個 Python 整數。用于為分布創建一個隨機種子。查看 tf.set_random_seed 行為。
name：操作的名稱（可選）。
返回：
用于填充隨機均勻值的指定形狀的張量。
可能引發的異常：
ValueError：如果 dtype 是整數并且 maxval 沒有被指定。
TensorFlow四舍五入：tf.round函數
tf.round 函數
round(x,name=None)
定義在：tensorflow/python/ops/math_ops.py。
請參閱指南：數學函數>基本數學函數
將張量的值四舍五入為最接近的整數，元素。
均勻的舍入。也被稱為banker四舍五入。如果要根據當前系統舍入模式進行舍入，請使用tf ::
cint。例如：
x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])
tf.round(x)? # [1.0, 2.0, 2.0, 2.0, -4.0 ]
參數：
x：一個Tensor，類型必須為float32或float64。
name：操作的名稱（可選）。
返回：
tf.round函數返回一個與x具有相同的形狀和類型的Tensor。
tf.round(x,name=None) 舍入最接近的整數
# ‘a’ is [0.9, 2.5, 2.3, -4.4]
tf.round(a) ==> [ 1.0, 3.0, 2.0, -4.0 ]
