PyTorch教程- 回归问题

参考：

      主要参考 课时5 简单回归问题-2_哔哩哔哩_bilibili，

系统的回顾一下pytorch

目录

    1： 简单回归问题

    2： 回归问题实战

一    简单回归问题（Linear Regression）

          根据预测值,或者标签值不同

         线性回归问题

         损失函数

         参数学习：

              梯度下降原理（泰勒公式展开）

              设

      二 回归问题实战

        数据集

         模型

                     

         参数学习

                      设 

                      

          梯度

                     

                     

          参数更新           

                     

                     

三 例

  3.1 训练部分

  

   

    

     

    
    

     

      # -*- coding: utf-8 -*-
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     

      Created on Thu Nov 10 21:33:37 2022
     
    
   

    

     

    
    

     

      
     
    
   

    

     

    
    

     

      @author: cxf
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import torch 
     
    
   

    

     

    
    

     

      import numpy 
      as np
     
    
   

    

     

    
    

     

      from  torch.utils.data 
      import Dataset, DataLoader
     
    
   

    

     

    
    

     

      from  draw 
      import  draw_loss
     
    
   

    

     

    
    

     

      #需要继承data.Dataset
     
    
   

    

     

    
    

     

      class 
      MyDataset(
      Dataset):
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      def 
      __init__(
      self, data, target):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              self.x = data
     
    
   

    

     

    
    

     

              self.y = target
     
    
   

    

     

    
    

     

              self.
      len = self.x.shape[
      0] 
      #样本个数
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      def 
      __getitem__(
      self, index):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

               x = self.x[index]
     
    
   

    

     

    
    

     

               y = self.y[index]
     
    
   

    

     

    
    

     
         
      return x,y
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      def 
      __len__(
      self):
     
    
   

    

     

    
    

     
        
      return self.
      len
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #linear regression
     
    
   

    

     

    
    

     

      class 
      LR:
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       预测值
     
    
   

    

     

    
    

     

       args
     
    
   

    

     

    
    

     

       w: 权重系数
     
    
   

    

     

    
    

     

       b: 偏置系数
     
    
   

    

     

    
    

     

       
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      predict(
      self,w,b,x):
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              predY= torch.mm(w.T,x)+b
     
    
   

    

     

    
    

     
        
      return predY
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       梯度更新
     
    
   

    

     

    
    

     

       args
     
    
   

    

     

    
    

     

       w_cur: 权重系数
     
    
   

    

     

    
    

     

       b_cur 偏置
     
    
   

    

     

    
    

     

       trainX: 训练数据集
     
    
   

    

     

    
    

     

       trainY: 标签集
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      step_gradient(
      self,w_cur,b_cur, trainX,trainY):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              w_gradient = 
      0
     
    
   

    

     

    
    

     

              b_gradient = 
      0
     
    
   

    

     

    
    

     

              m = trainX.shape[
      0]
     
    
   

    

     

    
    

     

              N = 
      float(m)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      for i 
      in 
      range(
      0,m):
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     

                  x = trainX[i].view(self.n,
      1)
     
    
   

    

     

    
    

     

                  y = trainY[i]
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     

                  predY = self.predict(w_cur,b_cur,x)
     
    
   

    

     

    
    

     

                  delta = predY - y
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     

                  b_gradient +=(
      2/N)*delta
     
    
   

    

     

    
    

     

                  w_gradient +=(
      2/N)*delta*x
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              new_b = b_cur- self.learnRate*b_gradient
     
    
   

    

     

    
    

     

              new_w = w_cur- self.learnRate*w_gradient
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      return new_w,new_b
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       梯度下降训练
     
    
   

    

     

    
    

     

       args
     
    
   

    

     

    
    

     

       dataX: 数据集
     
    
   

    

     

    
    

     

       dataY: 标签集
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      train(
      self,dataX,dataY):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
       
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              y_train_loss =[]
     
    
   

    

     

    
    

     

              b_cur = torch.zeros([
      1,
      1],dtype=torch.
      float)
     
    
   

    

     

    
    

     

              w_cur = torch.rand((self.n,
      1),dtype=torch.
      float)
     
    
   

    

     

    
    

     

              trainData = MyDataset(dataX, dataY)
     
    
   

    

     

    
    

     

              train_loader = DataLoader(dataset = trainData, batch_size =self.batch, shuffle = 
      True,drop_last =
      True)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      for epoch 
      in 
      range(self.maxIter):
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
            
      for step, (batch_x, batch_y) 
      in 
      enumerate(train_loader): 
     
    
   

    

     

    
    

     
                
     
    
   

    

     

    
    

     

                      w,b = self.step_gradient(w_cur, b_cur, batch_x,batch_y)
     
    
   

    

     

    
    

     

                      w_cur = w
     
    
   

    

     

    
    

     

                      b_cur = b
     
    
   

    

     

    
    

     
                
     
    
   

    

     

    
    

     

                  loss = self.compute_error(w, b, dataX, dataY)
     
    
   

    

     

    
    

     
            
      #print("\n epoch: ",epoch,"\n loss ",loss)
     
    
   

    

     

    
    

     

                  y_train_loss.append(loss)
     
    
   

    

     

    
    

     
        
      return y_train_loss
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      def 
      compute_error(
      self,w,b, dataX,dataY):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              totalError = 
      0.0
     
    
   

    

     

    
    

     

              m = 
      len(dataX)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      for i 
      in 
      range(
      0,m):
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     

                  x = dataX[i].view(self.n,
      1)
     
    
   

    

     

    
    

     

                  y = dataY[i]
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     

                  predY = self.predict(w, b, x)
     
    
   

    

     

    
    

     

                  z = predY-y
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     

                  loss = np.power(z,
      2)
     
    
   

    

     

    
    

     

                  totalError+=loss
     
    
   

    

     

    
    

     

              totalError = totalError.numpy()[
      0,
      0]
     
    
   

    

     

    
    

     
        
      return totalError
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
   
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       加载数据集
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      loadData(
      self):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              data = np.genfromtxt(
      "data.csv",delimiter=
      ",")
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

              trainData  = data[:,
      0:-
      1]
     
    
   

    

     

    
    

     

              trainLabel = data[:,-
      1]     
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

              x = torch.tensor(trainData,  dtype=torch.
      float)
     
    
   

    

     

    
    

     

              y = torch.tensor(trainLabel, dtype = torch.
      float)
     
    
   

    

     

    
    

     

              self.m ,self.n=x.shape[
      0],x.shape[
      1]
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      print(
      "\n m ",self.m,
      "\t n",self.n)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      return x,y
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      def 
      __init__(
      self):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              self.w = 
      0 
      #权重系数
     
    
   

    

     

    
    

     

              self.b = 
      0 
      #偏置
     
    
   

    

     

    
    

     

              self.m = 
      0 
      #样本个数
     
    
   

    

     

    
    

     

              self.n = 
      0 
      #样本维度
     
    
   

    

     

    
    

     

              self.batch = 
      20 
      #训练用的样本数
     
    
   

    

     

    
    

     

              self.maxIter = 
      1000 
      #最大迭代次数
     
    
   

    

     

    
    

     

              self.learnRate = 
      0.01 
      #学习率
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      "__main__":
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          lr = LR()
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          x,y = lr.loadData()
     
    
   

    

     

    
    

     

          loss = lr.train(x, y)
     
    
   

    

     

    
    

     

          draw_loss(loss)
     
    
   

    

     

    
    

     
        
     
    
  
 

  
 

3.2 绘图部分

  

   

    

     

    
    

     

      # -*- coding: utf-8 -*-
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     

      Created on Mon Nov 14 20:14:28 2022
     
    
   

    

     

    
    

     

      
     
    
   

    

     

    
    

     

      @author: cxf
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import numpy 
      as np
     
    
   

    

     

    
    

     

      import matplotlib.pyplot 
      as plt
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def 
      draw_loss(
      y_train_loss):
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          plt.figure()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          x_train_loss = 
      range(
      len(y_train_loss))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 去除顶部和右边框框
     
    
   

    

     

    
    

     

          ax = plt.axes()
     
    
   

    

     

    
    

     

          ax.spines[
      'top'].set_visible(
      False)
     
    
   

    

     

    
    

     

          ax.spines[
      'right'].set_visible(
      False)
     
    
   

    

     

    
    

     
    
      #标签
     
    
   

    

     

    
    

     

          plt.xlabel(
      'iters')
     
    
   

    

     

    
    

     

          plt.ylabel(
      'accuracy')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          plt.plot(x_train_loss, y_train_loss, linewidth=
      1, linestyle=
      "solid", label=
      "train loss")
     
    
   

    

     

    
    

     

          plt.legend()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          plt.title(
      'train loss')
     
    
   

    

     

    
    

     

          plt.show()
     
    
  
 

  
 

3.3 数据部分

  

   

    

     

    
    

     

      # -*- coding: utf-8 -*-
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     

      Created on Fri Nov 11 22:17:07 2022
     
    
   

    

     

    
    

     

      
     
    
   

    

     

    
    

     

      @author: cxf
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import numpy 
      as np
     
    
   

    

     

    
    

     

      import csv
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def 
      makeData():
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          wT = np.array([[
      1.0,
      2.0,
      2.0]])
     
    
   

    

     

    
    

     

          b = 
      0.5
     
    
   

    

     

    
    

     

          Data = np.random.random((
      200,
      3))
     
    
   

    

     

    
    

     

          m,n = np.shape(Data)
     
    
   

    

     

    
    

     

          trainData =[]
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      for i 
      in 
      range(m):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              x = Data[i].T
     
    
   

    

     

    
    

     

              y = np.matmul(wT,x)+b
     
    
   

    

     

    
    

     

              item =
      list(x)
     
    
   

    

     

    
    

     

              item.append(y[
      0])      
     
    
   

    

     

    
    

     

              trainData.append(item)
     
    
   

    

     

    
    

     
    
      return trainData
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def 
      save(
      data):
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          csvFile = 
      open(
      "data.csv",
      'w',newline=
      '')
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          wr = csv.writer(csvFile)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          m = 
      len(data)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      for i 
      in 
      range(m):
     
    
   

    

     

    
    

     

              wr.writerow(data[i])
     
    
   

    

     

    
    

     

          csvFile.close()
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      makeData()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ ==
      "__main__":
     
    
   

    

     

    
    

     
     
     
    
   

    

     

    
    

     

            data = makeData()
     
    
   

    

     

    
    

     

            save(data)