mxnet实现softmax regression（多层感知机）

古城微笑少年丶 2022-05-12 06:20 246阅读 0赞

'coding = utf-8'
    import mxnet.ndarray as nd
    from mxnet import gluon
    import matplotlib.pyplot as plt
    from mxnet import nd
    import sys
    from mxnet import autograd
    
    def transform(data,label):
        return data.astype('float32')/255,label.astype('float32')
    mnist_train = gluon.data.vision.FashionMNIST(train=True,transform=transform)
    mnist_test = gluon.data.vision.FashionMNIST(train=False,transform=transform)
    
    data,label = mnist_train[0]
    print('example shape:',data.shape,'label:',label)
    
    def show_images(images):
        n = images.shape[0]
        _,figs = plt.subplot(1,n,figsize=(15,15))
        for i in range(n):
            figs[i].imshow(images[i].reshape((28,28)).asnumpy())
            figs[i].axes.get_xaxis().set_visible(False)
            figs[i].axes.get_yaxis().set_visible(False)
        plt.show()
    
    def get_text_labels(label):
        text_labels = ['t-shirt','trouser','pullover','dress','coat','sandal','shirt','sneaker','bag','ankle boot']
        return [text_labels[int(i)] for i in label]
    data,label = mnist_train[0:9]
    show_images(data)
    print(get_text_labels(label))
    
    #数据读取
    batch_size = 256
    train_data = gluon.data.DataLoader(mnist_train,batch_size,shuffle=True)
    test_data = gluon.data.DataLoader(mnist_test,batch_size,shuffle=False)
    
    #初始化模型参数
    num_inputs = 784
    num_outputs = 10
    
    w = nd.random_normal(shape=(num_inputs,num_outputs))
    b = nd.random_normal(shape=num_outputs)
    
    params = [w,b]
    
    for param in params:
        param.attach_grad()
    
    
    #定义模型
    def softmax(x):
        exp = nd.exp(x)
        partition = exp.sum(axis=1,keepdims=True)
        return exp / partition
    
    x = nd.random_normal(shape=(2,5))
    x_prob = softmax(x)
    print(x)
    print(x_prob)
    print(x_prob.sum(axis=1))
    
    def net(x):
        return softmax(nd.dot(x.reshape((-1,num_inputs)),w) + b)
    
    #交叉熵loss
    def cross_entropy(yhat,y):
        return - nd.pick(nd.log(yhat), y)
    
    #计算精度
    def accuracy(output,label):
        return nd.mean(output.argmax(axis=1)==label).asscalar()
    
    def evaluate_accuracy(data_iterator,net):
        acc = 0.
        for data,label in data_iterator:
            output = net(data)
            acc += accuracy(output,label)
            return acc / len(data_iterator)
    
    evaluate_accuracy(test_data,net)
    
    #训练
    def SGD(params,lr):
        for param in params:
            param[:] = param - lr * param.grad
    sys.path.append('..')
    
    learning_rate = 0.1
    
    for epoch in range(5):
        train_loss = 0.
        train_acc = 0.
        for data,label in train_data:
            with autograd.record():
                output = net(data)
                loss = cross_entropy(output,label)
            loss.backward()
            SGD(params, learning_rate / batch_size)
    
            train_loss += nd.mean(loss).asscalar()
            train_acc += accuracy(output,label)
        test_acc = evaluate_accuracy(test_data,net)
        print('Epoch %d.Loss: %f,Train_acc %f,Test_acc %f' % (epoch,train_loss/len(train_data),train_acc/len(train_data),test_acc/len(test_data)))
    
    #预测
    data,label = mnist_test[0:9]
    show_images(data)
    print('ture lables')
    print(get_text_labels(label))
    
    predicted_lables = net(data).argmax(axis=1)
    print('predicted lables')
    print(get_text_labels(predicted_lables.asnumpy()))