PyTorch应用实战三：构建神经网络

文章目录

  • 神经网络
  • 1.继承Module构建神经网络
  • 2.结构化构建神经网络
  • 3.函数式操作
  • 附：系列文章

神经网络

构建神经网络的一般步骤如下：

  1. 确定网络的结构：这包括输入层、输出层和隐藏层的数量以及每层中的节点数等。

  2. 收集和准备数据：这包括收集训练数据、清洗数据、转换数据格式等。

  3. 初始化权重：权重是神经元之间的连接强度，需要在训练前随机初始化。

  4. 前向传播计算：根据输入数据和权重计算输出结果。

  5. 计算损失函数：损失函数衡量预测输出和真实输出之间的误差。

  6. 反向传播计算：反向传播是一种优化算法，用于调整权重以最小化损失函数。

  7. 更新权重：根据反向传播算法计算出的梯度更新权重，以优化模型。

  8. 重复以上步骤：反复执行前向传播和反向传播，调整权重，直到损失函数收敛。

  9. 测试和评估模型：使用测试数据集对模型进行评估和测试。

  10. 使用模型进行预测：使用已训练的模型对新数据进行预测。

1.继承Module构建神经网络

构建神经网络

import torch
import torch.nn as nn
from torch import optim
from torchvision import datasets, transforms
from torch.nn.functional import conv2d, cross_entropy 
class SimpleCNN(nn.Module):def __init__(self, in_channel=1):super(SimpleCNN, self).__init__()self.conv1 = nn.Conv2d(in_channel, 4, 5, 2, 0)self.relu1 = nn.ReLU()self.conv2 = nn.Conv2d(4, 8, 3, 2, 0)self.relu2 = nn.ReLU()self.linear = nn.Linear(200, 10)def forward(self, x):x = self.conv1(x)x = self.relu1(x)x = self.conv2(x)x = self.relu2(x)x = x.view(-1, 200)x = self.linear(x)return x

这个程序定义了一个简单的CNN模型 SimpleCNN，用于进行图像分类任务。它包含以下几个部分：

  1. 导入所需的 PyTorch 模块。这些模块是 torch、nn、optim、datasets、transforms 和 nn.functional。
  2. 定义了一个名为 SimpleCNN 的类，继承了 nn.Module。
  3. 在 __init__ 函数中定义模型的结构。这个模型包含两层卷积层和一个全连接层：
    • 第1层卷积层：输入通道数为 in_channel，输出通道数为 4，卷积核大小为 5x5，步长为 2，填充为 0。
    • 第1个ReLU激活函数：将卷积层的输出进行非线性变换。
    • 第2层卷积层：输入通道数为 4，输出通道数为 8，卷积核大小为 3x3，步长为 2，填充为 0。
    • 第2个ReLU激活函数：再次对卷积层的输出进行非线性变换。
    • 平铺层：将卷积层的输出展成一维向量。
    • 全连接层：输入大小为 200，输出大小为 10，用于输出分类结果。
  4. 在 forward 函数中实现模型的前向传播过程。将输入 x 依次经过卷积层、ReLU激活函数、卷积层、ReLU激活函数和全连接层处理，最终输出分类结果。
#测试
model = SimpleCNN()
data = torch.randn(3, 1, 28, 28)
output = model(data)
output.shape

torch.Size([3, 10])

卷积层计算

(28-5)/2+1=12
(12-3)/2+1=5

3×1×28×28
3×4×12×12
3×8×5×5
3×200
3×10

神经网络模型

model

SimpleCNN((conv1): Conv2d(1, 4, kernel_size=(5, 5), stride=(2, 2))(relu1): ReLU()(conv2): Conv2d(4, 8, kernel_size=(3, 3), stride=(2, 2))(relu2): ReLU()(linear): Linear(in_features=200, out_features=10, bias=True)
)

for key, value in model._modules.items():print(key, value)

conv1 Conv2d(1, 4, kernel_size=(5, 5), stride=(2, 2))
relu1 ReLU()
conv2 Conv2d(4, 8, kernel_size=(3, 3), stride=(2, 2))
relu2 ReLU()
linear Linear(in_features=200, out_features=10, bias=True)

model = SimpleCNN()
model.parameters()for p in model.parameters():print(p.shape)

torch.Size([4, 1, 5, 5])
torch.Size([4])
torch.Size([8, 4, 3, 3])
torch.Size([8])
torch.Size([10, 200])
torch.Size([10])

导入数据集

train_batch_size = 100  #一共60000个数据,100个数据一组,一共600组(N=100)
test_batch_size = 100   #一共10000个数据,100个数据一组,一共100组(N=100)
# 训练集
train_loader = torch.utils.data.DataLoader(datasets.MNIST('./data',train=True,download=True,  transform=transforms.Compose([transforms.ToTensor(),  #转为tensortransforms.Normalize((0.5),(0.5)) #正则化])),batch_size = train_batch_size, shuffle=True  #打乱位置
)
# 测试集
test_loader = torch.utils.data.DataLoader(datasets.MNIST('./data',train=False,download=True,transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5),(0.5))])),batch_size = test_batch_size, shuffle=False
)

这段代码主要用于加载 MNIST 数据集，并生成对应的数据加载器 train_loader 和 test_loader。具体包含以下几个步骤：

  1. 定义训练集的批次大小 train_batch_size，设为 100。
  2. 定义测试集的批次大小 test_batch_size，也设为 100。
  3. 调用 torch.utils.data.DataLoader 函数生成训练集加载器 train_loader，加载器将使用 datasets.MNIST 函数加载 MNIST 数据集，并进行以下操作：
    • 设置 MNIST 数据集的路径为 ./data。
    • 将数据集设置为训练集，下载数据集。
    • 对数据进行 transforms.Compose 序列变换操作，包括：
      • transforms.ToTensor()：将数据转为 Tensor 类型。
      • transforms.Normalize((0.5),(0.5))：将数据进行正则化。
    • 将训练集数据划分为大小为 train_batch_size 的批次，进行随机打乱。
  4. 调用 torch.utils.data.DataLoader 函数生成测试集加载器 test_loader，加载器将使用 datasets.MNIST 函数加载 MNIST 数据集，并进行相同的处理流程，但测试集不需要随机打乱。

这样生成的 train_loader 和 test_loader 可以用于对数据进行批量加载，方便后续的模型训练和评估。

训练测试

alpha = 0.1  #学习率
epochs = 100  #训练次数
interval = 100  #打印间隔
for epoch in range(epochs):optimizer = optim.SGD(model.parameters(), lr=0.1)for i, (data, label) in enumerate(train_loader):output = model(data)optimizer.zero_grad()  #梯度归零loss = cross_entropy(output, label)  #交叉熵函数loss.backward()   #反向求导optimizer.step()  #更新参数if i % interval == 0:print("Epoch %03d [%03d/%03d]\tLoss:%.4f"%(epoch, i, len(train_loader), loss.item()))correct_num = 0total_num = 0with torch.no_grad():for data, label in test_loader:output = model(data)pred = output.max(1)[1]correct_num += (pred == label).sum().item()total_num += len(data)acc = correct_num / total_numprint('...Testing @ Epoch %03d\tAcc:%.4f'%(epoch, acc))

Epoch 000 [000/600]	Loss:2.2848
Epoch 000 [100/600]	Loss:0.4144
Epoch 000 [200/600]	Loss:0.2014
Epoch 000 [300/600]	Loss:0.2790
Epoch 000 [400/600]	Loss:0.1858
Epoch 000 [500/600]	Loss:0.1649
...Testing @ Epoch 000	Acc:0.9538
Epoch 001 [000/600]	Loss:0.1593
Epoch 001 [100/600]	Loss:0.2436
Epoch 001 [200/600]	Loss:0.0649
Epoch 001 [300/600]	Loss:0.2830
Epoch 001 [400/600]	Loss:0.1208
Epoch 001 [500/600]	Loss:0.0937
...Testing @ Epoch 001	Acc:0.9678
Epoch 002 [000/600]	Loss:0.1210
Epoch 002 [100/600]	Loss:0.0737
Epoch 002 [200/600]	Loss:0.0857
Epoch 002 [300/600]	Loss:0.0712
Epoch 002 [400/600]	Loss:0.2700
Epoch 002 [500/600]	Loss:0.0849
...Testing @ Epoch 002	Acc:0.9708
Epoch 003 [000/600]	Loss:0.1094
Epoch 003 [100/600]	Loss:0.0727
Epoch 003 [200/600]	Loss:0.1756
Epoch 003 [300/600]	Loss:0.1473
Epoch 003 [400/600]	Loss:0.1013
Epoch 003 [500/600]	Loss:0.0879
...Testing @ Epoch 003	Acc:0.9741
Epoch 004 [000/600]	Loss:0.1503
Epoch 004 [100/600]	Loss:0.0832
Epoch 004 [200/600]	Loss:0.0731
Epoch 004 [300/600]	Loss:0.1040
Epoch 004 [400/600]	Loss:0.0720
Epoch 004 [500/600]	Loss:0.0490
...Testing @ Epoch 004	Acc:0.9745
Epoch 005 [000/600]	Loss:0.0720
Epoch 005 [100/600]	Loss:0.1124
Epoch 005 [200/600]	Loss:0.0674
Epoch 005 [300/600]	Loss:0.0477
Epoch 005 [400/600]	Loss:0.1164
Epoch 005 [500/600]	Loss:0.0662
...Testing @ Epoch 005	Acc:0.9758
Epoch 006 [000/600]	Loss:0.0445
Epoch 006 [100/600]	Loss:0.0500
Epoch 006 [200/600]	Loss:0.0236
Epoch 006 [300/600]	Loss:0.1068
Epoch 006 [400/600]	Loss:0.0767
Epoch 006 [500/600]	Loss:0.0549
...Testing @ Epoch 006	Acc:0.9800
Epoch 007 [000/600]	Loss:0.0539
Epoch 007 [100/600]	Loss:0.0319
Epoch 007 [200/600]	Loss:0.1369
Epoch 007 [300/600]	Loss:0.0301
Epoch 007 [400/600]	Loss:0.0881
Epoch 007 [500/600]	Loss:0.0642
...Testing @ Epoch 007	Acc:0.9792
Epoch 008 [000/600]	Loss:0.0564
Epoch 008 [100/600]	Loss:0.0845
Epoch 008 [200/600]	Loss:0.1877
Epoch 008 [300/600]	Loss:0.0963
Epoch 008 [400/600]	Loss:0.0671
Epoch 008 [500/600]	Loss:0.1053
...Testing @ Epoch 008	Acc:0.9757
Epoch 009 [000/600]	Loss:0.0117
Epoch 009 [100/600]	Loss:0.0201
Epoch 009 [200/600]	Loss:0.1933
Epoch 009 [300/600]	Loss:0.0726
Epoch 009 [400/600]	Loss:0.0449
Epoch 009 [500/600]	Loss:0.1415
...Testing @ Epoch 009	Acc:0.9807
Epoch 010 [000/600]	Loss:0.0505
Epoch 010 [100/600]	Loss:0.0410
Epoch 010 [200/600]	Loss:0.0325
Epoch 010 [300/600]	Loss:0.0403
Epoch 010 [400/600]	Loss:0.0249
Epoch 010 [500/600]	Loss:0.0682
...Testing @ Epoch 010	Acc:0.9805
Epoch 011 [000/600]	Loss:0.0816
Epoch 011 [100/600]	Loss:0.1179
Epoch 011 [200/600]	Loss:0.1244
Epoch 011 [300/600]	Loss:0.0465
Epoch 011 [400/600]	Loss:0.1324
Epoch 011 [500/600]	Loss:0.0763
...Testing @ Epoch 011	Acc:0.9799
……

这段代码实现了简单 CNN 模型的训练和测试，具体实现步骤如下：

  1. 定义学习率 alpha，设为 0.1。
  2. 定义训练次数 epochs，设为 100。
  3. 定义打印间隔 interval，设为 100。
  4. 使用 range 函数循环 epochs 次，进行模型训练和测试。
  5. 在每个 epoch 循环中，定义优化器 optimizer，使用随机梯度下降法（SGD）优化器，对模型参数进行更新。
  6. 循环训练数据加载器 train_loader 中的数据，对数据进行前向传播，计算损失函数（交叉熵函数），通过反向传播求解梯度，并通过优化器对模型参数进行更新。
  7. 在每个间隔 interval 打印一次训练进度，输出当前训练的 epoch、批次、总批次数和当前损失函数值，以及测试集的准确率。
  8. 在每个 epoch 循环的末尾，使用 torch.no_grad() 防止梯度更新，在测试集加载器 test_loader 中进行数据的前向传播，计算模型的预测值和真实值，计算模型的准确率并输出。

这样就完成了模型的训练和测试，通过输出可以了解模型的训练进度和测试效果。

2.结构化构建神经网络

构建神经网络

Model = nn.Sequential(nn.Conv2d(1, 4, 5, 2, 0),nn.ReLU(),nn.Conv2d(4, 8, 3, 2, 0),nn.ReLU(),nn.Flatten(),nn.Linear(200, 10)
)

神经网络模型

Model

Sequential((0): Conv2d(1, 4, kernel_size=(5, 5), stride=(2, 2))(1): ReLU()(2): Conv2d(4, 8, kernel_size=(3, 3), stride=(2, 2))(3): ReLU()(4): Flatten(start_dim=1, end_dim=-1)(5): Linear(in_features=200, out_features=10, bias=True)
)

#测试
data = torch.randn(3, 1, 28, 28)
output = Model(data)
output.shape

torch.Size([3, 10])

for p in Model.parameters():print(p.shape)

torch.Size([4, 1, 5, 5])
torch.Size([4])
torch.Size([8, 4, 3, 3])
torch.Size([8])
torch.Size([10, 200])
torch.Size([10])

训练测试

alpha = 0.1  #学习率
epochs = 100  #训练次数
interval = 100  #打印间隔
for epoch in range(epochs):optimizer = optim.SGD(Model.parameters(), lr=0.1)for i, (data, label) in enumerate(train_loader):output = Model(data)optimizer.zero_grad()  #梯度归零loss = cross_entropy(output, label)  #交叉熵函数loss.backward()   #反向求导optimizer.step()  #更新参数if i % interval == 0:print("Epoch %03d [%03d/%03d]\tLoss:%.4f"%(epoch, i, len(train_loader), loss.item()))correct_num = 0total_num = 0with torch.no_grad():for data, label in test_loader:output = Model(data)pred = output.max(1)[1]correct_num += (pred == label).sum().item()total_num += len(data)acc = correct_num / total_numprint('...Testing @ Epoch %03d\tAcc:%.4f'%(epoch, acc))

Epoch 000 [000/600]	Loss:2.3005
Epoch 000 [100/600]	Loss:0.3855
Epoch 000 [200/600]	Loss:0.2832
Epoch 000 [300/600]	Loss:0.3216
Epoch 000 [400/600]	Loss:0.2495
Epoch 000 [500/600]	Loss:0.0687
...Testing @ Epoch 000	Acc:0.9554
Epoch 001 [000/600]	Loss:0.1364
Epoch 001 [100/600]	Loss:0.2104
Epoch 001 [200/600]	Loss:0.1206
Epoch 001 [300/600]	Loss:0.0859
Epoch 001 [400/600]	Loss:0.1187
Epoch 001 [500/600]	Loss:0.1903
...Testing @ Epoch 001	Acc:0.9668
Epoch 002 [000/600]	Loss:0.1893
Epoch 002 [100/600]	Loss:0.1033
Epoch 002 [200/600]	Loss:0.1633
Epoch 002 [300/600]	Loss:0.1038
Epoch 002 [400/600]	Loss:0.1250
Epoch 002 [500/600]	Loss:0.2345
...Testing @ Epoch 002	Acc:0.9725
Epoch 003 [000/600]	Loss:0.0566
Epoch 003 [100/600]	Loss:0.1781
Epoch 003 [200/600]	Loss:0.0779
Epoch 003 [300/600]	Loss:0.2852
Epoch 003 [400/600]	Loss:0.0428
Epoch 003 [500/600]	Loss:0.1369
...Testing @ Epoch 003	Acc:0.9714
Epoch 004 [000/600]	Loss:0.1098
Epoch 004 [100/600]	Loss:0.1288
Epoch 004 [200/600]	Loss:0.1078
Epoch 004 [300/600]	Loss:0.1325
Epoch 004 [400/600]	Loss:0.0649
Epoch 004 [500/600]	Loss:0.0683
...Testing @ Epoch 004	Acc:0.9739
Epoch 005 [000/600]	Loss:0.0984
Epoch 005 [100/600]	Loss:0.1322
Epoch 005 [200/600]	Loss:0.0641
Epoch 005 [300/600]	Loss:0.0769
Epoch 005 [400/600]	Loss:0.1507
Epoch 005 [500/600]	Loss:0.0377
...Testing @ Epoch 005	Acc:0.9742
Epoch 006 [000/600]	Loss:0.0954
Epoch 006 [100/600]	Loss:0.0889
Epoch 006 [200/600]	Loss:0.0666
Epoch 006 [300/600]	Loss:0.0448
Epoch 006 [400/600]	Loss:0.0285
Epoch 006 [500/600]	Loss:0.0581
...Testing @ Epoch 006	Acc:0.9773
Epoch 007 [000/600]	Loss:0.0305
Epoch 007 [100/600]	Loss:0.0651
Epoch 007 [200/600]	Loss:0.1007
Epoch 007 [300/600]	Loss:0.1537
Epoch 007 [400/600]	Loss:0.0233
Epoch 007 [500/600]	Loss:0.0925
...Testing @ Epoch 007	Acc:0.9750
Epoch 008 [000/600]	Loss:0.1807
Epoch 008 [100/600]	Loss:0.0373
Epoch 008 [200/600]	Loss:0.0600
Epoch 008 [300/600]	Loss:0.2233
Epoch 008 [400/600]	Loss:0.0469
Epoch 008 [500/600]	Loss:0.0817
...Testing @ Epoch 008	Acc:0.9795
Epoch 009 [000/600]	Loss:0.1331
Epoch 009 [100/600]	Loss:0.1417
Epoch 009 [200/600]	Loss:0.0429
Epoch 009 [300/600]	Loss:0.0552
Epoch 009 [400/600]	Loss:0.0117
Epoch 009 [500/600]	Loss:0.0611
...Testing @ Epoch 009	Acc:0.9780
Epoch 010 [000/600]	Loss:0.0386
Epoch 010 [100/600]	Loss:0.2372
Epoch 010 [200/600]	Loss:0.0092
Epoch 010 [300/600]	Loss:0.0623
Epoch 010 [400/600]	Loss:0.0530
Epoch 010 [500/600]	Loss:0.0345
...Testing @ Epoch 010	Acc:0.9797
Epoch 011 [000/600]	Loss:0.1051
Epoch 011 [100/600]	Loss:0.0507
Epoch 011 [200/600]	Loss:0.1075
Epoch 011 [300/600]	Loss:0.0414
Epoch 011 [400/600]	Loss:0.0256
Epoch 011 [500/600]	Loss:0.0631
...Testing @ Epoch 011	Acc:0.9778
Epoch 012 [000/600]	Loss:0.0873
Epoch 012 [100/600]	Loss:0.0693
Epoch 012 [200/600]	Loss:0.0779
Epoch 012 [300/600]	Loss:0.2842
Epoch 012 [400/600]	Loss:0.0314
Epoch 012 [500/600]	Loss:0.0197
...Testing @ Epoch 012	Acc:0.9778
……

3.函数式操作

见《PyTorch应用实战二:实现卷积神经网络进行图像分类》

附：系列文章

序号文章目录直达链接
1PyTorch应用实战一：实现卷积操作https://want595.blog.csdn.net/article/details/132575530
2PyTorch应用实战二：实现卷积神经网络进行图像分类https://want595.blog.csdn.net/article/details/132575702
3PyTorch应用实战三：构建神经网络https://want595.blog.csdn.net/article/details/132575758
4PyTorch应用实战四：基于PyTorch构建复杂应用https://want595.blog.csdn.net/article/details/132625270
5PyTorch应用实战五：实现二值化神经网络https://want595.blog.csdn.net/article/details/132625348
6PyTorch应用实战六：利用LSTM实现文本情感分类https://want595.blog.csdn.net/article/details/132625382

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

CleanMyMac X4.14.1最新版本下载

CleanMyMac X4.14.1最新版本下载

CleanMyMac X是一个功能强大的Mac清理软件，它的设计理念是提供多个模块，包括垃圾清理、安全保护、速度优化、应用程序管理和文档管理粉碎等，以满足用户的不同需求。软件的界面简洁直观，让用户能够轻松进行日常的清理操作。 使用C…
阅读更多...
PLL锁相环倍频原理

PLL锁相环倍频原理

晶振8MHz，但是处理器输入可以达到72MHz，是因为PLL锁相环提供了72MHz。 锁相环由PD（鉴相器）、LP（滤波器）、VCO（压控振荡器）组成。 处理器获得的72MHz并非晶振提供，而是锁…
阅读更多...
OpenCV利用Camshift实现目标追踪

OpenCV利用Camshift实现目标追踪

目录 原理 做法 代码实现 结果展示 原理 做法 代码实现 import numpy as np import cv2 as cv# 读取视频 cap cv.VideoCapture(video.mp4)# 检查视频是否成功打开 if not cap.isOpened():print("Error: Cannot open video file.")exit()# 获取第一帧图像&#x…
阅读更多...
AS环境，版本问题，android开发布局知识

AS环境，版本问题，android开发布局知识

项目模式下有一个build.gradle,每个模块也有自己的build.gradle Android模式下有多个build.gradle，汇总在一起。（都会有标注是哪个模块下的） C:\Users\Administrator\AndroidStudioProjects 项目默认位置 Java web项目与android项目的区别…
阅读更多...
JVM(Java虚拟机)

JVM(Java虚拟机)

目录 1.JVM 简介 1.1 JVM 发展史 1.Sun Classic VM 2.Exact VM 3.HotSpot VM 4.JRockit 5.J9 JVM 6.Taobao JVM（国产研发） 1.2 JVM 和《Java虚拟机规范》 2. JVM 运行流程 JVM 执行流程 3. JVM 运行时数据区 3.1 堆（线程共享&…
阅读更多...
基于SpringBoot的图书进销存管理系统

基于SpringBoot的图书进销存管理系统

目录 前言 一、技术栈 二、系统功能介绍 用户信息管理 图书类型管理 商品退货管理 客户信息管理 图书添加 客户添加 应收金额 三、核心代码 1、登录模块 2、文件上传模块 3、代码封装 前言 随着信息技术在管理上越来越深入而广泛的应用，管理信息系统的实…
阅读更多...
【Java 进阶篇】JDBC数据库连接池Druid详解

【Java 进阶篇】JDBC数据库连接池Druid详解

在Java应用程序中，与数据库进行交互是一个常见的任务。为了更有效地管理数据库连接并提高性能，数据库连接池是一种常见的解决方案。Druid是一个流行的JDBC数据库连接池，它具有丰富的功能和高性能。本博客将详细介绍Druid连接池，包…
阅读更多...
解决高分屏DPI缩放PC端百度网盘界面模糊的问题

解决高分屏DPI缩放PC端百度网盘界面模糊的问题

第一步 更新最新版本 首先，在百度网盘官网下载最新安装包： https://pan.baidu.com/download 进行覆盖安装 第二步 修改兼容性设置 右键百度网盘图标，点击属性，在兼容性选项卡中点击更改所有用户的设置 弹出的选项卡中选择更改高…
阅读更多...
嵌入式Linux裸机开发（一）基础介绍及汇编LED驱动

嵌入式Linux裸机开发（一）基础介绍及汇编LED驱动

系列文章目录 文章目录 系列文章目录前言IMX6ULL介绍主要资料IO表现形式 汇编LED驱动原理图初始化流程时钟设置IO复用设置电气属性设置使用GPIO 编写驱动编译程序编译.o文件地址链接.elf格式转换.bin反汇编（其他） 综合成Makefile完成一步编译烧录程序imx…
阅读更多...
正则表达式 Regular Expression学习

正则表达式 Regular Expression学习

该文章内容为以下视频的学习笔记： 10分钟快速掌握正则表达式_哔哩哔哩_bilibili正则表达式在线测试工具：https://regex101.com/, 视频播放量 441829、弹幕量 1076、点赞数 19330、投硬币枚数 13662、收藏人数 26242、转发人数 2768, 视频作者 奇乐编程学…
阅读更多...
【Zookeeper专题】Zookeeper特性与节点数据类型详解

【Zookeeper专题】Zookeeper特性与节点数据类型详解

目录 前言前置知识课程内容一、Zookeeper介绍二、Zookeeper快速开始2.1 Zookeeper安装2.2 客户端命令行操作2.3 GUI工具 三、Zookeeper数据结构3.1 ZNode节点分类3.2 ZNode状态信息3.3 监听机制详解3.3.1 永久性Watch 3.4 节点ZNode特性总结3.5 应用场景详解3.5.1 统一命名服务…
阅读更多...
游戏设计模式专栏(五）：三步学会原型模式

游戏设计模式专栏(五）：三步学会原型模式

引言 大家好，我是亿元程序员，一位有着8年游戏行业经验的主程。 本系列是《和8年游戏主程一起学习设计模式》，让糟糕的代码在潜移默化中升华，欢迎大家关注分享收藏订阅。 原型模式在游戏开发中是一种重要的设计模式，…
阅读更多...
vertx的学习总结7之用kotlin 与vertx搞一个简单的http

vertx的学习总结7之用kotlin 与vertx搞一个简单的http

这里我就简单的聊几句&#xff0c;如何用vertx web来搞一个web项目的 1、首先先引入几个依赖&#xff0c;这里我就用maven了&#xff0c;这个是kotlinvertx web <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apac…
阅读更多...
纪念在CSDN的2048天

纪念在CSDN的2048天

时间真快&#xff5e;
阅读更多...
GEE土地分类——Property ‘B1‘ of feature ‘LE07_066018_20220603‘ is missing.错误

GEE土地分类——Property ‘B1‘ of feature ‘LE07_066018_20220603‘ is missing.错误

简介&#xff1a; 我正在尝试使用我在研究区域中选择的训练点对图像集合中的每个图像进行分类。就背景而言&#xff0c;我正在进行的项目正在研究陆地卫星生命周期内冰川面积的变化以及随后的植被变化。这意味着自 1984 年以来&#xff0c;我正在处理大量图像&#xff0c;每年一…
阅读更多...
SpringCloud-消息组件

SpringCloud-消息组件

1 简介 了解过RabbitMQ后&#xff0c;可能我们会遇到不同的系统在用不同的队列。比如系统A用的Kafka&#xff0c;系统B用的RabbitMQ&#xff0c;但是没了解过Kafka&#xff0c;因此可以使用Spring Stream&#xff0c;它能够屏蔽地产&#xff0c;像JDBC一样&#xff0c;只关心SQ…
阅读更多...
阿里云ECS和轻量服务器有什么区别？

阿里云ECS和轻量服务器有什么区别？

阿里云服务器ECS和轻量应用服务器有什么区别&#xff1f;轻量和ECS优缺点对比&#xff0c;云服务器ECS是明星级云产品&#xff0c;适合企业专业级的使用场景&#xff0c;轻量应用服务器是在ECS的基础上推出的轻量级云服务器&#xff0c;适合个人开发者单机应用访问量不高的网站…
阅读更多...
API基础————包

API基础————包

什么是包&#xff0c;package实际上就是一个文件夹&#xff0c;便于程序员更好的管理维护自己的代码。它可以使得一个项目结构更加清晰明了。 Java也有20年历史了&#xff0c;这么多年有这么多程序员写了无数行代码&#xff0c;其中有大量重复的&#xff0c;为了更加便捷省时地…
阅读更多...
如何使用 LeiaPix 让照片动起来

如何使用 LeiaPix 让照片动起来

在过去&#xff0c;想要让照片动起来&#xff0c;需要使用专业的软件和技巧。但是&#xff0c;随着科技的发展&#xff0c;现在只需使用一个简单的工具&#xff0c;就可以轻松地让照片动起来。 LeiaPix 是一个免费的在线工具&#xff0c;可以将静态照片转换为动画。该工具使用…
阅读更多...
十天学完基础数据结构-第九天（堆（Heap））

十天学完基础数据结构-第九天（堆（Heap））

堆的基本概念 堆是一种特殊的树形数据结构&#xff0c;通常用于实现优先级队列。堆具有以下两个主要特点&#xff1a; 父节点的值始终大于或等于其子节点的值&#xff08;最大堆&#xff09;&#xff0c;或者父节点的值始终小于或等于其子节点的值&#xff08;最小堆&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023