基于Pytorch框架构建ResNet模型

Pytorch

  • 一、训练模型
    • 1.导入资源包
    • 2.定义数据预处理
    • 3.读取数据
  • 二、定义卷积神经网络
    • 1.导入必要的库
    • 2.定义名为convolutional_block的卷积块类
    • 3.定义了一个名为identity_block的恒等块类
    • 4.定义了一个名为Resnet的深度卷积神经网络类
  • 三、创建模型
    • 1. 检查GPU设备
    • 2. 训练过程
  • 四、训练模型
    • 1. 设置模型为训练模式
    • 2.定义实验过程
    • 3.增加学习率调度器
  • 六、测试模型
    • 1.导入资源包
    • 2.定义数据预处理
  • 定义数据预处理
    • 3.自定义Resnet50模型
    • 4.实例化 Resnet50 类

一、训练模型

1.导入资源包

import torch.optim as optim: 导入PyTorch的优化工具包，其中包括了各种优化算法，如SGD、Adam等。
import torchvision.transforms as transforms: 导入PyTorch的视觉变换工具包，用于对图像进行预处理和变换，如调整大小、裁剪、归一化等。
from torchvision import models: 从torchvision模块中导入预训练的模型，如ResNet、AlexNet、VGG等。

from sched import scheduler
import torch.optim as optim
import torch
import torch.nn as nn
import torch.utils.data
import torchvision.transforms as transforms
import torchvision.datasets as datasets
from torch.utils.data import DataLoader
import torch.optim.lr_scheduler as lr_scheduler
import os
from torchvision import models

2.定义数据预处理

这些预处理操作的目的是为了增强模型的泛化能力，并确保模型在训练和验证时输入数据的格式一致。通过这些操作，模型能够接受不同尺寸、角度和方向的图像，从而提高其在实际应用中的表现。同时，归一化处理有助于稳定训练过程，加速模型收敛。，这些预处理操作的目的是为了增强模型的泛化能力，并确保模型在训练和验证时输入数据的格式一致。通过这些操作，模型能够接受不同尺寸、角度和方向的图像，从而提高其在实际应用中的表现。同时，归一化处理有助于稳定训练过程，加速模型收敛。

# 定义数据预处理
transform = {'train': transforms.Compose([transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),transforms.RandomRotation(degrees=15),transforms.RandomHorizontalFlip(),transforms.CenterCrop(size=224),transforms.ToTensor(),transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])]),'val': transforms.Compose([transforms.Resize(size=256),transforms.CenterCrop(size=224),transforms.ToTensor(),transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])])
}

3.读取数据

# 读取数据
dataset = './dataset'
train_directory = os.path.join(dataset, 'train')
valid_directory = os.path.join(dataset, 'val')batch_size = 32
num_classes = 2  # 修改为您的分类数data = {'train': datasets.ImageFolder(root=train_directory, transform=transform['train']),'val': datasets.ImageFolder(root=valid_directory, transform=transform['val'])
}train_loader = DataLoader(data['train'], batch_size=batch_size, shuffle=True, num_workers=8)
test_loader = DataLoader(data['val'], batch_size=batch_size, shuffle=False, num_workers=8)

注：这段代码的主要目的是读取和准备图像数据集，以便用于训练和验证深度学习模型，这段代码设置了数据加载器，它们将在训练和验证过程中提供经过预处理的图像数据。这些数据加载器是PyTorch中用于批量加载数据并使其易于迭代的重要工具。

二、定义卷积神经网络

1.导入必要的库

from torch.autograd import Variable: 从torch.autograd模块中导入Variable类。Variable是PyTorch中自动微分的关键类，它封装了张量，并提供了自动计算梯度等功能。然而，从PyTorch 0.4版本开始，Variable已经被整合到torch.Tensor中，因此不再需要显式地从torch.autograd中导入Variable。在最新的PyTorch版本中，直接使用torch.Tensor即可，它继承了Variable的所有功能。

# 神经网络
import torch
import torch.nn as nn
from torch.autograd import Variable

2.定义名为convolutional_block的卷积块类

这个convolutional_block类定义了一个卷积块，它将输入张量通过两个并行路径（step1和step2），然后将它们的结果相加，并应用ReLU激活函数。这种结构通常用于残差网络（ResNet）中，有助于解决深度网络训练过程中的梯度消失问题。

class convolutional_block(nn.Module):#convolutional_block层def __init__(self,cn_input,cn_middle,cn_output,s=2):super(convolutional_block,self).__init__()self.step1=nn.Sequential(nn.Conv2d(cn_input,cn_middle,(1,1),(s,s),padding=0,bias=False),nn.BatchNorm2d(cn_middle,affine=False),nn.ReLU(inplace=True),nn.Conv2d(cn_middle,cn_middle,(3,3),(1,1),padding=(1,1),bias=False),nn.BatchNorm2d(cn_middle,affine=False),nn.ReLU(inplace=True),nn.Conv2d(cn_middle,cn_output,(1,1),(1,1),padding=0,bias=False),nn.BatchNorm2d(cn_output,affine=False))self.step2=nn.Sequential(nn.Conv2d(cn_input,cn_output,(1,1),(s,s),padding=0,bias=False),nn.BatchNorm2d(cn_output,affine=False))self.relu=nn.ReLU(inplace=True)def forward(self,x):x_tmp=xx=self.step1(x)x_tmp=self.step2(x_tmp)x=x+x_tmpx=self.relu(x)return x

3.定义了一个名为identity_block的恒等块类

定义了一个名为identity_block的恒等块类，它也是nn.Module的子类。这个类实现了一个恒等块的构造和前向传播过程，它通常用于深度卷积神经网络（CNN）中，特别是在残差网络（ResNet）结构中。恒等块的主要特点是输入和输出之间有一个直接的联系（即残差连接），这有助于解决深度网络训练过程中的梯度消失问题。

class identity_block(nn.Module):#identity_block层
def __init__(self,cn,cn_middle):
super(identity_block,self).__init__()
self.step=nn.Sequential(nn.Conv2d(cn,cn_middle,(1,1),(1,1),padding=0,bias=False),nn.BatchNorm2d(cn_middle,affine=False),nn.ReLU(inplace=True),
nn.Conv2d(cn_middle,cn_middle,(3,3),(1,1),padding=1,bias=False),nn.BatchNorm2d(cn_middle,affine=False),nn.ReLU(inplace=True),
nn.Conv2d(cn_middle,cn,(1,1),(1,1),padding=0,bias=False),nn.BatchNorm2d(cn,affine=False))
self.relu=nn.ReLU(inplace=True)
def forward(self,x):
x_tmp=x
x=self.step(x)
x=x+x_tmp
x=self.relu(x)
return x

4.定义了一个名为Resnet的深度卷积神经网络类

class Resnet(nn.Module):#主层
def __init__(self,c_block,i_block):
super(Resnet,self).__init__()
self.conv=nn.Sequential(nn.Conv2d(3,64,(7,7),(2,2),padding=(3,3),bias=False),nn.BatchNorm2d(64,affine=False),nn.ReLU(inplace=True),nn.MaxPool2d((3,3),2,1))      
self.layer1=c_block(64,64,256,1)
self.layer2=i_block(256,64)
self.layer3=c_block(256,128,512)
self.layer4=i_block(512,128)
self.layer5=c_block(512,256,1024)
self.layer6=i_block(1024,256)
self.layer7=c_block(1024,512,2048)
self.layer8=i_block(2048,512)
self.out=nn.Linear(2048,2,bias=False)
self.avgpool=nn.AvgPool2d(7,7)def forward(self,input):
x=self.conv(input)
x=self.layer1(x)
for i in range(2):            
x=self.layer2(x)
x=self.layer3(x)
for i in range(3):
x=self.layer4(x)
x=self.layer5(x)
for i in range(5):
x=self.layer6(x)
x=self.layer7(x)
for i in range(2):
x=self.layer8(x)x=self.avgpool(x)
x=x.view(x.size(0),-1)
output=self.out(x)
return outputnet=Resnet(convolutional_block,identity_block).cuda()

注：这段代码定义了一个ResNet结构的深度学习模型，它可以用于图像分类任务。模型的结构是模块化的，可以通过调整卷积块和恒等块的数量和配置来适应不同的需求和数据集。最后，模型被移动到GPU上以加速训练和推理过程。

三、创建模型

1. 检查GPU设备

如果 GPU 可用，则定义一个 torch.device 对象，表示使用 GPU。如果 GPU 不可用，则定义一个 torch.device 对象，表示使用 CPU。

以下是函数的详细步骤：
1)检查 GPU 可用性:

  • if torch.cuda.is_available(): 这行代码检查是否有可用的 GPU 设备。

  • device = torch.device(‘cuda’): 如果 GPU 可用，则定义一个 torch.device 对象，表示使用 GPU。

  • print(“CUDA is available! Using GPU for training.”): 打印一条消息，表示 CUDA
    可用，并且使用 GPU 进行训练。

  • else: 如果 GPU 不可用，则执行以下代码。

2)使用 CPU 进行训练:

  • evice = torch.device(‘cpu’): 定义一个 torch.device 对象，表示使用 CPU。
  • print(“CUDA is not available. Using CPU for training.”): 打印一条消息，表示 CUDA 不可用，并且使用 CPU 进行训练。
# 首先，检查是否有可用的 GPU
if torch.cuda.is_available():# 定义 GPU 设备device = torch.device('cuda')print("CUDA is available! Using GPU for training.")
else:# 如果没有可用的 GPU，则使用 CPUdevice = torch.device('cpu')print("CUDA is not available. Using CPU for training.")

2. 训练过程

如果 GPU 可用，将模型移动到 GPU 上，并使用 GPU 进行训练；如果 GPU 不可用，则使用 CPU 进行训练。

3)将模型移动到 GPU:

  • model.to(device): 将模型移动到之前定义的 device 对象所表示的设备上。如果 device 是 ‘cuda’，则模型将被移动到 GPU；如果 device 是 ‘cpu’，则模型将被移动到 CPU。

4)定义损失函数:

  • criterion = nn.CrossEntropyLoss(): 定义交叉熵损失函数，这是用于分类问题的常见损失函数。

5)创建优化器:

  • optimizer = optim.Adam(Alex_model.parameters(), lr=0.001, weight_decay=1e-4): 创建Adam 优化器，其中 lr=0.001 表示学习率为 0.001，weight_decay=1e-4 表示权重衰减为 0.0001。
# 将模型移动到 GPU
model.to(device)# 定义损失函数
criterion = nn.CrossEntropyLoss()# 创建优化器
optimizer = optim.Adam(Alex_model.parameters(), lr=0.001, weight_decay=1e-4)

运行结果：
在这里插入图片描述

四、训练模型

1. 设置模型为训练模式

这个函数是训练过程中的核心部分，它执行了模型的前向传播、损失计算、反向传播和参数更新，以及定期输出训练进度和性能指标。

def train(model, device, train_loader, optimizer, epoch):
model.train()
running_loss = 0.0
correct = 0
total = 0
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
running_loss += loss.item()
_, predicted = torch.max(output.data, 1)
total += target.size(0)
correct += (predicted == target).sum().item()if batch_idx % 10 == 0:  # 每10个批次打印一次
print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item()}')print(f'Epoch {epoch}, Loss: {running_loss / len(train_loader)}, Accuracy: {100 * correct / total}%')

2.定义实验过程

这个函数是模型评估过程中的核心部分，它计算了模型在验证集上的损失和准确率，这些指标对于监控模型性能和调整训练策略非常重要。

# 定义验证过程
def val(model, device, test_loader, criterion):
model.eval()
running_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
loss = criterion(output, target)
running_loss += loss.item()
_, predicted = torch.max(output.data, 1)
total += target.size(0)
correct += (predicted == target).sum().item()print(f'Validation, Loss: {running_loss / len(test_loader)}, Accuracy: {100 * correct / total}%')

3.增加学习率调度器

通过训练和验证过程来优化模型参数，并使用学习率调度器来调整学习率，以提高模型的性能。在实际应用中，EPOCHS通常会设置为一个较大的值，以确保模型得到充分的训练。

# 创建优化器
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)# 创建学习率调度器
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)# 训练模型
EPOCHS = 1
for epoch in range(1, EPOCHS + 1):
train(model, device, train_loader, optimizer, epoch)
val(model, device, test_loader, criterion)
scheduler.step()  # 调整学习率

运行结果：
在这里插入图片描述

六、测试模型

1.导入资源包

torchvision.transforms：这个模块提供了一组图像转换操作，可以在数据加载时对图像进行预处理，例如调整大小、裁剪、翻转等。

import torch
from PIL import Image
import torchvision.transforms as transforms
from torchvision import models
from torch.autograd import Variable

2.定义数据预处理

定义图像的预处理步骤，并将使用GPU（如果可用）进行模型训练。在实际应用中，您需要根据自己的数据集和任务需求来调整这些参数。

定义数据预处理

transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])# 定义类别
classes = ['cat', 'dog']  # 替换为您的实际类别名称# 检查是否有可用的 GPU
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

3.自定义Resnet50模型

定义了一个自定义的ResNet-50模型，这是一个在图像识别任务中广泛使用的卷积神经网络（CNN）架构。代码中使用了一些简写，比如c_block和i_block，这些应该是在代码的其他部分定义的类，分别代表ResNet中的convolution block（卷积块）和identity block（恒等块）。

# 定义自定义的  Resnet50 模型
class Resnet(nn.Module):#主层
def __init__(self,c_block,i_block):
super(Resnet,self).__init__()
self.conv=nn.Sequential(nn.Conv2d(3,64,(7,7),(2,2),padding=(3,3),bias=False),nn.BatchNorm2d(64,affine=False),nn.ReLU(inplace=True),nn.MaxPool2d((3,3),2,1))      
self.layer1=c_block(64,64,256,1)
self.layer2=i_block(256,64)
self.layer3=c_block(256,128,512)
self.layer4=i_block(512,128)
self.layer5=c_block(512,256,1024)
self.layer6=i_block(1024,256)
self.layer7=c_block(1024,512,2048)
self.layer8=i_block(2048,512)
self.out=nn.Linear(2048,2,bias=False)
self.avgpool=nn.AvgPool2d(7,7)def forward(self,input):
x=self.conv(input)
x=self.layer1(x)
for i in range(2):            
x=self.layer2(x)
x=self.layer3(x)
for i in range(3):
x=self.layer4(x)
x=self.layer5(x)
for i in range(5):
x=self.layer6(x)
x=self.layer7(x)
for i in range(2):
x=self.layer8(x)x=self.avgpool(x)
x=x.view(x.size(0),-1)
output=self.out(x)
return output

4.实例化 Resnet50 类

用于加载预训练的ResNet-50模型，并使用该模型对上传的图片进行预测，image = Variable(image).to(DEVICE): 这一行将预处理后的图像转换为PyTorch变量（如果您的模型需要），并将其移动到DEVICE上。

# 实例化 Resnet50 类
model=Resnet(convolutional_block,identity_block).cuda()
# 加载权重
model.load_state_dict(torch.load("Resnet50.pth"))
model.to(DEVICE)
model.eval()# 定义预测函数
def predict_image(image_path):
# 打开图片
image = Image.open(image_path)
# 应用预处理
image = transform(image).unsqueeze(0)  # 添加batch维度
# 转换为Variable（如果模型需要）
image = Variable(image).to(DEVICE)
# 获取模型预测
output = model(image)
_, prediction = torch.max(output.data, 1)
return classes[prediction.item()]# 上传的图片路径
uploaded_image_path = '77.jpg'
# 进行预测
predicted_class = predict_image(uploaded_image_path)print(f"The uploaded image is predicted as: {predicted_class}")

运行结果：
在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

玄机平台流量特征分析—蚂蚁爱上树

玄机平台流量特征分析—蚂蚁爱上树

前言 依旧是流量分析，老规矩先看看要求。 步骤1.1 这里要求我们找到admin的密码，ctrlf筛选出product2.php的访问包，因为只有这类型流量包才有东西。其他的流量包都是没啥用的，至于我为啥知道，因为每个类型的流量包我…
阅读更多...
地信大四，实习重要吗？怎么找实习岗位?

地信大四，实习重要吗？怎么找实习岗位?

“地信怎么找实习啊？” “实习三个月以上？暑假只有两个月啊” “什么岗位实习比较有用？” “助理类岗位是做什么？” …… 同学们好啊，不知不觉24年已经是过完一小半了，24届毕业的同学们也差不多就要迎来…
阅读更多...
测试工程师如何学习系统架构

测试工程师如何学习系统架构

面对同一个“知识点”不同的工作角色需要考虑的问题不一样，比如在系统架构中会使用到消息队列功能，系统架构师，开发人员，测试人员，运维人员，需求人员等需要考虑的问题不一样。 系统架构师在考虑消息队列功能…
阅读更多...
数电大作业-四输入表决器

数电大作业-四输入表决器

（PCB和multisim仿真画的有很大问题，没有VCC输入和GND，没学过直接裸画的，之后会好好看视频学习） 应用背景： 四个评委，三个及以上评委同时按下通过按钮时，选手才能通过。否则不通过。…
阅读更多...
自动驾驶ADAS

自动驾驶ADAS

1 ToF摄像头分类 1.1 ToF原理 类似雷达测距，生成3D点云，或者叫3D贴图。ToF相机的分辨率一般在3万像素左右。ToF距离计算公式如图所示。 Figure 1-1 ToF距离计算公式 D：距离 c：光速 PHI：相位差 fmod：调制频率…
阅读更多...
创新指南｜品牌电商新策略：五大转型思路与RGM举措

创新指南｜品牌电商新策略：五大转型思路与RGM举措

在流量红利过去的背景下，品牌电商面对多渠道运营的难题，如缺乏统盘经营、绩效管理分散、价格战失控、用户体验不足以及流量过度依赖，品牌电商如何有效应对这些挑战，本文从5个维度探讨全渠道电商RGM破局之路，实现品牌的…
阅读更多...
pyppeteer模块经常使用的功能，相关操作案例

pyppeteer模块经常使用的功能，相关操作案例

官方仓库地址：https://github.com/miyakogi/pyppeteer 官方文档地址：API Reference — Pyppeteer 0.0.25 documentation Selenium环境的相关配置比较繁琐，此外，有的网站会对selenium和webdriver进行识别和反爬，因此在…
阅读更多...
【MySQL】数据库——事务

【MySQL】数据库——事务

一.事务概念 事务是一种机制、一个操作序列，包含了一组数据库操作命令，并且把所有的命令作为一个整体一起向系统提交或撤销操作请求，即这一组数据库命令要么都执行，要么都不执行事务是一个不可分割的工作逻辑单元，在数…
阅读更多...
【因果推断python】54_效应异质性和非线性带来的挑战2

【因果推断python】54_效应异质性和非线性带来的挑战2

目录 Continues Treatment and Non Linearity Key Concepts Continues Treatment and Non Linearity 我们只是深入探讨了二元结果增加异质性治疗效果分析难度的一个例子。但这种现象并不局限于市场营销中的转换问题。例如，2021 年，全球成功向公众提供了…
阅读更多...
深度学习 --- stanford cs231学习笔记五(训练神经网络的几个重要组成部分之三，权重矩阵的初始化)

深度学习 --- stanford cs231学习笔记五(训练神经网络的几个重要组成部分之三，权重矩阵的初始化)

权重矩阵的初始化 3，权重矩阵的初始化 深度学习所学习的重点就是要根据损失函数训练权重矩阵中的系数。即便如此，权重函数也不能为空，总是需要初始化为某个值。 3，1 全都初始化为同一个常数可以吗？ 首先要简单回顾一下…
阅读更多...
仿微信图片查看器`WPF`实现`ListBox` 鼠标滑动批量选中与反选效果

仿微信图片查看器`WPF`实现`ListBox` 鼠标滑动批量选中与反选效果

看到微信中，上传图片时的图片查看功能可以通过手指长按并滑动实现多选，于是为解析实现思路，也通过WPF 使用ListBox 实现了一版案例。 参考效果 微信效果如下，支持图片单选和鼠标长按滑动实现批量操作。 WPF模仿效果&#xff1a…
阅读更多...
Mysql: SQL-DDL

Mysql: SQL-DDL

一.SQL通用语法 1.SQL可以单行或者多行书写,以分号结尾。 2.SQL语句可以使用空格/缩进来增强语句的可读性。 3.MySQL数据库的SQL语句不区分大小写,关键字建议用大写。 4.注释: 单行注释:注释内容或#注释内容(Mysql特有) 多行注释：/*注释内容*/ 二.SQL分类 1.D…
阅读更多...
信息学奥赛初赛天天练-34-CSP-J2021完善程序-按位异或、模拟算法、数组模拟环、约瑟夫问题应用

信息学奥赛初赛天天练-34-CSP-J2021完善程序-按位异或、模拟算法、数组模拟环、约瑟夫问题应用

PDF文档公众号回复关键字:20240624 2021 CSP-J 完善程序3 1 完善程序 (单选题 ，每小题3分，共30分) （Josephus问题）有n个人围成一个圈，依次标号0至n-1。从0号开始，依次 0，1，0&#…
阅读更多...
0801功率放大问题

0801功率放大问题

3个学时讲一个电路（两个共集共集并联），4个问题，发展线索 丙类放大电路用在高频通讯行业，低频功放是甲类，乙类，甲乙类 PT三极管的损耗 Pv电源提供的功率 现代模电通常使用方法b 只有交流…
阅读更多...
用Vue3打造一个交互式营养追踪仪表盘

用Vue3打造一个交互式营养追踪仪表盘

本文由ScriptEcho平台提供技术支持 项目地址：传送门 使用 Vue.js 构建营养仪表盘卡片 应用场景介绍 营养仪表盘卡片是一个可视化工具，用于跟踪个人的营养摄入情况。它通常包含以下信息： 卡路里摄入目标和进度营养成分（如脂肪…
阅读更多...
2024中国·淮安高端人才精英赛北京分站赛首战告捷

2024中国·淮安高端人才精英赛北京分站赛首战告捷

“诚意满淮，创赢未来”！6月20-21日，2024中国淮安高端人才精英赛首场分站赛在北京产业创新中心顺利举办。淮安市科技局党组书记、局长胡长青，淮安市委组织部人才处处长沈雪娇，淮安经开区党工委委员、管委会副主任、科技…
阅读更多...
C++(part2、3-Linux系统编程+数据库项目)：Linux网络云盘

C++(part2、3-Linux系统编程+数据库项目)：Linux网络云盘

文章目录 一、项目需求分析1.一期：命令行解析(1)cd(用栈管理)、ls、pwd(2)puts、gets(3)mkdir、touch、rmdir、rm 2.二期：密码验证、日志、断点续传、大文件传输(1)密码验证(2)日志(3)断点续传(4)大文件传输 3.三期：用户注册、用户登录、虚拟…
阅读更多...
springboot+vue+mybatis穷游管理系统+PPT+论文+讲解+售后

springboot+vue+mybatis穷游管理系统+PPT+论文+讲解+售后

随着现在网络的快速发展，网上管理系统也逐渐快速发展起来，网上管理模式很快融入到了许多企业的之中，随之就产生了“基于vue的穷游管理系统”，这样就让基于vue的穷游管理系统更加方便简单。 对于本基于vue的穷游管理系统的设计来说…
阅读更多...
企业文件传输系统只能传输？分享功能同样重要！（下）

企业文件传输系统只能传输？分享功能同样重要！（下）

上篇我们讲述了企业大文件传输的重要性以及镭速在传输方面的优势，同时企业文件的快速共享显得尤为重要。镭速软件在这方面的表现一样尤为突出，它不仅提供了强大的文件传输功能，而且在文件分享方面也有其独到之处。本文将探讨镭速软件在文件分…
阅读更多...
协程: Flow 异步流 /

协程: Flow 异步流 /

以异步方式返回多个返回值的方案: 在 Kotlin 协程 Coroutine 中 , 使用 suspend 挂起函数 以异步的方式 返回单个返回值肯定可以实现 , 如果要 以异步的方式 返回多个元素的返回值 , 可以使用如下方案 : 集合序列Suspend 挂起函数Flow 异步流 同步调用返回多个值的弊端&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023