pytorch【线性回归】【逻辑回归】【softmax回归】

最新推荐文章于 2023-03-26 21:07:32 发布
最新推荐文章于 2023-03-26 21:07:32 发布
阅读量1.2k 收藏 14
点赞数 3
分类专栏： 深度学习 文章标签： pytorch 回归 线性回归 逻辑回归 softmax回归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62684026/article/details/128434139
版权

文章目录

零、前置函数

线性相乘

#线性相乘
def linreg(X, w):
    return torch.mm(X, w)

均方误差损失函数

#均方误差损失函数
#这里的y_hat是我们预测出来的结果，y是我们的正确的结果
def squared_loss(y_hat, y):
#使用y.numel获取到我们y中的元素个数
    num_ = y.numel()
    #reshape(-1,1)的作用就是将我们的函数变成一维的
    #然后我们就将这两个向量对应位置进行相减，然后对新生成的向量的每一个元素都进行求平方的操作
    #然后将这个向量的每一个元素都加起来，得到我们的平方误差和
    sse = torch.sum((y_hat.reshape(-1, 1) - y.reshape(-1, 1)) ** 2)
    #平方误差和除以我们的元素大的个数就是我们的均方误差和 
    return sse / num_

梯度下降函数

def sgd(params, lr):
	#将我们传入的当前位置的w，减去我们的学习率乘以我们梯度
	#我们就得到了我们的一次迭代后我们的新的位置
    params.data -= lr * params.grad 
    #将我们的当前点的梯度清零，节省我们的内存空间，便于我们下一次的计算
    params.grad.zero_()

数据的生成函数

数据的生成函数 小批量数据的随机生成函数

一、线性回归

1.手动实现线性回归

#创建我们的数据集
features, labels = tensorGenReg()
#这个函数在我们上面的数据生成函数的那一篇博文中有
#默认1生成1000行的数据，然后初始的权重是[2,-1,1]，默认是有偏置的
#也就是默认返回一个1000行，2列的数据特征数据
#然后返回一个1000行的标签，也就是1000×2的特征矩阵再乘上一个2×1权重也就是我们上面[2,-1]
#然后再加上我们的偏置，我们就得到了我们的特征
#y=2(x1)-1(x2)+1

# 设置随机数种子
torch.manual_seed(420)    

# 初始化核心参数
batch_size = 10                                # 每一个小批的数量
lr = 0.03                                      # 学习率
#也就是说我们全部都训练完的话，我们一共需要完整地遍历三遍全部的数据
num_epochs = 3                                 # 训练过程遍历几次数据
#生成一个三行一列的全0的权重向量，并且允许这个向量进行求导
#这个特征按照我们的传入的数据有多少个特征，我们就生成一个多长的权重矩阵
w = torch.zeros(3, 1, requires_grad = True)    # 随机设置初始权重

# 参与训练的模型方程
net = linreg                                   # 使用回归方程
loss = squared_loss                            # MSE作为损失函数

# 模型训练过程
#我们的模型迭代的次数
for epoch in range(num_epochs):
	#这个data_iter的函数定义在我们上面前置函数的数据的生成模块中有定义
	#传入的三个参数分别是我们的每一个小批量数据的阿晓
	#我们的特征和标签
	#分别取出我们每一次的小批量数据中的特征和标签
    for X, y in data_iter(batch_size, features, labels):
    #用特征乘以权重，然后跟我们的y异同传入我们的误差计算的函数，计算均方误差，
        l = loss(net(X, w), y)
        #将l进行反向传播，也就是由我们的当前的根节点对于我们前面的一个个节点进行求导操作
        l.backward()
        #进行梯度下降，也就是更新我们的权重矩阵
        sgd(w, lr)
    #在我们完成一轮对于全部的数据集的读取之后，我们将我们的特征乘以我们的权重，也就是x*w，然后用跟我们的正确的标签进行比较，计算我们的均方误差，并且打印出来。
    train_l = loss(net(features, w), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l))

在这里插入图片描述

2.调库实现线性回归

# 设置随机数种子
torch.manual_seed(420)   

# 创建数据集
features, labels = tensorGenReg()
features = features[:, :-1]                                  # 剔除最后全是1的列
data = TensorDataset(features, labels)                       # 数据封装
#传入我们的数据，然后传入每一个小批量数据集当中的元素个数，然后设置打乱顺序
batchData = DataLoader(data, batch_size = batch_size, shuffle = True)      # 数据加载

1.定义我们线性回归的模型

class LR(nn.Module):
# 定义模型的点线结构
    def __init__(self, in_features=2, out_features=1):       
        super(LR, self).__init__()
		#定义我们的线性模型，默认是传入两个特征，返回一个预测结果
        self.linear = nn.Linear(in_features, out_features)
    
     # 定义模型的正向传播规则
    def forward(self, x):                              
    	#我们的输出就是一对x进行线性回归     
        out = self.linear(x)             
        return out

# 实例化模型
LR_model = LR()

2.定义我们的误差函数

#也就是我们的均方误差
criterion = nn.MSELoss()

3.定义优化方法

#SGD也就是我们的梯度下降的方法，
#传入的两个参数分别是我们模型的全部参数（特征，标签，权重），然后我们的学习率是0.03
optimizer = optim.SGD(LR_model.parameters(), lr = 0.03)

4.模型的训练

#这里定义一个训练函数
#分别传入的是我们的神经网络模型
#我们的损失函数
#我们的优化方法
#我们的每一个小批量的数据的数据个数
#我们的整一个数据集我们一共想完整地遍历几次
def fit(net, criterion, optimizer, batchdata, epochs):
#遍历我们的每一个小批量的数据集
    for epoch in range(epochs):
    #取出每一个小批量数据集当中的特征和标签
        for X, y in batchdata:
        #向前传播，然后得到我们的预测的yhat
		#也就是我们的初始权重乘以我们的特征矩阵的结果
            yhat = net.forward(X)
            #计算我们的均方误差
            loss = criterion(yhat, y)
            #将我们的模型的梯度清空
            optimizer.zero_grad()
            #对我们的模型进行反向传播，也就是一次计算我们的结果对于我们每一个
            #前向结点的导数
            loss.backward()
            #我们的梯度下降进行一次迭代
            optimizer.step()

5.开始训练

# 设置随机数种子
torch.manual_seed(420)   
#传入我们对应的参数
fit(net = LR_model, 
    criterion = criterion, 
    optimizer = optimizer, 
    batchdata = batchData, 
    epochs = num_epochs)

6.查看模型的参数

# 查看模型参数
list(LR_model.parameters())

在这里插入图片描述

7.计算我们模型的当前的均方误差

# 计算MSE
criterion(LR_model(features), labels)

二、逻辑回归

# 设置随机数种子
torch.manual_seed(420)   

# 创建数据集
#这个函数在我们上面的前置函数的数据生成函数的链接中有
# 创建我们的分类数据集，其中分类的类别一共是两类，并且生成偏置项
#然后如果我们不写参数的话，我们的每一个类别都会有500个数据
#然后一共是两类，也就是一共有1000条数据，然后默认的特征是两个
#也就是我们会得到一个1000×2形状的特征和1000×1的标签
features, labels = tensorGenCla(num_class=2, bias=True)

# 可视化展示
plt.scatter(features[:, 0], features[:, 1], c = labels)

在这里插入图片描述

1.手动实现逻辑回归

1.激活函数

#这里我们指定sigmid函数作为我们的激活函数，这里的z是w*x，也就是我们预测出来德吉结果
#我们预测出来的结果是一个连续型变量，我们需要将其转换成01型变量。
def sigmoid(z):
    return 1/(1+torch.exp(-z))

2.逻辑回归函数

#也就是将我们逻辑回归的结果进行返回
#也就是调用我们上面1中的函数，然后我们就得到了一个我们的模型对于数据集预测的结果
def logistic(X, w):
    return sigmoid(torch.mm(X, w))

3.辅助函数设定阈值

#辅助函数就是将我们传入的sigma函数之后的结果转换成0-1二分类的结果
#这里我们将sigmid函数大于0.5的标记为1类
#小于等于0.5的标记位第0类
#然后如果我们直接sigma>=p的话我们得到的是一个布尔类型的数组
#我们想要将其变成0,1的话，就需要将其转换成浮点的类型
def cal(sigma, p=0.5):
    return((sigma >= p).float())

4.定义准确率函数

#这个sigma是我们的数据再经过sigmiod函数预测之后的结果，y是我们正确的标签
def accuracy(sigma, y):
    #将两个张量拉平，
    #将我们的sigma根据阈值判别成0,1类型，然后和我们的标签进行比较
    acc_bool = cal(sigma).flatten() == y.flatten()
    #求出平均值，也就是我们的预测正确的个数1（true就是1，然后累加，除以总数）
    #然后得到我们预测正确的百分比
    acc = torch.mean(acc_bool.float())
    return(acc)

5.定义损失函数

#y.numel()是y中一共有多少条数据
def cross_entropy(sigma, y):
#这里我们二分类的损失函数我们定义成交叉熵损失函数
    return(-(1/y.numel())*torch.sum((1-y)*torch.log(1-sigma)+y*torch.log(sigma)))

6.定义优化方法

#这里我们用梯度下降对我们的模型进行优化
#这里的params是我们的权重系数w
def sgd(params, lr):
#这里我们需要单独将data进行迭代，否则我们的函数的可导属性就会丢失
        params.data -= lr * params.grad 
        #将我们的导数清空，便于我们的下一次迭代，并且节省内存
        params.grad.zero_()

7.训练模型

# 设置随机数种子
torch.manual_seed(420)    

# 初始化核心参数
batch_size = 10                                # 每一个小批的数量
lr = 0.03                                      # 学习率
num_epochs = 3                                 # 训练过程遍历几次数据
w = torch.ones(3, 1, requires_grad = True)     # 随机设置初始权重

# 参与训练的模型方程
net = logistic                                 # 使用逻辑回归方程
loss = cross_entropy                           # 交叉熵损失函数

# 训练过程
for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
    #计算损失函数
        l = loss(net(X, w), y)
        #进行反向传播
        l.backward()
        #对我们的模型进行梯度下降，进行迭代
        sgd(w, lr)
    #计算模型这一轮迭代的准确率
    #也就是将我们的预测出来的准确率跟我们的标签进行对比
    train_acc = accuracy(net(features, w), labels)
    print('epoch %d, accuracy %f' % (epoch + 1, train_acc))

在这里插入图片描述

2.调库实现逻辑回归

1.定义核心参数

batch_size = 10                                # 每一个小批的数量
lr = 0.03                                      # 学习率
num_epochs = 3                                 # 训练过程遍历几次数据

2.创建数据集

# 设置随机数种子
torch.manual_seed(420)   

# 创建数据集
features, labels = tensorGenCla(num_class=2)
labels = labels.float()                        # 损失函数要求标签也必须是浮点型
#将我们店的特征和标签进行打包，形成一恶搞对象
data = TensorDataset(features, labels)
#将我们的数据加载到batchData中            
batchData = DataLoader(data, batch_size = batch_size, shuffle = True)

3.定义模型

class logisticR(nn.Module):
    def __init__(self, in_features=2, out_features=1):       # 定义模型的点线结构
        super(logisticR, self).__init__()
        #这里我们定义一层线性回归的模型
        self.linear = nn.Linear(in_features, out_features)
        
    def forward(self, x):                                    
        out = self.linear(x)             
        return out

# 实例化模型
logic_model = logisticR()

4.定义损失函数

#也就是我们的交叉熵损失函数
criterion = nn.BCEWithLogitsLoss()

5.定义优化方法

#这里我们的优化方法就是梯度下降法，然后我们需要传入我们模型的所有数据，然后传入我们的学习率
optimizer = optim.SGD(logic_model.parameters(), lr = lr)

6.定义训练函数

#分别传入我们的神经网络模型，我们的损失函数，我们的优化方法，我们的每一个小批量数据集中元素的个数
#还有我们一共想要在整个完整的数据集上迭代几次
def fit(net, criterion, optimizer, batchdata, epochs):
    for epoch in range(epochs):
        for X, y in batchdata:
        #让我们的模型前向传播，得到我们的一轮的预测结果
            zhat = net.forward(X)
            #用我们第一轮的预测结果计算我们当前的损失
            loss = criterion(zhat, y)
            #将我们的优化方法中的导数进行清空
            #因为我们的梯度是累积的，如果不进行清空的话，梯度就会累计起来
            optimizer.zero_grad()
            #将我们的loss函数进行反向传播
            loss.backward()
            #我们的梯度下降函数进行步进，也就是更新我们的w
            optimizer.step()

7.开始训练

# 设置随机数种子
torch.manual_seed(420)   
#分别传入我们对应的参数
fit(net = logic_model, 
    criterion = criterion, 
    optimizer = optimizer, 
    batchdata = batchData, 
    epochs = num_epochs)

8.查看训练结果

# 查看模型参数
list(logic_model.parameters())

在这里插入图片描述

9.计算交叉熵损失函数

# 计算交叉熵损失
criterion(logic_model(features), labels)

10.计算准确率

def acc_zhat(zhat, y):
    """输入为线性方程计算结果，输出为逻辑回归准确率的函数

    :param zhat：线性方程输出结果 
    :param y: 数据集标签张量
    :return：准确率 
    """
    sigma = sigmoid(zhat)
    return accuracy(sigma, y)

三、softmax回归

# 设置随机数种子
torch.manual_seed(420)   
#这里我们指定我们的均值是6，然后方差是2的正太分布的数据

#然后我们的数据再创建的时候就自动将其调整到我们的0的对称的两边（存在惩罚因子）
features, labels = tensorGenCla(bias=True, deg_dispersion=[6, 2])
plt.scatter(features[:, 0], features[:, 1], c = labels)

在这里插入图片描述

1.手动实现softmax回归

1.softmax函数的定义

def softmax(X, w):
	#将我们预测出来的结果全部变成以e为底的指数
    m = torch.exp(torch.mm(X, w))
    #将我们的上面的m按照行进行相加，然后将我们的性转转换成一列
    sp = torch.sum(m, 1).reshape(-1, 1)
    #用m除以我们的sp，也就是m向量中的每一个元素都会sp中对应行的累加和
    #这样我们就实现了我们的softmax函数
    return m / sp

2.定义交叉熵损失函数

#传入我们预测的结果soft_z和y也就是我们的正确的标签
#这里的soft_z是我们wx进行soft_max函数之后的结果，也就是生成了每一个数据对于不同的标签的概率
#比防说[0.7,0.2,0.1]这样的话就代表着当前这个记录是0类的概率是0.7，是1类的概率是0.2
#是2类的概率是0.1
#
def m_cross_entropy(soft_z, y):
    y = y.long()
    #gather是批量索引的功能，1就是按照行进行索引，y是我们正确的标签
    #也就是我们会索引出我们对于y这个正确的标签预测出来的概率
    prob_real = torch.gather(soft_z, 1, y)
    #y.numel得到y中元素的总个数
    #我们需要将每一个数据进行取对数，然后加和，然后取平均值
    return (-(1/y.numel()) * torch.log(prob_real).sum())

在这里插入图片描述

3.定义准确率函数

def m_accuracy(soft_z, y):
#argmax返回当前张量中最大的元素的下标，这里我们也就是我们预测当前样本属于哪一类概率最大的索引
#将这个索引和y进行比较，看看有多少个是标记正确的
#flatten就是将这个数据拉平
    acc_bool = torch.argmax(soft_z, 1).flatten() == y.flatten()
    acc = torch.mean(acc_bool.float())
    return(acc)

在这里插入图片描述

4.定义优化函数

#定义梯度下降函数
def sgd(params, lr):
    params.data -= lr * params.grad 
    params.grad.zero_()

5.开始训练我们的模型

# 设置随机数种子
torch.manual_seed(420)  

# 初始化核心参数
batch_size = 10                                # 每一个小批的数量
lr = 0.03                                      # 学习率
num_epochs = 3                                 # 训练过程遍历几次数据
w = torch.randn(3, 3, requires_grad = True)    # 随机设置初始权重

# 参与训练的模型方程
net = softmax                                     # 使用回归方程
loss = m_cross_entropy                            # 交叉熵损失函数

train_acc = []

# 模型训练过程
for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
    #计算交叉熵损失
        l = loss(net(X, w), y)
        #进行反向传播，反向进行求导
        l.backward()
        #进行梯度下降，更新我们的w
        sgd(w, lr)
    train_acc = m_accuracy(net(features, w), labels)
    print('epoch %d, acc %f' % (epoch + 1, train_acc))

在这里插入图片描述
这是我们的w，因为是三分类，所以有三列
在这里插入图片描述

2.调库实现softmax回归

1.定义核心参数

batch_size = 10                                # 每一个小批的数量
lr = 0.03                                      # 学习率
num_epochs = 3                                 # 训练过程遍历几次数据

2.创建数据

# 设置随机数种子
torch.manual_seed(420)   

# 创建数据集
features, labels = tensorGenCla(deg_dispersion = [6, 2])
labels = labels.float()                           # 损失函数要求标签也必须是浮点型
data = TensorDataset(features, labels)            
batchData = DataLoader(data, batch_size = batch_size, shuffle = True)

3.定义模型

class softmaxR(nn.Module):
    def __init__(self, in_features=2, out_features=3, bias=False):       
    # 定义模型的点线结构
        super(softmaxR, self).__init__()
        self.linear = nn.Linear(in_features, out_features)
        
    def forward(self, x):                          # 定义模型的正向传播规则
        out = self.linear(x)             
        return out

# 实例化模型和
softmax_model = softmaxR()

3.定义损失函数

#损失函数为交叉熵损失函数
criterion = nn.CrossEntropyLoss()

4.定义我们的优化方法

#我们的优化方法为梯度下降法，然后传入我们模型的所有参数，和学习率
optimizer = optim.SGD(softmax_model.parameters(), lr = lr)

5.定义我们模型的训练函数

#分别传入对应的参数
#我们定义的模型
#我们的损失函数
#我们的优化方法
#我们的每一个小批量数据集中的数据个数
#我们想要在完整的数据集上迭代几次
def fit(net, criterion, optimizer, batchdata, epochs):
    for epoch in range(epochs):
    #分别取出特征和标签
        for X, y in batchdata:
        #向前传播，得出我们的预测结果
            zhat = net.forward(X)
            y = y.flatten().long()       # 损失函数计算要求转化为整数
            #计算损失函数
            loss = criterion(zhat, y)
            #将我们的梯度下降的原有的导数进行清空
            optimizer.zero_grad()
            #将我们的损失函数进行反向传播
            loss.backward()
            #梯度下降，进行迭代
            optimizer.step()

6.训练我们的模型

fit(net = softmax_model, 
    criterion = criterion, 
    optimizer = optimizer, 
    batchdata = batchData, 
    epochs = num_epochs)

7.查看模型的相关参数

# 查看模型参数
print(list(softmax_model.parameters()))

在这里插入图片描述

# 计算交叉熵损失
criterion(softmax_model(features), labels.flatten().long())

在这里插入图片描述

# 借助F.softmax函数，计算准确率
m_accuracy(F.softmax(softmax_model(features), 1), labels)

在这里插入图片描述

桜キャンドル淵
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
pytorch实现基本的logistic和softmax回归实验（手动+torch）
qq_37534947的博客
08-23 1万+
前提：不是前馈神经网络，没有隐藏层。 一：Logistic回归实验–人工构造数据集，手动构造模型 要求： 动手从0实现logistic回归，实现二分类，人工构造数据集，并分析loss、训练集、测试集的准确率。（要求从零实现二元交叉熵） 实验过程： 1.1人工构造数据集 1. # #自定义数据---训练集 2. num_inputs = 2 3. n_data = torch.ones(1500, num_inputs) # 数据的基本形态 4. x1 = torch.normal(2 * n_d
PyTorch线性回归和逻辑回归实战示例.pdf
04-17
在 PyTorch 中实现逻辑回归，只需将线性层后的激活函数改为 `torch.sigmoid` 或直接使用内置的 `nn.LogSoftmax` 和 `nn.NLLLoss`。 这个实战示例提供了一个基础的 PyTorch 模型训练流程，适用于理解基本的神经网络...
pytorch之Softmax回归
如月之恒，如日之升
04-07 1529
理论推导 简介 softmax回归模型，实际是一个分类模型，与线性回归模型有很多不同的地方(与线性回归一样都是一个单层的神经网络） 分类问题介绍 输入图片的每一个像素值都可以用一个标量表示，我们将图片中的4个像素用 x1,x2,x3,x4表示 假设训练数据集中图像的真实标签为狗、猫或鸡（假设可以用4像素表示出这3种动物），这些标签分别对应离散值y 1 , y 2 , y 3 softmax回归模型 softmax回归跟线性回归一样将输入特征与权重做线性叠加。与线性回归的一个主要不同在于，s
基于pytorch的线性回归与Softmax分类模型
benrenyoudu的博客
02-14 323
线性回归 主要内容包括： 线性回归的基本要素 线性回归模型从零开始的实现 线性回归模型使用pytorch的简洁实现 线性回归的基本要素 模型 为了简单起见，这里我们假设价格只取决于房屋状况的两个因素，即面积（平方米）和房龄（年）。接下来我们希望探索价格与这两个因素的具体关系。线性回归假设输出与各个输入之间是线性关系: 数据集 我们通常收集一系列的真实数据，例如多栋房屋的真实售出价格和它们对应的面...
Pytorch笔记：线性回归、softmax回归
Mr___WQ的博客
07-06 1401
线性回归、softmax
DL-Pytorch Task01:线性回归；Softmax与分类模型；多层感知机
DEREKLN的博客
02-22 461
目录基本概念训练集、测试集、验证集损失函数优化算法线性回归的神经网络及代码实现线性回归模型的从零开始的实现线性回归模型使用pytorch的简洁实现softmax回归的神经网络及代码实现获取Fashion-MNIST训练集和读取数据多层感知机多层感知机pytorch实现 基本概念 训练集、测试集、验证集 训练集是用来训练模型内参数的数据集。 验证集用于在训练过程中检验模型的状态，收敛情况。验证集通常...
基于pytorch的logistic与softmax回归模型python代码
12-11
- **概念**：Softmax回归，也称为多项式逻辑回归，用于多分类任务。它扩展了Logistic回归，通过计算所有类别的概率并归一化，得到每个类别属于样本的概率。 - **Softmax函数**：Softmax函数是多个独立的Sigmoid...
PyTorch 实现 逻辑回归、多元分类-谢TS的博客.pdf
07-17
它与线性回归和非线性回归的主要区别在于，后者预测的是连续的数值，而逻辑回归则是用来处理离散的二分类问题，输出结果为0或1，代表两种不同的类别。 逻辑回归的核心是Sigmoid函数，它将输入映射到(0,1)之间，这个...
Regression:简单的线性和逻辑回归
04-27
简单线性回归与逻辑回归是两种广泛应用于统计学和机器学习领域的预测模型。它们都是基于概率理论，并在Python编程环境中有着丰富的实现库，如NumPy、Pandas和PyTorch。 简单线性回归是一种基本的统计方法，用于研究...
DeepLearning tutorial（1）Softmax回归代码详解
01-26
在Python中，我们可以使用诸如TensorFlow、PyTorch或scikit-learn等库来实现Softmax回归。不过，这里我们将讨论一个基于Python原生的简单实现。 在提供的文件"**logistic_sgd(comment_by_wepon).py**"和"logistic_...
TensorReg：用于张量回归的Matlab工具箱
02-03
TensorReg：用于张量回归的Matlab工具箱
动手学深度学习PyTorch版 | （1）线性回归、softmax与分类、多层感知机
MissingDi的博客
02-14 670
一、线性回归 线性回归输出是一个连续值，因此适用于回归问题。回归问题在实际中很常见，如预测房屋价格、⽓温、销售额等连续值的问题。与回归问题不同，分类问题中模型的最终输出是⼀个离散值。我们所说的图像分类、垃圾邮件识别、疾病检测等输出为离散值的问题都属于分类问题的范畴。softmax回归则适用于分类问题。 –线性回归的基本要素 以一个简单的房屋价格预测作为例子来解释线性回归的基本要素。⽬标是预测一栋房...
PyTorch学习笔记二：用PyTorch逻辑回归（二分类问题）
xjq0000的博客
10-23 1112
相关知识 1、分类问题不同于线性回归，是输出属于每一个类别的概率。概率最大的就是最后的类别。 2、sigmoid函数 使用sigmoid函数将线性回归里的输出值[-无穷，+无穷]映射到[0,1]。 其他的sigmoid函数： 这些函数满足的条件： 函数值有极限、都是单调的增函数、都是饱和函数。 逻辑回归模型： 损失函数的变化： 这里使用的是交叉熵损失，交叉熵损失描述的的是两个分布之间的差异，越大越好，这里加了一负号，所以是越小越好。 代码 代码部分和线性回归模型差不多还是分为四步。 一、Prepar
深度学习 第3章线性分类 实验四 pytorch实现 Softmax回归 中篇
weixin_51395608的博客
09-21 1020
深度学习 线性分类 pytorch python Softmax回归 中篇 详细的讲解了Softmax的模型
Pytorch基础(5)——SOFTMAX回归相关知识
Ccendoc的博客
10-28 720
训练SOFTMAX模型及相关函数知识
pytorch学习--softmax回归
weixin_45349682的博客
11-11 117
简单解析softmax回归
第12课：（2）线性回归建模实验
weixin_44953928的博客
04-15 297
文章目录一、深度学习建模流程二、线性回归的手动实现 一、深度学习建模流程 数据准备就绪，接下来就是建模实验环节，在实际深度学习建模过程中，无论是手动实现还是调库实现，我们都需要遵循深度学习建模一般流程。在此前的学习过程中，我们曾两次提及深度学习建模流程，结合此前学习内容，我们先进行简单回顾。 根据此流程，我们进行线性回归建模 二、线性回归的手动实现 首先，考虑如何手动实现建模过程。 # 随机模块 import random # 绘图模块 import matplotlib as mpl import m
PyTorch深度学习——Logistic回归（二分类问题）
weixin_42603976的博客
08-09 2511
pytorch深度学习中有关于logistic回归二分类问题的代码详解
使用Pytorch实现softmax回归
qq_63013294的博客
03-26 533
softmax回归的简要实现
pytorch线性回归掉包
最新发布
05-26
如果你想使用PyTorch进行线性回归，可以使用以下步骤： 1. 导入PyTorch库和其他必要的库： ``` import torch import torch.nn as nn import numpy as np import matplotlib.pyplot as plt ``` 2. 准备数据集。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

桜キャンドル淵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值