宇宙超级无敌小菜鸡

Pytorch实现InceptionV4模型

模型简介
split-transform-merge模型
InceptionV4的基本模块及源码
- 卷积模块
- InceptionA模块
- InceptionB模块
- InceptionC模块
- ReductionA模块
- ReductionB模块
- Stem模块
InceptionV4模型及源码
完整源码

模型简介

论文链接：https://arxiv.org/pdf/1602.07261.pdf
模型提出时间：2016年

split-transform-merge模型

split-transform-merge模型即“分离-变换-合并”模型，顾名思义，该模型包括分离、变换和合并三步。
神经网络中的单个神经元(perceptron)就是最简单的split-transform-merge模型，其工作过程包括：将输入矢量x=[x₁,x₂,…,x_D]分离为D个数值(split)，各维矢量值与权值相乘(transform)，累加求和(merge)。

Inception系列的模型均属于split-transform-merge模型，其工作过程包括：将输入图片分为多个通道进行处理(split)，各通道内的卷积、池化变换(transform)，各通道的输出叠加得到最终输出(merge)。

InceptionV4的基本模块及源码

卷积模块

InceptionV4的所有卷积模块均有三部分构成：卷积、批标准化和激活。模型中一共包含了三类卷积核：第一类卷积核stride=2且padding=0，功能是压缩图片的大小；第二类卷积核stride=1且padding=⌊kernelsize/2⌋，功能是提取特征但不改变图片的大小；第三类卷积核是非对称卷积核，kernelsize=(x,y),stride=1且padding=(⌊x/2⌋,⌊y/2⌋)，功能是提取特征但不改变图片的大小。下文中三类卷积核分别由红色、绿色和蓝色标注，源码如下：

# 卷积核1：stride=2，padding=0
def Conv1(input_channel, output_channel, kernel_size):
    return nn.Sequential(
        nn.Conv2d(input_channel, output_channel, kernel_size, stride=2, padding=0),
        nn.BatchNorm2d(output_channel),
        nn.ReLU(inplace = True)
    )
# 卷积核2：对称卷积核，stride=1, padding=kernel_size//2
def Conv2(input_channel, output_channel, kernel_size):
    return nn.Sequential(
        nn.Conv2d(input_channel, output_channel, kernel_size, stride=1, padding=kernel_size//2),
        nn.BatchNorm2d(output_channel),
        nn.ReLU(inplace=True)
    )
# 卷积核3：非对称卷积核，kernel_size=(kernel_size1, kernel_size2),
#          stride=1，padding=(kernel_size1//2, kernel_size2//2)
def Conv3(input_channel, output_channel, kernel_size1, kernel_size2):
    return nn.Sequential(
        nn.Conv2d(input_channel, output_channel, kernel_size=(kernel_size1, kernel_size2), 
                  stride=1, padding=(kernel_size1//2, kernel_size2//2)),
        nn.BatchNorm2d(output_channel),
        nn.ReLU(inplace = True)
    )

InceptionA模块

InceptionA模块的源码如下：

# InceptionA
class InceptionA(nn.Module):
    def __init__(self, input_channel):
        super(InceptionA, self).__init__()
        self.block1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            Conv2(input_channel, 96, 1)
        )
        self.block2 = Conv2(input_channel, 96, 1)
        self.block3 = nn.Sequential(
            Conv2(input_channel, 64, 1),
            Conv2(64, 96, 3)
        )
        self.block4 = nn.Sequential(
            Conv2(input_channel, 64, 1),
            Conv2(64, 96, 3),
            Conv2(96, 96, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x4 = self.block4(x)
        x = torch.cat([x1, x2, x3, x4], dim=1)
        return x

InceptionB模块

InceptionB模块的源码如下：

# InceptionB
class InceptionB(nn.Module):
    def __init__(self, input_channel):
        super(InceptionB, self).__init__()
        self.block1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            Conv2(input_channel, 128, 1)
        )
        self.block2 = Conv2(input_channel, 384, 1)
        self.block3 = nn.Sequential(
            Conv2(input_channel, 192, 1),
            Conv3(192, 224, 1, 7),
            Conv3(224, 256, 1, 7)
        )
        self.block4 = nn.Sequential(
            Conv2(input_channel, 192, 1),
            Conv3(192, 192, 1, 7),
            Conv3(192, 224, 7, 1),
            Conv3(224, 224, 1, 7),
            Conv3(224, 256, 7, 1)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x4 = self.block4(x)
        x = torch.cat([x1, x2, x3, x4], dim=1)
        return x

InceptionC模块

InceptionC模块的源码如下：

# InceptionC
class InceptionC(nn.Module):
    def __init__(self, input_channel):
        super(InceptionC, self).__init__()
        self.block1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            Conv2(input_channel, 256, 1)
        )
        self.block2 = Conv2(input_channel, 256, 1)
        self.block3 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 256, 1, 3)
        )
        self.block4 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 256, 3, 1)    
        )
        self.block5 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 448, 1, 3),
            Conv3(448, 512, 3, 1),
            Conv3(512, 256, 3, 1)
        )
        self.block6 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 448, 1, 3),
            Conv3(448, 512, 3, 1),
            Conv3(512, 256, 1, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x4 = self.block4(x)
        x5 = self.block5(x)
        x6 = self.block6(x)
        x = torch.cat([x1, x2, x3, x4, x5, x6], dim=1)
        return x

ReductionA模块

ReductionA模块的源码如下：

# ReductionA:将35*35的图片降维至17*17
class ReductionA(nn.Module):
    def __init__(self, input_channel, k, l, m, n):
        super(ReductionA, self).__init__()
        self.block1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.block2 = Conv1(input_channel, n, 3)
        self.block3 = nn.Sequential(
            Conv2(input_channel, k, 1),
            Conv2(k, l, 3),
            Conv1(l, m, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x = torch.cat([x1, x2, x3], dim=1)
        return x

ReductionB模块

ReductionB模块的源码如下：

# ReductionB:将17*17的图片降维至8*8
class ReductionB(nn.Module):
    def __init__(self, input_channel):
        super(ReductionB, self).__init__()
        self.block1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.blocl2 = nn.Sequential(
            Conv2(input_channel, 192, 1),
            Conv1(192, 192, 3)
        )
        self.block3 = nn.Sequential(
            Conv2(input_channel, 256, 1),
            Conv3(256, 256, 1, 7),
            Conv3(256, 320, 7, 1),
            Conv1(320, 320, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x = torch.cat([x1, x2, x3], dim=1)
        return x

Stem模块

Stem模块的源码如下：

# Stem
class Stem(nn.Module):
    def __init__(self):
        super(Stem, self).__init__()
        self.block1 = nn.Sequential(
            Conv1(3, 32, 3),
            nn.Conv2d(32, 32, 3, stride=1, padding=0),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            Conv2(32, 64, 3)
        )
        self.block2_1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.block2_2 = nn.Sequential(
            Conv1(64, 96, 3)
        )
        self.block3_1 = nn.Sequential(
            Conv2(160, 64, 1),
            nn.Conv2d(160, 96, 3, stride=1, padding=0),
            nn.BatchNorm2d(96),
            nn.ReLU()
        )
        self.block3_2 = nn.Sequential(
            Conv2(160, 64, 1),
            Conv3(64, 64, 7, 1),
            Conv3(64, 64, 1, 7),
            nn.Conv2d(64, 96, 3, stride=1, padding=0),
            nn.BatchNorm2d(96),
            nn.ReLU()
        )
        self.block4_1 = Conv1(192, 192, 3)
        self.block4_2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)    
    def forward(self, x):
        x = self.block1(x)
        x1 = self.block2_1(x)
        x2 = self.block2_2(x)
        x = torch.cat([x1, x2], dim=1)
        x1 = self.block3_1(x)
        x2 = self.block3_2(x)
        x = torch.cat([x1, x2], dim=1)
        x1 = self.block4_1(x)
        x2 = self.block4_2(x)
        x = torch.cat([x1, x2], dim=1)
        return x

InceptionV4模型及源码

IncpetionV4模型由第三部分的基本模块构成，其结构如下图所示：

IncpetionV4模型的源码如下：

# InceptionV4 Network
class InceptionV4(nn.Module):
    def __init__(self):
        super(InceptionV4, self).__init__()
        self.block1 = Stem()
        self.block2 = nn.Sequential(
            InceptionA(384),
            InceptionA(384),
            InceptionA(384),
            InceptionA(384)
        )
        self.block3 = ReductionA(384, 192, 224, 256, 384)
        self.block4 = nn.Sequential(
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024)
        )
        self.block5 = ReductionB(1024)
        self.block6 = nn.Sequential(
            InceptionC(1536),
            InceptionC(1536),
            InceptionC(1536),
        )
        self.block7 = nn.Sequential(
            nn.AvgPool2d(kernel_size=8),
            nn.Dropout(p=0.8)
        )
        self.linear = nn.Linear(1536,1000)
    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = self.block6(x)
        x = self.block7(x)
        x = x.view(x.size(0), -1)
        x = self.linear(x)
        return x

完整源码

import torch
import torch.nn as nn
'''Inception V4 model'''
# 卷积核1：stride=2，padding=0
def Conv1(input_channel, output_channel, kernel_size):
    return nn.Sequential(
        nn.Conv2d(input_channel, output_channel, kernel_size, stride=2, padding=0),
        nn.BatchNorm2d(output_channel),
        nn.ReLU(inplace = True)
    )
# 卷积核2：对称卷积核，stride=1, padding=kernel_size//2
def Conv2(input_channel, output_channel, kernel_size):
    return nn.Sequential(
        nn.Conv2d(input_channel, output_channel, kernel_size, stride=1, padding=kernel_size//2),
        nn.BatchNorm2d(output_channel),
        nn.ReLU(inplace=True)
    )
# 卷积核3：非对称卷积核，kernel_size=(kernel_size1, kernel_size2),
#          stride=1，padding=(kernel_size1//2, kernel_size2//2)
def Conv3(input_channel, output_channel, kernel_size1, kernel_size2):
    return nn.Sequential(
        nn.Conv2d(input_channel, output_channel, kernel_size=(kernel_size1, kernel_size2), 
                  stride=1, padding=(kernel_size1//2, kernel_size2//2)),
        nn.BatchNorm2d(output_channel),
        nn.ReLU(inplace = True)
    )
# InceptionA
class InceptionA(nn.Module):
    def __init__(self, input_channel):
        super(InceptionA, self).__init__()
        self.block1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            Conv2(input_channel, 96, 1)
        )
        self.block2 = Conv2(input_channel, 96, 1)
        self.block3 = nn.Sequential(
            Conv2(input_channel, 64, 1),
            Conv2(64, 96, 3)
        )
        self.block4 = nn.Sequential(
            Conv2(input_channel, 64, 1),
            Conv2(64, 96, 3),
            Conv2(96, 96, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x4 = self.block4(x)
        x = torch.cat([x1, x2, x3, x4], dim=1)
        return x
# InceptionB
class InceptionB(nn.Module):
    def __init__(self, input_channel):
        super(InceptionB, self).__init__()
        self.block1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            Conv2(input_channel, 128, 1)
        )
        self.block2 = Conv2(input_channel, 384, 1)
        self.block3 = nn.Sequential(
            Conv2(input_channel, 192, 1),
            Conv3(192, 224, 1, 7),
            Conv3(224, 256, 1, 7)
        )
        self.block4 = nn.Sequential(
            Conv2(input_channel, 192, 1),
            Conv3(192, 192, 1, 7),
            Conv3(192, 224, 7, 1),
            Conv3(224, 224, 1, 7),
            Conv3(224, 256, 7, 1)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x4 = self.block4(x)
        x = torch.cat([x1, x2, x3, x4], dim=1)
        return x
# InceptionC
class InceptionC(nn.Module):
    def __init__(self, input_channel):
        super(InceptionC, self).__init__()
        self.block1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=3, stride=1, padding=1),
            Conv2(input_channel, 256, 1)
        )
        self.block2 = Conv2(input_channel, 256, 1)
        self.block3 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 256, 1, 3)
        )
        self.block4 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 256, 3, 1)    
        )
        self.block5 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 448, 1, 3),
            Conv3(448, 512, 3, 1),
            Conv3(512, 256, 3, 1)
        )
        self.block6 = nn.Sequential(
            Conv2(input_channel, 384, 1),
            Conv3(384, 448, 1, 3),
            Conv3(448, 512, 3, 1),
            Conv3(512, 256, 1, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x4 = self.block4(x)
        x5 = self.block5(x)
        x6 = self.block6(x)
        x = torch.cat([x1, x2, x3, x4, x5, x6], dim=1)
        return x
# ReductionA:将35*35的图片降维至17*17
class ReductionA(nn.Module):
    def __init__(self, input_channel, k, l, m, n):
        super(ReductionA, self).__init__()
        self.block1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.block2 = Conv1(input_channel, n, 3)
        self.block3 = nn.Sequential(
            Conv2(input_channel, k, 1),
            Conv2(k, l, 3),
            Conv1(l, m, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x = torch.cat([x1, x2, x3], dim=1)
        return x
# ReductionB:将17*17的图片降维至8*8
class ReductionB(nn.Module):
    def __init__(self, input_channel):
        super(ReductionB, self).__init__()
        self.block1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.blocl2 = nn.Sequential(
            Conv2(input_channel, 192, 1),
            Conv1(192, 192, 3)
        )
        self.block3 = nn.Sequential(
            Conv2(input_channel, 256, 1),
            Conv3(256, 256, 1, 7),
            Conv3(256, 320, 7, 1),
            Conv1(320, 320, 3)
        )
    def forward(self, x):
        x1 = self.block1(x)
        x2 = self.block2(x)
        x3 = self.block3(x)
        x = torch.cat([x1, x2, x3], dim=1)
        return x
# Stem
class Stem(nn.Module):
    def __init__(self):
        super(Stem, self).__init__()
        self.block1 = nn.Sequential(
            Conv1(3, 32, 3),
            nn.Conv2d(32, 32, 3, stride=1, padding=0),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            Conv2(32, 64, 3)
        )
        self.block2_1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.block2_2 = nn.Sequential(
            Conv1(64, 96, 3)
        )
        self.block3_1 = nn.Sequential(
            Conv2(160, 64, 1),
            nn.Conv2d(160, 96, 3, stride=1, padding=0),
            nn.BatchNorm2d(96),
            nn.ReLU()
        )
        self.block3_2 = nn.Sequential(
            Conv2(160, 64, 1),
            Conv3(64, 64, 7, 1),
            Conv3(64, 64, 1, 7),
            nn.Conv2d(64, 96, 3, stride=1, padding=0),
            nn.BatchNorm2d(96),
            nn.ReLU()
        )
        self.block4_1 = Conv1(192, 192, 3)
        self.block4_2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)    
    def forward(self, x):
        x = self.block1(x)
        x1 = self.block2_1(x)
        x2 = self.block2_2(x)
        x = torch.cat([x1, x2], dim=1)
        x1 = self.block3_1(x)
        x2 = self.block3_2(x)
        x = torch.cat([x1, x2], dim=1)
        x1 = self.block4_1(x)
        x2 = self.block4_2(x)
        x = torch.cat([x1, x2], dim=1)
        return x
# InceptionV4 Network
class InceptionV4(nn.Module):
    def __init__(self):
        super(InceptionV4, self).__init__()
        self.block1 = Stem()
        self.block2 = nn.Sequential(
            InceptionA(384),
            InceptionA(384),
            InceptionA(384),
            InceptionA(384)
        )
        self.block3 = ReductionA(384, 192, 224, 256, 384)
        self.block4 = nn.Sequential(
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024),
            InceptionB(1024)
        )
        self.block5 = ReductionB(1024)
        self.block6 = nn.Sequential(
            InceptionC(1536),
            InceptionC(1536),
            InceptionC(1536),
        )
        self.block7 = nn.Sequential(
            nn.AvgPool2d(kernel_size=8),
            nn.Dropout(p=0.8)
        )
        self.linear = nn.Linear(1536,1000)
    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = self.block6(x)
        x = self.block7(x)
        x = x.view(x.size(0), -1)
        x = self.linear(x)
        return x

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
多线程之——ExecutorCompletionService 阿福德
在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
tiff批量转png 诺有缸的高飞鸟 opencv 图像处理 python opencv 图像处理
目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
windows下python opencv ffmpeg读取摄像头实现rtsp推流拉流图像处理大大大大大牛啊 opencv实战代码讲解视觉图像项目 windows python opencv
windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
c++ opencv4.3 sift匹配图像处理大大大大大牛啊图像处理 opencv实战代码讲解 opencv sift c++opencv4 特征点
c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！小猪包333 写论文人工智能 AI写作深度学习计算机视觉
在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
ubuntu安装opencv最快的方法 Derek重名了
最快方法，当然不能太多文字$sudoapt-getinstallpython-opencv借助python就可以把ubuntu的opencv环境搞起来，非常快非常容易参考：https://docs.opencv.org/trunk/d2/de6/tutorial_py_setup_in_ubuntu.html
代码的执行效果高天
packagecom20210409;publicclassdemo04{publicstaticvoidmain(String[]args){//////&&当前的条件不满足,则最后结果一定不满足,后面的条件不再执行////&不管条件是否满足所有条件均作判断//intx=1,y=1;//if(++y==2&&x++==2){//x=7;//}//System.out.println("x="+x
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
使用Python和Playwright破解滑动验证码 asfdsgdf python 开发语言
滑动验证码是一种常见的验证码形式，通过拖动滑块将缺失的拼图块对准原图中的空缺位置来验证用户操作。本文将介绍如何使用Python中的OpenCV进行模板匹配，并结合Playwright实现自动化破解滑动验证码的过程。所需技术OpenCV模板匹配：用于识别滑块在背景图中的正确位置。Python：主要编程语言。Playwright：用于浏览器自动化，模拟用户操作。破解过程概述获取验证码图像：下载背景图和
神经网络-损失函数红米煮粥神经网络人工智能深度学习
文章目录一、回归问题的损失函数1.均方误差（MeanSquaredError,MSE）2.平均绝对误差（MeanAbsoluteError,MAE）二、分类问题的损失函数1.0-1损失函数（Zero-OneLossFunction）2.交叉熵损失（Cross-EntropyLoss）3.合页损失（HingeLoss）三、总结在神经网络中，损失函数（LossFunction）扮演着至关重要的角色，它
OpenCV图像处理技术（Python）——入门森屿_ opencv
©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
损失函数与反向传播 Star_. PyTorch pytorch 深度学习 python
损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
opencv学习：图像旋转的两种方法，旋转后的图片进行模板匹配代码实现夜清寒风学习 opencv 机器学习人工智能计算机视觉
图像旋转在图像处理中，rotate和rot90是两种常见的图像旋转方法，它们在功能和使用上有一些区别。下面我将分别介绍这两种方法，并解释它们的主要区别rot90方法rot90方法是NumPy提供的一种数组旋转函数，它主要用于对二维数组（如图像）进行90度的旋转。这个方法比较简单，只支持90度的倍数旋转，不支持任意角度旋转。使用NumPy进行旋转使用NumPy的rot90函数对模板图像进行旋转操作。
BP神经网络的传递函数大胜归来19 MATLAB
BP网络一般都是用三层的，四层及以上的都比较少用；传输函数的选择，这个怎么说，假设你想预测的结果是几个固定值，如1,0等，满足某个条件输出1，不满足则0的话，首先想到的是hardlim函数，阈值型的，当然也可以考虑其他的；然后，假如网络是用来表达某种线性关系时，用purelin---线性传输函数；若是非线性关系的话，用别的非线性传递函数，多层网络时，每层不一定要用相同的传递函数，可以是三种配合，可
探索创新科技： Lite-Mono - 简约高效的小型化Mono框架杭律沛Meris
探索创新科技：Lite-Mono-简约高效的小型化Mono框架Lite-Mono[CVPR2023]Lite-Mono:ALightweightCNNandTransformerArchitectureforSelf-SupervisedMonocularDepthEstimation项目地址:https://gitcode.com/gh_mirrors/li/Lite-Mono如果你在寻找一个轻
神经网络传递函数sigmoid,神经网络传递函数作用快乐的小荣荣神经网络机器学习深度学习人工智能
神经网络传递函数选取不同会有特别大差别嘛？只是最后一层，但前面层是非线性，那么可能存在区别不大的情况。线性函数f(a*input)=af(input),一般来说，input为向量，最简化情况下，可以假设input的各个维度，a1=a2=a3。。。意味着你线性层只是简单的对输入做了scale~而神经网络能起作用的原因，在于通过足够复杂的非线性函数，来模拟任何的分布。所以，神经网络必须要用非线性函数。
Python OpenCV图像处理：从基础到高级的全方位指南极客代码玩转Python 开发语言 python opencv 图像处理计算机视觉
目录第一部分：PythonOpenCV图像处理基础1.1OpenCV简介1.2PythonOpenCV安装1.3实战案例：图像显示与保存1.4注意事项第二部分：PythonOpenCV图像处理高级技巧2.1图像变换2.2图像增强2.3图像复原第三部分：PythonOpenCV图像处理实战项目3.1图像滤波3.2图像分割3.3图像特征提取第四部分：PythonOpenCV图像处理注意事项与优化策略4
多线程编程之卫生间周凡杨 java 并发卫生间线程厕所
如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
How to Install GUI to Centos Minimal sunjing linux Install Desktop GUI
http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
Shell 函数 daizj shell 函数
Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
Linux服务器新手操作之一周凡杨 Linux 简单操作
1.whoami 当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。此时可以使用whoami命令。 [ecuser@HA5-DZ05 ~]$ whoami e
浅谈Socket通信（一）朱辉辉33 socket
在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包 ServerSock
关于框架的简单认识西蜀石兰框架
入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。都说学前端的要知道三大框架，目前node.
You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids ) values('0ac91f167f754c8cbac00e9e3dc372
MySQL5.6的my.ini配置 aigo mysql
注意：以下配置的服务器硬件是：8核16G内存 [client] port=3306 [mysql] default-character-set=utf8 [mysqld] port=3306 basedir=D:/mysql-5.6.21-win
mysql 全文模糊查找便捷解决方案 alxw4616 mysql
mysql 全文模糊查找便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
自定义数据结构链表(单项 ,双向,环形) 百合不是茶单项链表双向链表
链表与动态数组的实现方式差不多, 数组适合快速删除某个元素链表则可以快速的保存数组并且可以是不连续的单项链表;数据从第一个指向最后一个实现代码: //定义动态链表 clas
threadLocal实例 bijian1013 java thread java多线程 threadLocal
实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
activemq安全设置—设置admin的用户名和密码 bijian1013 java activemq
ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。范型内容范型集合类范型类
【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证 1. 建立一个有两个列族的表 create 'members','colfam1','colfam2' 2. 在members表中的colfam1中插入50*5
Nginx 官方一个配置实例 ronin47 nginx 配置实例
user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
java-15.输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环 bylijinnan java
//use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
返回null还是empty bylijinnan java apache spring 编程
第一个问题，函数是应当返回null还是长度为0的数组（或集合）？第二个问题，函数输入参数不当时，是异常还是返回null？先看第一个问题有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》）理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
[科技与项目]工作流厂商的战略机遇期 comsci 工作流
在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。在微软，甲骨文，谷歌，IBM,SONY
过度设计-举例 cuityang 过度设计
过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。未来的事情，比如访问量，比如数据库的容量，比如是否需要改成分布式都是无法预料的再举一个例子，对闰年的判断逻辑：　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if ( ($Year%4==0 &am
java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。　　两类服务：　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
mac中用命令行运行mysql dcj3sjt126com mysql linux mac
参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html 感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
MongDB查询（1）——基本查询[五] eksliang mongodb mongodb 查询 mongodb find
MongDB查询转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....} 参数含义： query:查询参数 fie
base64，加密解密经融加密，对接 y806839048 经融加密对接
String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
JavaWeb之JSP概述 ihuning javaweb
什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。 JSP起源在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。如果使用Servl
apple watch 指南啸笑天 apple
1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina）译文译者原文概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
java经典的基础题目 macroli java 编程
1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象 regex
var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
[一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hive hive分析表 hive统计信息 hive Statistics
关键字：Hive统计信息、分析Hive表、Hive Statistics 类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等； 14.1 新表的统计信息对于一个新创建
Spring Boot 1.2.5 发布 wiselyman spring boot
Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。官方建议所有的Spring Boot用户升级这个版本。项目首页 | 源

Pytorch实现InceptionV4模型