import tensorflow as tf

#定義隱藏層參數，每個w變量是一個tensor(可以當成是n*m的數組，n表示上一層結點個數，m表示本層結點個數)表示上一層與本層的連接權重,這里先隨機定義權重
w1=tf.Variable(tf.random_normal([2,3]，stddev=1))
w2=tf.Variable(tf.random_normal([3,1]，stddev=1))

#定義存放輸入數據的地方，也就是x向量,這里shape為前一個傳入訓練的樣本個數，后面出入每個樣本的維度大小
x=tf.placeholder(tf.float32,shape=(None,2),name="input")
#矩陣乘法
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)

with tf.Session() as sess:
  #新版本好像不能用這個函數初始化所有變量了
  init_op=tf.initialize_all_variables()
  sess.run(init_op)
  #feed_dict用于向y中的x傳入參數，這里傳入3個，則y輸出為一個3*1的tensor
  print（sess.run(y,feed_dict={x:[[0.7,0.9],[1.0,1.5],[2.1,2.3]]}))

# -*- coding: utf-8 -*-
"""
Created on Fri Aug 18 14:02:19 2017

@author: osT
"""
import tensorflow as tf 
import numpy as np
#導入數據，這里的數據是每一行代表一個樣本，每一行最后一列表示樣本標簽，0-32一共33個類
data=np.loadtxt('train_data.txt',dtype='float',delimiter=',')

#將樣本標簽轉換成獨熱編碼
def label_change(before_label):
  label_num=len(before_label)
  change_arr=np.zeros((label_num,33))
  for i in range(label_num):
    #該樣本標簽原本為0-32的，本人疏忽下32標記成33
    if before_label[i]==33.0:
      change_arr[i,int(before_label[i]-1)]=1
    else:
      change_arr[i,int(before_label[i])]=1
  return change_arr

#定義神經網絡的輸入輸出結點，每個樣本為1*315維，以及輸出分類結果
INPUT_NODE=315
OUTPUT_NODE=33

#定義兩層隱含層的神經網絡，一層300個結點，一層100個結點
LAYER1_NODE=300
LAYER2_NODE=100

#定義學習率，學習率衰減速度，正則系數，訓練調整參數的次數以及平滑衰減率
LEARNING_RATE_BASE=0.5
LEARNING_RATE_DECAY=0.99
REGULARIZATION_RATE=0.0001
TRAINING_STEPS=2000
MOVING_AVERAGE_DECAY=0.99

#定義整個神經網絡的結構，也就是向前傳播的過程，avg_class為平滑可訓練量的類，不傳入則不使用平滑
def inference(input_tensor,avg_class,w1,b1,w2,b2,w3,b3):
  if avg_class==None:
    #第一層隱含層，輸入與權重矩陣乘后加上常數傳入激活函數作為輸出
    layer1=tf.nn.relu(tf.matmul(input_tensor,w1)+b1)
    #第二層隱含層，前一層的輸出與權重矩陣乘后加上常數作為輸出
    layer2=tf.nn.relu(tf.matmul(layer1,w2)+b2)
    #返回 第二層隱含層與權重矩陣乘加上常數作為輸出
    return tf.matmul(layer2,w3)+b3
  else:
    #avg_class.average()平滑訓練變量，也就是每一層與上一層的權重
    layer1=tf.nn.relu(tf.matmul(input_tensor,avg_class.average(w1))+avg_class.average(b1))
    layer2=tf.nn.relu(tf.matmul(layer1,avg_class.average(w2))+avg_class.average(b2))
    return tf.matmul(layer2,avg_class.average(w3))+avg_class.average(b3)

def train(data):
  #混洗數據
  np.random.shuffle(data)
  #取錢850個樣本為訓練樣本，后面的全是測試樣本，約250個
  data_train_x=data[:850,:315]
  data_train_y=label_change(data[:850,-1])
  data_test_x=data[850:,:315]
  data_test_y=label_change(data[850:,-1])

  #定義輸出數據的地方，None表示無規定一次輸入多少訓練樣本,y_是樣本標簽存放的地方
  x=tf.placeholder(tf.float32,shape=[None,INPUT_NODE],name='x-input')
  y_=tf.placeholder(tf.float32,shape=[None,OUTPUT_NODE],name='y-input')

  #依次定義每一層與上一層的權重，這里用隨機數初始化，注意shape的對應關系
  w1=tf.Variable(tf.truncated_normal(shape=[INPUT_NODE,LAYER1_NODE],stddev=0.1))
  b1=tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))

  w2=tf.Variable(tf.truncated_normal(shape=[LAYER1_NODE,LAYER2_NODE],stddev=0.1))
  b2=tf.Variable(tf.constant(0.1,shape=[LAYER2_NODE]))

  w3=tf.Variable(tf.truncated_normal(shape=[LAYER2_NODE,OUTPUT_NODE],stddev=0.1))
  b3=tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))

  #輸出向前傳播的結果
  y=inference(x,None,w1,b1,w2,b2,w3,b3)

  #每訓練完一次就會增加的變量
  global_step=tf.Variable(0,trainable=False)

  #定義平滑變量的類，輸入為平滑衰減率和global_stop使得每訓練完一次就會使用平滑過程
  variable_averages=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
  #將平滑應用到所有可訓練的變量，即trainable=True的變量
  variable_averages_op=variable_averages.apply(tf.trainable_variables())

  #輸出平滑后的預測值
  average_y=inference(x,variable_averages,w1,b1,w2,b2,w3,b3)

  #定義交叉熵和損失函數，但為什么傳入的是label的arg_max(),就是對應分類的下標呢，我們遲點再說
  cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.arg_max(y_,1))
  #計算交叉熵的平均值，也就是本輪訓練對所有訓練樣本的平均值
  cross_entrip_mean=tf.reduce_mean(cross_entropy)

  #定義正則化權重，并將其加上交叉熵作為損失函數
  regularizer=tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
  regularization=regularizer(w1)+regularizer(w2)+regularizer(w3)
  loss=cross_entrip_mean+regularization

  #定義動態學習率，隨著訓練的步驟增加不斷遞減
  learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,900,LEARNING_RATE_DECAY)
  #定義向后傳播的算法，梯度下降發，注意后面的minimize要傳入global_step
  train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
  #管理需要更新的變量，傳入的參數是包含需要訓練的變量的過程
  train_op=tf.group(train_step,variable_averages_op)

  #正確率預測
  correct_prediction=tf.equal(tf.arg_max(average_y,1),tf.arg_max(y_,1))
  accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

  with tf.Session() as sess:
    #初始所有變量
    tf.global_variables_initializer().run()
    #訓練集輸入字典
    validate_feed={x:data_train_x,y_:data_train_y}
    #測試集輸入字典
    test_feed={x:data_test_x,y_:data_test_y}

    for i in range(TRAINING_STEPS):
      if i%1000==0:
        validate_acc=sess.run(accuracy,feed_dict=validate_feed)
        print("After %d training step(s),validation accuracy using average model is %g"%(i,validate_acc))
      #每一輪通過同一訓練集訓練，由于樣本太少，沒辦法了
      sess.run(train_op,feed_dict=validate_feed)
    #用測試集查看模型的準確率
    test_acc=sess.run(accuracy,feed_dict=test_feed)
    print("After %d training step(s),test accuracy using average model is %g"%(TRAINING_STEPS,test_acc))
train(data)