pytorch构建模型训练数据集

pytorch构建模型训练数据集

  • pytorch构建模型训练数据集
    • 1.AlexNet:
      • 1.1.导入必要的库：
      • 1.2.数据预处理和增强：
      • 1.3.加载数据集：
      • 1.4.划分测试集和训练集：
      • 1.5.创建数据加载器：
      • 1.6.加载AlexNet模型：
      • 1.7.修改模型以适应您的数据集类别数
      • 1.8.定义损失函数和优化器
      • 1.9.将模型移动到GPU（如果可用）
      • 1.10.初始化列表来存储每个epoch的损失和准确率
      • 1.11.训练模型
      • 1.12.绘制损失图表和准确率图标：
    • 2.LeNet-5:
      • 2.1.导入必要的库：
      • 2.2.数据预处理和增强：
      • 2.3.加载数据集：
      • 2.4.划分训练集和测试集：
      • 2.5.创建数据加载器：
      • 2.6.定义LeNet-5模型结构：
      • 2.7.初始化LeNet-5模型
      • 2.8. 定义损失函数和优化器
      • 2.9.将模型移动到GPU（如果可用）
      • 2.10.初始化列表来存储每个epoch的损失和准确率
      • 2.11.训练模型
    • 3.ResNet:
      • 3.1.导入必要的库：
      • 3.2.数据预处理和增强：
      • 3.3.加载数据集：
      • 3.4.划分训练集和测试集：
      • 3.5.创建数据加载器：
      • 3.6.使用ResNet-18模型：
      • 3.7.修改全连接层以适应数据集：
      • 3.8.定义损失函数和优化器：
      • 3.9.将模型移动到GPU（如果可用）：
      • 3.10.初始化列表来存储每个epoch的损失和准确率：
      • 3.11.训练模型并输出：
    • 4.VGG-16:
      • 4.1.导入必要的库：
      • 4.2.数据预处理和增强：
      • 4.3.加载数据集：
      • 4.4.划分训练集和测试集：
      • 4.5.创建数据加载器：
      • 4.6.加载VGG16模型：
      • 4.8.定义损失函数和优化器：
      • 4.9.将模型移动到GPU（如果可用）：
      • 4.10.初始化列表来存储每个epoch的损失和准确率：
      • 4.11.训练模型与输出：
    • 5.VGG-19:
      • 5.1.导入必要的库：
      • 5.2.数据预处理和增强：
      • 5.3.加载数据集：
      • 5.4.划分训练集和测试集：
      • 5.5.创建数据加载器：
      • 5.6.加载VGG19模型：
      • 5.7.修改模型以适应数据集类别数：
      • 5.8.定义损失函数和优化器：
      • 5.9.将模型移动到GPU（如果可用）：
      • 5.10.初始化列表来存储每个epoch的损失和准确率：
      • 5.11.训练模型与输出：

pytorch构建模型训练数据集

1.AlexNet:

1.1.导入必要的库：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

1.2.数据预处理和增强：

transform = transforms.Compose([transforms.Resize((227, 227)),  # AlexNet需要227x227像素的输入transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # AlexNet的标准归一化参数
])

1.3.加载数据集：

data_path = 'D:/工坊/Pytorch的框架/flower_photos'
dataset = datasets.ImageFolder(data_path, transform=transform)

1.4.划分测试集和训练集：

train_size = int(0.8 * len(dataset))
test_size = len(dataset) - train_sizetrain_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

1.5.创建数据加载器：

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

1.6.加载AlexNet模型：

model = models.alexnet(pretrained=True)

1.7.修改模型以适应您的数据集类别数

num_classes = len(dataset.classes)
model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes)

1.8.定义损失函数和优化器

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

1.9.将模型移动到GPU（如果可用）

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

1.10.初始化列表来存储每个epoch的损失和准确率

train_losses = []
train_accuracies = []

1.11.训练模型

num_epochs = 50
for epoch in range(num_epochs):model.train()running_loss = 0.0correct = 0total = 0for inputs, labels in train_loader:inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()epoch_loss = running_loss / len(train_loader)epoch_accuracy = 100 * correct / totaltrain_losses.append(epoch_loss)train_accuracies.append(epoch_accuracy)
print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss}, Accuracy: {epoch_accuracy}%')

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

1.12.绘制损失图表和准确率图标：

#创建图表
plt.figure(figsize=(10, 5))#绘制损失
plt.subplot(1, 2, 1)
plt.plot(range(1, len(train_losses) + 1), train_losses, 'bo-', label='Training Loss')
plt.title('Training Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
#绘制准确率
plt.subplot(1, 2, 2)
plt.plot(range(1, len(train_accuracies) + 1), train_accuracies, 'ro-', label='Training Accuracy')
plt.title('Training Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy (%)')
plt.legend()
#显示图表
plt.tight_layout()
plt.show()

2.LeNet-5:

2.1.导入必要的库：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

2.2.数据预处理和增强：

#数据预处理和增强
transform = transforms.Compose([transforms.Resize((227, 227)),  # AlexNet需要227x227像素的输入transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # AlexNet的标准归一化参数
])

2.3.加载数据集：

data_path = 'D:/工坊/Pytorch的框架/flower_photos'
dataset = datasets.ImageFolder(data_path, transform=transform)

2.4.划分训练集和测试集：

train_size = int(0.8 * len(dataset))
test_size = len(dataset) - train_sizetrain_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

2.5.创建数据加载器：

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

2.6.定义LeNet-5模型结构：

  • 包含两个卷积层和三个全连接层
class LeNet5(nn.Module):def __init__(self, num_classes):super(LeNet5, self).__init__()self.conv_net = nn.Sequential(nn.Conv2d(3, 6, kernel_size=5),nn.Tanh(),nn.AvgPool2d(kernel_size=2, stride=2),nn.Conv2d(6, 16, kernel_size=5),nn.Tanh(),nn.AvgPool2d(kernel_size=2, stride=2))self.fc_net = nn.Sequential(nn.Linear(44944, 120),  # 修改这里以匹配卷积层的输出尺寸nn.Tanh(),nn.Linear(120, 84),nn.Tanh(),nn.Linear(84, num_classes))def forward(self, x):x = self.conv_net(x)x = x.view(x.size(0), -1)  # 展平多维卷积层输出x = self.fc_net(x)return x

2.7.初始化LeNet-5模型

num_classes = len(dataset.classes)
model = LeNet5(num_classes)

2.8. 定义损失函数和优化器

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

2.9.将模型移动到GPU（如果可用）

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

2.10.初始化列表来存储每个epoch的损失和准确率

train_losses = []
train_accuracies = []

2.11.训练模型

num_epochs = 50
for epoch in range(num_epochs):model.train()running_loss = 0.0correct = 0total = 0for inputs, labels in train_loader:inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()epoch_loss = running_loss / len(train_loader)epoch_accuracy = 100 * correct / totaltrain_losses.append(epoch_loss)train_accuracies.append(epoch_accuracy)print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss}, Accuracy: {epoch_accuracy}%')

3.ResNet:

3.1.导入必要的库：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

3.2.数据预处理和增强：

#数据预处理和增强
transform = transforms.Compose([transforms.Resize((224, 224)),  # 调整图像大小为 224x224像素，符合ResNet输入transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  
#ResNet的标准化参数
])

3.3.加载数据集：

#加载数据集
data_path = 'D:/工坊/深度学习/img/weather_photos'
dataset = datasets.ImageFolder(data_path, transform=transform)

3.4.划分训练集和测试集：

#划分训练集和测试集
train_size = int(0.8 * len(dataset))
test_size = len(dataset) - train_sizetrain_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

3.5.创建数据加载器：

  • 为数据集提供批量加载和随机洗牌的功能。
#创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

3.6.使用ResNet-18模型：

  • models.resnet18(pretrained=True)：加载预训练的ResNet-18模型，修改全连接层以适应您的数据集：替换模型的最后一层，使其输出类别数与您的数据集类别数相匹配。
#使用ResNet-18模型
model = models.resnet18(pretrained=True)

3.7.修改全连接层以适应数据集：

num_classes = len(dataset.classes)  # 假设dataset是您之前定义的ImageFolder对象
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)

3.8.定义损失函数和优化器：

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

3.9.将模型移动到GPU（如果可用）：

  • 检查是否有可用的GPU，如果有，则将模型和数据移动到GPU以加速训练。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

3.10.初始化列表来存储每个epoch的损失和准确率：

  • 用于监控训练过程中的损失和准确率。
train_losses = []
train_accuracies = []

3.11.训练模型并输出：

  • 在多个epoch上迭代训练模型，在每个epoch中，遍历训练数据集，进行前向传播、计算损失、反向传播和参数更新，计算每个epoch的总损失和准确率，并打印出来。
  • 每个epoch的损失和准确率会被打印出来，以便监控训练过程
num_epochs = 50
for epoch in range(num_epochs):model.train()running_loss = 0.0correct = 0total = 0for inputs, labels in train_loader:inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()epoch_loss = running_loss / len(train_loader)epoch_accuracy = 100 * correct / totaltrain_losses.append(epoch_loss)train_accuracies.append(epoch_accuracy)print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss}, Accuracy: {epoch_accuracy}%')

4.VGG-16:

4.1.导入必要的库：

  • 用于构建和训练神经网络，以及处理图像数据。
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

4.2.数据预处理和增强：

  • 使用VGG16模型的标准归一化参数。
transform = transforms.Compose([transforms.Resize((224, 224)),  # VGG16需要224x224像素的输入transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # VGG16的标准归一化参数
])

4.3.加载数据集：

  • 从指定路径加载数据集。
data_path = 'D:/工坊/Pytorch的框架/flower_photos'
dataset = datasets.ImageFolder(data_path, transform=transform)

4.4.划分训练集和测试集：

  • 将数据集随机分为训练集和测试集。
train_size = int(0.8 * len(dataset))
test_size = len(dataset) - train_sizetrain_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

4.5.创建数据加载器：

  • 为训练集和测试集创建数据加载器。
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

4.6.加载VGG16模型：

  • 使用models.vgg16(pretrained=True)加载预训练的VGG16模型。
model = models.vgg16(pretrained=True)
  • 修改VGG16模型的分类器层的最后一层，使其输出类别数与您的数据集类别数相匹配。
num_classes = len(dataset.classes)
model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes)

4.8.定义损失函数和优化器：

  • 使用交叉熵损失函数和Adam优化器。
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

4.9.将模型移动到GPU（如果可用）：

  • 检查是否有可用的GPU，如果有，则将模型和数据移动到GPU以加速训练。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

4.10.初始化列表来存储每个epoch的损失和准确率：

  • 用于监控训练过程中的损失和准确率。
train_losses = []
train_accuracies = []

4.11.训练模型与输出：

  • 每个epoch的损失和准确率会被打印出来，以便监控训练过程。
num_epochs = 1000
for epoch in range(num_epochs):model.train()running_loss = 0.0correct = 0total = 0for inputs, labels in train_loader:inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()epoch_loss = running_loss / len(train_loader)epoch_accuracy = 100 * correct / totaltrain_losses.append(epoch_loss)train_accuracies.append(epoch_accuracy)print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss}, Accuracy: {epoch_accuracy}%')

5.VGG-19:

5.1.导入必要的库：

  • 用于构建和训练神经网络，以及处理图像数据。
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

5.2.数据预处理和增强：

-使用VGG19模型的标准归一化参数。

transform = transforms.Compose([transforms.Resize((224, 224)),  # VGG19需要224x224像素的输入transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # VGG16的标准归一化参数
])

5.3.加载数据集：

  • 从指定路径加载数据集。
data_path = 'D:/工坊/Pytorch的框架/flower_photos'
dataset = datasets.ImageFolder(data_path, transform=transform)

5.4.划分训练集和测试集：

  • 将数据集随机分为训练集和测试集。
train_size = int(0.8 * len(dataset)) test_size = len(dataset) - train_sizetrain_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

5.5.创建数据加载器：

  • 为训练集和测试集创建数据加载器。
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

5.6.加载VGG19模型：

  • 使用models.vgg19(pretrained=True)加载预训练的VGG19模型。
model = models.vgg19(pretrained=True)

5.7.修改模型以适应数据集类别数：

  • 修改VGG19模型的分类器层的最后一层，使其输出类别数与您的数据集类别数相匹配。
num_classes = len(dataset.classes)
model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes)

5.8.定义损失函数和优化器：

使用交叉熵损失函数和Adam优化器。

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

5.9.将模型移动到GPU（如果可用）：

  • 检查是否有可用的GPU，如果有，则将模型和数据移动到GPU以加速训练。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

5.10.初始化列表来存储每个epoch的损失和准确率：

  • 用于监控训练过程中的损失和准确率。
train_losses = []
train_accuracies = []

5.11.训练模型与输出：

  • 每个epoch的损失和准确率会被打印出来，以便监控训练过程。
num_epochs = 1000
for epoch in range(num_epochs):model.train()running_loss = 0.0correct = 0total = 0for inputs, labels in train_loader:inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()epoch_loss = running_loss / len(train_loader)epoch_accuracy = 100 * correct / totaltrain_losses.append(epoch_loss)train_accuracies.append(epoch_accuracy)print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss}, Accuracy: {epoch_accuracy}%')

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

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

相关文章

帝国cms接入腾讯云人脸识别认证代码

帝国cms接入腾讯云人脸识别认证代码

利用帝国cms在做一些会员系统的时候，需要做人脸识别认证，之前接入了某api接口，发现身份证识别率真的低，还好充值的少，否则要出问题，后来发现会员注册率降低了不少，最终还是决定使用腾讯云的人脸…
阅读更多...
三十五篇：数字化转型的引擎：赋能企业的ERP系统全景

三十五篇：数字化转型的引擎：赋能企业的ERP系统全景

数字化转型的引擎：赋能企业的ERP系统全景 1. 引言 在这个快速变化的数字时代，现代企业面临着前所未有的挑战和机遇。企业资源计划（ERP）系统，作为数字化转型的核心，扮演着至关重要的角色。它不仅是企业运营…
阅读更多...
NFT Insider #133：苏富比将拍卖BAYC系列NFT，Taiko创世NFT系列已上线

NFT Insider #133：苏富比将拍卖BAYC系列NFT，Taiko创世NFT系列已上线

引言：NFT Insider由NFT收藏组织WHALE Members （https://twitter.com/WHALEMembers）、BeepCrypto （https://twitter.com/beep_crypto）联合出品，浓缩每周NFT新闻，为大家带来关于NFT最全面、最新鲜…
阅读更多...
立创·天空星开发板-GD32F407VE-EXTI

立创·天空星开发板-GD32F407VE-EXTI

本文以 立创天空星开发板-GD32F407VET6-青春版 作为学习的板子，记录学习笔记。 立创天空星开发板-GD32F407VE-EXTI 中断硬件触发中断示例软件触发中断示例 中断 中断分为内部中断和外部中断 外部中断是由外部设备（如按键、传感器、通信接口等&#xff09…
阅读更多...
rollup.js（入门篇）

rollup.js（入门篇）

前沿 Rollup 是一个用于 JavaScript 的模块打包工具，它将小的代码片段编译成更大、更复杂的代码，例如库或应用程序。它使用 JavaScript 的 ES6 版本中包含的新标准化代码模块格式，而不是以前的 CommonJS 和 AMD 等特殊解决方案。ES 模块允许…
阅读更多...
一文读懂AI时代GPU的内存新宠-HBM

一文读懂AI时代GPU的内存新宠-HBM

一文读懂GPU最强辅助：HBM HBM，即高带宽内存，是一项领先的3D堆叠DRAM技术，专为高性能计算和图形处理单元（GPU）设计，满足其对内存带宽和容量的极致需求。该技术由AMD与海力士携手研发，…
阅读更多...
Apache安装教程

Apache安装教程

目录 一、Apache知识点 Apache服务简介 Apache下载网址 Apache的主要特点 二、Apache服务的搭建 1. 关闭防火墙 2. 安装依赖环境以及编译工具 3. 将apache安装包拖入xshell内 4. 解压压缩包 5. 进入httpd主包 6. 指定安装路径，启用字符集支持等 7. 优化执…
阅读更多...
重庆工商大学社会工作专业试题及答案，分享几个实用搜题和学习工具 #媒体#学习方法#知识分享

重庆工商大学社会工作专业试题及答案，分享几个实用搜题和学习工具 #媒体#学习方法#知识分享

搜题软件一般都是通过识别题目内容搜索出问题的答案，当识别内容不正确或搜索不到答案时，又得重新到其他软件进行重复的操作，很是麻烦。所以我们可以使用专业的识别工具，对题目内容进行识别，然后把提取出来的内容单独保…
阅读更多...
流量录制学习

流量录制学习

AREX Cloud | AREX (arextest.com) 流量录制学习，比vivo的moonbox要好用
阅读更多...
【数据结构】平衡二叉树左旋右旋与红黑树

【数据结构】平衡二叉树左旋右旋与红黑树

平衡二叉树左旋右旋与红黑树 平衡二叉树 定义 平衡二叉树是二叉搜索树的一种特殊形式。二叉搜索树（Binary Search Tree，BST）是一种具有以下性质的二叉树： 对于树中的每个节点，其左子树中的所有节点都小于该节点的值…
阅读更多...
【vector模拟实现】附加代码讲解

【vector模拟实现】附加代码讲解

vector模拟实现 一、看源代码简单实现1. push_backcapacity（容量）sizereserve（扩容）operator[ ] （元素访问） 2. pop_back3. itorator（迭代器）4.insert & erase （头插…
阅读更多...
哈夫曼树的创建

哈夫曼树的创建

要了解哈夫曼树，可以先了解一下哈夫曼编码，假设我们有几个字母，他们的出现频率是A: 1 B: 2 C: 3 D: 4 E: 5 F: 6 G: 7。那么如果想要压缩数据的同时让访问更加快捷，就要让频率高的字母离根节点比较进，容易访问&#xf…
阅读更多...
立创·天空星开发板-GD32F407VE-GPIO

立创·天空星开发板-GD32F407VE-GPIO

本文以 立创天空星开发板-GD32F407VET6-青春版 作为学习的板子，记录学习笔记。 立创天空星开发板-GD32F407VE-GPIO 基础概念三极管MOS管 GPIO输出模式输出线与GPIO输入模式GPIO点灯 基础概念 GPIO，全称为“通用输入/输出”（General Purpose …
阅读更多...
算法金 | 这次终于能把张量（Tensor）搞清楚了！

算法金 | 这次终于能把张量（Tensor）搞清楚了！

大侠幸会，在下全网同名[算法金] 0 基础转 AI 上岸，多个算法赛 Top [日更万日，让更多人享受智能乐趣] 1. 张量（Tensor）基础概念 1.1 张量的定义与重要性 张量是深度学习中用于表示数据的核心结构，它可以视…
阅读更多...
《帝国时代 III：决定版》秘籍 怎么在苹果电脑上玩《帝国时代 III：决定版》

《帝国时代 III：决定版》秘籍 怎么在苹果电脑上玩《帝国时代 III：决定版》

《帝国时代 III：决定版》是一款让玩家沉浸于历史长河体验从大航海时代到工业革命时期的游戏。下面我们来看看《帝国时代 III：决定版》是什么类型的游戏，《帝国时代 III：决定版》Mac安装教程的相关内容。 一、《帝国时代 III&…
阅读更多...
【BOM02】本地存储

【BOM02】本地存储

一：什么是本地存储 数据存储在用户浏览器中，用户设置、读取方便，同时页面刷新时不会丢失数据。存储在浏览器中数据约5M，分为sessionStorage和localStorage两种存储方式 二：localStorage存储 作用 将数据永久存储在…
阅读更多...
opencv实战小结-银行卡号识别

opencv实战小结-银行卡号识别

实战1-银行卡号识别 项目来源：opencv入门 项目目的：识别传入的银行卡照片中的卡号 难点：银行卡上会有一些干扰项，如何排除这些干扰项，并且打印正确的号码是一个问题 最终效果如上图 实现这样的功能需要以下几个步骤…
阅读更多...
算法导论实战（三）（算法导论习题第二十四章）

算法导论实战（三）（算法导论习题第二十四章）

🌈 个人主页：十二月的猫-CSDN博客 🔥 系列专栏： 🏀算法启示录 💪🏻 十二月的寒冬阻挡不了春天的脚步，十二点的黑夜遮蔽不住黎明的曙光 目录 前言 第二十四章 24.1-3 24.1-4 2…
阅读更多...
【Week-R2】使用LSTM实现火灾预测（tf版本）

【Week-R2】使用LSTM实现火灾预测（tf版本）

【Week-R2】使用LSTM实现火灾预测（tf版本） 一、 前期准备1.1 设置GPU1.2 导入数据1.3 数据可视化 二、数据预处理(构建数据集)2.1 设置x、y2.2 归一化2.3 划分数据集 三、模型创建、编译、训练、得到训练结果3.1 构建模型3.2 编译模型3.3 训练模型3.4 模…
阅读更多...
超详细的java Comparable，Comparator接口解析

超详细的java Comparable，Comparator接口解析

前言 Hello大家好呀，在java中我们常常涉及到对象的比较，不同于基本数据类型，对于我们的自定义对象，需要我们自己去建立比较标准，例如我们自定义一个People类，这个类有name和age两个属性，那么问…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023