import numpy

    
 import os
    
 import urllib
    
 import gzip
    
 import struct
    
 def read_data(label_name, image_name):
    
     s=os.getenv('DATA')
    
     with gzip.open(os.getenv('DATA')+'\ MNIST\ '+label_name) as flbl:
    
     magic, num = struct.unpack(">II", flbl.read(8))
    
     label = numpy.fromstring(flbl.read(), dtype=numpy.int8)
    
     with gzip.open(os.getenv('DATA')+'\ MNIST\ '+image_name, 'rb') as fimg:
    
     magic, num, rows, cols = struct.unpack(">IIII", fimg.read(16))
    
     image = numpy.fromstring(fimg.read(), dtype=numpy.uint8).reshape(len(label), rows, cols)
    
     return (label, image)
    
 (train_lbl, train_img) = read_data('train-labels-idx1-ubyte.gz', 'train-images-idx3-ubyte.gz')
    
 (val_lbl, val_img) = read_data('t10k-labels-idx1-ubyte.gz','t10k-images-idx3-ubyte.gz')
    
 def to4d(img):
    
     return img.reshape(img.shape[0], 1, 28, 28).astype(numpy.float32)/255
    
 def repack_data(d):
    
     t = numpy.zeros((d.size, 10))
    
     for i in range(d.size):
    
     t[i][d[i]] = 1
    
     return t
    
 train_img=to4d(train_img)
    
 val_img=to4d(val_img)
    
 batch_size = 100
    
 num_epoch =5
    
 #backend='mxnet'
    
 backend='keras'
    
 if backend=='keras':
    
     from keras.models import *
    
     from keras.layers import *
    
     from keras.optimizers import *
    
     model = Sequential()
    
     model.add(Convolution2D(64, 5, 5, input_shape=(1,28,28), init='uniform', activation='relu'))
    
     model.add(MaxPooling2D())
    
     model.add(Convolution2D(128, 5, 5, init='uniform', activation='relu'))
    
     model.add(MaxPooling2D())
    
     model.add(Flatten())
    
     model.add(Dense(1024, init='uniform', activation='relu'))
    
     model.add(Dense(1024, init='uniform', activation='relu'))
    
     model.add(Dense(10, init='uniform', activation='softmax'))
    
     model.summary()
    
     model.compile(loss='categorical_crossentropy', optimizer=adadelta(), metrics=['accuracy'])
    
     model.fit(train_img,repack_data(train_lbl),batch_size=batch_size,nb_epoch=num_epoch,validation_data=(val_img,repack_data(val_lbl)))
    
 else:
    
     import mxnet
    
     train_iter = mxnet.io.NDArrayIter(train_img, train_lbl, batch_size, shuffle=True)
    
     val_iter = mxnet.io.NDArrayIter(val_img, val_lbl, batch_size)
    
     data = mxnet.symbol.Variable('data')
    
     conv1 = mxnet.sym.Convolution(data=data, kernel=(5, 5), num_filter=64)
    
     relu1 = mxnet.sym.Activation(data=conv1, act_type="relu")
    
     pool1 = mxnet.sym.Pooling(data=relu1, pool_type="max", kernel=(2, 2), stride=(2, 2))
    
     conv2 = mxnet.sym.Convolution(data=pool1, kernel=(5, 5), num_filter=128)
    
     relu2 = mxnet.sym.Activation(data=conv2, act_type="relu")
    
     pool2 = mxnet.sym.Pooling(data=relu2, pool_type="max", kernel=(2, 2), stride=(2, 2))
    
     flatten = mxnet.sym.Flatten(data=pool2)
    
     fc1 = mxnet.symbol.FullyConnected(data=flatten, num_hidden=1024)
    
     relu3 = mxnet.sym.Activation(data=fc1, act_type="relu")
    
     fc2 = mxnet.symbol.FullyConnected(data=relu3, num_hidden=1024)
    
     relu4 = mxnet.sym.Activation(data=fc2, act_type="relu")
    
     fc3 = mxnet.sym.FullyConnected(data=relu4, num_hidden=10)
    
     net = mxnet.sym.SoftmaxOutput(data=fc3, name='softmax')
    
     mxnet.viz.plot_network(symbol=net, shape= {"data" : (batch_size, 1, 28, 28)}).render('mxnet')
    
     model = mxnet.model.FeedForward(
    
     ctx=mxnet.gpu(0),  # use GPU 0 for training, others are same as before
    
     symbol=net,
    
     num_epoch=num_epoch,
    
     learning_rate=0.1,
    
     optimizer='AdaDelta',
    
     initializer=mxnet.initializer.Uniform())
    
     import logging
    
     logging.getLogger().setLevel(logging.DEBUG)
    
     model.fit(
    
     X=train_iter,
    
     eval_data=val_iter,
    
     batch_end_callback=mxnet.callback.Speedometer(batch_size, 200)
    
     )