采用sigmoid激活函数，BCE损失函数进行网络训练，训练过程中loss不断下降，但其精确度acc却一直不变

模型代码

#!usr/bin/env python
# -*- coding:utf-8 -*-
"""
@author: liujie
@file: LR_Model.py
@time: 2022/09/05
@desc:PyTorch实现LR模型
"""
import torch
import numpy as np
import torch.nn as nn


class LogisticRegression(nn.Module):
    def __init__(self, field_dims, emb_size):
        """
        :param field_dims: 特征数量列表，其和为总特征数量
        :param emb_size: embedding的维度
        """
        super(LogisticRegression, self).__init__()
        # embedding层
        self.emb = nn.Embedding(sum(field_dims), emb_size)
        # 模型初始化,针对激活函数：饱和函数，如Sigmoid，Tanh
        nn.init.xavier_uniform_(self.emb.weight.data)
        # 偏置项
        self.offset = np.array((0, *np.cumsum(field_dims)[:-1]), dtype=np.long)
        # 可梯度更新
        self.bias = nn.Parameter(torch.zeros((1,)))

    def forward(self, x):
        """
        前向传播
        :param x: 输入数据,(batch,seq_len)
        :return:
        """
        x = x + x.new_tensor(self.offset)
        # (batch,seq_len) => (batch,seq_len,1) => (batch,1)
        x = self.emb(x).sum(1) + self.bias
        x = torch.sigmoid(x)
        return x

训练及预测代码：

#!usr/bin/env python
# -*- coding:utf-8 -*-
"""
@author: liujie
@file: main.py
@time: 2022/09/05
@desc:
"""

import tqdm
import torch
import numpy as np
import pandas as pd
import torch.nn as nn
from torch import optim
from LR_Model import LogisticRegression
import matplotlib.pyplot as plt
from dataSet import My_DataSet
from torch.utils.data import DataLoader
from dataProcess import DataProcess
from sklearn.metrics import f1_score, recall_score, roc_auc_score

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
criteo_file = "criteo-100k.txt"
nrows = 100000
sizes = [0.75, 0.25]
embedding_size = 1
batch_size = 1024
num_epochs = 200
learning_rate = 1e-5
weight_decay = 1e-6


def train_and_test(train_dataloader, test_dataloader, model):
    # 损失函数
    criterion = nn.BCELoss()
    # 优化器
    optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
    # 记录训练与测试过程的损失，用于绘图
    train_loss, test_loss, train_acc, test_acc = [], [], [], []
    for epoch in range(num_epochs):
        train_loss_sum = 0.0
        train_len = 0
        train_correct = 0
        # 显示训练进度
        train_dataloader = tqdm.tqdm(train_dataloader)
        train_dataloader.set_description('[%s%04d/%04d]' % ('Epoch:', epoch + 1, num_epochs))

        # 训练模式
        model.train()
        model.to(device)
        for i, data_ in enumerate(train_dataloader):
            x, y = data_[0].to(device), data_[1].to(device)
            # 开始当前批次训练时，优化器的梯度置零，否则，梯度会累加
            optimizer.zero_grad()
            # output size = (batch,)
            output = model(x)
            loss = criterion(output.squeeze(1), y)
            # 反向传播
            loss.backward()
            # 利用优化器更新参数
            optimizer.step()
            # 默认reduction="mean",因此需要乘以个数
            train_loss_sum += loss.detach() * len(y)
            train_len += len(y)
            _, predicted = torch.max(output, 1)
            train_correct += (predicted == y).sum().item()
            # print("train_correct=\n", train_correct)
            # print("train_acc=\n", train_correct / train_len)
            F1 = f1_score(y.cpu(), predicted.cpu(), average="weighted")
            Recall = recall_score(y.cpu(), predicted.cpu(), average="micro")

            # 设置日志
            postfic = {"train_loss: {:.5f},train_acc:{:.3f}%,F1: {:.3f}%,Recall:{:.3f}%".
                           format(train_loss_sum / train_len, 100 * train_correct / train_len, 100 * F1, 100 * Recall)}
            train_dataloader.set_postfix(log=postfic)
        train_loss.append((train_loss_sum / train_len).item())
        train_acc.append(round(train_correct / train_len, 4))

        # 测试
        test_dataloader = tqdm.tqdm(test_dataloader)
        test_dataloader.set_description('[%s%04d/%04d]' % ('Epoch:', epoch + 1, num_epochs))
        model.eval()
        model.to(device)
        with torch.no_grad():
            test_loss_sum = 0.0
            test_len = 0
            test_correct = 0
            for i, data_ in enumerate(test_dataloader):
                x, y = data_[0].to(device), data_[1].to(device)
                output = model(x)
                loss = criterion(output.squeeze(1), y)
                test_loss_sum += loss.detach() * len(x)
                test_len += len(y)
                _, predicted = torch.max(output, 1)
                test_correct += (predicted == y).sum().item()
                F1 = f1_score(y.cpu(), predicted.cpu(), average="weighted")
                Recall = recall_score(y.cpu(), predicted.cpu(), average="micro")
                # 设置日志
                postfic = {"test_loss: {:.5f},test_acc:{:.3f}%,F1: {:.3f}%,Recall:{:.3f}%".
                               format(test_loss_sum / test_len, 100 * test_correct / test_len, 100 * F1, 100 * Recall)}
                test_dataloader.set_postfix(log=postfic)
            test_loss.append((test_loss_sum / test_len).item())
            test_acc.append(round(test_correct / test_len, 4))

    return train_loss, test_loss, train_acc, test_acc


def main():
    """
    主函数
    :return:
    """
    dataProcess = DataProcess(criteo_file, nrows, sizes, device)
    field_dims, (x_train, y_train), (x_test, y_test) \
        = dataProcess.train_valid_test_split(sizes)
    # 构造数据集
    trainDataset = My_DataSet(x_train, y_train)
    train_dataloader = DataLoader(trainDataset, batch_size=batch_size, shuffle=True)

    testDataset = My_DataSet(x_test, y_test)
    test_dataloader = DataLoader(testDataset, batch_size=batch_size)

    # 模型实例化
    model = LogisticRegression(field_dims, embedding_size)

    # 训练与测试
    train_loss, test_loss, train_acc, test_acc = train_and_test(train_dataloader, test_dataloader, model)

    # 绘图，展示损失变化
    epochs = np.arange(num_epochs)
    plt.plot(epochs, train_loss, 'b-', label='Training loss')
    plt.plot(epochs, test_loss, 'r--', label='Validation loss')
    plt.title('Training And Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    epochs = np.arange(num_epochs)
    plt.plot(epochs, train_acc, 'b-', label='Training acc')
    plt.plot(epochs, test_acc, 'r--', label='Validation acc')
    plt.title('Training And Validation acc')
    plt.xlabel('Epochs')
    plt.ylabel('acc')
    plt.legend()
    plt.show()


if __name__ == '__main__':
    main()

结果展示

D:\softwares\anaconda3\envs\tfpt368\python.exe D:/PycharmProjects/sxlj/Recommendation/CF/LR/main.py
[Epoch:0001/0020]: 100%|██████████| 37/37 [00:00<00:00, 40.72it/s, log={'train_loss: 0.67913,train_acc:77.339%,F1: 63.968%,Recall:74.764%'}]
[Epoch:0001/0020]: 100%|██████████| 13/13 [00:00<00:00, 53.43it/s, log={'test_loss: 0.66259,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0002/0020]: 100%|██████████| 37/37 [00:00<00:00, 44.81it/s, log={'train_loss: 0.64821,train_acc:77.339%,F1: 68.450%,Recall:78.066%'}]
[Epoch:0002/0020]: 100%|██████████| 13/13 [00:00<00:00, 55.70it/s, log={'test_loss: 0.63518,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0003/0020]: 100%|██████████| 37/37 [00:00<00:00, 47.80it/s, log={'train_loss: 0.62221,train_acc:77.339%,F1: 65.347%,Recall:75.786%'}]
[Epoch:0003/0020]: 100%|██████████| 13/13 [00:00<00:00, 55.48it/s, log={'test_loss: 0.61244,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0004/0020]: 100%|██████████| 37/37 [00:00<00:00, 48.78it/s, log={'train_loss: 0.60060,train_acc:77.339%,F1: 69.637%,Recall:78.931%'}]
[Epoch:0004/0020]: 100%|██████████| 13/13 [00:00<00:00, 54.09it/s, log={'test_loss: 0.59368,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0005/0020]: 100%|██████████| 37/37 [00:00<00:00, 49.18it/s, log={'train_loss: 0.58267,train_acc:77.339%,F1: 69.529%,Recall:78.852%'}]
[Epoch:0005/0020]: 100%|██████████| 13/13 [00:00<00:00, 60.35it/s, log={'test_loss: 0.57828,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0006/0020]: 100%|██████████| 37/37 [00:00<00:00, 42.04it/s, log={'train_loss: 0.56785,train_acc:77.339%,F1: 65.773%,Recall:76.101%'}]
[Epoch:0006/0020]: 100%|██████████| 13/13 [00:00<00:00, 56.91it/s, log={'test_loss: 0.56569,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0007/0020]: 100%|██████████| 37/37 [00:01<00:00, 36.04it/s, log={'train_loss: 0.55563,train_acc:77.339%,F1: 65.666%,Recall:76.022%'}]
[Epoch:0007/0020]: 100%|██████████| 13/13 [00:00<00:00, 54.54it/s, log={'test_loss: 0.55540,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0008/0020]: 100%|██████████| 37/37 [00:00<00:00, 38.80it/s, log={'train_loss: 0.54552,train_acc:77.339%,F1: 66.092%,Recall:76.336%'}]
[Epoch:0008/0020]: 100%|██████████| 13/13 [00:00<00:00, 52.56it/s, log={'test_loss: 0.54695,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0009/0020]: 100%|██████████| 37/37 [00:01<00:00, 33.45it/s, log={'train_loss: 0.53709,train_acc:77.339%,F1: 67.698%,Recall:77.516%'}]
[Epoch:0009/0020]: 100%|██████████| 13/13 [00:00<00:00, 49.37it/s, log={'test_loss: 0.54005,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0010/0020]: 100%|██████████| 37/37 [00:00<00:00, 39.34it/s, log={'train_loss: 0.53003,train_acc:77.339%,F1: 66.413%,Recall:76.572%'}]
[Epoch:0010/0020]: 100%|██████████| 13/13 [00:00<00:00, 47.92it/s, log={'test_loss: 0.53433,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0011/0020]: 100%|██████████| 37/37 [00:00<00:00, 37.54it/s, log={'train_loss: 0.52403,train_acc:77.339%,F1: 66.840%,Recall:76.887%'}]
[Epoch:0011/0020]: 100%|██████████| 13/13 [00:00<00:00, 49.94it/s, log={'test_loss: 0.52961,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0012/0020]: 100%|██████████| 37/37 [00:00<00:00, 39.26it/s, log={'train_loss: 0.51891,train_acc:77.339%,F1: 66.840%,Recall:76.887%'}]
[Epoch:0012/0020]: 100%|██████████| 13/13 [00:00<00:00, 47.93it/s, log={'test_loss: 0.52559,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0013/0020]: 100%|██████████| 37/37 [00:01<00:00, 35.10it/s, log={'train_loss: 0.51445,train_acc:77.339%,F1: 66.733%,Recall:76.808%'}]
[Epoch:0013/0020]: 100%|██████████| 13/13 [00:00<00:00, 50.14it/s, log={'test_loss: 0.52217,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0014/0020]: 100%|██████████| 37/37 [00:00<00:00, 39.56it/s, log={'train_loss: 0.51053,train_acc:77.339%,F1: 66.626%,Recall:76.730%'}]
[Epoch:0014/0020]: 100%|██████████| 13/13 [00:00<00:00, 49.19it/s, log={'test_loss: 0.51921,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0015/0020]: 100%|██████████| 37/37 [00:01<00:00, 34.69it/s, log={'train_loss: 0.50701,train_acc:77.339%,F1: 66.840%,Recall:76.887%'}]
[Epoch:0015/0020]: 100%|██████████| 13/13 [00:00<00:00, 50.13it/s, log={'test_loss: 0.51664,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0016/0020]: 100%|██████████| 37/37 [00:00<00:00, 39.56it/s, log={'train_loss: 0.50383,train_acc:77.339%,F1: 68.342%,Recall:77.987%'}]
[Epoch:0016/0020]: 100%|██████████| 13/13 [00:00<00:00, 50.52it/s, log={'test_loss: 0.51434,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0017/0020]: 100%|██████████| 37/37 [00:01<00:00, 35.54it/s, log={'train_loss: 0.50090,train_acc:77.339%,F1: 69.313%,Recall:78.695%'}]
[Epoch:0017/0020]: 100%|██████████| 13/13 [00:00<00:00, 48.46it/s, log={'test_loss: 0.51225,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0018/0020]: 100%|██████████| 37/37 [00:00<00:00, 39.15it/s, log={'train_loss: 0.49816,train_acc:77.339%,F1: 67.698%,Recall:77.516%'}]
[Epoch:0018/0020]: 100%|██████████| 13/13 [00:00<00:00, 48.65it/s, log={'test_loss: 0.51036,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0019/0020]: 100%|██████████| 37/37 [00:01<00:00, 32.66it/s, log={'train_loss: 0.49559,train_acc:77.339%,F1: 68.020%,Recall:77.752%'}]
[Epoch:0019/0020]: 100%|██████████| 13/13 [00:00<00:00, 49.38it/s, log={'test_loss: 0.50860,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]
[Epoch:0020/0020]: 100%|██████████| 37/37 [00:00<00:00, 39.33it/s, log={'train_loss: 0.49315,train_acc:77.339%,F1: 67.590%,Recall:77.437%'}]
[Epoch:0020/0020]: 100%|██████████| 13/13 [00:00<00:00, 50.32it/s, log={'test_loss: 0.50695,test_acc:77.332%,F1: 68.127%,Recall:77.830%'}]

Process finished with exit code 0

尝试调整batch，学习率等都不起作用

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除
收藏举报

1条回答默认最新

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
Kungs8 2022-09-09 15:24
关注
从以下几点查看：

损失函数的使用
样本数据集
参数的设置，类似学习率等等
解决无用
评论打赏
分享
举报

评论

按下Enter换行，Ctrl+Enter发表内容

报告相同问题？

关注问题

TensorFlow 2.0 深度学习实战 —— 详细介绍损失函数、优化器、激活函数、多层感知机的实现原理
2022-03-28 18:04

风尘浪子的博客 15 个常用损失函数的计算方式和使用场景，讲解 SGD、AdaGrad、Adam、RMSProp 4类优化器的公式原理，对阶跃激活函数、Sigmoid 激活函数、ReLU激活函数、Leaky ReLU 激活函数、Tanh 激活函数、Softmax激活函数等进行...
纯手写版BP神经网络实战之Python实现
2021-06-27 16:54

TerryBlog的博客 BP神经网络手写实战（理论+实践）
pytorch练习-BP神经网络
2022-08-14 10:54

try and wait.的博客 BP神经网络
《深入浅出OCR》前言知识（一）：机器学习最新全面总结
2023-08-24 11:17

GoAI的博客经过几个月的精心筹备，本作者推出全新系列《深入浅出OCR》专栏，**对标最全OCR教程**，具体章节如导图所示，将分别从OCR技术发展、方向...面向对象：本篇前言知识主要介绍机器学习，方便小白或AI爱好者学习基础知识。
分割项目学习过程，完结撒花
2023-04-24 11:31

浪漫细菌的博客分割项目学习过程，unet
【NLP】神经网络基础组件
2021-11-03 20:59

chaser&upper的博客【NLP】神经网络基础组件神经网络基础组件感知机：最简单的神经网络激活函数SigmoidTanhReLUSoftmax损失函数均方误差损失类别交叉熵损失二元交叉熵深入监督学习构造玩具数据选择模型转换概率到具体类选择损失函数...
实时分割网络（持续更新）
2021-12-04 18:10

ZRX_GIS的博客另一派为工程派,旨在将算法更稳定高效的落地在硬件平台上,效率是其追求的目标复杂的模型固然具有更好的性能,但是高额的存储空间计算资源消耗是使其难以有效的应用在各硬件平台上的重要原因。（学院派以论文为导向，...
【深度学习】保姆级教程，用PyTorch构建第一个神经网络
2021-12-12 12:00

风度78的博客 PyTorch是一个基于python的科学计算包，主要针对两类人群：作为NumPy的替代品，可以利用GPU的性能进行计算作为一个高灵活性、速度快的深度学习平台在PyTorch中搭建神经网络...
Pytorch极简入门教程（八）—— 精确率计算
2020-12-07 14:22

沐雲小哥的博客 ='left']].values X = torch.from_numpy(X_data).type(torch.FloatTensor) loss_fn = nn.BCELoss() batch = 64 no_of_batches = len(data)//batch epochs = 100 import torch.nn.functional as F class Model(nn....
2024 MathorCupB 题甲骨文智能识别中原始拓片单字自动分割与识别研究
2024-04-12 12:50

蟹堡王首席大厨的博客 人工智能和大数据技术被应用于甲骨文全息性研究及数字化工程建设，成为甲骨文信息处理领域的研究热点。甲骨文拓片图像分割是甲骨文数字化工程的基础问题，其目的是利用数字图像处理和计算机视觉技术，在甲骨文原始...
pytorch02：数据读取DataLoader与Dataset、数据预处理transform
2023-12-27 16:20

慕溪同学的博客目录模型训练数据处理一、DataLoader 1.1torch.utils.data.DataLoader 1.2数据常见概念二、Dataset 2.1torch.utils.data.Dataset 2.2代码展示 2.2.1划分数据集 2.2.2训练代码三、transform 3.1 torchvision视觉...
PyTorch深度学习入门
2023-11-02 14:48

helloworld大王的博客逻辑回归求解二分类问题知识点：sigmoid激活函数，交叉熵损失函数BCELoss 问题描述：针对于输出为离散的分类问题主要思路：利用sigmoid函数求解某一类的概率，利用交叉熵损失函数BCELoss衡量不同分布的差异大小 ...
文献翻译：基于弱监督学习的激光散斑对比度原始复杂图像鲁棒血管分割
2024-05-19 10:32

来自宇宙的曹先生的博客激光散斑对比成像(LSCI)被广泛应用于体内局部血流微循环的实时检测和分析由于其非侵入性和出色的时空分辨率。然而，由于病变区域血液微循环结构的复杂性和血管畸变的不规则性，使得LSCI图像的血管分割仍然面临很多...
第二十三章 LaneAF框架结构以及接入MMDetection3D模型(车道线感知)
2023-11-02 16:05

小酒馆燃着灯的博客近期参与到了的车道线检测的学习中去，以此系列笔记记录学习与思考的全过程。车道线检测系列会持续更新，力求完整精炼，引人启示。所需前期知识，可以结合进行系统的学习。
PyTorch—学习笔记（附源码）
2020-07-16 18:20

长吟永叹的博客 torch.Size() #查看其形状 torch对象相加的三种写法 y.add_(x) #这种加法会改变y的值 x+y #不会改变y的值 result=torch.Tensor(a,b) #预先分配空间 torch.add(x , y, out=result)#输入到resul
单阶段目标检测重要论文总结
2022-05-18 20:11

秋天的风儿的博客 YOLOv1做法：backbone网络先在ImageNet上进行预训练，预训练时所输入的图像尺寸是224×224，而做检测任务时，YOLOv1所接收的输入图像尺寸是448×448，不难想到，训练过程中，网络必须要先克服由分辨率尺寸的剧变所...
【单目3D目标检测】FCOS3D + PGD论文解析与代码复现
2022-11-08 17:48

嗜睡的篠龙的博客本文对OpenMMLab在Monocular 3D detection领域做的两项工作FCOS3D和PGD（也被称作FCOS3D++）进行介绍。
没有解决我的问题, 去提问