深度学习 - CNN

第一部分：基础知识

1. 什么是卷积神经网络（CNN）

定义和基本概念
卷积神经网络（CNN）是一种专门用于处理具有网格结构数据（如图像）的深度学习模型。它们在图像识别和计算机视觉领域表现尤为突出。与传统的全连接神经网络不同，CNN利用局部连接和共享权重的方式，能够有效减少参数数量，提高计算效率。

CNN在图像处理中的优势

  • 局部连接：只处理图像的局部区域，减少参数量。
  • 共享权重：同一个滤波器在图像不同位置扫描，进一步减少参数量。
  • 池化操作：通过降采样减少数据维度，提取重要特征。
2. CNN的基本结构

输入层
处理输入数据，比如一张图片，通常用三维数组表示（宽度，高度，颜色通道数）。

卷积层
通过应用不同的滤波器来提取特征。滤波器滑过输入图像，生成特征映射。

池化层
进行降采样，减少数据维度，提高计算效率，同时保留重要特征。

全连接层
将卷积层和池化层提取的特征展开成一维向量，并通过多个全连接层进行分类。

输出层
根据具体任务（如分类、回归）输出最终结果。
在这里插入图片描述

第二部分：深入理解

卷积操作（Convolution Operation）

实例：
假设有一个3x3的输入图像和一个2x2的滤波器：

输入图像：

1 2 3
4 5 6
7 8 9

滤波器：

1 0
0 -1

卷积操作是将滤波器应用于图像的每个局部区域，计算它们的点积和：

1*1 + 2*0 + 4*0 + 5*(-1) = 1 - 5 = -4
2*1 + 3*0 + 5*0 + 6*(-1) = 2 - 6 = -4
4*1 + 5*0 + 7*0 + 8*(-1) = 4 - 8 = -4
5*1 + 6*0 + 8*0 + 9*(-1) = 5 - 9 = -4

最终得到的特征映射：

-4 -4
-4 -4
激活函数（ReLU, Sigmoid, Tanh等）

实例：
ReLU（Rectified Linear Unit）：f(x) = max(0, x)
假设输入为[-1, 2, -3, 4]，经过ReLU后：

ReLU([-1, 2, -3, 4]) = [0, 2, 0, 4]
池化操作（Max Pooling, Average Pooling）

实例：
Max Pooling：
输入：

1 2
3 4

最大池化结果：

4

Average Pooling：
输入：

1 2
3 4

平均池化结果：

(1+2+3+4)/4 = 2.5
损失函数（Cross-Entropy Loss等）

实例：
假设有两个类别，实际标签为[1, 0]（表示第一类），预测概率为[0.8, 0.2]。
交叉熵损失计算：

Loss = - (1 * log(0.8) + 0 * log(0.2)) = - log(0.8) = 0.223

第三部分：实战应用

1. 使用PyTorch实现CNN

安装和配置PyTorch

pip install torch torchvision

构建简单的CNN模型

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

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)  # 3个输入通道，16个输出通道，3x3的卷积核，步长1
        self.conv2 = nn.Conv2d(16, 32, 3, 1)
        self.fc1 = nn.Linear(32 * 6 * 6, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2, 2)
        x = x.view(-1, 32 * 6 * 6)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

数据预处理

import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

训练和评估模型

import torch.optim as optim

model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

for epoch in range(10):  # 训练10个epoch
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:    # 每100个批次打印一次
            print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 100:.3f}')
            running_loss = 0.0

print('Finished Training')
2. 经典CNN架构

LeNet
由Yann LeCun提出，适用于手写数字识别。

AlexNet
由Alex Krizhevsky提出，首次在ImageNet竞赛中大放异彩。

VGGNet
由Oxford大学Visual Geometry Group提出，使用多个小卷积核代替大卷积核。

GoogLeNet/Inception
由Google提出，使用Inception模块提高模型性能。

ResNet
由Microsoft提出，引入残差连接解决深层网络训练困难问题。

DenseNet
由Cornell大学提出，通过密集连接提高梯度流动。

3. 转移学习与预训练模型

使用预训练模型

from torchvision import models

resnet = models.resnet18(pretrained=True)

微调（Fine-Tuning）

for param in resnet.parameters():
    param.requires_grad = False

resnet.fc = nn.Linear(resnet.fc.in_features, 10)

第四部分：高级主题

1. 优化与调整

学习率调度

scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)

正则化方法

self.dropout = nn.Dropout(0.5)  # 在网络中使用dropout防止过拟合

批量归一化

self.bn1 = nn.BatchNorm2d(16)  # 在卷积层后添加批量归一化层
2. 增强技术

数据增强

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

混合精度训练

from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()

for epoch in range(10):
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, labels)
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
3.模型参数推荐
数据集规模数据集大小推荐的卷积层数量推荐的卷积核数（每层）推荐的全连接层数量推荐的全连接神经元数（每层）说明
小型数据集1,000 - 10,0002 - 332 - 641 - 2128 - 256例如MNIST等简单任务，可以用少量卷积层和全连接层。
中型数据集10,000 - 100,0003 - 564 - 1282 - 3256 - 512例如CIFAR-10等任务，需要更多的卷积层来提取特征。
大型数据集100,000 - 1,000,0005 - 10128 - 2562 - 4512 - 1024例如CIFAR-100、ImageNet子集等任务，复杂特征需要更多的卷积层。
超大型数据集1,000,000+10+256+3 - 51024+例如完整的ImageNet数据集或更大规模的任务，深度网络（如ResNet）通常是必要的。
小型数据集示例（如MNIST）
import torch.nn as nn
import torch.nn.functional as F

class SmallCNN(nn.Module):
    def __init__(self):
        super(SmallCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # 假设输入图像大小为28x28
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

在这个示例中：

  • 卷积层数量：2层（conv1 和 conv2）
  • 每层卷积核数：32和64
  • 全连接层数量：2层（fc1 和 fc2）
  • 每层全连接神经元数：128和10
中型数据集示例（如CIFAR-10）
import torch.nn as nn
import torch.nn.functional as F

class MediumCNN(nn.Module):
    def __init__(self):
        super(MediumCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(256 * 4 * 4, 512)  # 假设输入图像大小为32x32
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 256 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

在这个示例中：

  • 卷积层数量：3层（conv1, conv2 和 conv3）
  • 每层卷积核数：64, 128和256
  • 全连接层数量：2层（fc1 和 fc2）
  • 每层全连接神经元数：512和10
大型数据集示例（如ImageNet子集）
import torch.nn as nn
import torch.nn.functional as F

class LargeCNN(nn.Module):
    def __init__(self):
        super(LargeCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1)
        self.conv4 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1)
        self.conv5 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(1024 * 1 * 1, 1024)  # 假设输入图像大小为32x32
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = self.pool(F.relu(self.conv4(x)))
        x = self.pool(F.relu(self.conv5(x)))
        x = x.view(-1, 1024 * 1 * 1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

在这个示例中：

  • 卷积层数量：5层（conv1, conv2, conv3, conv4 和 conv5）
  • 每层卷积核数：64, 128, 256, 512和1024
  • 全连接层数量：3层（fc1, fc2 和 fc3）
  • 每层全连接神经元数：1024, 512和10
4. CNN的其他应用

对抗生成网络（GANs）
生成与判别网络相互竞争，提高生成图像质量。

目标检测（Object Detection）
检测图像中的多个对象并定位它们的边界框。

语义分割（Semantic Segmentation）
将图像中的每个像

素分类到特定类别。

第五部分：项目与实践

1. 手写数字识别（MNIST）

项目介绍
MNIST数据集是一个经典的手写数字识别数据集，包含60,000个训练样本和10,000个测试样本。每个样本是28x28的灰度图像，表示从0到9的数字。

步骤

  1. 数据准备
  2. 模型构建
  3. 模型训练
  4. 模型评估

详细过程

  1. 数据准备
import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)
  1. 模型构建
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.fc1 = nn.Linear(12 * 12 * 64, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(self.conv2(x), 2)
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)
  1. 模型训练
import torch.optim as optim

model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(5):  # 训练5个epoch
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
  1. 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total:.2f}%')
2. 图像分类（CIFAR-10）

项目介绍
CIFAR-10数据集包含60,000张32x32的彩色图像，分为10个类别。每个类别有6,000张图像。

步骤

  1. 数据准备
  2. 模型构建
  3. 模型训练
  4. 模型评估

详细过程

  1. 数据准备
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)
  1. 模型构建
class CIFAR10CNN(nn.Module):
    def __init__(self):
        super(ImprovedImageClassifier, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv3 = nn.Conv2d(64, 128, 3, stride=1, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.dropout = nn.Dropout(0.1)  # 加入Dropout层
        self.fc1 = nn.Linear(128 * 4 * 4, 256)
        self.fc2 = nn.Linear(256, 128)
        self.out = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.pool(torch.relu(self.bn1(self.conv1(x))))
        x = self.pool(torch.relu(self.bn2(self.conv2(x))))
        x = self.pool(torch.relu(self.bn3(self.conv3(x))))
        x = x.view(-1, 128 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)
        x = torch.relu(self.fc2(x))
        x = self.out(x)
        return x
  1. 模型训练
model = CIFAR10CNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):  # 训练10个epoch
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
  1. 模型评估
# 构建数据加载器
dataloader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=True)
model.eval()

# 计算精度和其他评估指标
y_true = []
y_pred = []
with torch.no_grad():
    for x, y in dataloader:
        x = x.to(device)
        y = y.to(device)
        output = model(x)
        y_pred.extend(torch.argmax(output, dim=-1).cpu().numpy())
        y_true.extend(y.cpu().numpy())

# 混淆矩阵和分类报告
conf_mat = confusion_matrix(y_true, y_pred)
class_report = classification_report(y_true, y_pred, target_names=train_dataset.classes)

# 打印分类报告
print("Classification Report:\n", class_report)

# 绘制混淆矩阵
plt.figure(figsize=(10, 8))
sns.heatmap(conf_mat, annot=True, fmt='d', cmap='Blues', xticklabels=train_dataset.classes, yticklabels=train_dataset.classes)
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()
3. 自然图像识别（ImageNet）

项目介绍
ImageNet数据集包含超过100万张带标签的高分辨率图像，分为1000个类别。它是深度学习和计算机视觉领域的标准数据集。

步骤

  1. 使用预训练模型
  2. 微调模型
  3. 模型评估

详细过程

  1. 使用预训练模型
from torchvision import models

model = models.resnet18(pretrained=True)
  1. 微调模型
# 冻结除最后一层外的所有层
for param in model.parameters():
    param.requires_grad = False

# 替换最后一层
model.fc = nn.Linear(model.fc.in_features, 1000)

# 仅训练最后一层
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
  1. 模型训练
for epoch in range(5):  # 训练5个epoch
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
  1. 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total:.2f}%')

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

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

相关文章

欢乐钓鱼大师通关必备秘籍！云手机游戏辅助！

欢乐钓鱼大师通关必备秘籍！云手机游戏辅助！

《欢乐钓鱼大师》是一款让玩家沉浸在放松钓鱼乐趣中的手机游戏。不同于传统钓鱼游戏，它融合了收集、升级和竞技等元素，让每位玩家可以根据自己的喜好和目标来发展钓鱼技艺。本攻略将为您详细介绍如何在游戏中迅速提升实力，达到通关的最高境界…
阅读更多...
idea Alt+/ 自动补全变量名开头是大写 改 选择小写开头变量名

idea Alt+/ 自动补全变量名开头是大写 改 选择小写开头变量名

idea 中自动补全变量名是非常常见的操作，变量名一般都需要小写开头，但是idea中 Alt / 自动补全变量名时 补全的变量名是大写的，这就很难受了。如下图所示： AutowiredLogService LogService;Ctrl 空格 快捷键 虽然不像 Alt / 一…
阅读更多...
基于51单片机的智能语音电子秤设计

基于51单片机的智能语音电子秤设计

一.硬件方案 电子秤的测量原理是被称量物体的重量使传感器弹性体发生变形，输出与重量成正比的电信号，传感器输出信号经放大器放大后，输入转换器进行转换，转换成的频率信号直接送入微处理器中，其数字量由微机进行处理&…
阅读更多...
PMS助力制造企业高效运营︱PMO大会

PMS助力制造企业高效运营︱PMO大会

全国PMO专业人士年度盛会 北京易贝恩项目管理科技有限公司副总经理朱洪泽女士受邀为PMO评论主办的2024第十三届中国PMO大会演讲嘉宾，演讲议题为“PMS助力制造企业高效运营”。大会将于6月29-30日在北京举办，敬请关注！ 议题简要： …
阅读更多...
【Better Lighting V2】Blender商城10周年免费送插件灯光预设和图案轮库场景打光和模拟光透过图案水滴波纹效果

【Better Lighting V2】Blender商城10周年免费送插件灯光预设和图案轮库场景打光和模拟光透过图案水滴波纹效果

Blender商城10周年免费送插件：https://blendermarket.com/birthday Better Lighting V2 灯光预设和图案轮库 模拟各种环境下光线透过物体效果 各种预设快速调整 非常简单和快速打光调色 更多详细介绍：https://blendermarket.com/products/bette…
阅读更多...
基于python_CNN的人体姿态行为识别-含数据集+pyqt界面

基于python_CNN的人体姿态行为识别-含数据集+pyqt界面

代码下载地址： https://download.csdn.net/download/qq_34904125/89383060 本代码是基于python pytorch环境安装的。 下载本代码后，有个requirement.txt文本，里面介绍了如何安装环境，环境需要自行配置。 或可直接参考下面博文…
阅读更多...
【数据结构与算法】哈夫曼树与哈夫曼编码

【数据结构与算法】哈夫曼树与哈夫曼编码

文章目录 哈夫曼树（最优二叉树）定义举个🌰（WPL的计算） 哈夫曼树的构造（最优二叉树的构造）举个🌰 哈夫曼树的性质 哈夫曼编码定义构造 哈夫曼树（最优二叉树） …
阅读更多...
SD3开源：AI绘画的新纪元，出图效果巨好，不容错过！（附教程）

SD3开源：AI绘画的新纪元，出图效果巨好，不容错过！（附教程）

大家好，我是画画的小强。 这两天，Stability AI 将史上最牛的AI绘画模型SD3开源了，真是有格局！ 虽说只是中杯的20亿参数版本，但我已经很满足了，再高的版本，我这普通的16G 4070Ti Super 显卡也跑…
阅读更多...
【Java】类与类的关系及其总结

【Java】类与类的关系及其总结

类和类的关系 代码 总结： 【1】面向对象的思维：找参与者，找女孩类，找男孩类 【2】体会了什么叫方法的性擦，什么叫方法的实参： 具体传入的内容 实参： 【3】类和类可以产生关系： …
阅读更多...
IIC通信总线

IIC通信总线

文章目录 1. IIC总线协议1. IIC简介2. IIC时序1. 数据有效性2. 起始信号和终止信号3. 数据格式4. 应答和非应答信号5. 时钟同步6. 写数据和读数据 2. AT24C023. AT24C02读写时序4. AT24C02配置步骤5. 代码部分1. IIC基本信号2. AT24C02驱动代码3. 实验结果分析 1. IIC总线协议 …
阅读更多...
上位机图像处理和嵌入式模块部署（h750和市场上的开发板）

上位机图像处理和嵌入式模块部署（h750和市场上的开发板）

【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing 163.com】 目前在电商网站上面，关于h750的开发板很多。一种是某原子和某火出品的板子，这一类的板子就是做的比较大，功能比…
阅读更多...
【python-AI篇】人工智能技能树思维导图

【python-AI篇】人工智能技能树思维导图

大致总结一下得出如下思维导图，如不完善日后迭代更新 1. python基础三方库 1.1 科学计算库 ---- numpy库 1.2 科学计算库 ---- Scipy库 1.3 数据分析处理库 ---- pandas库 1.4 可视化库 ---- matplotlib库 1.5 可视化库 ---- seaborn库 1.6 机器学习和数据挖掘库 …
阅读更多...
定个小目标之刷LeetCode热题（20）

定个小目标之刷LeetCode热题（20）

这题与上一题有一点不同，上一题是判断链表是否存在环，这题是寻找入环的第一个节点，有一个规则是这样的，在存在环的情况下，运用快慢指针判断是否有环结束时，把快指针指向头结点，慢指针不变&#…
阅读更多...
【TB作品】MSP430 G2553 单片机 口袋板 日历 时钟 闹钟 万年历 电子时钟 秒表显示

【TB作品】MSP430 G2553 单片机 口袋板 日历 时钟 闹钟 万年历 电子时钟 秒表显示

文章目录 功能介绍操作方法部分流程图代码录制了一个演示视频可以下载观看 功能介绍 时间与日期显示： 实时显示当前时间（小时、分钟、秒）和日期（年、月、日）。 闹钟功能： 设置闹钟时间（小时、分…
阅读更多...
仿FC数学金刚游戏介绍

仿FC数学金刚游戏介绍

简介 Math Monkey是Simple2l工作室开发的第二款小游戏，灵感来源于FC游戏平台的数学金刚游戏。小学时玩FC游戏是业余时间最期待的事情，还记得有一次和玩伴玩游戏时已经晚上了，于是约定再玩一把就各回各家，没想到又连玩了N把每一把…
阅读更多...
12.容器间的互联（--link 是单方向的！！！）

12.容器间的互联（--link 是单方向的！！！）

容器间的互联（–link 是单方向的！！！） –link意思就是链接容器进行通信 用法：--link 容器名字:随意设置别名；例如：--link nginx:nginx 注释：同一个容器中，可…
阅读更多...
mysql报错Access denied for user ‘root‘,navicat可以连接mysql，spring不能连mysql

mysql报错Access denied for user ‘root‘,navicat可以连接mysql，spring不能连mysql

首先修改配置文件跳过验证，编辑你自己挂载的配置文件的位置 #查找my.cnf位置 sudo find / -name "my.cnf"编辑mysql配置文件 vim /opt/soft/mysql/conf/my.cnf #在[mysqld]下面添加 skip_grant_tables#重启mysql docker restart mysql#进入容器 docke…
阅读更多...
【ARMv8/ARMv9 硬件加速系列 3.2 -- SVE 读写内存指令 st1b | st1w | st1w | st1d 使用介绍】

【ARMv8/ARMv9 硬件加速系列 3.2 -- SVE 读写内存指令 st1b | st1w | st1w | st1d 使用介绍】

文章目录 SVE Load 和 Store 指令使用介绍LD1 加载指令ST1 存储指令PFR 预取指令参考示例LD1 加载示例ST1 存储示例代码实例SVE Load 和 Store 指令使用介绍 ARMv9架构中的SVE（Scalable Vector Extension）指令集为向量计算提供了强大支持，特别是针对不同数据类型和访问模式…
阅读更多...
计算机游戏因为d3dcompiler_47.dll丢失无法启动怎么办？解决只要d3dcompiler_47.dll丢失无法启动游戏软件的方法

计算机游戏因为d3dcompiler_47.dll丢失无法启动怎么办？解决只要d3dcompiler_47.dll丢失无法启动游戏软件的方法

d3dcompiler_47.dll 是一个动态链接库文件，属于 Microsoft DirectX 的一部分，主要负责编译和运行 3D 图形程序。它是支持 Direct3D 功能的核心组件，Direct3D 是一种用于编程 3D 图形的 API，广泛应用于游戏和图形密集型应用程序中。…
阅读更多...
面试官考我Object类中的所有方法及场景使用？我...

面试官考我Object类中的所有方法及场景使用？我...

咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及Java 知识点啦，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯&a…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站