Pytorch基礎中的邏輯回歸是怎么樣的

這篇文章將為大家詳細講解有關Pytorch基礎中的邏輯回歸是怎么樣的，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

邏輯回歸基本表示：

對于簡單邏輯回歸，我們可以采用一個神經網絡進行表示：

所以可以看到，輸入為兩個輸入，所以對應的權值也是兩個，權值矩陣為2*1的矩陣；

輸出為o=w1*x1+w2*x2；

對于三個樣本，可以看到如下公式：

所以轉換為矢量乘積方式：

所以，針對于三個參數，可以得到梯度向量：

輸入處理：

num_inputs=2#輸入個數
num_examples=1000#樣本個數
true_w=[2,-3.4] #w參數矩陣
true_b=4.2  #b偏置參數
features=torch.tensor(np.random.normal(0,1,(num_examples,num_inputs)),dtype=torch.float)
#構建基本樣本集：其中采用0~1的分布采樣，輸入的樣本集為2*1000；
labels=true_w[0]*features[:,0]*features[:,0]+true_w[1]*features[:,1]+true_b
#標簽集，也就是最后的y，直接進行公式累乘即可；
labels+=torch.tensor(np.random.normal(0,0.01,size=labels.size()),dtype=torch.float)
#增加一個擾動項
batch_size=10
dataset=Data.TensorDataset(features,labels)
#使用Data函數構建數據集；
data_iter=Data.DataLoader(dataset,batch_size,shuffle=True)
#對構建的dataset進行切分，按照的個數參照batch_size

對于輸入可以參照上述，對于自己的數據集可以直接采用Data.TensorDataset來進行構造；

之后我們指定網絡的結構和初始參數，直接進行加載dataset進行參數學習即可；

網絡結構：

對于網絡結構的定義，通常有兩種方式：
1.采用類繼承進行定義；

2.通過使用函數傳參逐層累加的方式進行定義；

如果通過類繼承進行定義：

class LinearNet(nn.Module):
    def __init__(self, n_feature):
        super(LinearNet, self).__init__()
        self.linear = nn.Linear(n_feature, 1)
    # forward 定義前向傳播
    def forward(self, x):
        y = self.linear(x)
        return y

net = LinearNet(num_inputs)

可以看到LinearNet類繼承自nn.Module類；

如果通過逐層類加進行定義：

通常是使用Sequential函數進行定義：

# 寫法一
net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # 此處還可以傳入其他層
    )
# 寫法二
net = nn.Sequential()
net.add_module('linear', nn.Linear(num_inputs, 1))
# net.add_module ......
# 寫法三
from collections import OrderedDict
net = nn.Sequential(OrderedDict([
          ('linear', nn.Linear(num_inputs, 1))
          # ......
        ]))

可以看到三種最常用的方法；

其實網絡結構寫法很多，也可以采用自己定義的網絡構造函數返回一個net，這樣也是比較常見的操作；

在構建網絡后，需要初始化模型參數，也就是要把網絡中的w，b全部給予一個默認值：

init.normal_(net[0].weight,mean=0,std=0.01)
init.constant_(net[0].bias,val=0)

將權重參數每個元素初始化為隨機采樣于均值為0、標準差為0.01的正態分布，偏差初始化為零；

之后我們定義一個損失函數，對于線性回歸，采用MSEloss即可；

對于優化器，我們采用learning rate=0.03，SGD梯度下降算法進行優化；

loss=nn.MSELoss()
optimizer=optim.SGD(net.parameters(),lr=0.003);

對于學習率的調整，我們也可以進行動態調整，例如分層調整，動態調整：

optimizer =optim.SGD([
                # 如果對某個參數不指定學習率，就使用最外層的默認學習率
                {'params': net.subnet1.parameters()}, # lr=0.03
                {'params': net.subnet2.parameters(), 'lr': 0.01}
            ], lr=0.03)

# 調整學習率
for param_group in optimizer.param_groups:
    param_group['lr'] *= 0.1 # 學習率為之前的0.1倍

訓練階段：

num_epochs = 3
for epoch in range(1, num_epochs + 1):
    for X, y in data_iter:
        output = net(X)
        l = loss(output, y.view(-1, 1))
        optimizer.zero_grad() # 梯度清零，等價于net.zero_grad()
        l.backward()
        optimizer.step()
    print('epoch %d, loss: %f' % (epoch, l.item()))

dense = net[0]
print(true_w, dense.weight)
print(true_b, dense.bias)

所以看到，最后可以通過查看參數，來進行對比；

值得注意的是，每輪訓練之后，要記得將優化器的殘留梯度清0，防止累加；

關于Pytorch基礎中的邏輯回歸是怎么樣的就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。