• 机器学习与Tensorflow(6)——LSTM的Tensorflow实现、Tensorboard简单实现、CNN应用


    最近写的一些程序以及做的一个关于轴承故障诊断的程序

    最近学习进度有些慢

    而且马上假期

    要去补习班

    去赚下学期生活费

    额。。。。

    抓紧时间再多学习点

    1.RNN递归神经网络Tensorflow实现程序

     1 import os
     2 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
     3 import tensorflow as tf
     4 from tensorflow.examples.tutorials.mnist import input_data
     5 #载入数据集
     6 mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
     7 
     8 # 输入图片是28*28
     9 n_inputs = 28 #输入一行,一行有28个数据
    10 max_time = 28 #一共28行
    11 lstm_size = 100 #隐层单元
    12 n_classes = 10 # 10个分类
    13 batch_size = 50 #每批次50个样本
    14 n_batch = mnist.train.num_examples // batch_size #计算一共有多少个批次
    15 
    16 #这里的none表示第一个维度可以是任意的长度
    17 x = tf.placeholder(tf.float32,[None,784])
    18 #正确的标签
    19 y = tf.placeholder(tf.float32,[None,10])
    20 
    21 #初始化权值
    22 weights = tf.Variable(tf.truncated_normal([lstm_size, n_classes], stddev=0.1))
    23 #初始化偏置值
    24 biases = tf.Variable(tf.constant(0.1, shape=[n_classes]))
    25 
    26 
    27 #定义RNN网络
    28 def RNN(X,weights,biases):
    29     # inputs=[batch_size, max_time, n_inputs]
    30     inputs = tf.reshape(X,[-1,max_time,n_inputs])
    31     #定义LSTM基本CELL
    32     lstm_cell = tf.contrib.rnn.core_rnn_cell.BasicLSTMCell(lstm_size)
    33     # final_state[0]是cell state
    34     # final_state[1]是hidden_state
    35     outputs,final_state = tf.nn.dynamic_rnn(lstm_cell,inputs,dtype=tf.float32)
    36     results = tf.nn.softmax(tf.matmul(final_state[1],weights) + biases)
    37     return results
    38     
    39     
    40 #计算RNN的返回结果
    41 prediction= RNN(x, weights, biases)  
    42 #损失函数
    43 cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction,labels=y))
    44 #使用AdamOptimizer进行优化
    45 train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    46 #结果存放在一个布尔型列表中
    47 correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
    48 #求准确率
    49 accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#把correct_prediction变为float32类型
    50 #初始化
    51 init = tf.global_variables_initializer()
    52 
    53 with tf.Session() as sess:
    54     sess.run(init)
    55     for epoch in range(6):
    56         for batch in range(n_batch):
    57             batch_xs,batch_ys =  mnist.train.next_batch(batch_size)
    58             sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})
    59         
    60         acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
    61         print ("Iter " + str(epoch) + ", Testing Accuracy= " + str(acc))
    View Code

    2.关于Tensorboard的简单学习(以MNIST手写数据集程序为例)

     1 import os
     2 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
     3 import tensorflow as tf
     4 from tensorflow.examples.tutorials.mnist import input_data
     5 #载入数据集
     6 mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
     7 #每个批次的大小(即每次训练的图片数量)
     8 batch_size = 100
     9 #计算一共有多少个批次
    10 n_bitch = mnist.train.num_examples // batch_size
    11 #参数概要
    12 def variable_summaries(var):
    13     with tf.name_scope('summaries'):
    14         mean = tf.reduce_mean(var)
    15         tf.summary.scalar('mean', mean)  #平均值
    16         with tf.name_scope('stddev'):
    17             stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
    18         tf.summary.scalar('stddev', stddev) #标准差
    19         tf.summary.scalar('max', tf.reduce_max(var))
    20         tf.summary.scalar('min', tf.reduce_min(var))
    21         tf.summary.histogram('histogram', var)#直方图
    22 #定义一个命名空间
    23 with tf.name_scope('input'):
    24     #定义两个placeholder
    25     x = tf.placeholder(tf.float32, [None, 784], name='x_input')
    26     y = tf.placeholder(tf.float32, [None, 10], name='y_input')
    27 with tf.name_scope('layer'):
    28     #创建一个只有输入层(784个神经元)和输出层(10个神经元)的简单神经网络
    29     with tf.name_scope('weights'):
    30         Weights = tf.Variable(tf.zeros([784, 10]), name='w')
    31         variable_summaries(Weights)
    32     with tf.name_scope('biases'):
    33         Biases = tf.Variable(tf.zeros([10]), name='b')
    34         variable_summaries(Biases)
    35     with tf.name_scope('Wx_plus_B'):
    36         Wx_plus_B = tf.matmul(x, Weights) + Biases
    37     with tf.name_scope('softmax'):
    38         prediction = tf.nn.softmax(Wx_plus_B)
    39 #二次代价函数
    40 with tf.name_scope('loss'):
    41     loss = tf.reduce_mean(tf.square(y - prediction))
    42     tf.summary.scalar('loss', loss)
    43 #使用梯度下降法
    44 with tf.name_scope('train'):
    45     train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
    46 #初始化变量
    47 init = tf.global_variables_initializer()
    48 #结果存放在一个布尔型列表中
    49 with tf.name_scope('accuracy'):
    50     with tf.name_scope('correct_prediction'):
    51         correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(prediction, 1)) #argmax返回一维张量中最大的值所在的位置,标签值和预测值相同,返回为True
    52 #求准确率
    53     with tf.name_scope('correct_prediction'):
    54         accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) #cast函数将correct_prediction的布尔型转换为浮点型,然后计算平均值即为准确率
    55 
    56 #合并所有的summary
    57 merged = tf.summary.merge_all()
    58 
    59 #定义会话
    60 with tf.Session() as sess:
    61     sess.run(init)
    62     writer = tf.summary.FileWriter('logs/', sess.graph)
    63     #将测试集循环训练50次
    64     for epoch in range(51):
    65         #将测试集中所有数据循环一次
    66         for batch in range(n_bitch):
    67             batch_xs, batch_ys = mnist.train.next_batch(batch_size)   #取测试集中batch_size数量的图片及对应的标签值
    68             summary,_= sess.run([merged, train_step], feed_dict={x:batch_xs, y:batch_ys})  #将上一行代码取到的数据进行训练
    69         writer.add_summary(summary, epoch)
    70         acc = sess.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels})  #准确率的计算
    71         print('Iter : ' + str(epoch) + ',Testing Accuracy = ' + str(acc))
    View Code

    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数据处理程序

     1 clear all;
     2 clc;
     3 load DataSet;
     4 [iType, iCondition] = size(A);
     5 iExtSize = 24*24;
     6 iSampleRate = 12000;
     7 iTime = 10;
     8 iOverlap = floor(iExtSize * 0.9);
     9 iUCover = iExtSize - iOverlap;
    10 iGetDataLen = iSampleRate*iTime + iExtSize;
    11 iLen2 = floor((iGetDataLen-iExtSize)/iUCover) + 1;
    12 iLen1 =  floor(iLen2/100)*100;
    13 iGetDataLen = iLen1*iUCover + iExtSize;
    14 fExtSamp = zeros(iType, iGetDataLen);
    15  
    16 tmp = 0;
    17 for jCnt = 1: iType
    18     str1 = sprintf('%03d',A(jCnt,1));
    19     szValName = strcat('X', str1, '_DE_time');
    20     eval(strcat('tmp=',szValName,';'));
    21     fExtSamp(jCnt,:) = tmp(1:iGetDataLen);
    22 end
    23 iLen = iLen1;
    24 iSampSize = iLen * iType;
    25 fData = zeros(iSampSize, iExtSize);
    26 fLabel = zeros(iSampSize, 4);
    27  
    28 for iCnt = 1:1:iLen
    29     iInterval = (iCnt -1)*iUCover + (1:1:iExtSize);
    30     for jCnt =1:1:iType
    31         fData((iCnt - 1)*iType + jCnt,:) = fExtSamp(jCnt, iInterval);
    32         if (jCnt ==1)
    33             fLabel((iCnt - 1)*iType + jCnt,:) = [1 0 0 0];
    34         end
    35         if (jCnt >=2 && jCnt<=5)
    36             fLabel((iCnt - 1)*iType + jCnt,:) = [0 1 0 0];
    37         end
    38         if (jCnt >=6 && jCnt<=9)
    39             fLabel((iCnt - 1)*iType + jCnt,:) = [0 0 1 0];
    40         end
    41         if (jCnt >=10)
    42             fLabel((iCnt - 1)*iType + jCnt,:) = [0 0 0 1];
    43         end
    44     end
    45 end
    46 save('DL_Data90.mat','fData', 'fLabel');  
    View Code

    3.3 CNN轴承故障诊断模型

      1 import os
      2 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
      3 import numpy as np
      4 import tensorflow as tf
      5 from tensorflow.contrib import rnn
      6 import matplotlib.pyplot as plt
      7  
      8 nSampleSize = 20000     # 总样本数
      9 nSig_dim = 576          # 单个样本维度
     10 nLab_dim = 4            # 类别维度
     11  
     12 learning_rate = 1e-3
     13 batch_size = tf.placeholder(tf.int32, [])   # 在训练和测试,用不同的 batch_size
     14 input_size = 24     # 每个时刻的输入维数为 24
     15 timestep_size = 24  # 时序长度为24
     16 hidden_size = 128   # 每个隐含层的节点数
     17 layer_num = 3       # LSTM layer 的层数
     18 class_num = nLab_dim       # 类别维数
     19  
     20 def getdata(nSampSize=20000):
     21     # 读取float型二进制数据
     22     signal = np.fromfile('DLdata90singal.raw', dtype=np.float64)
     23     labels = np.fromfile('DLdata90labels.raw', dtype=np.float64)
     24     #由于matlab 矩阵写入文件是按照【列】优先, 需要按行读取
     25     mat_sig = np.reshape(signal,[-1, nSampSize])
     26     mat_lab = np.reshape(labels,[-1, nSampSize])
     27     mat_sig = mat_sig.T # 转换成正常样式 【样本序号,样本维度】
     28     mat_lab = mat_lab.T
     29     return mat_sig, mat_lab
     30  
     31 def zscore(xx):
     32     # 样本归一化到【-1,1】,逐条对每个样本进行自归一化处理
     33     max1 = np.max(xx,axis=1)    #按行或者每个样本,并求出单个样本的最大值
     34     max1 = np.reshape(max1,[-1,1])  # 行向量 ->> 列向量
     35     min1 = np.min(xx,axis=1)    #按行或者每个样本,并求出单个样本的最小值
     36     min1 = np.reshape(min1,[-1,1])  # 行向量 ->> 列向量
     37     xx = (xx-min1)/(max1-min1)*2-1
     38     return xx
     39  
     40 def NextBatch(iLen, n_batchsize):
     41     # iLen: 样本总数
     42     # n_batchsize: 批处理大小
     43     # 返回n_batchsize个随机样本(序号)
     44     ar = np.arange(iLen)    # 生成0到iLen-1,步长为1的序列
     45     np.random.shuffle(ar)   # 打乱顺序
     46     return ar[0:n_batchsize]
     47  
     48 xs = tf.placeholder(tf.float32, [None, nSig_dim])
     49 ys = tf.placeholder(tf.float32, [None, class_num])
     50 keep_prob = tf.placeholder(tf.float32)
     51  
     52 x_input = tf.reshape(xs, [-1, 24, 24])
     53  
     54 # 搭建LSTM 模型
     55 def unit_LSTM():
     56     # 定义一层 LSTM_cell,只需要说明 hidden_size
     57     lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)
     58     #添加 dropout layer, 一般只设置 output_keep_prob
     59     lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
     60     return lstm_cell
     61  
     62 #调用 MultiRNNCell 来实现多层 LSTM
     63 mLSTM_cell = rnn.MultiRNNCell([unit_LSTM() for icnt in range(layer_num)], state_is_tuple=True)
     64  
     65 #用全零来初始化state
     66 init_state = mLSTM_cell.zero_state(batch_size, dtype=tf.float32)
     67 outputs, state = tf.nn.dynamic_rnn(mLSTM_cell, inputs=x_input,initial_state=init_state, time_major=False)
     68 h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]
     69  
     70 #设置 loss function 和 优化器
     71 W = tf.Variable(tf.truncated_normal([hidden_size, class_num], stddev=0.1), dtype=tf.float32)
     72 bias = tf.Variable(tf.constant(0.1,shape=[class_num]), dtype=tf.float32)
     73 y_pre = tf.nn.softmax(tf.matmul(h_state, W) + bias)
     74 
     75 #损失和评估函数
     76 cross_entropy = tf.reduce_mean(tf.reduce_sum(-ys*tf.log(y_pre),reduction_indices=[1]))
     77 train_op = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy)
     78 correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(ys,1))
     79 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
     80  
     81  
     82 mydata = getdata()
     83 iTrainSetSize =  np.floor(nSampleSize*3/4).astype(int) # 训练样本个数
     84 iIndex = np.arange(nSampleSize) # 按照顺序,然后划分训练样本、测试样本
     85 train_index = iIndex[0:iTrainSetSize]
     86 test_index = iIndex[iTrainSetSize:nSampleSize]
     87  
     88 train_data = mydata[0][train_index]     # 训练数据
     89 train_y = mydata[1][train_index]        # 训练标签
     90 test_data = mydata[0][test_index]       # 测试数据
     91 test_y = mydata[1][test_index]          # 测试标签
     92  
     93 train_x = zscore(train_data)        # 对训练数据进行归一化
     94 test_x = zscore(test_data)          # 对测试数据进行归一化
     95  
     96 init = tf.global_variables_initializer()
     97 
     98 with tf.Session() as sess:
     99     sess.run(init)
    100     for icnt in range(1000):
    101         _batch_size = 100
    102         intervals = NextBatch(iTrainSetSize, _batch_size) # 每次从所有样本中随机取100个样本(序号)
    103         xx = train_x[intervals]
    104         yy = train_y[intervals]   
    105         if (icnt+1)%100 == 0:
    106             train_accuracy = sess.run(accuracy, feed_dict={
    107                 xs:xx, ys: yy, keep_prob: 1.0, batch_size: _batch_size})
    108             print("step: " + "{0:4d}".format(icnt+1) + ",  train acc:" + "{:.4f}".format(train_accuracy))
    109         sess.run(train_op, feed_dict={ xs:xx, ys: yy, keep_prob: 0.9, batch_size: _batch_size})
    110     bsize = test_x.shape[0]
    111     test_acc = sess.run(accuracy,feed_dict={xs:test_x, ys:test_y, keep_prob: 1.0, batch_size:bsize})
    112     print("test acc:" + "{:.4f}".format(test_acc))
    View Code

    #写在后面

    新的一年了

    感觉开始的一塌糊涂

    不过这两天好像调整过来了

    让自己成为一个有计划的人

    坚持健身、坚持减肥、学习理财、学习穿搭、学BEC中级、学机器学习、学Java、学Python、学深度学习框架、准备实习、积极准备找工作!

    坚持早点睡觉、坚持早点起床

    坚持不拖延

    坚持放下手机

    坚持不去抱怨生活、不去抱怨别人

    坚持!做一个自律、自信的小伙郭

    忙碌起来

    为最好的那个自己而不断努力

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

    而是在每一个今天,都活出最精彩的一天

    羡慕那些活的精致的人

    我也要好好加油才好!

  • 相关阅读:
    CoreData数据库浅析
    FMDB第三方框架
    SQLite浅析
    iOS开发工程师面试题(二)
    iOS开发工程师面试题(一)
    RunTime&RunLoop初见
    GCD定时器
    2016年4月21百度iOS实习生在线笔试题&编程题
    网络天荒地老之UIWebView&WebKit
    expdp/impdp
  • 原文地址:https://www.cnblogs.com/guoruxin/p/10231579.html
Copyright © 2020-2023  润新知