对于昨天的代码使用代码自身的函数和模块进行进一步的精简

    1. import torch.nn as nn
    2. import time
    3. time_start=time.time()
    4. N,D_in,H,D_out = 64,1000,100,10
    6. x=torch.randn(N,D_in,requires_grad=True)#default is False
    7. y=torch.randn(N,D_out,requires_grad=True)
    9. class TwoLayerNet(torch.nn.Module):
    10.     def __init__(self,D_in,H,D_out):
    11.         # define model architecture
    12.         super(TwoLayerNet,self).__init__()
    13.         self.linear1=torch.nn.Linear(D_in,H,bias=False)
    14.         self.linear2=torch.nn.Linear(H,D_out,bias=False)
    15.     def forward(self,x):
    16.         y_pred =self.linear2(self.linear1(x). clamp(min=0))
    17.         return y_pred
    19. #model=torch.nn.Sequential(
    20. #    torch.nn.Linear(D_in,H),
    21. #    torch.nn.ReLU(),
    22. #    torch.nn.Linear(H,D_out),
    23. #)
    25. model=TwoLayerNet(D_in,H,D_out)
    27. learning_rate=1e-4
    28. #torch.nn.init.normal_(model[0].weight)
    29. #torch.nn.init.normal_(model[2].weight)
    30. optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)
    32. if torch.cuda.is_available():
    33.     model=model.cuda()
    34.     x=x.cuda()
    35.     y=y.cuda()
    37. loss_func=nn.MSELoss(reduction='sum')
    40. for t in range(1000):
    41.     # forward pass
    43.     y_pred =model(x).cuda()
    45.     #compute loss and use square loss
    46.     loss = loss_func(y_pred , y).cuda()
    48.     loss_num=loss.item()
    49.     print(t,loss_num)
    50.     #backward pass
    51.     # compute gradiend
    53.     optimizer.zero_grad()
    54.     loss.backward()
    56.     # Update weights
    57.     optimizer.step()
    58. time_end=time.time()
    59. print('totally cost',time_end-time_start)

    同时定义了一个简单的游戏，然后没有告知规则的情况下利用数据进行训练
    经过测试训练100回合正确率61%，1000回合正确率94%，训练10000回合正确率98%

    2. def fizz_buzz_encode(i):
    3.     if i % 15 == 0:
    4.         return 3
    5.     elif i % 5 == 0:
    6.         return 2
    7.     elif i % 3 == 0:
    8.         return 1
    9.     else:
    10.         return 0
    11. def fizz_buzz_decode(i,prediction):
    12.     return [str(i), "fizz", "buzz", "fizzbuzz"][prediction]
    14. def helper(i):
    15.     print(fizz_buzz_decode(i,fizz_buzz_encode(i)))
    18. import numpy as np
    19. import torch
    21. NUM_DIGITS = 10
    23. # Represent each input by an array of its binary digits.
    24. def binary_encode(i, num_digits):
    25.     return np.array([i >> d & 1 for d in range(num_digits)][::-1])
    28. trX = torch.Tensor([binary_encode(i, NUM_DIGITS) for i in range(101, 2 ** NUM_DIGITS)])
    29. trY = torch.LongTensor([fizz_buzz_encode(i) for i in range(101, 2 ** NUM_DIGITS)])
    31. # Define the model
    32. NUM_HIDDEN = 100
    33. model = torch.nn.Sequential(
    34.     torch.nn.Linear(NUM_DIGITS, NUM_HIDDEN),
    35.     torch.nn.ReLU(),
    36.     torch.nn.Linear(NUM_HIDDEN, 4)
    37. )
    38. loss_fn = torch.nn.CrossEntropyLoss()
    39. optimizer = torch.optim.SGD(model.parameters(), lr = 0.5)
    40. # Start training it
    41. BATCH_SIZE = 128
    43. if torch.cuda.is_available():
    44.     model=model.cuda()
    45.     trX=trX.cuda()
    46.     trY=trY.cuda()
    47. for epoch in range(10000):
    48.     for start in range(0, len(trX), BATCH_SIZE):
    49.         end = start + BATCH_SIZE
    50.         batchX = trX[start:end]
    51.         batchY = trY[start:end]
    52.         batchX=batchX.cuda()
    53.         batchY=batchY.cuda()
    54.         y_pred = model(batchX)
    55.         y_pred=y_pred.cuda()
    56.         loss = loss_fn(y_pred, batchY)
    58.         optimizer.zero_grad()
    59.         loss.backward()
    60.         optimizer.step()
    62.     # Find loss on training data
    63.     loss = loss_fn(model(trX), trY).item()
    64.     print('Epoch:', epoch, 'Loss:', loss)
    65. # Output now
    66. testX = torch.Tensor([binary_encode(i, NUM_DIGITS) for i in range(1, 101)])
    67. testX=testX.cuda()
    68. with torch.no_grad():
    69.     testY = model(testX)
    70. predictions = zip(range(1, 101), list(testY.max(1)[1].data.tolist()))
    72. print([fizz_buzz_decode(i, x) for (i, x) in predictions])
    73. print(np.sum(testY.cpu().max(1)[1].numpy() == np.array([fizz_buzz_encode(i) for i in range(1,101)])))
    74. testY.cpu().max(1)[1].numpy() == np.array([fizz_buzz_encode(i) for i in range(1,101)])