实习中的小技能-CV算法篇-2

最新推荐文章于 2024-08-09 18:47:50 发布
最新推荐文章于 2024-08-09 18:47:50 发布
阅读量622 收藏 2
点赞数
分类专栏： 深度学习 文章标签： 神经网络 pytorch caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44259490/article/details/103538228
版权
本文介绍如何将PyTorch模型转换为Caffe格式，并使用imgaug库进行高效的数据增强，包括算术操作、混合、模糊、颜色调整等。同时，详细解释了PyTorch、PIL和OpenCV三种方式下的图片归一化方法。
摘要由CSDN通过智能技术生成

目录

1. Pytorch2Caffe

Pytorch2caffe
example路径下可直接转，如有全局平均池化，需自己在prototxt中加入，测试squeezenet没有问题

2. 数据增强-imgaug

import random
from imgaug import augmenters as iaa
from imgaug import parameters as iap
from itertools import chain
import imgaug as ia
import cv2
import imageio as imgio
import numpy as np


def _arithmetic(num):
    supported_ops = [
        iaa.Add((-40, 40)),
        iaa.AddElementwise((-40, 40), per_channel=0.5),
        iaa.AdditiveGaussianNoise((0, 0.2 * 255), per_channel=0.5),
        iaa.AdditiveLaplaceNoise(scale=0.2*255, per_channel=True),
        iaa.AdditivePoissonNoise((0, 40), per_channel=True),
        iaa.Multiply((0.5, 1.5), per_channel=0.5),
        iaa.MultiplyElementwise((0.5, 1.5), per_channel=0.5),
        iaa.Dropout(p=(0, 0.2), per_channel=0.5),
        iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25)),
        iaa.CoarseDropout(0.02, size_percent=0.15, per_channel=0.5),
        iaa.ReplaceElementwise(0.1, iap.Normal(128, 0.4*128), per_channel=0.5),
        iaa.ReplaceElementwise(
            iap.FromLowerResolution(iap.Binomial(0.1), size_px=8),
            iap.Normal(128, 0.4*128),
            per_channel=0.5),
        iaa.ImpulseNoise(0.1),
        iaa.SaltAndPepper(0.1, per_channel=True),
        iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.1)),
        iaa.CoarseSaltAndPepper(
            0.05, size_percent=(0.01, 0.1), per_channel=True),
        iaa.Salt(0.1),
        iaa.CoarseSalt(0.05, size_percent=(0.01, 0.1)),
        iaa.Pepper(0.1),
        iaa.CoarsePepper(0.05, size_percent=(0.01, 0.1)),
        iaa.Invert(0.5),
        iaa.Invert(0.25, per_channel=0.5),
        iaa.ContrastNormalization((0.5, 1.5)),
        iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
        iaa.JpegCompression(compression=(70, 99))
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)


def _blend(num):
    supported_ops = [
        iaa.Alpha(0.5, iaa.Grayscale(1.0)),
        iaa.Alpha((0.0, 1.0), iaa.Grayscale(1.0)),
        iaa.Alpha(
            (0.0, 1.0),
            iaa.Affine(rotate=(-20, 20)),
            per_channel=0.5),
        iaa.Alpha(
            (0.0, 1.0),
            first=iaa.Add(100),
            second=iaa.Multiply(0.2)),
        iaa.Alpha([0.25, 0.75], iaa.MedianBlur(13)),
        iaa.AlphaElementwise(0.5, iaa.Grayscale(1.0)),
        iaa.AlphaElementwise((0, 1.0), iaa.Grayscale(1.0)),
        iaa.AlphaElementwise(
            (0.0, 1.0),
            iaa.Affine(rotate=(-20, 20)),
            per_channel=0.5),
        iaa.AlphaElementwise(
            (0.0, 1.0),
            first=iaa.Add(100),
            second=iaa.Multiply(0.2)),
        iaa.AlphaElementwise([0.25, 0.75], iaa.MedianBlur(13)),
        iaa.SimplexNoiseAlpha(
            iaa.EdgeDetect(1.0),
            upscale_method="nearest"),
        iaa.SimplexNoiseAlpha(
            iaa.EdgeDetect(1.0),
            sigmoid_thresh=iap.Normal(10.0, 5.0)),
        iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0)),
        iaa.FrequencyNoiseAlpha(
            first=iaa.EdgeDetect(1.0),
            upscale_method="nearest"),
        iaa.FrequencyNoiseAlpha(
            first=iaa.EdgeDetect(1.0),
            upscale_method="linear"),
        iaa.FrequencyNoiseAlpha(
            first=iaa.EdgeDetect(1.0),
            upscale_method="linear",
            exponent=-2,
            sigmoid=False),
        iaa.FrequencyNoiseAlpha(
            first=iaa.EdgeDetect(1.0),
            sigmoid_thresh=iap.Normal(10.0, 5.0))
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)


def _blur(num):
    supported_ops = [
        iaa.GaussianBlur(sigma=(0.0, 3.0)),
        iaa.AverageBlur(k=(2, 11)),
        iaa.AverageBlur(k=((5, 11), (1, 3))),
        iaa.MedianBlur(k=(3, 11)),
        iaa.BilateralBlur(
            d=(3, 10), sigma_color=(10, 250), sigma_space=(10, 250)),
        iaa.MotionBlur(k=15),
        iaa.MotionBlur(k=15, angle=[-45, 45]),
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)


def _color(num):
    supported_ops = [
        iaa.WithColorspace(
            to_colorspace="HSV",
            from_colorspace="RGB",
            children=iaa.WithChannels(
                0,
                iaa.Add((0, 50))
            )
        ),
        iaa.WithHueAndSaturation(
            iaa.WithChannels(0, iaa.Add((0, 50)))
        ),
        iaa.WithHueAndSaturation([
            iaa.WithChannels(0, iaa.Add((-30, 10))),
            iaa.WithChannels(1, [
                iaa.Multiply((0.5, 1.5)),
                iaa.LinearContrast((0.75, 1.25))
            ])
        ]),
        iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True),
        iaa.MultiplyHueAndSaturation(mul_hue=(0.5, 1.5)),
        iaa.MultiplyHueAndSaturation(mul_saturation=(0.5, 1.5)),
        iaa.MultiplyHue((0.5, 1.5)),
        iaa.MultiplySaturation((0.5, 1.5)),
        iaa.AddToHueAndSaturation((-50, 50), per_channel=True),
        iaa.AddToHue((-50, 50)),
        iaa.AddToSaturation((-50, 50)),
        iaa.Sequential([
            iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
            iaa.WithChannels(0, iaa.Add((50, 100))),
            iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB")
        ]),
        iaa.Grayscale(alpha=(0.0, 1.0)),
        iaa.KMeansColorQuantization(),
        iaa.KMeansColorQuantization(n_colors=(4, 16)),
        iaa.KMeansColorQuantization(
            to_colorspace=[iaa.ChangeColorspace.RGB, iaa.ChangeColorspace.HSV]),
        iaa.UniformColorQuantization(),
        iaa.UniformColorQuantization(n_colors=8),
        iaa.UniformColorQuantization(n_colors=(4, 16)),
        iaa.UniformColorQuantization(
            from_colorspace=iaa.ChangeColorspace.BGR,
            to_colorspace=[iaa.ChangeColorspace.RGB, iaa.ChangeColorspace.HSV])
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)


def _contrast(num):
    supported_ops = [
        iaa.GammaContrast((0.5, 2.0)),
        iaa.GammaContrast((0.5, 2.0), per_channel=True),
        iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
        iaa.SigmoidContrast(
            gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True),
        iaa.LogContrast(gain=(0.6, 1.4)),
        iaa.LogContrast(gain=(0.6, 1.4), per_channel=True),
        iaa.LinearContrast((0.4, 1.6)),
        iaa.LinearContrast((0.4, 1.6), per_channel=True),
        iaa.AllChannelsCLAHE(),
        iaa.AllChannelsCLAHE(clip_limit=(1, 10)),
        iaa.AllChannelsCLAHE(clip_limit=(1, 10), per_channel=True),
        iaa.CLAHE(
            tile_grid_size_px=iap.Discretize(iap.Normal(loc=7, scale=2)),
            tile_grid_size_px_min=3),
        iaa.CLAHE(
            from_colorspace=iaa.CLAHE.BGR,
            to_colorspace=iaa.CLAHE.HSV),
        iaa.AllChannelsHistogramEqualization(),
        iaa.Alpha((0.0, 1.0), iaa.AllChannelsHistogramEqualization()),
        iaa.HistogramEqualization(
            from_colorspace=iaa.HistogramEqualization.BGR,
            to_colorspace=iaa.HistogramEqualization.HSV)
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)


def _flip(num):
    supported_ops = [
        iaa.Fliplr(0.5),
        iaa.Flipud(0.5)
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)

def _geometric(num):
    supported_ops = [
        iaa.Affine(scale=(0.5, 1.5)),
        iaa.Affine(scale={"x": (0.5, 1.5), "y": (0.5, 1.5)}),
        iaa.Affine(translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)}),
        iaa.Affine(rotate=(-45, 45)),
        iaa.Affine(translate_percent={"x": -0.20}, mode=ia.ALL, cval=(0, 255)),
        iaa.PerspectiveTransform(scale=(0.01, 0.15)),
        iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25)
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)

def _pooling(num):
    supported_ops = [
        iaa.AveragePooling([2, 8]),
        iaa.MaxPooling(2),
        iaa.MaxPooling([2, 8]),
        iaa.MaxPooling(((1, 7), (1, 7))),
        iaa.MinPooling([2, 8]),
        iaa.MinPooling(((1, 7), (1, 7)))
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)


def _weather(num):
    supported_ops = [
        iaa.FastSnowyLandscape(
            lightness_threshold=140,
            lightness_multiplier=2.5
        ),
        iaa.FastSnowyLandscape(
            lightness_threshold=[128, 200],
            lightness_multiplier=(1.5, 3.5)
        ),
        iaa.Clouds(),
        iaa.Snowflakes(flake_size=(0.7, 0.95), speed=(0.001, 0.03))
    ]
    if num > len(supported_ops):
        return "the number must less %s" % len(supported_ops)
    return random.sample(supported_ops, num)
class img_aug(object):

    def __init__(self, all_some_one='all', use_arithmetic_num=None, use_blend_num=None, use_blur_num=None,
                 use_color_num=None, use_contrast_num=None, use_flip_num=None, use_geometric_num=None,
                 use_pooling_num=None, use_weather_num=None):

        self.flag = all_some_one
        self.use_arithmetic_num = use_arithmetic_num
        self.use_blend_num = use_blend_num
        self.use_blur_num = use_blur_num
        self.use_color_num = use_color_num
        self.use_contrast_num = use_contrast_num
        self.use_flip_num = use_flip_num
        self.use_geometric_num = use_geometric_num
        self.use_pooling_num = use_pooling_num
        self.use_weather_num = use_weather_num
        self.functions = []
        if self.use_arithmetic_num:
            self.functions.append(_arithmetic(self.use_arithmetic_num))
        if self.use_blend_num:
            self.functions.append(_arithmetic(self.use_blend_num))
        if self.use_blur_num:
            self.functions.append(_arithmetic(self.use_blur_num))
        if self.use_color_num:
            self.functions.append(_arithmetic(self.use_color_num))
        if self.use_contrast_num:
            self.functions.append(_arithmetic(self.use_contrast_num))
        if self.use_flip_num:
            self.functions.append(_arithmetic(self.use_flip_num))
        if self.use_pooling_num:
            self.functions.append(_arithmetic(self.use_pooling_num))
        if self.use_arithmetic_num:
            self.functions.append(_arithmetic(self.use_arithmetic_num))
        if self.use_weather_num:
            self.functions.append(_arithmetic(self.use_weather_num))

        self.functions = list(chain.from_iterable(self.functions))

    def __call__(self, img):

        if self.flag == 'all':
            return iaa.Sequential(self.functions).augment_images(img)
        elif self.flag == 'some':
            return iaa.SomeOf((0, len(self.functions)), self.functions).augment_images(img)
        elif self.flag == 'one':
            return iaa.OneOf(self.functions).augment_images(img)


if __name__ == "__main__":
    imgfile_add = 'xxx.jpg'
    imgfile_clear = 'xxx.jpg'
    imgfile_push = 'xxx.jpg'
    add = cv2.imread(imgfile_add)
    push = cv2.imread(imgfile_push)
    clear = cv2.imread(imgfile_clear)

    b, g, r = cv2.split(add)
    add = cv2.merge([r, g, b])

    b, g, r = cv2.split(push)
    push = cv2.merge([r, g, b])

    b, g, r = cv2.split(clear)
    clear = cv2.merge([r, g, b])

    imgs =[add, push, clear]
    img_aug = img_aug(all_some_one='one', use_arithmetic_num=3, use_weather_num=1, use_blur_num=2,  use_blend_num=1, use_contrast_num=0, use_flip_num=1, use_geometric_num=1)

    ia.imshow(np.hstack(img_aug(imgs)))
    # ia.imshow(np.hstack(imgs))

3. 图片归一化

3.1 Pytorch
import torchvision.transforms as transforms
import numpy as np
from PIL import Image
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                      std=[0.229, 0.224, 0.225])
#transforms.ToTensor()
transform1 = transforms.Compose([
    transforms.Resize([224, 224]),
    transforms.ToTensor(),
    normalize,
    ]
 )
# ##numpy.ndarray
imgfile= 'xxx.jpg'
img = Image.open(imgfile).convert('RGB')# 读取图像
#print(img)
#img = cv2.resize(img,(224,244))
img = transform1(img) # 归一化到 [0.0,1.0]
# img = img.unsqueeze(0)
img
3.2 PIL
import torchvision.transforms as transforms
import numpy as np
from PIL import Image

imgfile= 'xxx.jpg'
img = Image.open(imgfile).convert('RGB')# 读取图像
#print(img)
img = img.resize((224, 224), Image.BILINEAR)
#img = cv2.resize(img,(224,244))
# img = np.array(img)/255
img = img.transpose(2, 0, 1)
# mu = np.array([[[0.485]],[[0.456]],[[0.406]]])
# sigma = np.array([[[0.229]],[[0.224]],[[0.225]]])
# img = (img - mu)/sigma
img = np.around(img, decimals=4)
img


img2 = cv2.imread(imgfile)
b,g,r = cv2.split(img2)
img2 = cv2.merge([r,g,b])
img2 = cv2.resize(img2, (224, 224), interpolation=cv2.INTER_LINEAR)  

img2 = np.array(img2)/255
img2 = img2.transpose(2, 0, 1)
mu = np.array([[[0.485]],[[0.456]],[[0.406]]])
sigma = np.array([[[0.229]],[[0.224]],[[0.225]]])
img2 = (img2 - mu)/sigma
img2 = np.around(img2, decimals=4)
img2

diff = abs(img - img2)
diff = np.mean(diff)
diff
3.3 OpenCV
import cv2
import numpy as np
imgfile= 'xxx.jpg'
img = cv2.imread(imgfile)
b,g,r = cv2.split(img)
img = cv2.merge([r,g,b])
img = cv2.resize(img, (224, 224), interpolation=cv2.INTER_LINEAR)  
cv2.imwrite('xxxt.jpg', img)
img = np.array(img)/255
img = img.transpose(2, 0, 1)
mu = np.array([[[0.485]],[[0.456]],[[0.406]]])
sigma = np.array([[[0.229]],[[0.224]],[[0.225]]])
img = (img - mu)/sigma
img = np.around(img, decimals=4)
img
ImgAug图像增强
AutoMan的博客
06-19 1421
imgaug常用图像增强方法总结和效果图展示
imgaug数据增强神器：增强器一览
XerCis的博客
04-01 1万+
官网：https://imgaug.readthedocs.io/en/latest/ 文章目录一、Sequential 顺序增强器二、SomeOf 子项增强器三、OneOf 其一增强器四、Sometimes 部分增强器五、WithColorspace 附带颜色空间增强器六、WithChannels 通道增强器七、Noop 无操作增强器八、Lambda Lambda增强器九、AssertLamb...
数据增强库albumentations使用指南
最新发布
lishanlu136的博客
08-09 1639
albumentations数据增强库使用指南。
VOC数据增强与调整大小
pengxiang1998的博客
02-11 1813
数据增强是针对数据集图像数量太少所采取的一种方法。博主在实验过程中，使用自己的数据集时发现其数据量过少，只有280张，因此便想到使用数据增强的方式来获取更多的图像信息。对于图像数据，我们可以采用旋转等操作来获取更多的图像。对于已经标注好的图片，则可以通过imgaug实现对图片和标签中的boundingbox同时变换。首先，安装依赖库。
【图像增广库imgaug】官方文档翻译（三）：增强分割图
knight0_o的博客
06-08 1094
分割图图像扩充
Python-2020年的算法实习岗位信息表部分包括内推码和常见深度学习算法岗面试题及答案
08-10
暑期计算机视觉实习面经和总结，这部分内容可能是前人实习经验的分享，包括但不限于项目经历、技术栈、面试过程中的挑战以及解决方法。计算机视觉（CV）是深度学习应用的一个热门领域，涉及到图像处理、特征提取、...
【虹软25届实习】----算法&amp；开发&amp；产品&amp；测试-可转正
2301_79125431的博客
02-26 907
本人二本大四在实习，实习学不到什么东西，转正的概率不大。华为车bu捞我啦，本人机械专业，之前投华子嵌入式软件速通，但是没泡出来，最近车bu捞我，但是岗位是通用软开，不是很懂，大概14。进行一些push和自我push投了一些远程实习岗，包括算法岗、数据分析、行研、Python，算法没有一个回的，一个行研约了明天面试，一个Python发了笔试，数。base北京2.201.JVM虚拟机相关内容，元空间，创建的对象存在哪里（项目的问题，大概就是功能的实现，还有对应的考量）2.你认为一个产品需求的开发和对应技术。
计算机视觉算法竞聘者的职业技能需求
我的博客
03-02 3156
原创：王稳钺 资料来源：二可 有很多对计算机视觉方向竞聘者对于CV面试过程当中需要具备哪些技能不太了解，本文主要介绍计算机视觉面试中主要的考核技术点。 1. CV算法岗的总体能力需求 首先CV的应用领域非常广泛。比如无人车，其中会需要车道线的检测等；比如利用GAN来实现老照片修复、美颜等。现在还有一些比较前沿的应用——元宇宙，其实在之前被称为虚拟现实领域，它背后其实隐藏着大量的理论。比如虚拟的物体，它如何能够像真实物体一样，定在某一位置，不随着设备的移动而移动，其实这背后是非常复杂的数学原理，需要实时地去计
imgaug批量椒盐噪声 python_python图像扩增-imgaug
weixin_39942992的博客
12-20 226
# encoding=utf-8import osimport imageioimport randomimport numpy as npimport imgaug as iaimport concurrent.futuresfrom imgaug import augmenters as iaaimport matplotlib.pyplot as pltfrom argparse impor...
目标检测中的数据增强方法
如果想成为中心，那么就到中心去吧。
09-02 1198
文章目录CutmixMixup Cutmix def load_cutmix_image_and_boxes(self, index, imsize=1024): """ This implementation of cutmix author: https://www.kaggle.com/nvnnghia Refactoring and adaptation: https://www.kaggle.com/shonenkov ""
深度学习之数据扩容
qq_41188434的博客
04-24 1145
简介 Augmentor是一个Python包，旨在帮助机器学习任务的图像数据人工生成和数据增强。它主要是一种数据增强工具，但也将包含基本的图像预处理功能。 特色 Augmentor是用于图像增强的软件包，重点在于提供通常用于生成机器学习问题的图像数据的操作。 Augmentor包含许多用于标准图像处理功能的类，例如Rotate 旋转类、Crop 裁剪类等等。 包含的操作有：旋转rotate...
[深度学习系列]-Albumentations数据增强方法（可结合pytorch调用）
Monster_H7的博客
12-07 5567
Albumentations数据增强方法 目录 Albumentations数据增强方法 1.前言-常用数据增强方法 2.使用-参考GIt example 3.Augmentations examples.及效果图的展示 1.MultiplicativeNoise 2.ToSepia 3.JpegCompression 4.ChannelDropout 5.ChannelShuffle 6.Cutout 7.ToGray 8.InvertImg 9.VerticalFlip.
机器学习笔记 - Albumentations库实现的图像增强功能一览
学以致用 知行合一
10-03 1617
Albumentations库致力于用更少的数据做更多的事情。Albumentations 是一种计算机视觉工具，可以提高深度卷积神经网络的性能。该库广泛用于工业、深度学习研究、机器学习竞赛和开源项目。Albumentations 是一个用于快速灵活的图像增强的 Python 库。Albumentations 有效地实现了丰富多样的图像变换操作，这些操作针对性能进行了优化，同时为不同的计算机视觉任务（包括对象分类、分割和检测）提供了简洁而强大的图像增强接口。
利用imgaug数据增强库增强图片源码解读
m0_54361461的博客
11-30 575
利用imgaug数据增强库增强图片源码解读
imgaug库图像增强指南（22）：iaa.ImpulseNoise——图像增强的新篇章
创作高质量博文，分享知识，共同进步！
01-14 997
在本博客中，我们将向您详细介绍imgaug库的数据增强方法 —— ImpulseNoise方法。
Pytorch使用albumentations实现数据增强
热门推荐
张家四少
07-31 2万+
目录 摘要 代码和效果 原始图像 模糊图像 围绕X轴垂直翻转 围绕Y轴水平翻转 垂直或水平和垂直翻转 交换行和列来转置 裁剪 RandomGamma 随机旋转90度 随机应用仿射变换：平移，缩放和旋转输入 裁剪输入的中心部分 网格失真 弹性变换 图像上随机排列的网格单元 随机更改输入图像的色相，饱和度和值 垫图像的一面/如果一面小于所需数目，则为最大值 为输入RGB图像的每个通道随机移动值 使用具有随机核大小的高斯滤波器对输入图像进行模糊处理 将对比度受限的自适应.
目标检测通用trick
Mao_Jonah的博客
10-13 436
目标检测通用trick 1. 数据增强 离线增强 ： 直接对数据集进行处理，数据的数目会变成增强因子 x 原数据集的数目 ，这种方法常常用于数据集很小的时候 在线增强 ： 这种增强的方法用于，获得 batch 数据之后，然后对这个 batch 的数据进行增强，如旋转、平移、翻折等相应的变化，由于有些数据集不能接受线性级别的增长，这种方法长用于大的数据集，很多机器学习框架已经支持了这种数据增强方式，并且可以使用 GPU 优化计算。 1.1 在线增强常用 空间几何变换：翻转（水平和垂直）、随机裁剪、旋转、放
炼丹笔记三：数据增强
u010139630的博客
02-15 1058
欢迎大家关注微信公众号：baihuaML，白话机器学习。 码字不易，未经授权禁止转载，如转载，请添加知乎好友：会写代码的好厨师，私信我！ 在这里，我们一起分享AI的故事。 您可以在后台留言，关于机器学习、深度学习的问题，我们会选择其中的优质问题进行回答！ 本期的问题： 能不能谈一谈数据增强问题？ 深度学习像是在炼丹，但实际上也是有一些区别的。在深度学习中，我们可能会有海量的数据，...
模式识别课程-H-K算法详解
"⑶H-K算法-现代模式识别配套课件" 这篇摘要介绍的是与模式识别相关的课程资料，特别是强调了H-K算法在求解最佳权矢量中的应用。模式识别是一门涉及统计学、概率论、线性代数等多个学科的交叉领域，主要目的是通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值