一步一步對照代碼寫出規範的TensorFlow代碼,面向只會函數式Python編程的小白(如鄙人)
- 定義一些常用函數:
- Xavier初始化器:
- standard_scale:
def standard_scale(X_train, X_test): # 分別進行standard操作
- get_random_block_from_data:
def get_random_block_from_data(data, batch_size): # 隨機抽取block,不放回抽樣,提高數據的使用率
- 定義一個網絡的時候常用子函數:
def __init__(接收輸入參數,transfer_function=tf.nn.softplus, # 函數可以加括號也可以不加括號,不加括號就不用參數,自動適應 ): # 這裏,編寫把輸入參數傳給成員變量 # 在這裏,寫構建網絡的代碼,每一層是怎麼乘起來的 # 在這運行全局初始化子圖:(TensorFlow就是需要這樣的(乍看起來)毫無意義的初始化) init = tf.global_variables_initializer() self.sess = tf.Session() self.sess.run(init) def _initialize_weights(self): # 權重生成器 return all_weights def partial_fit(self, X): # fit方法一般接受cost和優化器,還有scale等訓練的時候要用的東西,並開始run # fit方法對輸入的X進行訓練子圖,一般是傳入一個batch進行訓練 cost, opt = self.sess.run((self.cost, self.optimizer), feed_dict={self.x: X, self.scale: self.training_scale}) return cost def calc_total_cost(self, X): # cost方法根據X進行計算cost,是驗證的時候計算總cost的時候用的 return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale })
- 另外,再定義一下作爲一個autoencoder所需要的一些函數,比如獲取中間層權重之類的:
def getWeights(self): # 獲取中間層的權重 return self.sess.run(self.weights['w1']) def getBiases(self): return self.sess.run(self.weights['b1']) def transform(self, X): # 中間層的接口,跟如傳入的X計算中間層輸出,注意,hidden是第一層輸出乘第二層權重, # 也就是說返回的是前兩層的結果 # 因此可以說是獲取中間層輸出的子圖(不是訓練子圖) return self.sess.run(self.hidden, feed_dict={self.x: X, self.scale: self.training_scale })
- 最後,定義batch_size等,進行預處理和訓練
基本tensorflow代碼寫作順序(sequenial):
1.輸入層初始化
2.dropout
3.第二層x第一層....
4.loss function
5.定義優化器
5.迭代地進行訓練:
優化器.run(x,y,參數表)
6.在測試集或者驗證集上驗證
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# from tensorflow.contrib.factorization.examples.mnist import fill_feed_dict
# 用Denosing AutoEncoder對minist進行重構實驗
def xavier_init(fan_in, fan_out, const=1):
# Xavier法對各個權重進行初始化,比較適合各種激活函數
low = -const * np.sqrt(6.0 / (fan_in + fan_out))
high = const * np.sqrt(6.0 / (fan_in + fan_out))
return tf.random_uniform((fan_in, fan_out),
minval=low, maxval=high,
dtype=tf.float32)
class AdditiveGaussianNoiseAutoencoder(object):
def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus,
optimizer=tf.train.AdamOptimizer(), scale=0.1):
self.n_input = n_input
self.n_hidden = n_hidden
self.transfer = transfer_function
self.scale = tf.placeholder(tf.float32)
self.training_scale = scale
network_weights = self._initialize_weights()
self.weights = network_weights
self.x = tf.placeholder(tf.float32, [None, self.n_input]) # 輸入層
self.n_hidden = self.transfer(tf.add(tf.matmul( # 隱含層,輸入加上噪聲乘以w加b
self.x + scale * tf.random_normal((n_input,)),
self.weights['w1']), self.weights['b1']))
self.reconstruction = tf.add(tf.matmul(self.n_hidden,
self.weights['w2']), self.weights['b2'])
self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(
self.reconstruction, self.x), 2.0))
self.optimizer = optimizer.minimize(self.cost) # 優化器相當方便,只要輸入一個cost函數就可以
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
def _initialize_weights(self): # 權重生成器
all_weights = dict()
all_weights['w1'] = tf.Variable(xavier_init(self.n_input,
self.n_hidden))
all_weights['b1'] = tf.Variable(tf.zeros(self.n_hidden,
dtype=tf.float32))
all_weights['w2'] = tf.Variable(tf.zeros([self.n_hidden,
self.n_input], dtype=tf.float32))
all_weights['b2'] = tf.Variable(tf.zeros([self.n_input],
dtype=tf.float32))
return all_weights
def partial_fit(self, X):
# fit方法一般接受cost和優化器,還有scale等訓練的時候要用的東西,並開始run
# fit方法對輸入的X進行訓練子圖,一般是傳入一個batch進行訓練
cost, opt = self.sess.run((self.cost, self.optimizer),
feed_dict={self.x: X, self.scale: self.training_scale})
return cost
def calc_total_cost(self, X):
# cost方法根據X進行計算cost,是驗證的時候計算總cost的時候用的
return self.sess.run(self.cost, feed_dict={self.x: X,
self.scale: self.training_scale
})
def transform(self, X):
# 中間層的接口,跟如傳入的X計算中間層輸出,注意,hidden是第一層輸出乘第二層權重,
# 也就是說返回的是前兩層的結果
# 因此可以說是獲取中間層輸出的子圖(不是訓練子圖)
return self.sess.run(self.hidden, feed_dict={self.x: X,
self.scale: self.training_scale
})
def generate(self, hidden=None):
# 還原子圖,以後這種子圖在模型訓練好之後,具有單獨的特徵提取和特徵還原功能
if hidden is None:
hidden = np.random.normal(size=self.weight['b1'])
return self.sess.run(self.reconstruction,
feed_dict={self.hidden: hidden})
def reconstruct(self, X):
# 單獨定義的還原子圖,本質上是上面那個函數的子函數
return self.sess.run(self.reconstruction, feed_dict={self.x: X,
self.scale: self.training_scale
})
def getWeights(self):
# 獲取中間層的權重
return self.sess.run(self.weights['w1'])
def getBiases(self):
return self.sess.run(self.weights['b1'])
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
def standard_scale(X_train, X_test):
# 分別進行standard操作
preprocess = prep.StandardScaler().fit(X_train)
# 在訓練數據上fit的scaler,在test上也可以用。
# 並且爲什麼不一起standard呢?因爲考慮訓練數據在訓練的時候要有均值假設,不能一扔進去就不是均值的了
X_train = preprocess.transform(X_train)
X_test = preprocess.transform(X_test)
return X_train, X_test
def get_random_block_from_data(data, batch_size):
# 隨機抽取block,不放回抽樣,提高數據的使用率
start_index = np.random.randint(0, len(data) - batch_size)
return data[start_index:(start_index + batch_size)]
X_train, X_test = standard_scale(mnist.train.images, mnist.test.images)
n_samples = int(mnist.train.num_examples)
training_epochs = 200
batch_size = 128
display_step = 1
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784,
n_hidden=256,
transfer_function=tf.nn.softplus,
# 函數可以加括號也可以不加括號,不加括號就不用參數,自動適應
optimizer=tf.train.AdamOptimizer(learning_rate=0.001),
scale=0.01)
# 每一個batch中,獲取一個block,進行fit,對cost做平均每個樣本的cost,累加
for epoch in range(training_epochs):
avg_cost = 0.
total_batch = int(n_samples / batch_size)
for i in range(total_batch):
batch_xs = get_random_block_from_data(X_train, batch_size)
cost = autoencoder.partial_fit(batch_xs)
avg_cost += cost / n_samples * batch_size
if epoch % display_step == 0:
print("Epoch:", '%04d' % (epoch + 1), "cost = ",
"{:.9f}".format(avg_cost))
print("Total cost:" + str(autoencoder.calc_total_cost(X_test)))