pytorch实现Unet模型

最新推荐文章于 2024-04-01 17:20:14 发布
最新推荐文章于 2024-04-01 17:20:14 发布
阅读量5.2k 收藏 15
点赞数 3
文章标签： python pytorch 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/all_bya/article/details/123782575
版权

自定义数据集

# -*- I Love Python!!! And You? -*-
# @Time    : 2022/3/27 12:25
# @Author  : sunao
# @Email   : 939419697@qq.com
# @File    : img_segData.py
# @Software: PyCharm
import matplotlib.pyplot as plt
import numpy as np
import torch
from PIL import Image
from torch.utils.data import Dataset,DataLoader
from torchvision import transforms
import torch.nn.functional as F
import os

class img_segData(Dataset):
	def __init__(self,img_h=256,img_w=256,path="./data/img_seg",data_file="images",label_file="profiles",
	             preprocess=True):
		'''
		数据集初始化
		:param img_h: resize图像高度
		:param img_w: resize图像宽度
		:param path: 数据集路径
		:param data_file: 数据特征值文件夹名称
		:param label_file: 数据标签文件夹名称
		:param preprocess: 是否进行数据预处理
		'''
		super(img_segData, self).__init__()
		self.file_list = os.listdir(path+"/"+data_file)
		self.data_file = data_file
		self.label_files = label_file
		self.path = path
		self.img_h = img_h
		self.img_w = img_w
		self.preprocess = preprocess
		pass
		
		
	def __len__(self):
		# 返回数据集大小
		return len(self.file_list)
		
	
	def __getitem__(self, item):
		# 返回指定索引的数据集
		img_name = self.file_list[item]
		label_name = img_name.split(".")[0]+"-profile.jpg"
		label_path = self.path+"/"+self.label_files+"/"+label_name
		img_path = self.path+"/"+self.data_file+"/"+img_name
		
		# 读取数据
		img = Image.open(img_path)
		label = Image.open(label_path)
		
		# 数据预处理
		if self.preprocess:
			trans_img = transforms.Compose([
				transforms.Resize(size=(self.img_w,self.img_h)),
				transforms.ToTensor(),
				transforms.Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))
			])
			img = trans_img(img)
			trans_label = transforms.Compose([
				transforms.Resize(size=(self.img_w,self.img_h)),
				transforms.ToTensor(),
			])
			label = trans_label(label)
		return img,label



if __name__ == '__main__':
	trans_data = img_segData()
	img,label = trans_data.__getitem__(5)
	print(img.size(),label.size())
	
	# plt.imshow(img.data.numpy().transpose([1,2,0]))
	# plt.show()
	# plt.imshow(label.data.numpy().reshape(256,256))
	# plt.show()
	label = torch.where(label==1,torch.full_like(label,0),torch.full_like(label,1))
	seg = label * img
	plt.imshow(seg.data.numpy().transpose([1,2,0]))
	plt.show()

模型

# -*- I Love Python!!! And You? -*-
# @Time    : 2022/3/27 13:02
# @Author  : sunao
# @Email   : 939419697@qq.com
# @File    : model.py
# @Software: PyCharm

import torch
import torch.nn as nn
import torch.nn.functional as F


class conv_block(nn.Module):
	def __init__(self,ch_in,ch_out):
		super(conv_block, self).__init__()
		self.conv = nn.Sequential(
			nn.Conv2d(in_channels=ch_in, out_channels=ch_out, kernel_size=3, stride=1, padding=1),
			nn.BatchNorm2d(ch_out),
			nn.ReLU(inplace=True),
			nn.Conv2d(in_channels=ch_out,out_channels=ch_out,kernel_size=3,stride=1,padding=1),
			nn.BatchNorm2d(ch_out),
			nn.ReLU(inplace=True),
		)
		
	def forward(self,x):
		out = self.conv(x)
		return out
	
class up_block(nn.Module):
	def __init__(self,ch_in,ch_out):
		super(up_block, self).__init__()
		self.conv = nn.Sequential(
			nn.Upsample(scale_factor=2),
			nn.Conv2d(in_channels=ch_in,out_channels=ch_out,kernel_size=3,stride=1,padding=1),
			nn.BatchNorm2d(ch_out),
			nn.ReLU(inplace=True),
		)
		
	def forward(self,x):
		out = self.conv(x)
		return out
	
class U_Net(nn.Module):
	def __init__(self,img_ch=3,output_ch=1):
		super(U_Net, self).__init__()
		self.ndf=64
		self.Maxpool = nn.MaxPool2d(2,2)
		self.conv1 = conv_block(ch_in=img_ch,ch_out=self.ndf)
		self.conv2 = conv_block(ch_in=self.ndf,ch_out=self.ndf * 2)
		self.conv3 = conv_block(ch_in=self.ndf*2,ch_out=self.ndf*2*2)
		self.conv4 = conv_block(ch_in=self.ndf*2*2,ch_out=self.ndf*2*2*2)
		self.conv5 = conv_block(ch_in=self.ndf*2*2*2,ch_out=self.ndf*2*2*2*2)
		
		self.up4 = up_block(ch_in=self.ndf*2*2*2*2,ch_out=self.ndf*2*2*2)
		self.up_conv4 = conv_block(ch_in=self.ndf*2*2*2*2,ch_out=self.ndf*2*2*2)
		
		self.up3 = up_block(ch_in=self.ndf*2*2*2,ch_out=self.ndf*2*2)
		self.up_conv3 = conv_block(ch_in=self.ndf*2*2*2,ch_out=self.ndf*2*2)
		
		self.up2 = up_block(ch_in=self.ndf*2*2,ch_out=self.ndf*2)
		self.up_conv2 = conv_block(ch_in=self.ndf*2*2,ch_out=self.ndf*2)
		
		self.up1 = up_block(ch_in=self.ndf*2,ch_out=self.ndf)
		self.up_conv1 = conv_block(ch_in=self.ndf * 2, ch_out=self.ndf)
		
		self.conv1_1 = conv_block(ch_in=self.ndf,ch_out=output_ch)
		
	def forward(self,x):
		# x [none,3, 256, 256]
		x1 = self.conv1(x) # [none,3,256,256]
		
		x1_ = self.Maxpool(x1) # [none,64,128,128]
		x2 = self.conv2(x1_) # [none,128,128,128]
		
		x2_ = self.Maxpool(x2) # [none,128,64,64]
		x3 = self.conv3(x2_) # [none,256,64,64]
		
		x3_ = self.Maxpool(x3) # [none,256,32,32]
		x4 = self.conv4(x3_) # [none,512,32,32]
		
		x4_ = self.Maxpool(x4)  # [none,512,16,16]
		x5 = self.conv5(x4_)  # [none,1024,16,16]
		
		u4_ = self.up4(x5) # [none,1024,32,32]
		u4 = self.up_conv4(torch.cat([x4,u4_],dim=1)) # [none,512,32,32]
		
		u3_ = self.up3(u4) # [none,512,64,64]
		u3 = self.up_conv3(torch.cat([x3,u3_],dim=1)) # [none,256,64,64]
		
		u2_ = self.up2(u3) # [none,256,128,128]
		u2 = self.up_conv2(torch.cat([x2,u2_],dim=1)) # [none,128,128,128]
		
		u1_ = self.up1(u2) # [none,128,256,256]
		u1 = self.up_conv1(torch.cat([x1,u1_],dim=1)) # [none,64,256,256]
		
		out = self.conv1_1(u1)  # [none,1,256,256]
		out = torch.sigmoid(out)
		return out
		




if __name__ == '__main__':
	unet = U_Net()
	print(unet)

训练模型

# -*- I Love Python!!! And You? -*-
# @Time    : 2022/3/27 15:34
# @Author  : sunao
# @Email   : 939419697@qq.com
# @File    : img2seg.py
# @Software: PyCharm

import numpy as np
import matplotlib.pyplot as plt
import torchvision
from img_segData import img_segData
from model import U_Net
from torch.utils import data
import torch
import os
from torchvision.utils import save_image

class Trainer(object):
	def __init__(self,img_ch=3,out_ch=3,lr=0.005,
	             batch_size=16,num_epoch=60,train_set=None,
	             model_path="./model"):
		"""
		训练器初始化
		:param img_ch: 输入图片通道
		:param out_ch: 输出图片通道
		:param lr: 学习率
		:param batch_size: 批量大小
		:param num_epoch: 迭代周期
		:param train_set: 训练数据集
		:param model_path: 模型保存路径
		"""
		self.img_ch = img_ch
		self.out_ch = out_ch
		self.lr = lr
		self.batch_size = batch_size
		self.num_epoch = num_epoch
		self.model_path = model_path
		self.data_loader = data.DataLoader(dataset=train_set,
		                                   batch_size=self.batch_size,
		                                   shuffle=True,num_workers=0)
		
		# 初始化模型
		self.unet = U_Net(self.img_ch,output_ch=self.out_ch)
		self.divice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
		self.unet.to(self.divice)
		self.loss = torch.nn.BCELoss()
		self.optim = torch.optim.Adam(self.unet.parameters(),lr=self.lr,betas=(0.5,0.99))
		
	def train(self):
		
		if os.path.exists(self.model_path):
			self.unet.load_state_dict(torch.load(self.model_path+"/Unet.pkl"))
			print("模型导入成功",self.model_path+"/Unet.pkl")
		
		
		
		best_loss = 1000000
		
		for epoch in range(self.num_epoch):
			self.unet.train(True)
			epoch_loss = 0
			for i,(bx,by) in enumerate(self.data_loader):
				bx = bx.to(self.divice)
				by = by.to(self.divice)
				
				bx_gen = self.unet(bx)
				loss = self.loss(bx_gen,by)
				self.optim.zero_grad()
				loss.backward()
				self.optim.step()
				epoch_loss += loss.item()
				
			print("| epoch %d/%d | loss %f |"%(epoch,self.num_epoch,epoch_loss))
			self.save_img(save_name="epoch"+str(epoch)+".png")
			if best_loss > epoch_loss:
				best_loss = epoch_loss
				if os.path.exists(self.model_path) is False:
					os.makedirs(self.model_path)
				torch.save(self.unet.state_dict(),self.model_path+"/Unet.pkl")
				
				
	
	def save_img(self,save_path="./saved/Unet",save_name="result.png"):
		data_iter = iter(self.data_loader)
		img,labels = next(data_iter)
		self.unet.eval()
		with torch.no_grad():
			bx_gen = self.unet(img.to(self.divice))
			
		img = img.data.cpu()[:5]
		print("img.shape ===",img.shape)
		gen_label = bx_gen.data.cpu()[:5]
		labels = labels.data.cpu()[:5]
		
		gen_label = torch.where(gen_label>0.5,torch.full_like(gen_label,0),
		                        torch.full_like(gen_label,1))
		print("gen_label.shape ===",gen_label.shape)
		labels = torch.where(labels>0.5,torch.full_like(labels,0),
		                     torch.full_like(labels,1))
		
		gen_label = torch.zeros([3,256,256]) + gen_label
		seg_img = img * gen_label
		# 0黑色，255白色
		seg_img = torch.where(seg_img==0,torch.full_like(seg_img,255),seg_img)
		seg_img2 = img * labels
		seg_img2 = torch.where(seg_img==0,torch.full_like(seg_img2,255),seg_img2)
		print(seg_img2.shape)
		save_tensor = torch.cat([img,gen_label,seg_img,seg_img2],0)
		if os.path.exists(save_path) is False:
			os.makedirs(save_path)
		save_image(save_tensor,save_path+'/'+save_name,nrow=5)
		



if __name__ == '__main__':
	# 读取数据
	torch.cuda.empty_cache()
	train_data = img_segData(img_h=256,img_w=256,path="./data/img_seg",data_file="images",
	                         label_file="profiles",preprocess="True")
	# 构建模型，训练模型
	trainer = Trainer(img_ch=3,out_ch=1,lr=0.01,batch_size=16,num_epoch=50,train_set=train_data)
	trainer.train()
语音不识别
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
基于Pytorch的UNet语义分割模型与代码
12-26
模型在FloodNet数据集上进行了训练，mIOU在0.83左右，可训练自己的数据集 建议在训练网络的时候将输入的训练集其切分为384x384的小图片后，再来进行训练 模型采用标准的UNet，可以采用如下方式训练你自己的模型 数据集地址可以在train.py中修改为你自己的文件夹 python train.py -- --epochs 20 --batch-size 16 --learning-rate 2e-4 --scale 1 --validation 0.1 --classes 10 --amp 其中--amp为半精度训练 --scale是训练的时候对图片进行缩放，已经裁剪为384x384后就不需要再裁剪了
Pytorch 搭建自己的Unet语义分割平台
weixin_42483745的博客
05-01 2262
文章目录前言Unet实现思路一、预测部分1、主干网络介绍2、加强特征提取结构3、利用特征获得预测结果二、训练部分1、训练文件详解2、LOSS解析训练自己的Unet模型一、数据集的准备二、数据集的处理三、开始网络训练四、训练结果预测 前言 Unet是一个优秀的语义分割模型，其主要执行过程与其它语义分割模型类似。 Unet可以分为三个部分，如下图所示： 第一部分是主干特征提取部分，我们可以利用主干部分获得一个又一个的特征层，Unet的主干特征提取部分与VGG相似，为卷积和最大池化的堆叠。利用主干特征提取部分我
【PyTorch 实战2：UNet 分割模型】10min揭秘 UNet 分割网络如何工作以及pytorch代码实现（详细代码实现）
最新发布
xiaoh_7的博客
04-01 2301
U-Net，自2015年诞生以来，便以其卓越的性能在分割领域崭露头角。我们详细介绍了如何使用PyTorch实现并训练一个U-Net模型，以及如何在训练和推理阶段使用它。
语义分割系列2-Unet（pytorch实现）
yumaomi的博客
05-13 7059
本文详细介绍了Unet的网络结构和论文思路，在pytorch框架上复现了Unet结构，在Camvid数据集上进行测试。
Unet——pytorch
m0_73901376的博客
04-22 2557
以往的网络模型依赖于大量的数据集进行训练，但是在医学图像的分割中，往往能够训练的数据相对较小而检测目标又会比较大，在unet网络中使用了数据增强；是为了解决生物医学图像方面的问题，最初也是在细胞数据集上使用的，由于效果确实很好后来也被广泛的应用在语义分割的各个方向，比如卫星图像分割，工业瑕疵检测等。U-Net的结构是用编码和解码，它左边和右边很类似（完全对称），U形的左侧是一个编码的过程，右侧是一个解码的过程。3，在训练过程中使用高梯度下降，这使得训练模型的学习率处在一个自我调节的过程中；
Pytorch深度学习实战教程（二）：UNet语义分割网络
AI研习社
12-28 2171
1前言本文属于Pytorch深度学习语义分割系列教程。该系列文章的内容有：Pytorch的基本使用语义分割算法讲解如果不了解语义分割原理以及开发环境的搭建，请看该系列教程的上一篇文章《Py...
Transformer-Unet:使用变压器编码器的Unet实现
03-05
变压器-Unet 使用变压器编码器的Unet实现
UNet（PyTorch）图像语义分割实战：训练自己的数据集
11-13
UNet是一种基于深度学习的图像语义分割方法，尤其在医学图像分割中表现优异。 本课程将手把手地教大家使用labelme图像标注工具制作自己的数据集，生成Mask图像，并使用PyTorch版UNet训练自己的数据集，从而能开展自己的图像分割应用。 本课程有两个项目实践： (1) Kaggle盐体识别比赛 ：利用PyTorch版UNet进行Kaggle盐体识别 (2) Pothole语义分割：对汽车行驶场景中的路坑进行标注和PyTorch版UNet语义分割 本课程使用PyTorch版本的UNet，在Ubuntu系统上用Jupyter Notebook做项目演示。 包括：数据集标注、数据集格式转换和Mask图像生成、编写UNet程序文件、训练自己的数据集、测试训练出的网络模型、性能评估。项目代码也可在Windows上运行，课程提供Windows环境搭建方法。本课程提供项目的数据集和Python程序代码。
pytorch快速入门与实战——三、Unet实现
无衣的博客
03-14 1万+
pytorch快速入门与实战——三、UNet适应输入AdUnet实现
Pytorch实战系列（一）——CNN之UNet代码解析
热门推荐
JeasunLok的博客
10-14 1万+
UNet网络结构及其编码详解
pytorch学习--UNet模型
qq_51363161的博客
07-13 4800
详细Unet网络结构可以查看Unet算法原理详解深度网络训练之中需要大量的有标样本，Unet作者提供了一种新的训练方法，可以更有效的运用相应的有标样本，使网络即使通过少量的训练图片也可以进行更精确的分割。这里只是记录一下近期在网站资源上学到的Unet模型项目的代码，代码中有较详细的解释（学习笔记）代码来源：GitHub - qiaofengsheng/pytorch-UNet: pytorch搭建自己的unet网络，训练自己的数据集。 B站视频地址全程带你手撸代码：https://www.bilibili.
unet-onnx工程原始模型下载
09-28
https://github.com/cagery/unet-onnx/tree/main 开源链接下载不了原始模型unet_carvana_scale1_epoch5.pth，使用git lfs下载也提示报错，最后各种找资源找到了，上传一份，供大家测试使用
Swin-Unet pytorch代码
05-01
Swin-Unet pytorch代码
unet 细胞分割 pytorch 模板（多分类也能用）
03-31
unet 细胞分割 pytorch 模板（多分类也能用）
pycharm运行scrapy过程图解
09-18
主要介绍了pycharm运行scrapy过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
PyTorch-UNet:UNet模型的PyTorch实现-https
05-16
U-Net-PyTorch实施模型（一种流行的图像分割网络）的实现。 这是非常稳定和可配置的，我已经在多个数据集中使用了它，并将其作为几个项目的组成部分。 更新：还支持基于的3-D卷的分段更新：所有批次归一化操作已被...
Pytorch-Unet
03-20
UNet：使用PyTorch进行语义分割在PyTorch中自定义实施以应对Kaggle的高清图像。该模型从头开始使用5000张图像进行了训练（无数据增强），并且在超过100k张测试图像上获得了0.988423的（735中的511分）。可以通过更多...
Pytorch下实现Unet对自己多类别数据集的语义分割
01-11
Unet通常应用到单类别的语义分割，经过调整后该代码适合于多类别的语义分割。对应博客：https://blog.csdn.net/brf_UCAS/article/details/112383722
portrait-matting-unet-flask：使用PyTorch在UNet中实现人像匹配
02-05
使用PyTorch在UNet中实现人像匹配。 细分演示结果： 哑光演示结果： 为了方便演示，我通过Flask构建了API服务，最后将其部署在微信小程序中。 微信小程序的代码部分在此处。 依存关系 Python 3.6 PyTorch> = 1.1.0...
使用pytorch实现unet
06-10
好的，下面是一个使用PyTorch实现的简单的UNet模型。 首先，需要安装PyTorch库。可以使用以下命令进行安装： ``` pip install torch ``` 然后，我们可以定义一个UNet模型。 ```python import torch import torch.nn as nn class DoubleConv(nn.Module): def __init__(self, in_channels, out_channels): super(DoubleConv, self).__init__() self.conv = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True) ) def forward(self, x): return self.conv(x) class Up(nn.Module): def __init__(self, in_channels, out_channels): super(Up, self).__init__() self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2) self.conv = DoubleConv(in_channels, out_channels) def forward(self, x1, x2): x1 = self.up(x1) diffX = x2.size()[2] - x1.size()[2] diffY = x2.size()[3] - x1.size()[3] x1 = nn.functional.pad(x1, (diffX // 2, diffX - diffX // 2, diffY // 2, diffY - diffY // 2)) x = torch.cat([x2, x1], dim=1) return self.conv(x) class UNet(nn.Module): def __init__(self, n_channels, n_classes): super(UNet, self).__init__() self.inc = DoubleConv(n_channels, 64) self.down1 = nn.Sequential(nn.MaxPool2d(2), DoubleConv(64, 128)) self.down2 = nn.Sequential(nn.MaxPool2d(2), DoubleConv(128, 256)) self.down3 = nn.Sequential(nn.MaxPool2d(2), DoubleConv(256, 512)) self.down4 = nn.Sequential(nn.MaxPool2d(2), DoubleConv(512, 1024)) self.up1 = Up(1024, 512) self.up2 = Up(512, 256) self.up3 = Up(256, 128) self.up4 = Up(128, 64) self.outc = nn.Conv2d(64, n_classes, kernel_size=1) def forward(self, x): x1 = self.inc(x) x2 = self.down1(x1) x3 = self.down2(x2) x4 = self.down3(x3) x5 = self.down4(x4) x = self.up1(x5, x4) x = self.up2(x, x3) x = self.up3(x, x2) x = self.up4(x, x1) return self.outc(x) ``` 在这个模型中，我们首先定义了一个双卷积层（DoubleConv）和一个上采样层（Up），然后将它们组合起来构建了一个UNet模型。UNet模型用于图像分割，将输入图像分割成多个部分，每个部分都对应着一个特定的标签。UNet模型的结构类似于自编码器，由一个下采样器和一个上采样器组成。下采样器用于提取特征，上采样器用于将特征图恢复到原始图像大小，并将特征图与下采样器对应的特征图进行特征融合。 接下来，我们可以定义一个函数来训练这个模型。 ```python def train(model, train_loader, val_loader, criterion, optimizer, n_epochs=10): for epoch in range(n_epochs): train_loss = 0 val_loss = 0 model.train() for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() train_loss += loss.item() model.eval() with torch.no_grad(): for batch_idx, (data, target) in enumerate(val_loader): output = model(data) loss = criterion(output, target) val_loss += loss.item() train_loss /= len(train_loader.dataset) val_loss /= len(val_loader.dataset) print('Epoch: {} Train Loss: {:.6f} Val Loss: {:.6f}'.format( epoch + 1, train_loss, val_loss)) ``` 在训练函数中，我们首先循环训练数据集，计算损失并更新模型参数。然后我们循环验证数据集，计算损失并输出训练和验证损失。 接下来，我们可以定义一个函数来测试这个模型。 ```python def test(model, test_loader): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: output = model(data) test_loss += criterion(output, target).item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print('Test Loss: {:.6f} Test Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) ``` 在测试函数中，我们首先将模型设置为评估模式，然后循环测试数据集，计算损失并输出测试精度。 最后，我们可以定义一个函数来进行训练和测试的循环。 ```python def train_and_test(model, train_loader, val_loader, test_loader, criterion, optimizer, n_epochs=10): for epoch in range(n_epochs): train(model, train_loader, val_loader, criterion, optimizer, n_epochs) test(model, test_loader) model = UNet(n_channels=3, n_classes=2) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() train_and_test(model, train_loader, val_loader, test_loader, criterion, optimizer, n_epochs=10) ``` 在这个函数中，我们首先定义了一些超参数，包括训练轮数、优化器和损失函数。然后我们循环训练和测试模型，并在每个epoch结束后输出测试结果。 这就是一个简单的基于PyTorch的UNet模型。当然，这里只是给出了一个简单的实现，还可以进行更多的优化和改进，例如使用更复杂的模型、使用预训练模型等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

语音不识别

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

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

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

打赏作者

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

抵扣说明：

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

余额充值