深度学习 Day13——P2彩色图片分类

基于深度学习的视觉检测小项目(八) 界面的配色系统和样式表的概念 由于我的业务范围偏向于工业scada软件,所以在设计风格和体系建设上都比较倾向于这方面。类似于scada和大数据展示这一类需要操作员长期盯着看的屏幕,有一个基本要求就是颜色不能过于鲜艳,就是说色纯度不要太高,尤其是不要大面积使用荧光色、纯红、纯绿、纯蓝这些过于显眼的颜色,容易引起人的视觉疲劳。这几年流行的暗灰界面,就很适合做scada的主界面。一个典型的优秀暗黑界面demo赏析:Intel killer软件界面。颜色配置很和谐,很舒服,看久不累。 阅读详情


前言

本文将采用pytorch框架创建CNN网络,实现简单彩色图片分类。讲述实现代码与执行结果,并浅谈涉及知识点。
关键字: torch.nn常用网络层Conv2d、Linear和MaxPool2d详解,torch.nn网络训练相关函数optimizer.zero_grad()、loss.backward()、optimizer.step()详解, opencv、matplotlib、pillow和pytorch读取数据的通道顺序。

1 我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境:
    torch == 1.9.1+cu111
    torchvision == 0.10.1+cu111
  • 显卡:NVIDIA GeForce RTX 4070

2 代码实现与执行结果

2.1 前期准备

2.1.1 引入库

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率
import torchvision
import numpy as np
from torchinfo import summary
import torch.nn.functional as F
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.1.2 设置GPU(如果设备上支持GPU就使用GPU,否则使用CPU)

"""前期准备-设置GPU-"""
# 如果设备上支持GPU就使用GPU,否则使用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

输出

cuda

2.1.3 导入数据

'''前期工作-导入数据'''
train_ds = torchvision.datasets.CIFAR10('data',
                                      train=True,
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

test_ds  = torchvision.datasets.CIFAR10('data',
                                      train=False,
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_ds, 
                                       batch_size=batch_size, 
                                       shuffle=True)

test_dl  = torch.utils.data.DataLoader(test_ds, 
                                       batch_size=batch_size)

2.1.4 查看数据

'''前期工作-查看数据'''                                       
# 取一个批次查看数据格式
# 数据的shape为:[batch_size, channel, height, weight]
# 其中batch_size为自己设定,channel,height和weight分别是图片的通道数,高度和宽度。
imgs, labels = next(iter(train_dl))  # 通过 iter(train_dl) 创建一个数据迭代器,然后使用 next(train_dl) 从训练数据加载一个批次的图像和对应的标签。
# images包含了一批图像,labels 包含了这些图像的类别标签。
print(imgs.shape)

输出

torch.Size([32, 1, 28, 28])

2.1.5.数据可视化

'''前期工作-数据可视化'''
# 指定图片大小,图像大小为20宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(20, 5))
for i, img in enumerate(imgs[:20]):
    npimg = img.numpy().transpose((1, 2, 0))# 转换图像的数组格式 : transpose (C, H, W) -> (H, W, C)
    # 将整个figure分成2行10列,绘制第i+1个子图。
    plt.subplot(2, 10, i + 1)
    plt.imshow(npimg)
    plt.axis('off')

plt.show()  #如果你使用的是Pycharm编译器,请加上这行代码

在这里插入图片描述

2.2 构建CNN网络模型

在这里插入图片描述

"""构建CNN网络"""


num_classes = 10  # 图片的类别数


class Model(nn.Module):
    def __init__(self):
        super().__init__()
        # 特征提取网络
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)  # 第一层卷积,卷积核大小为3*3
        self.pool1 = nn.MaxPool2d(kernel_size=2)  # 设置池化层,池化核大小为2*2
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3)  # 第二层卷积,卷积核大小为3*3
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3)  # 第二层卷积,卷积核大小为3*3
        self.pool3 = nn.MaxPool2d(kernel_size=2)

        # 分类网络
        self.fc1 = nn.Linear(512, 256)
        self.fc2 = nn.Linear(256, num_classes)

    # 前向传播
    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool2(F.relu(self.conv2(x)))
        x = self.pool3(F.relu(self.conv3(x)))

        x = torch.flatten(x, start_dim=1)

        x = F.relu(self.fc1(x))
        x = self.fc2(x)

        return x


# 将模型转移到GPU中(我们模型运行均在GPU中进行)
model = Model().to(device)
summary(model)

输出

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            1,792
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            36,928
├─MaxPool2d: 1-4                         --
├─Conv2d: 1-5                            73,856
├─MaxPool2d: 1-6                         --
├─Linear: 1-7                            131,328
├─Linear: 1-8                            2,570
=================================================================
Total params: 246,474
Trainable params: 246,474
Non-trainable params: 0
=================================================================

2.3 训练模型

2.3.1 训练模型

"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss()  # 创建损失函数,计算实际输出和真实相差多少,交叉熵损失函数,事实上,它就是做图片分类任务时常用的损失函数
learn_rate = 1e-2  # 学习率
opt = torch.optim.SGD(model.parameters(), lr=learn_rate)  # 作用是定义优化器,用来训练时候优化模型参数;其中,SGD表示随机梯度下降,用于控制实际输出y与真实y之间的相差有多大

2.3.2 编写训练函数

"""训练模型--编写训练函数"""
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小,一共60000张图片
    num_batches = len(dataloader)  # 批次数目,1875(60000/32)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 加载数据加载器,得到里面的 X(图片数据)和 y(真实标签)
        X, y = X.to(device), y.to(device) # 用于将数据存到显卡

        # 计算预测误差
        pred = model(X)  # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距,targets为真实值,计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # 清空过往梯度
        loss.backward()  # 反向传播,计算当前梯度
        optimizer.step()  # 根据梯度更新网络参数

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.3.3 编写测试函数

"""训练模型--编写测试函数"""
# 测试函数和训练函数大致相同,但是由于不进行梯度下降对网络权重进行更新,所以不需要传入优化器
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小,一共10000张图片
    num_batches = len(dataloader)  # 批次数目,313(10000/32=312.5,向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时,停止梯度更新,节省计算内存消耗
    with torch.no_grad(): # 测试时模型参数不用更新,所以 no_grad,整个模型参数正向推就ok,不反向更新参数
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#统计预测正确的个数

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

2.3.4 正式训练

"""训练模型--正式训练"""
epochs = 10
train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}')
    print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss))
print('Done')

输出

Epoch: 1, Train_acc:13.6%, Train_loss:2.263, Test_acc:22.1%,Test_loss:2.085
Epoch: 2, Train_acc:25.5%, Train_loss:2.003, Test_acc:29.4%,Test_loss:1.921
Epoch: 3, Train_acc:33.6%, Train_loss:1.808, Test_acc:32.6%,Test_loss:1.931
Epoch: 4, Train_acc:40.4%, Train_loss:1.630, Test_acc:41.6%,Test_loss:1.627
Epoch: 5, Train_acc:44.5%, Train_loss:1.527, Test_acc:45.4%,Test_loss:1.540
Epoch: 6, Train_acc:47.9%, Train_loss:1.441, Test_acc:49.7%,Test_loss:1.384
Epoch: 7, Train_acc:51.2%, Train_loss:1.355, Test_acc:51.3%,Test_loss:1.357
Epoch: 8, Train_acc:54.2%, Train_loss:1.283, Test_acc:53.7%,Test_loss:1.291
Epoch: 9, Train_acc:57.0%, Train_loss:1.212, Test_acc:57.4%,Test_loss:1.202
Epoch:10, Train_acc:59.0%, Train_loss:1.159, Test_acc:55.5%,Test_loss:1.251
Done

2.4 结果可视化

"""训练模型--结果可视化"""
epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

3 知识点详解

3.1 torch.nn常用网络层Conv2d、Linear和MaxPool2d详解

3.1.1 torch.nn.Conv2d()详解

函数原型:
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’, device=None, dtype=None)
关键参数说明:
in_channels ( int ) – 输入图像中的通道数
out_channels ( int ) – 卷积产生的通道数
kernel_size ( int or tuple ) – 卷积核的大小
stride ( int or tuple , optional ) – 卷积的步幅。默认值:1
padding ( int , tuple或str , optional ) – 添加到输入的所有四个边的填充。默认值:0
dilation (int or tuple, optional) - 扩张操作:控制kernel点(卷积核点)的间距,默认值:1。
padding_mode (字符串,可选) – ‘zeros’, ‘reflect’, ‘replicate’或’circular’. 默认:‘zeros’
关于dilation参数图解:
在这里插入图片描述
以下动图展示了in_channels=3、out_channels =2,kernel_size=3、stride=2、padding=1的卷积层运算过程。
换成Python语句可表示为

self.conv1 = nn.Conv2d(in_channels=3, out_channels=2, kernel_size=3, stride=2, padding=1)

在这里插入图片描述

3.1.2 torch.nn.Linear()详解

函数原型:
torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
关键参数说明:
in_features:每个输入样本的大小
out_features:每个输出样本的大小

3.1.3 torch.nn.MaxPool2d()详解

函数原型:
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
关键参数说明:
kernel_size:最大的窗口大小
stride:窗口的步幅,默认值为kernel_size
padding:填充值,默认为0
dilation:控制窗口中元素步幅的参数

3.1.4. 关于卷积层、池化层的计算:

下面的网络数据shape变化过程为:
3, 32, 32(输入数据)
-> 64, 30, 30(经过卷积层1)-> 64, 15, 15(经过池化层1)
-> 64, 13, 13(经过卷积层2)-> 64, 6, 6(经过池化层2)
-> 128, 4, 4(经过卷积层3) -> 128, 2, 2(经过池化层3)
-> 512 -> 256 -> num_classes(10)
参看文章深度学习CNN网络–卷积层、池化层、全连接层详解与其参数量计算可手动推导这个过程。
网络结构图(可单击放大查看):
在这里插入图片描述

3.2. torch.nn网络训练相关函数optimizer.zero_grad()、loss.backward()、optimizer.step()详解

3.2.1 optimizer.zero_grad()

函数会遍历模型的所有参数,通过内置方法截断反向传播的梯度流,再将每个参数的梯度值设为0,即上一次的梯度记录被清空。

3.2.2 loss.backward()

PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的,autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。

具体来说,torch.tensor是autograd包的基础类,如果你设置tensor的requires_grads为True,就会开始跟踪这个tensor上面的所有运算,如果你做完运算后使用tensor.backward(),所有的梯度就会自动运算,tensor的梯度将会累加到它的.grad属性里面去。

更具体地说,损失函数loss是由模型的所有权重w经过一系列运算得到的,若某个w的requires_grads为True,则w的所有上层参数(后面层的权重w)的.grad_fn属性中就保存了对应的运算,然后在使用loss.backward()后,会一层层的反向传播计算每个w的梯度值,并保存到该w的.grad属性中。

如果没有进行tensor.backward()的话,梯度值将会是None,因此loss.backward()要写在optimizer.step()之前。

3.2.3 optimizer.step()

step()函数的作用是执行一次优化步骤,通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的,所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

注意:optimizer只负责通过梯度下降进行优化,而不负责产生梯度,梯度是tensor.backward()方法产生的。

3.3 opencv、matplotlib、pillow和pytorch读取数据的通道顺序

  • opencv(imread,imshow):uint8的ndarray数据,通道顺序hwc,颜色通道BGR。
  • matplotlib(imread,imshow):uint8的ndarray数据,通道顺序hwc,颜色通道RGB。
  • pillow(open,show):自己的数据结构。可以np.array(image)转换成numpy数组:uint8的ndarray数据,通道顺序hwc,颜色通道RGB。可以Image.fromarray(image)将numpy数组类型转化为pillow类型。
  • pythorch(torchvision.datasets、torch.utils.data.DataLoader及torchvision.io.read_image):ToTensor()到[0, 1]的torch数据,通道顺序nchw,颜色通道RGB,查看图片方法及ToPILImage。

总结:除了pytorch得到的是nchw图片,其余方法得到的都是hwc图片;除了cv2得到的c是bgr图片,其余方法得到的c都是rgb图片;plt.imshow()既可以显示(H,W)灰色图片,也可以显示(H,W,C=3)的numpy或torch类型的RGB图片,但nhwc某批次里的图片只能一张一张显示.

总结

通过本文的学习,对torch.nn常用网络层Conv2d、Linear和MaxPool2d有了更深的了解。

深度学习模型图常用配色 将CVPR、ICCV、AAAI论文中模型图的配色进行了整理。 阅读详情

相关推荐

使用深度学习自动为黑白图片上色

随着深度学习技术的发展,图像处理领域取得了显著的进展。自动为黑白图片上色是计算机视觉领域的一个重要应用,它可以使老照片焕发新生,提高图像质量。在本文中,我们将使用卷积神经网络(CNN)来构建一个自动为黑白图片上色的模型。

斌擎科技 750

【深度学习——彩色图片分类】

池化层对提取到的特征信息进行降维,一方面使特征图变小,简化网络层计算复杂度;另一方面进行压缩,提取主要特征,增加平移不变性,减少过拟合风险。池化层包括最大池化层和平均池化层,均值池化对背景保留更好,最大池化对纹理提取更好。同卷积计算,池化层计算窗口内的平均值或者最大值。通过模型进行预测得到是每一个类别的概率,数字越大该图片为该类别的可能性越大。3的图片,通过填充一层边界,在通过2。

qq_45786199的博客 550

颜色分类leetcode-Pytorch-Model-Zoo:在PyTorch中实现的深度学习模型集合

颜色分类leetcode PyTorch 中的深度学习模型 注意:该项目不再积极维护。 随意发送 PR 或分叉它。 该存储库包含内置的深度学习模型。 旨在学习 PyTorch,此 repo 对具有基本 Python 和深度学习知识的人来说很容易理解。 各种重要的深度学习模型都在这里实现。 还提供了论文的链接。 每个项目的结构是一致的: model.py - 包含神经网络模型。 train.py - 预处理数据并训练网络。 test.py - 从经过训练的网络推断。 任何其他支持文件。 常用文件夹: 训练过的文件夹 - 训练过的模型可以保存在这里。 数据集文件夹 - 下载的数据集将存储在此处。 使用最佳实践,如 PEP8、dropout、批量标准化、合适的优化器。 IMP:为了在 CPU 上进行训练,请在您找到的任何地方删除 '.cuda()'。 楷模 1. CNN 图像分类: 空间变换网络 你只看一次 超分辨率 艺术风格转移 深度照片风格迁移 神经涂鸦 图像着色 2. RNN 语音识别:(如果可能的话)(也许) 生成序列: 序列到序列注意: 神经机器翻译: 会话模型: 跳过想法 3.

深度学习——(CNN)_彩色图片分类 | 01

目录 一、前期工作 1.设置GPU 2.导入数据 3.归一化 4.可视化 二、构建CNN网络 三、编译 四、训练模型 五、预测 六、模型评估 一、前期工作 1.设置GPU 2.导入数据 3.归一化 4.可视化 二、构建CNN网络 三、编译 四、训练模型 五、预测 六、模型评估 ...

weixin_45823221的博客 1060

AI虚拟人物 数字人直播,不用出镜,不用露脸的直播方式(附教程 软件)

我们先来看一组数据,这是我通过蝉妈妈查到的某位虚拟主播的一个带货数据,粉丝还不到 3000 人,每次直播 1 到 4 个小时,30天的总销量达到了1200单,15天,总销售额 2 万,可能相对来说客单价还是比较低,最关键的是才直播了 6 场,如果说他能够一个月直播 20 天,每天花 4个小时去直播,当个副业来做,就可以达到最起码月入 3 万的一个收入水平,我个人觉得是非常的不错的。大家把商品图片放在背景,只要场景设置的不错,场景和产品的关联度高,直播的时候挂上购买链接也会有一定的成交。

. 7万+

在 Linux/Debian/Ubuntu 上使用 Brasero 刻录光盘

在 Ubuntu 系统中,Brasero 是一个非常方便的光盘刻录工具。无论是创建数据光盘、音频光盘还是刻录光盘镜像文件,Brasero 都能轻松胜任。本文将介绍如何在 Ubuntu 上安装和使用 Brasero 进行光盘刻录。

I AM COMING BACK... 3553

深度学习 Day25——使用Pytorch实现彩色图片识别

365天深度学习训练营 [第十五周]——本期博客我们将学习使用Pytorch实现彩色图片的识别,并尝试通过PyTorchViz 库可视化我们构建的CNN网络结构。

北天的博客 3680

别再只用GWR了!用Python的mgtwr包搞定时空地理加权回归(GTWR)实战

本文详细介绍了如何使用Python的mgtwr包进行时空地理加权回归(GTWR)实战,突破传统GWR模型的局限。通过核心差异解析、实战全流程演示和进阶技巧,帮助读者掌握GTWR在房价波动、污染物扩散等时空数据分析中的应用,提升模型预测精度。

weixin_30899023的博客 349

【Day40】

训练完成,绘制训练历史...可视化模型预测结果...训练和测试的规范写法。

m0_70583395的博客 402

投第一篇SCIE英文期刊(详细步骤)

一个投稿SCIE英文期刊的过程

weixin_48849679的博客 1万+

IMX335摄像头原理图设计,已量产

从工程组织上看,IMX335 模组和 IMX415 模组属于同一类产品:核心矛盾不是外设多,而是高速图像链路、电源域和调试接口要同时兼顾。ATK-MCIMX335 这张图的结构也很直接,三路 LDO、本地 24MHz 可选时钟、4-lane MIPI 数据对和一组主板侧标准接口,构成了一张非常典型的量产摄像头子板。

不脱发的程序猿 443

day02--深度学习之彩色图片分类

深度学习

qq_44246906的博客 626

ASP.NET Core 6 Web API在IIS上的部署与调试

通过以上步骤和配置,你应该能够成功部署并调试你的ASP.NET Core 6 Web API在IIS上。记住,权限和配置是关键,确保你的环境和应用程序代码都正确设置。希望这篇博客对你部署和解决IIS上的问题有所帮助。

m0_74337424的博客 522

深度学习 Day2——T2彩色图片分类

关键字:CIFAR-10数据集介绍,CNN网络模型结构,神经网络程序调用顺序,loss、val_loss与accuracy、val_accuracy含义

LittleRuby的博客 324

YOLOv8改进,MobileNetV3轻量化架构改进特征提取网络,助力涨点

MobileNetV3通过结合硬件感知网络架构搜索(NAS)和NetAdapt算法,通过新颖的架构改进进一步提升了性能。本文开始探讨了自动化搜索算法与网络设计如何协同工作,以利用互补方法来提升整体技术水平。通过这一过程,创建了两个新的MobileNet模型:MobileNetV3-Large和MobileNetV3-Small,分别针对高资源和低资源使用场景。这些模型随后被适配并应用于目标检测和语义分割任务。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 3837

python批量调用大模型API:多线程和异步协程

本文介绍了利用多线程技术批量调用大模型API的实现方法。核心是通过并发请求提高处理效率,主要采用线程池管理并发数量、结果聚合等技术。文章提供了一个完整的Python实现示例,包含APIBatchCaller类及其single_api_call和batch_call方法,详细解析了并发控制、错误处理等关键点,并给出了使用注意事项,包括并发数设置、重试策略和超时处理等。该方案特别适合IO密集型任务,能显著提升批量API调用的效率。

Cachel Wood的博客 760

深度学习-第T2周——彩色图片分类

)#以上为简单的tf八股模板,可以看B站的北大老师曹健的tensorflow笔记#这里设置优化器,损失函数以及metrics#设置优化器为Adam优化器#设置损失函数为交叉熵损失函数#模型评估plt.show()上述代码使用TensorFlow和Keras构建了一个简单的卷积神经网络模型(CNN),并在CIFAR-10数据集上进行训练和评估。代码概要:1. 导入所需的库:tensorflow、numpy和matplotlib.pyplot。

qq_60245590的博客 600

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

深度学习笔记02-CNN实现彩色图片分类(Tensorflow)

🍨本文为🔗365天深度学习训练营中的学习记录博客🍖K同学啊对于灰度图像,每个像素只有一个亮度值,因此通道数为1,彩色图片通道数为3(对应红、绿、蓝三种颜色)。

boooo_hhh的博客 1301

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

【毕业设计】基于深度学习与图像处理的目标颜色识别示例

本文是基于TensorFlow Lite深度学习框架在树莓派主板上应用的分享案例,具体流程包括目标颜色的选取,大概300张照片的标注,4个小时的目标训练,以及最后的测试。最后测试效果不错,不仅对于训练的目标颜色物体识别率很高,且能较准确的识别出非训练物体的颜色。

weixin_57658191的博客 2336

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

CNN | 01实现颜色分类

1 实现颜色分类 1.1 提出问题 大家知道卷积神经网络可以在图像分类上发挥作用,而一般的图像都是彩色的,也就是说卷积神经网络应该可以判别颜色的。这一节中我们来测试一下颜色分类问题,也就是说,不管几何图形是什么样子的,只针对颜色进行分类。 先看一下样本数据,如图18-14。 图18-14 颜色分类样本数据图 在样本数据中,一共有6种颜色,分别是: 红色 red 绿色 green 蓝色 blue 青色(蓝+绿) cyan 黄色(红+绿) yellow 粉色(红+蓝) pink 而这6种颜色是分布在5种形

“逛丢一只鞋”的博客 9407

深度学习训练营之彩色图片分类

本次主要学习对图片进行分类的操作

qq_62904883的博客 502

365天深度学习训练营-第P2周:彩色图片识别

- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/xLjALoOD8HPZcH563En8bQ) 中的学习记录博客**>- **🍦 参考文章:[365天深度学习训练营-第P2周:彩色识别](https://mp.weixin.qq.com/s/BKsTrlOtu32bQzgORaMLEw)**>- **🍖 原作者:[K同学啊|接辅导、项目定制](https://mtyjkh.blog.youkuaiyun.com/)**📌第P2周:彩色图片识别📌。

weixin_44954995的博客 1049

LeetCode 学习:颜色分类

https://leetcode-cn.com/problems/sort-colors/ class Solution: def sortColors(self, nums: List[int]) -> None: """ Do not return anything, modify nums in-place instead. """ num_zero,num_one,num_two=0,0,0 for i

不积跬步,无以至千里 1435

深度学习:彩色图片识别

🍨 本文为🔗365天深度学习训练营中的学习记录博客365天深度学习训练营-第P2周:彩色识别通过这个案例,主要学习了卷积层的计算,以及池化层的计算。下一阶段目标将模型训练作为重点学习目标。

sinat_42392992的博客 1112

Tensorflow深度学习之十二:基础图像处理之二

首先放出原始图像:1、图像的翻转import tensorflow as tf import cv2# 这里定义一个tensorflow读取的图片格式转换为opencv读取的图片格式的函数 # 请注意: # 在tensorflow中,一个像素点的颜色顺序是R,G,B。 # 在opencv中,一个像素点的颜色顺序是B,G,R。 # 因此,我们循环遍历每一个像素点,将第0位的颜色和第2位的颜色数值换一下

DaVinciL的博客 4974

Nature审稿人喜欢的绘图配色分享(附颜色代码)

这篇笔记整理了【Nature正刊绘图配色】,对于写论文或者是参加数学建模比赛。

Magnolia_He的博客 1万+
上一篇: 深度学习 Day12——P1实现mnist手写数字识别
下一篇: 深度学习 Day14——P3天气识别
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值