torch、tensorflow1 GPU测速代码python3（MNIST，简易版）

系统管理员 2022-09-17 03:29 108阅读 0赞

# 1、torch #

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import numpy as np
    import matplotlib.pyplot as plt
    from torch.autograd import Variable
    import time
    
    # print start time
    start = time.time()
    print("Start time = " + time.ctime())
    
    # read data
    inp = np.random.rand(12225, 9)
    
    oup = np.random.rand(12225, 1)
    #inp = inp*[4,100,1,4,0.04,1]
    oup = oup * 500
    inp = inp.astype(np.float32)
    oup = oup.astype(np.float32)
    # Hyper Parameters
    input_size = inp.shape[1]
    hidden_size = 10
    output_size = 1
    num_epochs = 1000
    learning_rate = 0.001
    
    # Toy Dataset
    x_train = inp
    y_train = oup
    
    device = torch.device("cuda:0")
    
    
    # Linear Regression Model
    class Net(nn.Module):
        def __init__(self, input_size, hidden_size, output_size):
            super(Net, self).__init__()
            self.fc1 = nn.Linear(input_size, hidden_size)
            self.l1 = nn.ReLU()
            self.l2 = nn.Sigmoid()
            self.l3 = nn.Tanh()
            self.l4 = nn.ELU()
            self.l5 = nn.Hardshrink()
            self.ln = nn.Linear(hidden_size, hidden_size)
            self.fc2 = nn.Linear(hidden_size, output_size)
            # self.fc1 = nn.Linear(input_size, output_size)
    
        def forward(self, x):
            out = self.fc1(x)
            out = self.l3(out)
            out = self.ln(out)
            out = self.l1(out)
            out = self.fc2(out)
            return out
    
    
    model = Net(input_size, hidden_size, output_size)
    
    # Loss and Optimizer
    criterion = nn.MSELoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
    
    ###### GPU
    if torch.cuda.is_available():
        print("We are using GPU now!!!")
        model = model.to(device)
    
    # Train the Model
    for epoch in range(num_epochs):
        # Convert numpy array to torch Variable
        if torch.cuda.is_available():
            inputs = Variable(torch.from_numpy(x_train).to(device))
            targets = Variable(torch.from_numpy(y_train).to(device))
        else:
            inputs = Variable(torch.from_numpy(x_train))
            targets = Variable(torch.from_numpy(y_train))
    
        # Forward + Backward + Optimize
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
    
        if (epoch + 1) % 100 == 1:
            print('Epoch [%d/%d], Loss: %.4f' % (epoch + 1, num_epochs, loss.data))
    
    # print end time
    end = time.time()
    print("End time = " + time.ctime())
    print("time cost: " + str(end - start))
    
    # Plot the graph
    if torch.cuda.is_available():
        predicted = model(Variable(
            torch.from_numpy(x_train).to(device))).data.cpu().numpy()
    else:
        predicted = model(Variable(torch.from_numpy(x_train))).data.numpy()
    # plt.plot(y_train / 500, 'r-', label='Original data')
    # plt.plot(predicted / 500, '-', label='Fitted line')
    # #plt.plot(y_train/500, predicted/500,'.', label='Fitted line')
    # plt.legend()
    # plt.show()
    
    # Save the Model
    # torch.save(model.state_dict(), 'model.pkl')

# 2、tensorflow1 #

import tensorflow as tf
    import tensorflow.examples.tutorials.mnist.input_data as input_data
    import time
    
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    x = tf.placeholder(tf.float32, [None, 784])
    y_actual = tf.placeholder(tf.float32, shape=[None, 10])
    W = tf.Variable(tf.zeros([784, 10]))  #初始化权值W
    b = tf.Variable(tf.zeros([10]))  #初始化偏置项b
    y_predict = tf.nn.softmax(tf.matmul(x, W) + b)  #加权变换并进行softmax回归，得到预测概率
    cross_entropy = tf.reduce_mean(
        -tf.reduce_sum(y_actual * tf.log(y_predict), reduction_indices=1))  #求交叉熵
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(
        cross_entropy)  #用梯度下降法使得残差最小
    
    correct_prediction = tf.equal(tf.argmax(y_predict, 1),
                                  tf.argmax(y_actual, 1))  #在测试阶段，测试准确度计算
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))  #多个批次的准确度均值
    
    init = tf.initialize_all_variables()
    start = time.time()
    with tf.Session() as sess:
        sess.run(init)
        for i in range(10000):  #训练阶段，迭代1000次
            batch_xs, batch_ys = mnist.train.next_batch(100)  #按批次训练，每批100行数据
            sess.run(train_step, feed_dict={
                x: batch_xs,
                y_actual: batch_ys
            })  #执行训练
            if (i % 1000 == 0):  #每训练100次，测试一次
                print(
                    "accuracy:",
                    sess.run(accuracy,
                             feed_dict={
                                 x: mnist.test.images,
                                 y_actual: mnist.test.labels
                             }))
    
    end = time.time()
    print("time cost: " + str(end - start))