pyTorch如何實現softmax

這篇文章主要為大家展示了“pyTorch如何實現softmax”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“pyTorch如何實現softmax”這篇文章吧。

用PyTorch實現linear模型

模擬數據集

num_inputs = 2 #feature number
num_examples = 1000 #訓練樣本個數
true_w = torch.tensor([[2],[-3.4]]) #真實的權重值
true_b = torch.tensor(4.2) #真實的bias
samples = torch.normal(0,1,(num_examples,num_inputs))
noise = torch.normal(0,0.01,(num_examples,1))
labels = samples.matmul(true_w) + true_b + noise

定義模型

class LinearNet(nn.Module):
	def __init__(self,in_features):
		super().__init__()
		self.fc = nn.Linear(in_features=2,out_features=1)
	def forward(self,t):
		t = self.fc(t)
		return t

加載數據集

import torch.utils.data as Data
dataset = Data.TensorDataset(samples,labels)#類似于zip，把兩個張量打包
data_loader = Data.DataLoader(dataset,batch_size=100,shuffle=True)

optimizer

network = LinearNet(2)
optimizer = optim.SGD(network.paramters(),lr=0.05)

模型訓練

for epoch in range(10):
    total_loss = 0
    for data,label in data_loader:
        predict = network(data)
        loss = F.mse_loss(predict,label)
        total_loss += loss.item()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(
        'epoch',epoch,
        'loss',total_loss,
        'weight',network.weight,
        'bias',network.bias
    )

softmax回歸模型

sotfmax主要用于分類任務。regression最終得到的是一個scalar，根據input中的feature線性相加得到一個output。分類任務的結果是一個類別，是離散的。
假設現在有一批圖片是2 * 2大小的灰度圖片，這樣圖片中的每隔二像素用一個標量表示就行了。這批圖片一種是三類小動物，第一類是小狗，第二類是小貓，第三類是小兔子。
每張圖片總共4個像素點，我們可以看作是4個feature，假設這三類小動物的圖片線性可分，每一類對應一組weight和一個bias。

可以根據輸出值較大的來決定哪一類，可這樣有個問題，首先輸出值沒有明確的意義，且可能是實數范圍。其次，不好衡量輸出值與真實值之間的差距。所以采用softmax操作，將三個輸出值轉化成概率值，這樣輸出結果滿足概率分布。label采用one-hot編碼，相當于對應類別的概率是1，這樣就可以用cross_entropy來計算loss。

Fashion-MNIST

本次學習softmax模型采用torchvision.datasets中的Fashion-MNIST。

import torchvision
import torchvision.transforms as transforms
train_set = torchvision.datasets.FashionMNIST(
	root='./data',
	train=True,
	download=True,
	transform=transforms.ToTensor()
)

transforms.ToTensor()將尺寸為（H x W x C）且數據位于（0，255）的PIL圖片或者數據類型為np.uint8的NumPy數組轉換為尺寸為C x H x W且數據類型為torch.float32且位于（0.0，1.0）的Tensor

len(train_set),len(test_set)
> (60000,10000)

展示一下數據集中的圖片

import matplotlib.pyplot as plt
plt.figure(figsize=(10,10))
for i,(image,lable) in enumerate(train_set,start=1):
	plt.subplot(1,10,i)
	plt.imshow(image.squeeze())
	plt.title(train_set.classes[lable])
	plt.axis('off')
	if i == 10:
		break
plt.show()

train_loader = torch.utils.data.DataLoader(train_set,batch_size=100,shuffle=True,num_workers=4)
test_loader = torch.utils.data.DataLoader(test_set,batch_size=100,shuffle=False,num_workers=1)

cross_entropy

def net(samples,w,b):
	samples = samples.flatten(start_dim=1) #將c,h,w三個軸展成一個feature軸，長度為28 * 28
	samples = torch.exp(samples)#全體元素取以e為底的指數
	partial_sum = samples.sum(dim=1,keepdim=True) 
	samples = samples / partial_sum #歸一化，得概率，這里還應用了廣播機制
	return samples.matmul(w) + b	

i表示label對應的種類，pi為真實種類的預測概率，log是以e為底的對數
這里gather函數的作用，就是在predict上取到對應label的概率值，注意負號不能丟，pytorch中的cross_entropy對輸入先進行一次softmax操作，以保證輸入都是正的。

模型的實現

def net(samples,w,b):
	samples = samples.flatten(start_dim=1) #將c,h,w三個軸展成一個feature軸，長度為28 * 28
	samples = torch.exp(samples)#全體元素取以e為底的指數
	partial_sum = samples.sum(dim=1,keepdim=True) 
	samples = samples / partial_sum #歸一化，得概率，這里還應用了廣播機制
	return samples.matmul(w) + b	

利用PyTorch簡易實現softmax

import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as Data
import torchvision.transforms as transforms
import torch.optim as optim
import torch.nn.init as init
class SoftmaxNet(nn.Module):
    def __init__(self,in_features,out_features):
        super().__init__()
        self.fc = nn.Linear(in_features=in_features,out_features=out_features)
    def forward(self,t):
        t = t.flatten(start_dim=1)
        t = self.fc(t)
        return t
train_set = torchvision.datasets.FashionMNIST(
    root='E:\project\python\jupyterbook\data',
    train=True,
    download=True,
    transform=transforms.ToTensor()
)
test_set = torchvision.datasets.FashionMNIST(
    root='E:\project\python\jupyterbook\data',
    train=False,
    download=True,
    transform=transforms.ToTensor()
)
train_loader = Data.DataLoader(
    train_set,
    batch_size=100,
    shuffle=True,
    #num_workers=2
)
test_loader = Data.DataLoader(
    test_set,
    batch_size=100,
    shuffle=False,
    #num_workers=2
)
@torch.no_grad()
def get_correct_nums(predict,labels):
    return predict.argmax(dim=1).eq(labels).sum().item()
@torch.no_grad()
def evaluate(test_loader,net,total_num):
    correct = 0
    for image,label in test_loader:
        predict = net(image)
        correct += get_correct_nums(predict,label)
        pass
    return correct / total_num
network = SoftmaxNet()
optimizer = optim.SGD(network.parameters(),lr=0.05)
for epoch in range(10):
    total_loss = 0
    total_correct = 0
    for image,label in train_loader:
        predict = network(image)
        loss = F.cross_entropy(predict,label)
        total_loss += loss.item()
        total_correct += get_correct_nums(predict,label)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        pass
    print(
        'epoch',epoch,
        'loss',total_loss,
        'train_acc',total_correct / len(train_set),
        'test_acc',evaluate(test_loader,network,len(test_set))
    )

以上是“pyTorch如何實現softmax”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！