问题清除指南｜关于num_classes与 BCELoss、BCEWithLogitsLoss 和 CrossEntropyLoss 的关系

前言：关于「 num_classes = 1 」引发的探究。

2024年尾声，学弟问到一个问题：在研究工作 CNNDetection 的github开源代码 networks/trainer.py 文件的 line 27 self.model = resnet50(num_classes=1) 中，变量 num_classes 的值为1，而该工作完成的是一个二分类任务，于是就有了这篇博文的诞生。

首先求助 GPT-4o，获取初步解答如下：
在这里插入图片描述

进一步发现：trainer.py文件中 line 27 ，resnet50使用到的损失函数是BCEWithLogitsLoss(·)，

在二分类任务中，num_classes 通常设置为1或2，具体取决于使用的损失函数和模型的输出形式。下面是关于这两种情况的解释：

num_classes = 1

  • 模型输出：模型的最后一层输出一个值（logit），表示样本属于正类的概率。
  • 损失函数：使用带有逻辑回归的二分类交叉熵损失函数 (BCEWithLogitsLoss) 或二元交叉熵损失函数 (BCELoss)。
  • 代码示例：
import torch.nn as nn
import torchvision.models as models

class BinaryClassificationResNet50(nn.Module):
    def __init__(self, pretrained=True):
        super(BinaryClassificationResNet50, self).__init__()
        self.model = models.resnet50(pretrained=pretrained)
        self.model.fc = nn.Linear(self.model.fc.in_features, 1)  # 输出一个值

    def forward(self, x):
        return self.model(x)

# 初始化模型
model = BinaryClassificationResNet50(pretrained=True)

# 打印模型结构
print(model)
# 输出结果
BinaryClassificationResNet50(
  (model): ResNet(
    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (layer2): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (layer3): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (4): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (5): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (layer4): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
    (fc): Linear(in_features=2048, out_features=1, bias=True)
  )
)

num_classes = 2

  • 模型输出：模型的最后一层输出两个值，分别表示样本属于两个类别的概率（通过softmax函数转换为概率）。
  • 损失函数：使用交叉熵损失函数 (CrossEntropyLoss)。
  • 代码示例：
import torch
import torch.nn as nn
import torchvision.models as models

class BinaryClassificationResNet50(nn.Module):
    def __init__(self, pretrained=True):
        super(BinaryClassificationResNet50, self).__init__()
        self.model = models.resnet50(pretrained=pretrained)
        self.model.fc = nn.Linear(self.model.fc.in_features, 2)  # 输出两个值

    def forward(self, x):
        return self.model(x)

# 初始化模型
model = BinaryClassificationResNet50(pretrained=True)

# 打印模型结构
print(model)
# 输出结果
BinaryClassificationResNet50(
  (model): ResNet(
    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
	...
    (fc): Linear(in_features=2048, out_features=2, bias=True)
  )
)

写在最后：感谢 https://github.com/copilot ！！！免费试用 GPT-4o ～

参考资料

  • 【PyTorch】进阶学习：探索BCEWithLogitsLoss的正确使用—二元分类问题中的logits与标签形状问题-CSDN博客
  • Pytorch中BCELoss,BCEWithLogitsLoss和CrossEntropyLoss的区别_bcewithlogitsloss 与交叉熵在 多标签任务中得区别-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/949745.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

FinDKG: 用于检测金融市场全球趋势的动态知识图谱与大型语言模型

FinDKG: 用于检测金融市场全球趋势的动态知识图谱与大型语言模型

“FinDKG: Dynamic Knowledge Graphs with Large Language Models for Detecting Global Trends in Financial Markets” 论文地址：https://arxiv.org/pdf/2407.10909 摘要 动态知识图（DKG）能够表示对象间随时间变化的关系，适用于…
阅读更多...
Robot---奇思妙想轮足机器人

Robot---奇思妙想轮足机器人

1 背景 传统机器人有足式、轮式、履带式三种移动方式，每种移动方式都有各自的优缺点。轮式机器人依靠车轮在地面上移动，能源利用率高、移动速度快，但是仅以轮子与地面接触，缺乏越障能力和对复杂地形的适应能力，尤其面对…
阅读更多...
高效工作流：用Mermaid绘制你的专属流程图；如何在Vue3中导入mermaid绘制流程图

高效工作流：用Mermaid绘制你的专属流程图；如何在Vue3中导入mermaid绘制流程图

目录 高效工作流：用Mermaid绘制你的专属流程图 一、流程图的使用场景 1.1、流程图flowChart 1.2、使用场景 二、如何使用mermaid画出优雅的流程图 2.1、流程图添加图名 2.2、定义图类型与方向 2.3、节点形状定义 2.3.1、规定语法 2.3.2、不同节点案例 2.…
阅读更多...
.NET框架用C#实现PDF转HTML

.NET框架用C#实现PDF转HTML

HTML作为一种开放标准的网页标记语言，具有跨平台、易于浏览和搜索引擎友好的特性，使得内容能够在多种设备上轻松访问并优化了在线分享与互动。通过将PDF文件转换为HTML格式，我们可以更方便地在浏览器中展示PDF文档内容，同时也更容…
阅读更多...
Tableau数据可视化与仪表盘搭建-可视化原则及BI仪表盘搭建

Tableau数据可视化与仪表盘搭建-可视化原则及BI仪表盘搭建

目录 可视化原则 BI仪表盘搭建 仪表盘搭建原则 明确仪表盘主题 仪表盘主题拆解 开发设计工作表 经营情况总览：突出显示的文字 经营数据详情：表格 每日营收数据：多轴折线图 每日流量数据：双轴组合图 新老客占比&#xf…
阅读更多...
AIA - APLIC之三（附APLIC处理流程图）

AIA - APLIC之三（附APLIC处理流程图）

本文属于《 RISC-V指令集基础系列教程》之一，欢迎查看其它文章。 1 APLIC复位 APLIC复位后，其所有状态都变得有效且一致，但以下情况除外： 每个中断域的domaincfg寄存器（spec第 4.5.1 节）；可能是machine-level interrupt domain的MSI地址配置寄存器（spec第4.5.3 和4.5…
阅读更多...
unity学习5：创建一个自己的3D项目

unity学习5：创建一个自己的3D项目

目录 1 在unity里创建1个3D项目 1.1 关于选择universal 3d，built-in render pipeline的区别 1.2 创建1个universal 3d项目 2 打开3D项目 2.1 准备操作面板：操作界面 layout,可以随意更换 2.2 先收集资源：打开 window的 AssetStore 下载…
阅读更多...
AI赋能跨境电商：魔珐科技3D数字人破解出海痛点

AI赋能跨境电商：魔珐科技3D数字人破解出海痛点

跨境出海进入狂飙时代，AI应用正在深度渗透并重塑着跨境电商产业链的每一个环节，迎来了发展的高光时刻。生成式AI时代的大幕拉开，AI工具快速迭代，为跨境电商行业的突破与飞跃带来了无限可能性。 由于跨境电商业务自身特性鲜明&…
阅读更多...
我用Ai学Android Jetpack Compose之Text

我用Ai学Android Jetpack Compose之Text

这篇开始学习各种UI元素，答案来自 通义千问，通义千问没法生成图片，图片是我补充的。 下述代码只要复制到第一个工程，做一些import操作，一般import androidx.compose包里的东西，即可看到预览效果。完整工程代…
阅读更多...
HashMap总结使用+原理+面试

HashMap总结使用+原理+面试

文章目录 1.Hashmap的基本使用创建hashmap对象。遍历hashmap统计字母出现的次数用来投票计算返回JSON数据 2.hashmap源码阅读put源码阅读 3. HashMap 面试题目hashmap实现的原理什么时候数组需要进行扩容hashmap怎么确定把数据放到那个节点的哪个位置。为什么用 n - 1 与运算&a…
阅读更多...
JS中函数基础知识之查漏补缺(写给小白的学习笔记)

JS中函数基础知识之查漏补缺(写给小白的学习笔记)

函数 函数是ECMAScript中 最有意思的部分之一, 主要是因为函数实际上是对象.-- 每个函数 都是Function类型的实例,Function也有属性和方法. 因为函数是对象,所以函数名就是指向函数对象的指针. 常用的定义函数的语法: ①函数声明 ②函数表达式 ③箭头函数 function sum (n…
阅读更多...
Skyeye 云 VUE 版本 v3.15.3 发布，涉及 ERP、OA、财务等

Skyeye 云 VUE 版本 v3.15.3 发布，涉及 ERP、OA、财务等

Skyeye 云智能制造，采用 Springboot winUI 的低代码平台、移动端采用 UNI-APP。包含 30 多个应用模块、50 多种电子流程，CRM、PM、ERP、MES、ADM、EHR、笔记、知识库、项目、门店、商城、财务、多班次考勤、薪资、招聘、云售后、论坛、公告、问卷、报表…
阅读更多...
LInux单机安装Redis

LInux单机安装Redis

1. 安装gee工具包 由于Redis是基于c语言编写的所以安装的时候需要先安装gee以及gcc的依赖,yum云用不了可以看一下这个 linux 替换yum源镜像_更换yum镜像源-CSDN博客 yum install -y gcc tcl 2. 添加redis的压缩包 3. 上传到Linux 上传到 /usr/local/src 目录、这个目录一般用于…
阅读更多...
热备份路由HSRP及配置案例

热备份路由HSRP及配置案例

✍作者：柒烨带你飞 💪格言：生活的情况越艰难，我越感到自己更坚强；我这个人走得很慢，但我从不后退。 📜系列专栏：网路安全入门系列 目录 一，HSRP的相关概念二，…
阅读更多...
java开发springoot

java开发springoot

阅读理解 命令之间空一行：表示前面的是配置 红色背景：表示待验证蓝色背景：表示常用或推荐绿色背景：注意/推荐 json 转 对象 import com.fasterxml.jackson.databind.ObjectMapper; public DebangResp convertJsonToObject(Stri…
阅读更多...
gesp(C++一级)（17）洛谷：B4062：[GESP202412 一级] 温度转换

gesp(C++一级)（17）洛谷：B4062：[GESP202412 一级] 温度转换

gesp(C一级)（17）洛谷：B4062：[GESP202412 一级] 温度转换 题目描述 小杨最近学习了开尔文温度、摄氏温度和华氏温度的转换。令符号 K K K 表开尔文温度，符号 C C C 表摄氏温度，符号 F F F 表华氏温度&am…
阅读更多...
windows ping ssh

windows ping ssh

问题解决1：局域网内，为啥别人ping不到我的IP 问题解决2：ssh连接windows10拒绝连接 第一步：ssh使用的22端口，首先确认windows10的22端口是否开启。 –开启步骤 1.控制面板–>Windws Defender 防火墙–>高级设置…
阅读更多...
《Rust权威指南》学习笔记（二）

《Rust权威指南》学习笔记（二）

枚举enum 1.枚举的定义和使用如下图所示： 定义时还可以给枚举的成员指定数据类型，例如：enum IpAddr{V4(u8, u8, u8, u8),V6(String),}。枚举的变体都位于标识符的命名空间下，使用::进行分隔。 2.一个特殊的枚举Option&#xff0…
阅读更多...
科研绘图系列：R语言单细胞数据常见的可视化图形

科研绘图系列：R语言单细胞数据常见的可视化图形

禁止商业或二改转载，仅供自学使用，侵权必究，如需截取部分内容请后台联系作者! 文章目录 介绍加载R包数据下载导入数据数据预处理图1图2图3图4图5图6系统信息参考介绍 单细胞数据常见的可视化图形 因为本教程是单细胞数据，因此运行本画图脚本需要电脑的内存最少32Gb 加载…
阅读更多...
打造三甲医院人工智能矩阵新引擎（二）：医学影像大模型篇--“火眼金睛”TransUNet

打造三甲医院人工智能矩阵新引擎（二）：医学影像大模型篇--“火眼金睛”TransUNet

一、引言 1.1 研究背景与意义 在现代医疗领域，医学影像作为疾病诊断与治疗的关键依据，发挥着不可替代的作用。从传统的X射线、CT（计算机断层扫描）到MRI（磁共振成像）等先进技术，医学影像能够直观呈现人体内部结构，为医生提供丰富的诊断信息，涵盖疾病识别、病灶定位、…
阅读更多...
最新文章

Copyright @ 2022~2023