深度学习学习笔记（三）练习1

最新推荐文章于 2024-01-11 17:07:21 发布

qq_16066781

最新推荐文章于 2024-01-11 17:07:21 发布

阅读量220

点赞数

分类专栏：深度学习

本文链接：https://blog.csdn.net/qq_16066781/article/details/102162747

版权

深度学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

FizzBuzz

FizzBuzz是一个简单的小游戏。游戏规则如下：从1开始往上数数，当遇到3的倍数的时候，说fizz，当遇到5的倍数，说buzz，当遇到15的倍数，就说fizzbuzz，其他情况下则正常数数。

我们可以写一个简单的小程序来决定要返回正常数值还是fizz, buzz 或者 fizzbuzz。

简单的小程序：

#将数字划分类别：(num:说出的数字)
def fizz_buzz_encoding(num):
    if num % 15 == 0:
        return 3
    elif num % 5 == 0:
        return 2
    elif num % 3 == 0:
        return 1
    else:
        return 0
    
#类别对应具体的输出：（classes:类别）
def fizz_buzz_decoding(num, classes):
    return [str(num), 'fizz', 'buzz', 'fizzbuzz'][classes]

result = []
for i in range(1, 101):
    result.append(fizz_buzz_decoding(i, fizz_buzz_encoding(i)))
print(result)


>>>    ['1', '2', 'fizz', '4', 'buzz', 'fizz', '7', '8', 'fizz', 'buzz', '11', 'fizz', '13', '14', 'fizzbuzz', '16', '17', 'fizz', '19', 'buzz', 'fizz', '22', '23', 'fizz', 'buzz', '26', 'fizz', '28', '29', 'fizzbuzz', '31', '32', 'fizz', '34', 'buzz', 'fizz', '37', '38', 'fizz', 'buzz', '41', 'fizz', '43', '44', 'fizzbuzz', '46', '47', 'fizz', '49', 'buzz', 'fizz', '52', '53', 'fizz', 'buzz', '56', 'fizz', '58', '59', 'fizzbuzz', '61', '62', 'fizz', '64', 'buzz', 'fizz', '67', '68', 'fizz', 'buzz', '71', 'fizz', '73', '74', 'fizzbuzz', '76', '77', 'fizz', '79', 'buzz', 'fizz', '82', '83', 'fizz', 'buzz', '86', 'fizz', '88', '89', 'fizzbuzz', '91', '92', 'fizz', '94', 'buzz', 'fizz', '97', '98', 'fizz', 'buzz']

下面写一个神经网络，让它学会自己玩这个游戏：

1、定义模型的输入与输出：

如果直接输入1，2，3。。。，模型训练困难；需要将数字转化成二进制来输入

注：

使用其它进制转二进制： int(‘num’, 2), int(‘num’, 8), 例如 int(‘1024’, 2)表示将二进制的1011转化为十进制
使用十进制转二进制： bin(num)
使用十进制转八进制：oct(num)
使用十进制转十六进制： hex(num)

#这里，自己来写一个进制函数，便于输入到神经网络：
import torch
import numpy as np


NUM_DIGITS = 10   #输入数字（转为二进制后，不够的位数前面补0）个数
def binary_encode(num, NUM_DIGITS):
    return np.array([num >> d & 1 for d in range(NUM_DIGITS)])[::-1]     #>>为移位符，num >> d & 1表示num的二进制向右移动d位，然后与1的二进制比较，相同的为1，不同的为0，最后转为十进制数字

device = torch.device('cuda'if torch.cuda.is_available() else 'cpu')

trX = torch.tensor([binary_encode(i, NUM_DIGITS) for i in range(101, 2**NUM_DIGITS)]).float().to(device)  #训练集：101~2^10-1
trY = torch.tensor([fizz_buzz_encoding(i) for i in range(101, 2**NUM_DIGITS)]).long().to(device)  #标签，用LabelEncoding

trX.shape, trY.shape


>>>(torch.Size([923, 10]), torch.Size([923]))

trX[:5], trY[:5]


>>> (tensor([[0., 0., 0., 1., 1., 0., 0., 1., 0., 1.],
             [0., 0., 0., 1., 1., 0., 0., 1., 1., 0.],
             [0., 0., 0., 1., 1., 0., 0., 1., 1., 1.],
             [0., 0., 0., 1., 1., 0., 1., 0., 0., 0.],
             [0., 0., 0., 1., 1., 0., 1., 0., 0., 1.]], device='cuda:0'),
     tensor([0, 1, 0, 0, 3], device='cuda:0'))

2、定义及训练模型：

为了让我们的模型学会FizzBuzz这个游戏，我们需要定义一个损失函数，和一个优化算法。
这个优化算法会不断优化（降低）损失函数，使得模型的在该任务上取得尽可能低的损失值。
损失值低往往表示我们的模型表现好，损失值高表示我们的模型表现差。
由于FizzBuzz游戏本质上是一个分类问题，我们选用Cross Entropyy Loss函数。
优化函数我们选用Stochastic Gradient Descent。

import torch.nn as nn

HIDDEN = 100
learning_rate = 0.05
BATCH_SIZE = 128

model = nn.Sequential(                  
    nn.Linear(NUM_DIGITS, HIDDEN),
    nn.ReLU(),
    nn.Linear(HIDDEN, 4)
).to(device)
    
nn.init.normal_(model[0].weight)        #初始化参数
#nn.init.normal_(model[0].bias)
nn.init.normal_(model[2].weight)
#nn.init.normal_(model[2].bias)

loss_fn = nn.CrossEntropyLoss()        #损失函数为交叉熵
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)   #选用随机梯度下降

for epoch in range(10000):          
    for start in range(0, len(trX), BATCH_SIZE):       #这里因为使用了BATCH_SIZE，多出一个内循环
        end = start + BATCH_SIZE
        batchX = trX[start:end]
        batchY = trY[start:end]
        #forward pass
        y_pred = model(batchX)
        loss = loss_fn(y_pred, batchY)
        #backward pass
        optimizer.zero_grad()        #梯度清零
        loss.backward()              #反向传播
        optimizer.step()             #参数更新
    loss_epoch = loss_fn(model(trX), trY).item()
    print('epoch:',epoch, 'loss:', loss_epoch)        


>>> epoch: 0 loss: 7.251105308532715
    epoch: 1 loss: 6.035614967346191
    epoch: 2 loss: 5.345699787139893
    epoch: 3 loss: 5.131191730499268
    epoch: 4 loss: 4.703280448913574
    epoch: 5 loss: 4.4611406326293945
    epoch: 6 loss: 4.351914405822754
    epoch: 7 loss: 4.086514472961426
    epoch: 8 loss: 3.830378293991089
    epoch: 9 loss: 3.534430503845215
    epoch: 10 loss: 3.27980637550354
    ...
    epoch: 9991 loss: 0.006885749753564596
    epoch: 9992 loss: 0.006884231697767973
    epoch: 9993 loss: 0.006883607245981693
    epoch: 9994 loss: 0.006882120855152607
    epoch: 9995 loss: 0.006881153676658869
    epoch: 9996 loss: 0.006880468223243952
    epoch: 9997 loss: 0.006879052147269249
    epoch: 9998 loss: 0.00687815435230732
    epoch: 9999 loss: 0.006877521518617868

用训练好的模型玩fizzbuzz

testX = torch.tensor([binary_encode(i, NUM_DIGITS) for i in range(1, 101)]).float().to(device)
    
with torch.no_grad():
    testY = model(testX)

prediction = zip(range(1, 101), testY.max(1)[1].tolist())

nn_result = []
for (num, classes) in prediction:
    nn_result.append(fizz_buzz_decoding(num, classes))
nn_result





>>> ['1',
     '2',
     'fizz',
     'fizz',
     'buzz',
     'fizz',
     '7',
     '8',
     'fizz',
     'buzz',
     '11',
     'fizz',
     '13',
     '14',
     'fizz',
     '16',
     '17',
     'fizz',
     '19',
     'buzz',
     'fizz',
     '22',
     '23',
     'fizz',
     '25',
     '26',
     'fizz',
     '28',
     '29',
     'fizzbuzz',
     '31',
     'buzz',
     'buzz',
     'buzz',
     'buzz',
     'fizz',
     '37',
     '38',
     'fizz',
     '40',
     '41',
     'fizz',
     '43',
     '44',
     'fizzbuzz',
     '46',
     '47',
     'fizz',
     '49',
     'buzz',
     'fizz',
     '52',
     '53',
     'fizz',
     'buzz',
     '56',
     'fizz',
     '58',
     '59',
     'fizzbuzz',
     '61',
     '62',
     'fizz',
     '64',
     'buzz',
     'fizz',
     '67',
     'fizz',
     '69',
     'buzz',
     '71',
     'fizz',
     '73',
     '74',
     'fizzbuzz',
     '76',
     '77',
     'fizz',
     '79',
     'buzz',
     '81',
     '82',
     '83',
     'fizz',
     'buzz',
     '86',
     'fizz',
     '88',
     '89',
     'fizzbuzz',
     '91',
     '92',
     '93',
     '94',
     'buzz',
     'fizz',
     '97',
     'fizz',
     'fizz',
     'buzz']

correct = 0
for i in range(len(result)):
    if nn_result[i] == result[i]:
        correct += 1
accracy = correct/len(result)
accracy


>>> 0.88

后记

emmmmm…效果不算太好，可能模型太过于简单了。等学完后面的，再回来改改。

qq_16066781

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
深度学习学习笔记（三）练习1

FizzBuzzFizzBuzz是一个简单的小游戏。游戏规则如下：从1开始往上数数，当遇到3的倍数的时候，说fizz，当遇到5的倍数，说buzz，当遇到15的倍数，就说fizzbuzz，其他情况下则正常数数。我们可以写一个简单的小程序来决定要返回正常数值还是fizz, buzz 或者 fizzbuzz。简单的小程序：#将数字划分类别：(num:说出的数字)def fizz_buzz_en...
复制链接

扫一扫