Softmax回归（使用tensorflow）

 # coding:utf8
 import numpy as np
 import cPickle
 import os
 import tensorflow as tf

 class SoftMax:
     def __init__(self,MAXT=30,step=0.0025):
         self.MAXT = MAXT
         self.step = step

     def load_theta(self,datapath="data/softmax.pkl"):
         self.theta = cPickle.load(open(datapath,'rb'))

     def process_train(self,data,label,typenum=10,batch_size=500):
         batches =  data.shape[0] / batch_size
         valuenum=data.shape[1]
         if len(label.shape)==1:
             label=self.reshape_data(label,typenum)
         x = tf.placeholder("float", [None,valuenum])
         theta = tf.Variable(tf.zeros([valuenum,typenum]))
         y = tf.nn.softmax(tf.matmul(x,theta))
         y_ = tf.placeholder("float", [None, typenum])
         cross_entropy = -tf.reduce_sum(y_*tf.log(y))  #交叉熵
         train_step = tf.train.GradientDescentOptimizer(self.step).minimize(cross_entropy)
         init = tf.initialize_all_variables()
         sess = tf.Session()
         sess.run(init)
         for epoch in range(self.MAXT):
             cost_=[]
             for index in xrange(batches):
                 c_,_=sess.run([cross_entropy,train_step], feed_dict={ x: data[index * batch_size: (index + 1) * batch_size],
                 y_: label[index * batch_size: (index + 1) * batch_size]})
                 cost_.append(c_)
             if epoch % 5 == 0:
                 print(( 'epoch %i, minibatch %i/%i,averange cost is %f') %
                         (epoch,index + 1,batches,np.mean(cost_)))
         self.theta=sess.run(theta)
         if not os.path.exists('data/softmax.pkl'):
             f= open("data/softmax.pkl",'wb')
             cPickle.dump(self.theta,f)
             f.close()
         return self.theta

     def process_test(self,data,label,typenum=10):
         valuenum=data.shape[1]
         if len(label.shape)==1:
             label=self.reshape_data(label,typenum)
         x = tf.placeholder("float", [None,valuenum])
         theta = self.theta
         y = tf.nn.softmax(tf.matmul(x,theta))
         y_ = tf.placeholder("float", [None, typenum])
         init = tf.initialize_all_variables()
         sess = tf.Session()
         sess.run(init)
         correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
         accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
         print "Accuracy: ",sess.run(accuracy, feed_dict={x: data,y_: label})

     def h(self,x):
         m = np.exp(np.dot(x,self.theta))
         sump = np.sum(m,axis=1)
         return m/sump

     def predict(self,x):
         return np.argmax(self.h(x),axis=1)

     def reshape_data(self,label,typenum):
         label_=[]
         for yl_ in label:
             tl_=np.zeros(typenum)
             tl_[yl_]=1.0
             label_.append(tl_)
         return np.mat(label_)

 if __name__ == '__main__':
     f = open('mnist.pkl', 'rb')
     training_data, validation_data, test_data = cPickle.load(f)
     training_inputs = [np.reshape(x, 784) for x in training_data[0]]
     data = np.array(training_inputs)
     training_inputs = [np.reshape(x, 784) for x in validation_data[0]]
     vdata = np.array(training_inputs)
     f.close()

     softmax = SoftMax()
     softmax.process_train(data,training_data[1])
     softmax.process_test(vdata,validation_data[1])  #Accuracy:  0.9269
     softmax.process_test(data,training_data[1])  #Accuracy:  0.92718