Softmax回归（使用theano）

 # coding:utf8
 import numpy as np
 import cPickle
 import theano
 import os
 import theano.tensor as T

 class SoftMax:
     def __init__(self,MAXT=50,step=0.15,landa=0):
         self.MAXT = MAXT
         self.step = step
         self.landa = landa  #在此权重衰减项未能提升正确率

     def load_theta(self,datapath):
         self.theta = cPickle.load(open(datapath,'rb'))

     def process_train(self,data,label,typenum,batch_size=500):
         valuenum=data.shape[1]
         batches =  data.shape[0] / batch_size
         data = theano.shared(np.asarray(data,dtype=theano.config.floatX))
         label = T.cast(theano.shared(np.asarray(label,dtype=theano.config.floatX)), 'int32')
         x = T.matrix('x')
         y = T.ivector('y')
         index = T.lscalar()
         theta =  theano.shared(value=0.001*np.zeros((valuenum,typenum),
             dtype=theano.config.floatX),
             name='theta',borrow=True)
         hx=T.nnet.softmax(T.dot(x,theta))
         cost =  -T.mean(T.log(hx)[T.arange(y.shape[0]), y]) +0.5*self.landa*T.sum(theta ** 2)  #权重衰减项
         g_theta = T.grad(cost, theta)
         updates = [(theta, theta - self.step * g_theta)]
         train_model = theano.function(
         inputs=[index],outputs=cost,updates=updates,givens={
             x: data[index * batch_size: (index + 1) * batch_size],
             y: label[index * batch_size: (index + 1) * batch_size]
         },allow_input_downcast=True
         )
         lastcostJ = np.inf
         stop = False
         epoch = 0
         costj=[]
         while (epoch < self.MAXT) and (not stop):
             epoch = epoch + 1
             for minibatch_index in xrange(batches):
                 costj.append(train_model(minibatch_index))
             if np.mean(costj)>=lastcostJ:
                 print "costJ is increasing !!!"
                 stop=True
             else:
                 lastcostJ=np.mean(costj)
                 print(( 'epoch %i, minibatch %i/%i,averange cost is %f') %
                         (epoch,minibatch_index + 1,batches,lastcostJ))
         self.theta=theta
         if not os.path.exists('data/softmax.pkl'):
             f= open("data/softmax.pkl",'wb')
             cPickle.dump(self.theta.get_value(),f)
             f.close()
         return self.theta.get_value()

     def process_test(self,data,label,batch_size=500):
         batches = label.shape[0] / batch_size
         data = theano.shared(np.asarray(data,dtype=theano.config.floatX))
         label = T.cast(theano.shared(np.asarray(label,dtype=theano.config.floatX)), 'int32')
         x = T.matrix('x')
         y = T.ivector('y')
         index = T.lscalar()
         hx=T.nnet.softmax(T.dot(x,self.theta))
         predict = T.argmax(hx, axis=1)
         errors=T.mean(T.neq(predict, y))
         test_model = theano.function(
         inputs=[index],outputs=errors,givens={
             x: data[index * batch_size: (index + 1) * batch_size],
             y: label[index * batch_size: (index + 1) * batch_size]
         },allow_input_downcast=True
         )
         test_losses=[]
         for minibatch_index in xrange(batches):
             test_losses.append(test_model(minibatch_index))
         test_score = np.mean(test_losses)
         print(( 'minibatch %i/%i, test error of model %f %%') %
               (minibatch_index + 1,batches,test_score * 100.))

     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)

 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],10)
     softmax.process_test(vdata,validation_data[1])
     #minibatch 20/20, test error of model 7.530000 %