机器学习知识点汇总

最新推荐文章于 2024-08-06 17:55:50 发布

什么都干的派森

最新推荐文章于 2024-08-06 17:55:50 发布

阅读量4.5k

点赞数 4

分类专栏： CV 文章标签：机器学习

本文链接：https://blog.csdn.net/weixin_43721000/article/details/113246299

版权

CV 专栏收录该内容

27 篇文章 8 订阅

订阅专栏

索引：

1.问题分类
 2.GAN 生成对抗网络训练方法
 3.SRGAN 超分辨率生成对抗网络模型
 4.RNN 循环神经网络简介
 5.LSTM RNN 长短期记忆循环神经网络简介
 6.GRU RNN 门循环单元循环神经网络简介
 7.CycleGAN 风格迁移生成对抗网络模型

一.问题分类

1.有监督学习
输入的数据集是被标记过的，神经网络通过数据集的标记反向传播修正输出结果

（1）.回归问题

特点：回归问题中的“回归”是指待遇测的Y值是连续的

例子：房价预测，股票走势

（2）.分类问题

特点：分类问题中的“分类”是指待遇测的Y值是离散的

例子：肿瘤的良性/恶性判断，图片分类

2.无监督学习
输入的数据集没有标记，神经网络通过数据的相似性对结果进行分类
例子：相似事件的新闻分类，相似视频的关联分类，多个声源的分离

二.GAN 生成对抗网络训练方法

写两个网络：

1.一个生成网络（生成器），这个生成器会尽力从随机噪声中生成近似真实的虚假图片，
2.一个判定网络（判定器），这个判定器会尽力的区分真实图片（自然界中真实存在物品的图片）与虚假图片（生成器生成的图片）

训练流程：
训练判定器：
1.将一张真实图片送入判定器，标记样本为真，对判定器进行训练
2.生成器生成一张虚假的图片送入判定器，标记样本为假，对判定器进行训练
训练生成器：
3.生成器生成一张虚假的图片送入判定器，根据判定结果对生成器进行训练（注意此时不要更新判定器的参数）
4.重复以上步骤就可以完成一个简单的GAN的训练了

三.SRGAN 超分辨率生成对抗网络模型

简介：
SRGAN全称为 Super Resolution Generative Adversarial，这是第一个对放大四倍真实自然图像做超分辨率的框架【模糊变清晰，有码变无码(狗头)】

生成器模型：

在这里插入图片描述
1.输入是一张低分辨率的图像
2.进入一个64通道步长为1的卷积
3.RELU激活
4.自定义个数的残差卷积快（每个卷积快结构：【1】64通道步长为1的卷积【2】BN参数标准化【3】RELU激活【4】64通道步长为1的卷积【5】BN参数标准化【6】将当前残差块之前的参数与当前参数连接）
5.进入一个64通道步长为1的卷积
6.BN参数标准化
7.将第一个残差块之前的参数与当前参数连接
8.【1】进入一个256通道步长为1的卷积【2】上采样或反卷积，将图片扩大至现在的两倍【3】RELU激活
9.重复第8步
10.进入一个3通道步长为1的卷积
11.输出是一张高分辨率假图

生成器代码【Keras】:

    def build_generator(self):
        '''
        生成器模型代码，实现方法减少了一些网络层数
        '''

        # 残差卷积快
        def residual_block(layer_input, filters):
            d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)
            d = BatchNormalization(momentum=0.8)(d)
            d = Activation('relu')(d)

            d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d)
            d = BatchNormalization(momentum=0.8)(d)
            d = Add()([d, layer_input])
            return d

        # 上采样
        def deconv2d(layer_input):
            u = UpSampling2D(size=2)(layer_input)
            u = Conv2D(256, kernel_size=3, strides=1, padding='same')(u)
            u = Activation('relu')(u)
            return u

        # 输入大小为128,128,3
        img_lr = Input(shape=self.lr_shape)
        # 第一部分，低分辨率图像进入后会经过一个卷积+RELU函数
        c1 = Conv2D(64, kernel_size=9, strides=1, padding='same')(img_lr)
        c1 = Activation('relu')(c1)

        # 第二部分，经过16个残差网络结构，每个残差网络内部包含两个卷积+标准化+RELU，还有一个残差边。
        r = residual_block(c1, 64)
        for _ in range(self.n_residual_blocks - 1):
            r = residual_block(r, 64)

        # 第三部分，将第一个残差块之前的参数与当前参数连接。
        c2 = Conv2D(64, kernel_size=3, strides=1, padding='same')(r)
        c2 = BatchNormalization(momentum=0.8)(c2)
        c2 = Add()([c2, c1])

		# 第四部分，上采样部分，将长宽进行放大，两次上采样后，变为原来的4倍，实现提高分辨率。
        u1 = deconv2d(c2)
        u2 = deconv2d(u1)
        gen_hr = Conv2D(self.channels, kernel_size=9, strides=1, padding='same', activation='tanh')(u2)

        # 返回模型
        return Model(img_lr, gen_hr)

判定器模型：
在这里插入图片描述
1.输入是一张高分辨率真实图像，或者生成器生成的高分辨率假图
2.进入一个64通道步长为1的卷积
3.RELU激活
4.【1】进入一个64通道步长为2的卷积【2】BN参数标准化【3】RELU激活
5.【1】进入一个128通道步长为1的卷积【2】BN参数标准化【3】RELU激活
6.【1】进入一个128通道步长为2的卷积【2】BN参数标准化【3】RELU激活
7.【1】进入一个256通道步长为1的卷积【2】BN参数标准化【3】RELU激活
8.【1】进入一个256通道步长为2的卷积【2】BN参数标准化【3】RELU激活
9.【1】进入一个512通道步长为1的卷积【2】BN参数标准化【3】RELU激活
10.【1】进入一个512通道步长为2的卷积【2】BN参数标准化【3】RELU激活
11.通过1024个神经元的全连接层
12.RELU激活
13.通过1个神经元的全连接层
14.S型函数输出判定结果

ps：进入全连接层之前，一共进行了四次步长为2的卷积，图片大小变为原来的1/16

判定器代码【Keras】:

    def build_discriminator(self):
        '''
        判定器模型代码
        '''

        # 几个相似的模型层
        def d_block(layer_input, filters, strides=1, bn=True):
            d = Conv2D(filters, kernel_size=3, strides=strides, padding='same')(layer_input)
            d = LeakyReLU(alpha=0.2)(d)
            if bn:
                d = BatchNormalization(momentum=0.8)(d)
            return d

        # 由一堆的卷积+LeakyReLU+BatchNor构成
        d0 = Input(shape=self.hr_shape)

        d1 = d_block(d0, 64, bn=False)

        d2 = d_block(d1, 64, strides=2)
        d3 = d_block(d2, 128)
        d4 = d_block(d3, 128, strides=2)
        d5 = d_block(d4, 256)
        d6 = d_block(d5, 256, strides=2)
        d7 = d_block(d6, 512)
        d8 = d_block(d7, 512, strides=2)

        d9 = Dense(64 * 16)(d8)
        d10 = LeakyReLU(alpha=0.2)(d9)
        validity = Dense(1, activation='sigmoid')(d10)
        
        # 返回模型
        return Model(d0, validity)

向训练好的生成器中传入低分辨率图片（共训练了10000轮）：

输入图片：本次训练输入图片像素大小固定为32*32
在这里插入图片描述

输出图片：输出图片像素大小扩展为原来的4倍（128*128）

在这里插入图片描述

生成网络通过自身的训练参数，根据传入的低分辨率图像自行绘制了一张高分辨率图像，由于32*32像素的输入图像的可提取特征较少，所以一些脸部的皱纹提取不到，输出结果中的女人会比打码之前显得年轻一点点（狗头）

四.RNN 循环神经网络简介

1990年, 美国认知科学家Jeffrey L. Elman 对jordan network进行了简化,并采用BP算法进行训练，便有了如今最简单的包含单个自连接节点的RNN 模型
循环神经网络，是指在全连接神经网络的基础上增加了前后时序上的关系，可以更好地处理比如机器翻译等的与时序相关的问题。
RNN的目的就是用来处理序列数据的。在传统的神经网络模型中，是从输入层到隐含层再到输出层，层与层之间是全连接的，每层之间的节点是无连接的。但是这种普通的神经网络对于很多问题都无能无力。比如你要预测句子的下一个单词是什么，一般需要用到前面的单词，因为一个句子中前后单词并不是独立的。又或者你要预测明天的股票价格，你就需要前段时间的股票价格作为输入。这些都需要每层之间的节点产生关联才能实现。
RNN之所以称为循环神经网路，即一个序列当前的输出与前面的输出也有关。具体的表现形式为网络会对前面的信息进行记忆并应用于当前输出的计算中，即隐藏层之间的节点不再无连接而是有连接的，并且隐藏层的输入不仅包括输入层的输出还包括上一时刻隐藏层的输出。
理论上，RNN能够对任何长度的序列数据进行处理。但是在实践中，为了降低复杂性往往假设当前的状态只与前面的几个状态相关，这也是RNN的局限性，当输入长度过长时，最早的输入可能会在神经网络反向传播时产生梯度爆炸或者梯度消失，导致RNN无法回忆起过于久远的记忆，会降低预测的准确率，于是就有了下面的 LSTM RNN网络。

单个RNN神经元结构：
在这里插入图片描述

五.LSTM RNN 长短期记忆循环神经网络简介

1997年，人工智能研究所的主任Jurgen Schmidhuber 提出长短期记忆（LSTM），LSTM使用门控单元及记忆机制大大缓解了早期RNN训练的问题。
LSTM RNN 和普通的 RNN 相比，多出了三个控制器（输入门，遗忘门和输出门）以便控制全局的记忆。
可以把 LSTM RNN 理解成一部电影，包含了主线和支线，当主线剧情进行时，如果某个支线对结局十分重要，输入门就会将这个支线按重要程度写入主线，在进行分析。如果此时支线改变了之前主线剧情的想法，那么遗忘门就会将之前某些主线剧情忘记，按比例替换成新支线剧情。最后，输出门会根据当前的主线剧情和支线剧情决定输出结果。
这样即使是经过了很长输入序列的的神经网络，也能记住久远的重要变化。

单个LSTM神经元结构：
在这里插入图片描述