#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
# @Time  : 2017-03-12 15:11 
# @Author : CC 
# @File  : net_load_data.py 
# @Software: PyCharm Community Edition 
 
from numpy import * 
import numpy as np 
import cPickle 
def load_data(): 
  """載入解壓后的數據，并讀取""" 
  with open('data/mnist_pkl/mnist.pkl','rb') as f: 
    try: 
      train_data,validation_data,test_data = cPickle.load(f) 
      print " the file open sucessfully" 
      # print train_data[0].shape #(50000,784) 
      # print train_data[1].shape  #(50000,) 
      return (train_data,validation_data,test_data) 
    except EOFError: 
      print 'the file open error' 
      return None 
 
def data_transform(): 
  """將數據轉化為計算格式""" 
  t_d,va_d,te_d = load_data() 
  # print t_d[0].shape # (50000,784) 
  # print te_d[0].shape # (10000,784) 
  # print va_d[0].shape # (10000,784) 
  # n1 = [np.reshape(x,784,1) for x in t_d[0]] # 將5萬個數據分別逐個取出化成（784,1），逐個排列 
  n = [np.reshape(x, (784, 1)) for x in t_d[0]] # 將5萬個數據分別逐個取出化成（784,1），逐個排列 
  # print 'n1',n1[0].shape 
  # print 'n',n[0].shape 
  m = [vectors(y) for y in t_d[1]] # 將5萬標簽（50000,1）化為（10,50000） 
  train_data = zip(n,m) # 將數據與標簽打包成元組形式 
  n = [np.reshape(x, (784, 1)) for x in va_d[0]] # 將5萬個數據分別逐個取出化成（784,1），排列 
  validation_data = zip(n,va_d[1])  # 沒有將標簽數據矢量化 
  n = [np.reshape(x, (784, 1)) for x in te_d[0]] # 將5萬個數據分別逐個取出化成（784,1），排列 
  test_data = zip(n, te_d[1]) # 沒有將標簽數據矢量化 
  # print train_data[0][0].shape #(784,） 
  # print "len(train_data[0])",len(train_data[0]) #2 
  # print "len(train_data[100])",len(train_data[100]) #2 
  # print "len(train_data[0][0])", len(train_data[0][0]) #784 
  # print "train_data[0][0].shape", train_data[0][0].shape #（784,1） 
  # print "len(train_data)", len(train_data) #50000 
  # print train_data[0][1].shape #(10,1) 
  # print test_data[0][1] # 7 
  return (train_data,validation_data,test_data) 
def vectors(y): 
  """賦予標簽""" 
  label = np.zeros((10,1)) 
  label[y] = 1.0 #浮點計算 
  return label 

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
# @Time  : 2017-03-12 16:07 
# @Author : CC 
# @File  : net_network.py 
 
import numpy as np 
import random 
class Network(object):  #默認為基類?用于繼承：print isinstance(network,object) 
  def __init__(self,sizes): 
    self.num_layers = len(sizes) 
    self.sizes = sizes 
    # print 'num_layers', self.num_layers 
    self.weight = [np.random.randn(a1, a2) for (a1, a2) in zip(sizes[1:], sizes[:-1])] #產生一個個數組 
    self.bias = [np.random.randn(a3,1) for a3 in sizes[1:]] 
    # print self.weight[0].shape #(20,10) 
 
  def SGD(self,train_data,min_batch_size,epoches,eta,test_data=False): 
    """ 1) 打亂樣本，將訓練數據劃分成小批次 
      2）計算出反向傳播梯度 
      3） 獲得權重更新""" 
    if test_data: n_test = len(test_data) 
    n = len(train_data)  #50000 
    random.shuffle(train_data) # 打亂 
    min_batches = [train_data[k:k+min_batch_size] for k in xrange(0,n,min_batch_size)] #提取批次數據 
    for k in xrange(0,epoches):  #利用更新后的權值繼續更新 
      random.shuffle(train_data) # 打亂 
      for min_batch in min_batches: #逐個傳入，效率很低 
        self.updata_parameter(min_batch,eta) 
      if test_data: 
        num = self.evaluate(test_data) 
        print "the {0}th epoches: {1}/{2}".format(k,num,len(test_data)) 
      else: 
        print 'epoches {0} completed'.format(k) 
 
  def forward(self,x): 
    """獲得各層激活值""" 
    for w,b in zip(self.weight,self.bias): 
      x = sigmoid(np.dot(w, x)+b) 
    return x 
 
  def updata_parameter(self,min_batch,eta): 
    """1) 反向傳播計算每個樣本梯度值 
      2） 累加每個批次樣本的梯度值 
      3） 權值更新""" 
    ndeltab = [np.zeros(b.shape) for b in self.bias] 
    ndeltaw = [np.zeros(w.shape) for w in self.weight] 
    for x,y in min_batch: 
      deltab,deltaw = self.backprop(x,y) 
      ndeltab = [nb +db for nb,db in zip(ndeltab,deltab)] 
      ndeltaw = [nw + dw for nw,dw in zip(ndeltaw,deltaw)] 
    self.bias = [b - eta * ndb/len(min_batch) for ndb,b in zip(ndeltab,self.bias)] 
    self.weight = [w - eta * ndw/len(min_batch) for ndw,w in zip(ndeltaw,self.weight)] 
 
 
  def backprop(self,x,y): 
    """執行前向計算，再進行反向傳播，返回deltaw,deltab""" 
    # [w for w in self.weight] 
    # print 'len',len(w) 
    # print "self.weight",self.weight[0].shape 
    # print w[0].shape 
    # print w[1].shape 
    # print w.shape 
    activation = x 
    activations = [x] 
    zs = [] 
    # feedforward 
    for w, b in zip(self.weight, self.bias): 
      # print w.shape,activation.shape,b.shape 
      z = np.dot(w, activation) +b 
      zs.append(z)  #用于計算f(z)導數 
      activation = sigmoid(z) 
      # print 'activation',activation.shape 
      activations.append(activation) # 每層的輸出結果 
    delta = self.top_subtract(activations[-1],y) * dsigmoid(zs[-1]) #最后一層的delta,np.array乘,相同維度乘 
    deltaw = [np.zeros(w1.shape) for w1 in self.weight] #每一次將獲得的值作為列表形式賦給deltaw 
    deltab = [np.zeros(b1.shape) for b1 in self.bias] 
    # print 'deltab[0]',deltab[-1].shape 
    deltab[-1] = delta 
    deltaw[-1] = np.dot(delta,activations[-2].transpose()) 
    for k in xrange(2,self.num_layers): 
      delta = np.dot(self.weight[-k+1].transpose(),delta) * dsigmoid(zs[-k]) 
      deltab[-k] = delta 
      deltaw[-k] = np.dot(delta,activations[-k-1].transpose()) 
    return (deltab,deltaw) 
 
  def evaluate(self,test_data): 
    """評估驗證集和測試集的精度,標簽直接一個數作為比較""" 
    z = [(np.argmax(self.forward(x)),y) for x,y in test_data] 
    zs = np.sum(int(a == b) for a,b in z) 
    # zk = sum(int(a == b) for a,b in z) 
    # print "zs/zk:",zs,zk 
    return zs 
 
  def top_subtract(self,x,y): 
    return (x - y) 
 
def sigmoid(x): 
  return 1.0/(1.0+np.exp(-x)) 
 
def dsigmoid(x): 
  z = sigmoid(x) 
  return z*(1-z) 

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
# @Time  : 2017-03-12 15:24 
# @Author : CC 
# @File  : net_test.py 
 
import net_load_data 
# net_load_data.load_data() 
train_data,validation_data,test_data = net_load_data.data_transform() 
 
import net_network as net 
net1 = net.Network([784,30,10]) 
min_batch_size = 10 
eta = 3.0 
epoches = 30 
net1.SGD(train_data,min_batch_size,epoches,eta,test_data) 
print "complete" 

the 9th epoches: 9405/10000 
the 10th epoches: 9420/10000 
the 11th epoches: 9385/10000 
the 12th epoches: 9404/10000 
the 13th epoches: 9398/10000 
the 14th epoches: 9406/10000 
the 15th epoches: 9396/10000 
the 16th epoches: 9413/10000 
the 17th epoches: 9405/10000 
the 18th epoches: 9425/10000 
the 19th epoches: 9420/10000