機器學習與Tensorflow（6）——LSTM的Tensorflow實現、Tensorboard簡單實現、CNN應用

最近寫的一些程序以及做的一個關於軸承故障診斷的程序

最近學習進度有些慢

而且馬上假期

要去補習班

去賺下學期生活費

額。。。。

抓緊時間再多學習點

1.RNN遞歸神經網絡Tensorflow實現程序

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
#載入數據集
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)

# 輸入圖片是28*28
n_inputs = 28 #輸入一行，一行有28個數據
max_time = 28 #一共28行
lstm_size = 100 #隱層單元
n_classes = 10 # 10個分類
batch_size = 50 #每批次50個樣本
n_batch = mnist.train.num_examples // batch_size #計算一共有多少個批次

#這里的none表示第一個維度可以是任意的長度
x = tf.placeholder(tf.float32,[None,784])
#正確的標簽
y = tf.placeholder(tf.float32,[None,10])

#初始化權值
weights = tf.Variable(tf.truncated_normal([lstm_size, n_classes], stddev=0.1))
#初始化偏置值
biases = tf.Variable(tf.constant(0.1, shape=[n_classes]))


#定義RNN網絡
def RNN(X,weights,biases):
    # inputs=[batch_size, max_time, n_inputs]
    inputs = tf.reshape(X,[-1,max_time,n_inputs])
    #定義LSTM基本CELL
    lstm_cell = tf.contrib.rnn.core_rnn_cell.BasicLSTMCell(lstm_size)
    # final_state[0]是cell state
    # final_state[1]是hidden_state
    outputs,final_state = tf.nn.dynamic_rnn(lstm_cell,inputs,dtype=tf.float32)
    results = tf.nn.softmax(tf.matmul(final_state[1],weights) + biases)
    return results
    
    
#計算RNN的返回結果
prediction= RNN(x, weights, biases)  
#損失函數
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction,labels=y))
#使用AdamOptimizer進行優化
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#結果存放在一個布爾型列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一維張量中最大的值所在的位置
#求准確率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#把correct_prediction變為float32類型
#初始化
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(6):
        for batch in range(n_batch):
            batch_xs,batch_ys =  mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})
        
        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print ("Iter " + str(epoch) + ", Testing Accuracy= " + str(acc))

2.關於Tensorboard的簡單學習（以MNIST手寫數據集程序為例）

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
#載入數據集
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
#每個批次的大小（即每次訓練的圖片數量）
batch_size = 100
#計算一共有多少個批次
n_bitch = mnist.train.num_examples // batch_size
#參數概要
def variable_summaries(var):
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)
        tf.summary.scalar('mean', mean)  #平均值
        with tf.name_scope('stddev'):
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
        tf.summary.scalar('stddev', stddev) #標准差
        tf.summary.scalar('max', tf.reduce_max(var))
        tf.summary.scalar('min', tf.reduce_min(var))
        tf.summary.histogram('histogram', var)#直方圖
#定義一個命名空間
with tf.name_scope('input'):
    #定義兩個placeholder
    x = tf.placeholder(tf.float32, [None, 784], name='x_input')
    y = tf.placeholder(tf.float32, [None, 10], name='y_input')
with tf.name_scope('layer'):
    #創建一個只有輸入層（784個神經元）和輸出層（10個神經元）的簡單神經網絡
    with tf.name_scope('weights'):
        Weights = tf.Variable(tf.zeros([784, 10]), name='w')
        variable_summaries(Weights)
    with tf.name_scope('biases'):
        Biases = tf.Variable(tf.zeros([10]), name='b')
        variable_summaries(Biases)
    with tf.name_scope('Wx_plus_B'):
        Wx_plus_B = tf.matmul(x, Weights) + Biases
    with tf.name_scope('softmax'):
        prediction = tf.nn.softmax(Wx_plus_B)
#二次代價函數
with tf.name_scope('loss'):
    loss = tf.reduce_mean(tf.square(y - prediction))
    tf.summary.scalar('loss', loss)
#使用梯度下降法
with tf.name_scope('train'):
    train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
#初始化變量
init = tf.global_variables_initializer()
#結果存放在一個布爾型列表中
with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(prediction, 1)) #argmax返回一維張量中最大的值所在的位置，標簽值和預測值相同，返回為True
#求准確率
    with tf.name_scope('correct_prediction'):
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) #cast函數將correct_prediction的布爾型轉換為浮點型，然后計算平均值即為准確率

#合並所有的summary
merged = tf.summary.merge_all()

#定義會話
with tf.Session() as sess:
    sess.run(init)
    writer = tf.summary.FileWriter('logs/', sess.graph)
    #將測試集循環訓練50次
    for epoch in range(51):
        #將測試集中所有數據循環一次
        for batch in range(n_bitch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)   #取測試集中batch_size數量的圖片及對應的標簽值
            summary,_= sess.run([merged, train_step], feed_dict={x:batch_xs, y:batch_ys})  #將上一行代碼取到的數據進行訓練
        writer.add_summary(summary, epoch)
        acc = sess.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels})  #准確率的計算
        print('Iter : ' + str(epoch) + ',Testing Accuracy = ' + str(acc))

3. CNN應用——簡單的軸承故障診斷模型

3.1數據來源及介紹

軸承、軸、齒輪是旋轉機械重要組成部分，為了驗證深度學習在旋轉裝備故障分類識別的有效性，

選取凱斯西儲大學軸承數據庫(Case Western Reserve University, CWRU)為驗證數據。

軸承通過電火花加工設置成四種尺寸的故障直徑，分別為0.007、0.014、0.021、0.028英寸。

實驗中使用加速度傳感器采集振動信號，傳感器分別被放置在電機驅動端與風扇端。

由於驅動端采集到的振動信號數據全面，並且收到其他部件和環境噪聲的干擾較少，選取驅動端采集的振動信號作為實驗數據。

實驗數據包括4種軸承狀態下采集到的振動信號，分別為正常狀態（Normal，N）、滾珠故障狀態（Ball Fault，BF）、外圈故障狀態（Outer Race Fault，ORF）以及內圈故障狀態（Inner Race Fault，IRF），

每種狀態下采集到的信號又按照故障直徑與負載的大小進行分類，其中故障直徑分別為0.007、0.014、0.021、0.028英寸，負載大小從0Hp-3Hp（1Hp=746W），對應轉速為1797rpm、1772rpm、1750rpm、1730rpm。

選取CWRU數據集中采樣頻率為12k Hz的各個狀態的樣本，通過深度學習建立故障診斷模型，對電機軸承的四種故障進行分類識別。

由於負載的不同，轉速不恆定，但采集的轉速都在1800rpm左右，采樣頻率為12kHz，轉軸轉一圈，約采集400（60/1800*12000 = 400）個數據點。

由於采用原始數據切分方式，通常取稍微大於一個周期的點數比較合適，為了便於多層CNN網絡的輸入，以24*24=576點作為輸入長度。

 

3.2 Matlab數據處理程序

clear all;
clc;
load DataSet;
[iType, iCondition] = size(A);
iExtSize = 24*24;
iSampleRate = 12000;
iTime = 10;
iOverlap = floor(iExtSize * 0.9);
iUCover = iExtSize - iOverlap;
iGetDataLen = iSampleRate*iTime + iExtSize;
iLen2 = floor((iGetDataLen-iExtSize)/iUCover) + 1;
iLen1 =  floor(iLen2/100)*100;
iGetDataLen = iLen1*iUCover + iExtSize;
fExtSamp = zeros(iType, iGetDataLen);
 
tmp = 0;
for jCnt = 1: iType
    str1 = sprintf('%03d',A(jCnt,1));
    szValName = strcat('X', str1, '_DE_time');
    eval(strcat('tmp=',szValName,';'));
    fExtSamp(jCnt,:) = tmp(1:iGetDataLen);
end
iLen = iLen1;
iSampSize = iLen * iType;
fData = zeros(iSampSize, iExtSize);
fLabel = zeros(iSampSize, 4);
 
for iCnt = 1:1:iLen
    iInterval = (iCnt -1)*iUCover + (1:1:iExtSize);
    for jCnt =1:1:iType
        fData((iCnt - 1)*iType + jCnt,:) = fExtSamp(jCnt, iInterval);
        if (jCnt ==1)
            fLabel((iCnt - 1)*iType + jCnt,:) = [1 0 0 0];
        end
        if (jCnt >=2 && jCnt<=5)
            fLabel((iCnt - 1)*iType + jCnt,:) = [0 1 0 0];
        end
        if (jCnt >=6 && jCnt<=9)
            fLabel((iCnt - 1)*iType + jCnt,:) = [0 0 1 0];
        end
        if (jCnt >=10)
            fLabel((iCnt - 1)*iType + jCnt,:) = [0 0 0 1];
        end
    end
end
save('DL_Data90.mat','fData', 'fLabel');  

3.3 CNN軸承故障診斷模型

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import numpy as np
import tensorflow as tf
from tensorflow.contrib import rnn
import matplotlib.pyplot as plt
 
nSampleSize = 20000     # 總樣本數
nSig_dim = 576          # 單個樣本維度
nLab_dim = 4            # 類別維度
 
learning_rate = 1e-3
batch_size = tf.placeholder(tf.int32, [])   # 在訓練和測試，用不同的 batch_size
input_size = 24     # 每個時刻的輸入維數為 24
timestep_size = 24  # 時序長度為24
hidden_size = 128   # 每個隱含層的節點數
layer_num = 3       # LSTM layer 的層數
class_num = nLab_dim       # 類別維數
 
def getdata(nSampSize=20000):
    # 讀取float型二進制數據
    signal = np.fromfile('DLdata90singal.raw', dtype=np.float64)
    labels = np.fromfile('DLdata90labels.raw', dtype=np.float64)
    #由於matlab 矩陣寫入文件是按照【列】優先, 需要按行讀取
    mat_sig = np.reshape(signal,[-1, nSampSize])
    mat_lab = np.reshape(labels,[-1, nSampSize])
    mat_sig = mat_sig.T # 轉換成正常樣式 【樣本序號，樣本維度】
    mat_lab = mat_lab.T
    return mat_sig, mat_lab
 
def zscore(xx):
    # 樣本歸一化到【-1，1】，逐條對每個樣本進行自歸一化處理
    max1 = np.max(xx,axis=1)    #按行或者每個樣本，並求出單個樣本的最大值
    max1 = np.reshape(max1,[-1,1])  # 行向量 ->> 列向量
    min1 = np.min(xx,axis=1)    #按行或者每個樣本，並求出單個樣本的最小值
    min1 = np.reshape(min1,[-1,1])  # 行向量 ->> 列向量
    xx = (xx-min1)/(max1-min1)*2-1
    return xx
 
def NextBatch(iLen, n_batchsize):
    # iLen: 樣本總數
    # n_batchsize: 批處理大小
    # 返回n_batchsize個隨機樣本（序號）
    ar = np.arange(iLen)    # 生成0到iLen-1，步長為1的序列
    np.random.shuffle(ar)   # 打亂順序
    return ar[0:n_batchsize]
 
xs = tf.placeholder(tf.float32, [None, nSig_dim])
ys = tf.placeholder(tf.float32, [None, class_num])
keep_prob = tf.placeholder(tf.float32)
 
x_input = tf.reshape(xs, [-1, 24, 24])
 
# 搭建LSTM 模型
def unit_LSTM():
    # 定義一層 LSTM_cell，只需要說明 hidden_size
    lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)
    #添加 dropout layer, 一般只設置 output_keep_prob
    lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    return lstm_cell
 
#調用 MultiRNNCell 來實現多層 LSTM
mLSTM_cell = rnn.MultiRNNCell([unit_LSTM() for icnt in range(layer_num)], state_is_tuple=True)
 
#用全零來初始化state
init_state = mLSTM_cell.zero_state(batch_size, dtype=tf.float32)
outputs, state = tf.nn.dynamic_rnn(mLSTM_cell, inputs=x_input,initial_state=init_state, time_major=False)
h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]
 
#設置 loss function 和 優化器
W = tf.Variable(tf.truncated_normal([hidden_size, class_num], stddev=0.1), dtype=tf.float32)
bias = tf.Variable(tf.constant(0.1,shape=[class_num]), dtype=tf.float32)
y_pre = tf.nn.softmax(tf.matmul(h_state, W) + bias)

#損失和評估函數
cross_entropy = tf.reduce_mean(tf.reduce_sum(-ys*tf.log(y_pre),reduction_indices=[1]))
train_op = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(ys,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
 
 
mydata = getdata()
iTrainSetSize =  np.floor(nSampleSize*3/4).astype(int) # 訓練樣本個數
iIndex = np.arange(nSampleSize) # 按照順序，然后划分訓練樣本、測試樣本
train_index = iIndex[0:iTrainSetSize]
test_index = iIndex[iTrainSetSize:nSampleSize]
 
train_data = mydata[0][train_index]     # 訓練數據
train_y = mydata[1][train_index]        # 訓練標簽
test_data = mydata[0][test_index]       # 測試數據
test_y = mydata[1][test_index]          # 測試標簽
 
train_x = zscore(train_data)        # 對訓練數據進行歸一化
test_x = zscore(test_data)          # 對測試數據進行歸一化
 
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for icnt in range(1000):
        _batch_size = 100
        intervals = NextBatch(iTrainSetSize, _batch_size) # 每次從所有樣本中隨機取100個樣本（序號）
        xx = train_x[intervals]
        yy = train_y[intervals]   
        if (icnt+1)%100 == 0:
            train_accuracy = sess.run(accuracy, feed_dict={
                xs:xx, ys: yy, keep_prob: 1.0, batch_size: _batch_size})
            print("step: " + "{0:4d}".format(icnt+1) + ",  train acc:" + "{:.4f}".format(train_accuracy))
        sess.run(train_op, feed_dict={ xs:xx, ys: yy, keep_prob: 0.9, batch_size: _batch_size})
    bsize = test_x.shape[0]
    test_acc = sess.run(accuracy,feed_dict={xs:test_x, ys:test_y, keep_prob: 1.0, batch_size:bsize})
    print("test acc:" + "{:.4f}".format(test_acc))

 

#寫在后面

新的一年了

感覺開始的一塌糊塗

不過這兩天好像調整過來了

讓自己成為一個有計划的人

堅持健身、堅持減肥、學習理財、學習穿搭、學BEC中級、學機器學習、學Java、學Python、學深度學習框架、准備實習、積極准備找工作！

堅持早點睡覺、堅持早點起床

堅持不拖延

堅持放下手機

堅持不去抱怨生活、不去抱怨別人

堅持！做一個自律、自信的小伙郭

忙碌起來

為最好的那個自己而不斷努力

不要患得患失的去迷茫明天

而是在每一個今天，都活出最精彩的一天

羡慕那些活的精致的人

我也要好好加油才好！