1.cnn
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
# 設定亂數種子
torch.manual_seed(0)
# 超引數
EPOCH = 1 # 訓練整批資料的次數
BATCH_SIZE = 50
DOWNLOAD_MNIST = False # 表示還沒有下載資料集，如果資料集下載好了就寫False
# 加載 MNIST 資料集
train_dataset = datasets.MNIST(
root="./mnist",
train=True,#True表示是訓練集
transform=transforms.ToTensor(),
download=False)
test_dataset = datasets.MNIST(
root="./mnist",
train=False,#Flase表示測驗集
transform=transforms.ToTensor(),
download=False)
# 將資料集放入 DataLoader 中
train_loader = torch.utils.data.DataLoader(
dataset=train_dataset,
batch_size=100,#每個批次讀取的資料樣本數
shuffle=True)#是否將資料打亂，在這種情況下為True，表示每次讀取的資料是隨機的
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)
# 為了節約時間, 我們測驗時只測驗前2000個
test_x = torch.unsqueeze(test_dataset.test_data, dim=1).type(torch.FloatTensor)[
:2000] / 255. # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_dataset.test_labels[:2000]
# 定義卷積神經網路模型
class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.conv1 = nn.Conv2d(#輸入影像的大小為（28,28,1）
in_channels=1,#當前輸入特征圖的個數
out_channels=32,#輸出特征圖的個數
kernel_size=3,#卷積核大小，在一個3*3空間里對當前輸入的特征影像進行特征提取
stride=1,#步長：卷積視窗每隔一個單位滑動一次
padding=1)#如果希望卷積后大小跟原來一樣，需要設定padding=(kernel_size-1)/2
#第一層結束后影像大小為（28,28,32）32是輸出影像個數，28計算方法為（h-k+2p)/s+1=(28-3+2*1)/1 +1=28
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)#可以縮小輸入影像的尺寸，同時也可以防止過擬合
#通過池化層之后影像大小變為（14,14,32）
self.conv2 = nn.Conv2d(#輸入影像大小為（14,14,32）
in_channels=32,#第一層的輸出特征圖的個數當做第二層的輸入特征圖的個數
out_channels=64,
kernel_size=3,
stride=1,
padding=1)#二層卷積之后影像大小為（14,14,64)
self.fc = nn.Linear(64 * 7 * 7, 10)#10表示最終輸出的
# 下面定義x的傳播路線
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))# x先通過conv1
x = self.pool(F.relu(self.conv2(x)))# 再通過conv2
x = x.view(-1, 64 * 7 * 7)
x = self.fc(x)
return x
# 實體化卷積神經網路模型
model = CNN()
# 定義損失函式和優化器
criterion = nn.CrossEntropyLoss()
#lr（學習率）是控制每次更新的引數的大小的超引數
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
# 訓練模型
for epoch in range(1):
for i, (images, labels) in enumerate(train_loader):
outputs = model(images) # 先將資料放到cnn中計算output
loss = criterion(outputs, labels)# 輸出和真實標簽的loss，二者位置不可顛倒
optimizer.zero_grad()# 清除之前學到的梯度的引數
loss.backward() # 反向傳播，計算梯度
optimizer.step()#應用梯度
if i % 50 == 0:
data_all = model(test_x)#不分開寫就會出現ValueError: too many values to unpack (expected 2)
last_layer = data_all
test_output = data_all
pred_y = torch.max(test_output, 1)[1].data.numpy()
accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.4f' % accuracy)
# print 10 predictions from test data
data_all1 = model(test_x[:10])
test_output = data_all1
_ = data_all1
pred_y = torch.max(test_output, 1)[1].data.numpy()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')
2.bpnn
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import torchvision
DOWNLOAD_MNIST = False # 表示還沒有下載資料集，如果資料集下載好了就寫False
BATCH_SIZE = 50
LR = 0.01 # 學習率
# 下載mnist手寫資料集
train_loader = torchvision.datasets.MNIST(
root='./mnist/', # 保存或提取的位置 會放在當前檔案夾中
train=True, # true說明是用于訓練的資料，false說明是用于測驗的資料
transform=torchvision.transforms.ToTensor(), # 轉換PIL.Image or numpy.ndarray
download=DOWNLOAD_MNIST, # 已經下載了就不需要下載了
)
test_loader = torchvision.datasets.MNIST(
root='./mnist/',
train=False # 表明是測驗集
)
train_data = https://www.cnblogs.com/twq46/p/torch.utils.data.DataLoader(dataset=train_loader, batch_size=BATCH_SIZE, shuffle=True)
# 為了節約時間, 我們測驗時只測驗前2000個
test_x = torch.unsqueeze(test_loader.test_data, dim=1).type(torch.FloatTensor)[
:2000] / 255. # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_loader.test_labels[:2000]
# 定義模型
class BPNN(nn.Module):
def __init__(self):
super(BPNN, self).__init__()
self.fc1 = nn.Linear(28 * 28, 512)#定義了一個全連接層fc1，該層的輸入是28 * 28個數字，輸出是512個數字
self.fc2 = nn.Linear(512, 512)
self.fc3 = nn.Linear(512, 10)
def forward(self, x):#x是輸入的影像
x = x.view(-1, 28 * 28)#將輸入x的形狀轉換為二維，分別是batch_size和28 * 28
x = F.relu(self.fc1(x))#將x通過第1個全連接層fc1進行計算，并將結果通過ReLU激活函式處理
x = F.relu(self.fc2(x))
x = self.fc3(x)
#Softmax函式是一種分類模型中常用的激活函式，它能將輸入資料映射到(0,1)范圍內，并且滿足所有元素的和為1
return F.log_softmax(x, dim=1)#dim=1表示對每一行的資料進行運算
# 初始化模型
bpnn = BPNN()
print(bpnn)
# 定義損失函式和優化器
optimizer = torch.optim.Adam(bpnn.parameters(), lr=LR) # optimize all parameters
loss_func = nn.CrossEntropyLoss() # the target label is not one-hotted
#
# criterion = nn.NLLLoss()
# optimizer = optim.SGD(bpnn.parameters(), lr=0.01, momentum=0.5)
# 訓練模型
for epoch in range(1):
for step, (b_x,b_y) in enumerate(train_data):
b_x = b_x.view(-1, 28, 28) # reshape x to (batch, time_step, input_size)
output = bpnn(b_x)
loss = loss_func(output, b_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step % 50 == 0:
test_x = test_x.view(-1, 28, 28)
test_output = bpnn(test_x)
pred_y = torch.max(test_output, 1)[1].data.squeeze()
acc = (pred_y == test_y).sum().float() / test_y.size(0)
print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy())
test_output = bpnn(test_x[:10].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')
# # 評估模型
# bpnn.eval()
# correct = 0
# with torch.no_grad():
# for data, target in test_loader:
# output = bpnn(data)
# pred = output.argmax(dim=1, keepdim=True)
# correct += pred.eq(target.view_as(pred)).sum().item()
#
# print('Test accuracy:', correct / len(test_loader.dataset))
3.lstm
import torch
from torch import nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
torch.manual_seed(1) # reproducible
# Hyper Parameters
EPOCH = 1 # 訓練整批資料多少次, 為了節約時間, 我們只訓練一次
BATCH_SIZE = 64
TIME_STEP = 28 # rnn 時間步數 / 圖片高度
INPUT_SIZE = 28 # rnn 每步輸入值 / 圖片每行像素
LR = 0.01 # learning rate
DOWNLOAD_MNIST = False # 如果你已經下載好了mnist資料就寫上 Fasle
# Mnist 手寫數字
train_data = https://www.cnblogs.com/twq46/p/dsets.MNIST(
root='./mnist/', # 保存或者提取位置
train=True, # this is training data
transform=transforms.ToTensor(), # 轉換 PIL.Image or numpy.ndarray 成
# torch.FloatTensor (C x H x W), 訓練的時候 normalize 成 [0.0, 1.0] 區間
download=DOWNLOAD_MNIST, # 沒下載就下載, 下載了就不用再下了
)
test_data = https://www.cnblogs.com/twq46/p/dsets.MNIST(root='./mnist/', train=False)
# 批訓練 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
# 為了節約時間, 我們測驗時只測驗前2000個
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[
:2000] / 255. # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_data.test_labels[:2000]
#LSTM默認input(seq_len,batch,feature)
class Lstm(nn.Module):
def __init__(self):
super(Lstm, self).__init__()
self.Lstm = nn.LSTM( # LSTM 效果要比 nn.RNN() 好多了
input_size=28, # 圖片每行的資料像素點,輸入特征的大小
hidden_size=64, # lstm模塊的數量相當于bp網路影藏層神經元的個數
num_layers=1, # 隱藏層的層數
batch_first=True, # input & output 會是以 batch size 為第一維度的特征集 e.g. (batch, time_step, input_size)
)
self.out = nn.Linear(64, 10) # 輸出層，接入線性層
def forward(self, x): # 必須有這個方法
# x shape (batch, time_step, input_size)
# r_out shape (batch, time_step, output_size)包含每個序列的輸出結果
# h_n shape (n_layers, batch, hidden_size)只包含最后一個序列的輸出結果，LSTM 有兩個 hidden states, h_n 是分線, h_c 是主線
# h_c shape (n_layers, batch, hidden_size)只包含最后一個序列的輸出結果
r_out, (h_n, h_c) = self.Lstm(x, None) # None 表示 hidden state 會用全0的 state
# 當RNN運行結束時刻，(h_n, h_c)表示最后的一組hidden states，這里用不到
# 選取最后一個時間點的 r_out 輸出
# 這里 r_out[:, -1, :] 的值也是 h_n 的值
out = self.out(r_out[:, -1, :]) # (batch_size, time step, input)，這里time step選擇最后一個時刻
# output_np = out.detach().numpy() # 可以使用numpy的sciview監視每次結果
return out
Lstm = Lstm()
print(Lstm)
optimizer = torch.optim.Adam(Lstm.parameters(), lr=LR) # optimize all parameters
loss_func = nn.CrossEntropyLoss() # the target label is not one-hotted
# training and testing
for epoch in range(EPOCH):
for step, (x, b_y) in enumerate(train_loader): # gives batch data
b_x = x.view(-1, 28, 28) # reshape x to (batch, time_step, input_size)
output = Lstm(b_x) # rnn output
loss = loss_func(output, b_y) # cross entropy loss
optimizer.zero_grad() # clear gradients for this training step
loss.backward() # backpropagation, compute gradients
optimizer.step() # apply gradients
# output_np = output.detach().numpy()
if step % 50 == 0:
test_x = test_x.view(-1, 28, 28)
test_output = Lstm(test_x)
pred_y = torch.max(test_output, 1)[1].data.squeeze()
acc = (pred_y == test_y).sum().float() / test_y.size(0)
print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy())
test_output = Lstm(test_x[:10].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/543725.html
標籤：Python