Welcome to BC.Wang's blog

• 神经网络图像风格化使用

  2017-07-10

  BCWang

  AI使用

  Python  图像处理  AI  NeuralNetwork

  Al.Application.StylizePictures.I

  • 利用神经网络进行风格化图片
  • 来自我的github项目:https://github.com/B-C-WANG/AI-Storage/tree/master/AI.Application/Al.Application.StylizePictures.I
  • 所用代码：https://github.com/anishathalye/neural-style

  使用

  • 参考cmd命令： python neural_style.py（运行脚本） --iterations 5000 （迭代次数） --content example.jpg （被风格化图片） --styles style.jpg （提供风格图片） --output result.jpg （输出图片名称） --checkpoint-iterations 50 （每多少次迭代输出一个check图片） --checkpoint-output temp%s.jpg（check图片的名称，需要带有%s）
  • 效果

  代码理解

  neural_style.py

  • 设置基本参数，以及VGG的路径（需要下载imagenet-vgg-verydeep-19.mat）
  • 在build_parser中设置命令行参数
  • 主函数中，首先获取命令行参数：
    • 读取VGG路径
    • 读取content图片
    • 读取多个style图片
    • 根据width，resize content image
    • 根据style_scale， resize style image
    • 根据style_blend_weights设置不同style图片所占的权重
    • 根据initial设置初始化图片
    • 检测ckpt的文件名设置
  • 最后用一个for循环，传递所有参数到stylize.py中的stylize函数中，返回iteration和image，如果有ckpt设置，就会周期性地输出image，并重命名，存储图片

  vgg.py

  vgg.py是stylize的基础，它有以下5个函数：

  • net(data_path, input_image)：输入VGG模型权重所在路径，以及图片，输出网络节点以及正则化均值
    • 建立一个layers的set用于建模
    • 载入VGG模型数据，得到其中的正则化以及layers的权重数据
    • 对于建立的set中的每一个元素，检测其名称，如果是conv卷积层，就载入相应的kernels和bias数据，并将kernels和bias的维度转化为符合tensorflow，如果是relu或pool层，不载入数据
    • 递归建立节点，并将节点用字典存储（对于每一个节点，这里存储的都是从一开始到这个节点的运算，而不是接着上一个节点的运算）
    • 返回节点和正则化均值
  • _conv_layer：建立卷积层，其中weight和bias的参数都是从VGG中来，步长为(1,1,1,1),padding=”SAME”
  • _pool_layer：建立池化层，k_size=(1,2,2,1)，步长(1,2,2,1)，padding=”SAME”
  • preprocess:image数据减去均值，用于预处理，去中心化
  • inprocess：image数据加上均值，还原

  stylize.py

  • 设置所涉及的layers，接着是stylize函数中的过程：
  • 前向传播计算content特征
  • 图片reshape为(1, image.shape)
  • 将VGG和图片数据传入上面的VGG.net，得到网络节点以及正则化均值数据
  • 对content图片进行正则化，得到content_pre(这里的处理都是采用placeholder，但是由于之后只会feed content_image的数据，所以这里直接描述content图片)
  • net[CONTENT_LAYER]截取VGG中从一开始到relu4_2这一层的节点，目的是提取content的特征，将节点设置feed_dict为content_pre图片，用新建的一个字典存储这个层的eval
  • 前向传播计算style特征
  • 同样的方法，对每个style_image进行预处理，此时这里style有多个层：relu1_1, relu2_1, relu3_1, relu4_1和relu5_1，对于每个层，feed进入style_image，截取得到从一开始到这几个层的节点，得到其eval的值。每个层都会进行reshape，然后和上一个层的转置相乘，并除以其size，最终和vgg.net一样，每一个层的输出节点都会存储在dict中(之后调不调用这些节点要看是否载入这些相应的字典元素)，而不是仅仅得到最终的输出节点。
  • 关于为什么如此操作并不是很理解，但是目的是用前向传播方法获得style的特征
  • 利用反向传播，生成风格化图片
  • 首先设置初始化过后的变量image，用于反向传播进行更新，shape与content_image相同，下面都image代表生成的风格化后的图片的数据
  • 计算image和content_image的loss，content_image所采用的节点，是之前在前向传播中设置好的节点，image所采用的节点，是在vgg.net中设置的节点，采用l2_loss算法，其中content有一个weight，用来表示content的风格占比多少
  • 计算image和style_image的loss，此时style的特征权重是多个层，需要将其相加，求得loss
  • 总loss之后会加上tv_loss，使其降噪
  • 之后采用反向传播方法，减少image的loss，使其和content以及和style的loss之和减小
  • 进行训练，并在ckpt或者训练结束之时，利用.eval()得到风格化图片的数据，输出
  • 补充，由于第二次看这个代码的时候又不理解了，所以补充一下描述：
  • 首先是输入image的节点，可以直接理解为net，net=vgg.net_preloaded，后面接哪个层就计算到哪个层
  • style_features是style的节点字典
  • 在进行反向传播前，都是只对节点进行存储到字典中，之后可以选择性地运行

  总结

  我所理解的风格化的实现过程如下：

  1. content用前向传播提取其特征，style用前向传播提取特征，但是由于content提取的层和style提取的层不同，所以特征的维度不一样，style提取的是低阶特征，具体到形状，而content提取的是高阶特征，对于整幅图。
  2. 也就是说，在高阶特征上，风格化的图形尽量和content保持一致，即loss减少，而在低阶特征上，风格化图形尽量和style保持一致，这就表明我们看风格化图片的局部，能够和style图片的局部相似，但是看风格化图片的整体，能够和content图片的整理相似，这是通过控制在哪一层进行loss计算是相关的
  3. style的特征提取是在relu1_1,relu2_1等较为低阶的层，而content是在relu4_2较为高阶的层，所以在低阶特征上，style有优势，并且这个风格化也是分层的，而content只有一层relu4_2

  展望

  • 在这里style图片分别提取了relu1_1,relu2_1等层，可以尝试不同层采用不同的style图片，实现分层的风格化
  • 图片的分层可以采用不同层的relu输出实现低阶到高阶的特征提取，这个例子中style就有很多层特征，而content只有一层高阶特征，利用此实现了风格化，想必应该有很多更加丰富的应用。可以把低阶和高阶的特征分别理解为世界的微观与宏观
  Read All

  ---

• 图像风格化代码理解和实验使用

  2017-07-10

  BCWang

  AI使用

  Python  图像处理  AI  NeuralNetwork

  LayerNeuralStylize

  • 来自我的github项目:https://github.com/B-C-WANG/AI-Storage/tree/master/AI.Experiment/AI.Exp.LayerNeuralStylize
  • The code is based on https://github.com/anishathalye/neural-style

  • In my project AI.Application.StylizePictures.I, I mentioned that to stylize a picture, is to minimize the sum of style loss, content loss and total varition denoising. The style loss, which is the sum of l2_loss of the difference between the calculated result of stylized image(a trainable variable) and style images, which the calculation is to get features in VGG model from beginning to layer relu1-1, relu2-1, relu3-1, relu4-1 and relu5-1. Shows in the following fig.

  • Here we use one style image to calculate its output of VGG model to layer relu1-1, relu2-1, relu3-1, relu4-1 and relu5-1, and calculate losses to back propagation.
  • And here I use five style images individually calculate its relu1-1, relu2-1, relu3-1, relu4-1 and relu5-1, get the total losses and back propagation, shows in the follow fig.
  • I do so because I think different layers(such as relu1-1 and relu5-1) represents different size of features, spliting the layers may help make stylized image more layering.
  • 【原始代码参考自https://github.com/anishathalye/neural-style 。在AI.Application的StylizePictures中，所采用的是，一张style图片同时计算其VGG模型中一开始到relu1-1, relu2-1, relu3-1, relu4-1和relu5-1的权重，并将其于生成图片的loss反向传播 在这里，我进行了一些更改，输入是5张作为style的图片，分别作为relu1-1至relu5-1的权重输出，这样，风格化的图片能够拥有5种不同层次的特征，同时计算量也能够减少。】

  code change

  1. Assert the number of the style image is 5, style_blend_weight remains but have different meanning.
  2. change for style_layer in STYLE_LAYERS: to layer=style_layer=STYLE_LAYERS[i]
     • 【强制输入5个层的风格化图片，对于每一个图片代表relu的不同层，style_blend_weight仍然有效。代码中的改变就是style_loss的求取这里，原来是对于5个STYLE_LAYERS都要求取loss，这里对于每一个style图片，求取不同层的loss】

       Experiment

     • Control group：
     • using original code to stylize, iteration is 1000.(the codes in https://github.com/anishathalye/neural-style have been upgraded, the codes I use is in ControlGroup and ExpGroup)【以原本的算法采用梵高的《星夜》去风格化某张图片，迭代次数为1000（其他参数与文件中的一致）】
     • Result:
     • content:
     • styles:
     • output: —
     • Exp1：
     • I chose a bigger-size version of the style image, and get its 1, 1/2, 1/4, 1/8, resize to the same 640 x 500 size(no scaling). And I chose another picture of Van Gogh as the relu1-1. The results shows that the picture becomes more blurry than control group, but I think a more blurry background makes the pircuture more layered, so I did Exp2.
     • 【改进后的此算法从一张较大的《星夜》中逐级放大提取出了4张图，分别是原图的1，1/2,1/4和1/8，缩放成同样的尺寸，并新增另一张梵高风格相似的图片作为relu5-1，进行风格化。由于进行了放大处理，所以得到的图片相对有些模糊，虽然图片中的房屋模糊了，但是对于背景来讲，这种模糊是一件好事，风格化很多情况下会在原图大片空白的地方出现循环的特征，这样的模糊有利于得到更加能够区分背景——焦点的层次化的图片，所以在此改进下，进行了实验2】
     • Exp1 Result：
     • styles:
     • output: —
     • Exp2
     • This time I keep relu5-1, relu4-1 and relu3-1 as the same picture as control group. Result shows that the main objects in the picture(the house) keeped its high resolution and background becomes more blurry, my designer friends says this one is better than the control group. And the brightness of the picture increased dut to the bright image I chose for relu2-1.
     • 【relu5-1, relu4-1和relu3-1保持原图，而relu2-1和relu1-1采用放大过后的图片，这一次良好地保留了主要场景的高分辨率，同时使背景模糊化，相对有更强的层次感，而且由于用了一张亮度较高的relu2-1的图片，整体亮度也提高了】
     • Exp2 Results：
     • styles:
     • output: —
     • Exp3
     • This time I generate four stylize images. The first one is almost the same as Exp2 except I replace the relu1-1 with an empty image(which every pixel in the image is (255, 255, 255)), and the iteration is 350. And also, for the second image, I replce relu1-1 and relu2-1 with empty images. And at last, I replce relu1-1, relu2-1, relu3-1 and relu4-1 with empty images. I got 4 reults, the first one is closest to Exp2, and the last is cloest to the content.
     • 【生成5张图片，分别是基于实验2的，将relu1-1至relu4-1依次用空白图片代替（比如第一次是relu1-1为空白，第二次就是relu1-1和relu2-1为空白，总共4次）。迭代次数由1000改为350】
     • 【下面的图分别是relu1-1为空白，relu1-1和2-1为空白，relu1-1,2-1,3-1为空白，relu1-1,2-1,3-1,4-1为空白生成的图片，其中第一张图接近于实验2的output，最后一张图接近原图，可以注意对比】
  Read All

  ---

• AI学习笔记5-VAE

  2017-07-10

  BCWang

  AI学习

  Python  Keras  AI  NeuralNetwork

  variational_autoencoder.py

  变分自编码器(VAE) 参考自：http://blog.csdn.net/jackytintin/article/details/53641885

  • 自编码器(autoencoder) 是一种非监督式学习的神经网络模型，采用原始数据作为输入和输出，含有一个数量小于输入输出的隐藏层。
  • 从输入到隐藏层，这一段神经元数量下降，被称为”encoder”，也可以称为模式识别模型或判别模型；而从隐藏层到输出，这一段神经元数量上升，被称为”decoder”，也称生成模型。因而编码器在一定程度上是类似于GAN的
  • 由于隐藏层数量小于输入，所以会对数据进行压缩，之后输出神经元数量大于隐藏层，压缩后的隐藏层相互组合重现原始输出
  • 它尝试使用一个函数，将输入逼近输出，经过训练之后，撤去输入层，仅凭隐藏层也可以实现重现输出
  • 这样隐藏层就需要做到提取主要成分的任务。这样的功能实现了隐藏层对于数据特征的提取，类似于主成分分析(PCA)
  • 稀疏自编码器(sparse autoencoder) 中的隐藏层数量会多于输入输出，此时需要抑制神经元。激活函数会使神经元处于抑制状态，这种抑制是稀疏性限制。比如采用sigmoid作为激活函数，就引入一个接近于0的稀疏性参数，这样会使得神经元的输出接近于0，从而在经过sigmoid函数之后会被抑制
  • 需要注意的是，在编码器中使用的维度变换，可以为任意结构如MLP, CNN, RNN等
  • 变分自编码器(VAE) 常常和GAN一同被提及，它们都属于生成模型，采用少量样本即可实现训练。步骤如下（结合后面的模型结构进行分析）:
    1. encoder或判别器将输入的n维数据转换为2个m维数据，其中第一个视作m个高斯分布的均值，第二个视作m个高斯分布方差的对数
    2. 根据上述2个m维的数据，生成m维的服从高斯分布的随机数
    3. 高斯分布先生成(None, m)的正态分布矩阵a，然后out = mean + exp(log_var/2) * a 输出encoder层的结果，注意是先生成N(0,1)再乘，而不是直接生成N(mean,log_var)，这样只涉及线性操作
    4. 模型结构如下：

  layer	shape	notes
  input	(None, n)	输入
  encoder	(None, ?)	判别器，可采用MLP,CNN,RNN等
  mean	(None, m)	均值，连接到hidden层
  log_var	(None, m)	方差对数，和mean层并列，直接连接到hidden层
  gaussian_out	(None, m)	生成高斯分布随机数
  decoder	(None, ?)	生成器
  output	(None, n)	恢复原始输出

  • 变分自编码器的意义以及和GAN的简单对比： 变分自编码器将decoder训练过后，根据正态分布的随机数，即可生成原始图像。而训练出的encoder，也可以作为数据降维，高维数据可视化的手段。
  • 与GAN的差异在于，VAE采用原始数据输入和输出，目的是训练encoder和decoder的能力，使其重现输入
  • 而GAN的discriminator(和encoder类似)并不是抽取高维特征，而是直接辨别真假结果，但是训练时也会逐渐习得特征。GAN的generator(和decoder)类似，是从随机数中生成数据用于判别，并逐渐训练使其接近原始输入
  • VAE和GAN是非常相似的，GAN的G-D模型，实际上可以理解为VAE的decoder，而GAN的D模型，也可理解为VAE的encoder
  • VAE的输入经过encoder之后，会提取均值和对数方差，这就是对于不同特征的样本，生成了不同特征的随机数，之后用随机数做生成 ，就不依赖于特定输入输出，GAN也是采用随机数作为输入生成，但是GAN的随机数的特征是固定的，VAE的随机数的特征(均值和方差)，会保留与输入的相关性。

  ---

  variational_autoencoder.py对VAE的实现

  1. encoder：输入(batch_size, original_dim)；用Dense将其转化为intermediate_dim数量的中间层，激活函数采用ReLU；z_mean和z_log_var均为shape:(batch_size, latent_dim)的矩阵。这个例子中并没有采用model.add的方式进行，而是利用<layer>(<parameter>)(<last_layer>)的方式连接，因为z_mean和z_log_var相互是并联在中间层上的，用sequence()无法实现
  2. 之后创建采样函数，输入z_mean和z_log_var，return一个方差为z_log_var/2，均值为z_mean的shape为(batch_size, latent_dim)的随机数矩阵。
  3. decoder：输入采样过后得到的随机数矩阵，将其转化为shape=(batch_size, intermediate_dim)的中间层，再转化为与输入相同shape的输出层decoded。
  4. 建立完成模型之后，建立一个继承自Layer的类，重写layer的call方法(每次调用)，其中输入为原始数据以及最终生成的数据。loss由两部分组成，第一部分是z_mean和z_log_var，另一部分是输入和最终输出(decoded)的binary cross-entropy，这个继承至layer的类，将以模型的输入和输出作为参数，使模型增添loss函数用以训练

  ---

  在创建了完整的VAE模型并增添loss函数之后，将喂入手写数据集用于训练(注意这里只会喂入image，没有任何label，因为是非监督的)；训练完成之后将输入和z_mean连在一起构成新的模型，喂入手写数据集进行可视化；之后将(latent_dim, )作为输入节点，最终生成的图片作为输出节点，构建decoder模型，喂入随机数生成图片

  1. 构建完整训练模型：首先将输入节点，即原始数据x，和输出节点，即生成的结果，一起作为参数传递到4.的layer中，用以定义损失函数。之后创建训练模型，将原始输入和损失函数作为节点连接(此时损失函数中就包含了运算图的信息)vae = Model(x, y)，之后创建优化函数，喂入手写数字数据集进行训练
  2. 构建encoder模型：用encoder = Model(x, z_mean)连接输入和z_mean输出节点，之后喂入手写数据进行预测，作图
  3. 构建generator模型：采用generator = Model(decoder_input, _x_decoder_mean)

  ---

  variational_autoencoder_deconv.py

  这个例子将上个例子的全连接隐藏层变为了卷积和反卷积层，也是采用<layer>(<parameter>)(<last_layer>)的方式构建完整VAE网络以及encoder和decoder，具体完整VAE模型结构如下

  layer	shape
  input	(None, 28, 28, 1)
  conv2d	(None, 28, 28, 1)
  conv2d	(None, 14, 14, 64)
  conv2d	(None, 14, 14, 64)
  conv2d	(None, 14, 14, 64)
  flatten	(None, 12544)
  dense_out	(None, 128)
  以下z_mean和z_log_var是并列关系	直接连接到dense_out
  z_mean	(None, 2)
  z_log_var	(None, 2)
  dense_decoder_in	(None, 128)
  dense	(None, 12544)
  reshape	(None, 14, 14, 64)
  deconv2d	(None, 14, 14, 64)
  deconv2d	(None, 14, 14, 64)
  deconv2d	(None, 29, 29, 64)
  conv2d	(None, 28, 28, 1)
  自建层	(None, 28, 28, 1)和(None, 28, 28, 1)，求取loss

  训练完成之后，用于特征提取的encoder的完整结构如下：

  layer	shape
  input	(None, 28, 28, 1)
  conv2d	(None, 28, 28, 1)
  conv2d	(None, 14, 14, 64)
  conv2d	(None, 14, 14, 64)
  conv2d	(None, 14, 14, 64)
  flatten	(None, 12544)
  dense	(None, 128)
  dense	(None, 2)

  decoder的结构如下：

  layer	shape
  input	(None, 2)
  dense	(None, 128)
  dense	(None, 12544)
  reshape	(None, 14, 14, 64)
  deconv2d	(None, 14, 14, 64)
  deconv2d	(None, 14, 14, 64)
  deconv2d	(None, 29, 29, 64)
  conv2d	(None, 28, 28, 1)

  完整的VAE模型相当于将encoder和decoder连接在一起，并增加loss函数用于训练

  体会与心得

  • 神经网络中，每个参数都有自己的功能，虽然机器并不会知道这些功能是什么，但是人类创建的模型的逻辑结构，决定了某些参数最适合做什么功能，而机器为了去达到更小的损失，就会学着将这些参数按照人类的意志使用。比如自编码器，人类的意图是用一个同等的输入输出，加上一个更小的隐藏层，达到数据的特征提取压缩，以及解压和重现；但是在机器眼中，就只有较小的隐藏层，和同样大小的输入输出层。然而在训练过程中，为了降低损失，机器采用的最佳的方式，就是像人类希望地那样，将隐藏层作为特征提取，于是就学会了完成人类的意图
  • 在GAN中也是如此，真实数据代表1，虚假数据代表0，机器不懂这是为了区别真假，但是它会这样去做。之后尝试将随机数生成判别为1的图片，人类是为了生成以假乱真的图片，但是机器不了解这个目的，不过也是会按照人类的意志去做
  • 所以深度学习，就像是人类给机器构建了一个自然选择的环境，而机器就自我进化。但是与大自然不同，人类需要去制定一些规则，这些规则实际上是不必要的，但是为了更快收敛是需要的。比如，如果采用全连接而不是卷积处理图像数据，机器最终也会在权重上反映出来某些间隔数据点是具有相关性的，这些数据点也就是二维中间隔相近的点，但是为了快速收敛，人类用卷积给了机器一个思考方式
  • 另外一例是在LSTM中的“遗忘门”，没有人告诉机器这个东西是来控制遗忘的，但是这个值能够在某些情况下抑制特定的神经元，机器在逐渐优化的过程中，就会为了减少loss而逐渐意识到这个东西是用来干什么的。
  • 也就是说，人类构建的模型应当是十分优化的，基于目的的，机器能够通过减少loss来迎合这种人类的目的。不过有时候，当构建模型时，人类将模型放得很开，此时就会反而不理解到底机器做了什么，比如卷积网络，人类的目的就是提取特征，连接高阶特征，保留二维数据的空间关系，不像LSTM的遗忘门那样在设计时就有明确的功能，于是这样当机器训练学成之后，人类也都无法理解机器进行了怎样的提取

  不过有时候我也这样想，当我们睁开眼睛，辨别物体的时候，是不是就像机器那样开始读取图像数据集，并训练成标签。而当我们闭上眼睛的时候，是不是就看到了那些训练好的卷积网络的隐藏层权重图像？而当我们做梦，是不是就相当于将训练好的标签经过decoder又返回变成图形？这样一想，突然感觉深度学习非常值得深入讨论，如何结合我们的大脑，构建强大的机器？ 也许有一天，如果我们构建了一个和大脑完全相同的神经网络结构，加上传感器，也许就能够完完全全创造一个人类的复制品，但是，人类研究这样久之后得到的东西，自然界又是怎样发展而来，达到如此小的功耗的呢？

  Read All

  ---

• AI学习笔记4-RNN

  2017-07-10

  BCWang

  AI学习

  Python  Keras  AI  NeuralNetwork  RNN

  babi_memnn.py

  用记忆神经网络训练bAbI数据集

  • bAbI数据集下载到一半时如果取消，会得到不完整的文件而报错，此时应当在代码中打印出下载地址，如path = get_file(...) print(path)，然后删除这个文件，不过一般在home目录下，windows在用户目录下
  • 在分析代码时，先直接看模型summary以及喂入的数据集，之后返回看数据集是怎样得到的。
    1. 函数tokenize(sent)：输入一个句子，将句子的每一个词和符号作为元素存储在list中
    2. parse_stories(lines, only_supporting)：only_supporting为True时，只有支持答案的句子才会出现。这个函数基于tokenize，针对bAbI的数据集，输入行，得到单词的list
    3. get_stories()：基于parse_stories，输入文件名，解析出句子中词语的list，比如某个输出：`[([‘Mary’, ‘moved’, ‘to’, ‘the’, ‘bathroom’, ‘.’, ‘John’, ‘went’, ‘to’, ‘the’, ‘hallway’, ‘.’], [‘Where’, ‘is’, ‘Mary’, ‘?’], ‘bathroom’), 每个set是一个完整的问题，含有两个list和一个string，前一个list是描述，后一个是问题，最后一个string是答案
    4. vectorize_stories()直接转换为词向量，一个单词具有独一无二的序号
    5. 描述的最大长度为68个单词，问题的最大长度为4个单词，用来训练的数据为10000组，用来测试的数据为1000组
    6. 所采用的问题集都是关于空间位置逻辑的，比如“a在b处，b在c处，问d在哪？”因而，描述的shape为(None, 68)，多为[0,0,0,…,18,n,1]，因为问题结尾多为”the … .”。问题的shape为(None, 4)，几乎都为[7,13,n,2]，对应于”where is … ?”，而答案的shape为(None, 22)，是22维的独热编码（整个数据集的词汇量为22个，多为“bedroom, hallway, bathroom”等空间位置词汇，以及人名）

  模型结构 模型结构包含并联层，在layer前用n-m-l注明，n为层的深度，m，l等等为同一个串联层的标志，在这里m=1代表描述的输入，m=2代表问题的输入。layer后面的括号中代表了对哪个层进行了运算(省略了dropout和activation层)

  layer	shape
  1-1, story_input	(None, 68)
  1-2, question_input	(None, 4)
  2-1-1, story_encoder_m, embedding(1-1)	(None, 68, 64)
  2-1-2, story_encoder_c, embedding(1-1)	(None, 68, 4)
  2-2, question_encoder, embedding(1-2)	(None, 4, 64)
  3, dot(2-1-1, 2-2)	(None, 68, 4)
  4, add(3, 2-1-2)	(None, 68, 4)
  5, permute(4)	(None, 4, 68)
  6, concatenate(5, 2-2)	(None, 4, 132)
  7, LSTM(6)	(None, 32)
  8, dense(7)	(None, 22)

  之后输出的(None, 22)和结果和真实答案(None, 22)进行损失计算。

  

  babi_rnn.py

  数据处理与上一例类似，只不过改变了数据集，描述的最大长度为552，问题最大长度为5，答案的维度（总也就是词汇量）为36 模型结构

  layer	shape
  1-1, story_input	(None, 552)
  1-2, question_input	(None, 5)
  2-1, story_encoded, embedding(1-1)	(None, 552, 50)
  2-2, question_encoded, embedding(1-2)	(None, 5, 50)
  3-2, recurrent.LSTM(2-2)	(None, 50)
  4-2, repeat_vector(3-2)	(None, 552, 50)
  5, add(2-1, 3-2)	(None, 552, 50)
  6, recurrent.LSTM(5)	(None, 50)
  7, dense(6)	(None, 36)

  

  conv_lstm.py

  • 这个例子首先认为创造一个移动的矩形，形成一段影片，之后根据这个影片预测出矩形之后的移动，涉及到图像处理和时间序列，因而需要ConvLSTM
  • 需要较高显存才可执行，可将n_samples调低一些，同时调整which
  • 模型结构(输入为(batch_size, n_frames[帧数], width, height, channels))

  layer	shape
  input	(None, None, 40, 40, 1)
  conv2d_LSTM	(None, None, 40, 40, 40)
  batch_normalization	-
  conv2d_LSTM	(None, None, 40, 40, 40)
  batch_normalization	-
  conv2d_LSTM	(None, None, 40, 40, 40)
  batch_normalization	-
  conv2d_LSTM	(None, None, 40, 40, 40)
  batch_normalization	-
  conv3d	(None, None, 40, 40, 1)

  1. 创建一个指定大小、帧率和batch_size的影片作为输入。在影片中添加3~7个正方形，设定正方形的运动起始点和运动方向
  2. 创建输入数据，即创建正方形的移动影片，并在视频加上噪点，是为了防止数据为0，增强模型robust
  3. 创建下一刻的数据作为y，y的影片时间为输入的时间t+1，相当于y总是快于输入一秒，这样训练能够预测，y不加入噪点
  4. 用上述模型，以完整影片作为输入，影片时间+1的y作为求取loss的输出，进行训练

  预测和可视化

  1. 训练完成之后，首先用which变量选择一个sample，之后会取7帧作为输入，进行fit，得到预测之后的几帧，变量为track
  2. 截取和预测片段相同的真实片段track2，将track和track2的每一帧作图在一起，输出图像进行对比

  imdb_lstm.py

  利用LSTM处理IMDB数据集，IMDB是一个网络电影数据集，输入是已经转化为词向量的数据，输出为正面或负面评价，是二分类问题。 模型

  layer	shape
  input	(None, 80)
  embedding	(None, None, 128)
  LSTM	(None, 128)
  dense	(None, 1)

  imdb_cnn_lstm.py

  在IMDB中使用conv1D的卷积。LSTM可以处理序列化的数据，而一维卷积则是类似于2维卷积，处理序列上相关的数据。 模型

  layer | shape :–: | :–: input | (None, 100) embedding | (None, 100, 128) dropout | (None, 100, 128) conv1d | (None, 96, 64) pooling | (None, 24, 64) LSTM | (None, 70) dense | (None, 1) activation | (None, 1)

  imdb_bidirecational_lstm.py

  双向LSTM网络 模型

  layer	shape
  input	(None, 100)
  embedding	(None, 100, 128)
  bidirectional	(None, 128)
  dropout	(None, 128)
  dense	(None, 1)

  mnist_hierarchical_rnn.py

  多层反馈神经网络，这个例子中是采用的keras函数式建模(不同于 Model.add()，采用layer(parameters)(last_layer))。 模型

  layer	shape
  input-x	(None, 28-row, 28-col, 1)
  LSTM(row)	(None, 128)
  timeDirtributed(x)	(None, 28, 128)
  LSTM(col)	(None, 128)
  dense	(None, 10)

  将(28, 1)的行向量用LSTM编码成(128)的行向量，之后将(28, 128)的图形用LSTM编码成(128)的图像向量，最后全连接获得标签。

  Read All

  ---

• AI学习笔记3-Keras例子2

  2017-07-10

  BCWang

  AI学习

  Python  Keras  AI  NeuralNetwork

  lstm_text_generation.py

  基于LSTM的文本生成。采用的数据集是尼采的著作，可以采用其他语料库进行替换生成（如中文、学科论文、笑话语料库等）

  • 数据库载入和预处理
  • 读取数据
  • 将数据中的字符(chars)提取，如”\n”, “a”, “)”和空格等
  • 构造字符和向量互换的两个词典，如{1: “a”, 2: “b”}和{“a”: 1, “b”: 2}
  • 建立x和y数据集，x是一个由maxlen个字符组成的句子，而y为该句子紧接着的下一个字符，其中每次取了40个字符之后就跳过3个字符，如x1=(0,40),y1=(41)和x2=(3,43),y2=(44)这样类似于conv中的步长，由于例子中步长为3，所以最终所得样本数量为原来字符数量的1/3
  • 得到了x,y之后，对于每一个字符组成的句子，建立一个长度为len(chars)的数组，采用独热编码表示单词，如abc就是[1,1,1,0,0,0,0…0]
  • 最终得到的shape为x: (200285, 40, 58), y: (200285, 58)，200285是上个步骤数据集生成的句子，在一次训练中只使用batch_size训练其中一小部分(本例子中batch_size为128)，所以上面的shape通常也记为(None, 40, 50)，None是batch_size
  • 模型

  layer	shape
  input	(None, 40, 58)
  LSTM	(None, 128)
  dense	(None, 58)
  activation	-

  • 训练和生成

  1. 例子中训练和生成时同时进行，总共有60次训练，每次喂入128个数据进行
  2. 每次训练结束后就测试，先选一个随机起点，得到40长度字符的句子，之后将字符转化为独热编码向量,shape为(40, 58)
  3. 用model.predict进行预测，输出为(58)的矩阵，然后用激活函数以及argmax求得概率最大的输出，用字符词典转换成相应的字符，就是最后预测的结果
  4. 每次predict得到一个字符，把它加进原来的句子中，然后重新取后面40个，相当于滑动窗口，这样能够基于生成的句子来预测（前面由于是原句，所以生成会较为合理，后面很多是生成的句子，不合理性较高）
  5. 用了一个循环语句，重复3~4过程，生成400个字符，组成句子
  6. 用sys.stdout.write进行输出

  心得和展望

  • 以字符为单位进行预测，而不是以词语为单位，这样减少了很多处理量，而且还能够完整地生成出单词，也许这是LSTM的优势所在
  • 用学术论文作为数据集进行训练，之后根据自己写的内容进行预测，以此达到论文润色的目的，需要关注低频词汇的影响。

  lstm_fasttext.py

  利用fast text进行text的分类

  1. create_ngram_set函数：输入一个list和int，将list转化为窗口为int，步长为1的元组列。create_ngram_set([1, 4, 9, 4, 1, 4], ngram_value=2)——[(4, 9), (4, 1), (1, 4), (9, 4)]。create_ngram_set([1, 4, 9, 4, 1, 4], ngram_value=3)——[(1, 4, 9), (4, 9, 4), (9, 4, 1), (4, 1, 4)]
  2. add_ngram函数：将输入的sequences按照create_mgram_set的方式进行处理，处理得到的输出用token_indice进行映射，转换成另一个int，需要注意这里采用的是ngram_range而不是ngram_value，如果ngram_range=4，则相当于ngram_value=1,2,3,4的情况都要进行转换
  3. 载入IMDB数据，长度为20000，得到的数据是二维嵌套数组，每一个数组中是一个句子的词向量构成的数组
  4. 如果ngram_range大于1，对于从2到ngram_range的int，都采用1. 中的函数进行转化，然后将所得得到set更新至ngram_set中(直接用<set>.update(<set>))，完成过后，得到了一些含多个词的词库，对于固定搭配很有用。比如，ngram_range=1，则ngram_set为((1),(2)…)，如果ngram_range=3，则ngram_set为((1),(2),(1,2),(1,2,3))，之后建立字典，在已有词的情况下（载入的数据在ngram_value=1的情况下已经实现了转换为词向量），在后面追加ngram_value=2,3…直到ngram_range词语数量对应的映射。
  5. 建立的词库即为token_indice，用add_ngram借助token_indice进行转化
  6. 之后进行训练，模型：

  layer	shape
  input	(None, 400)
  embedding	(None, 400, 50)
  global_average_pooling1D	(None, 50)
  dense	(None, 1)

  Read All

  ---

• AI学习笔记2-Keras例子1

  2017-07-10

  BCWang

  AI学习

  Python  Keras  AI  NeuralNetwork

  addition_rnn.py

  让机器学会加法运算 如遇运行报错，检查tensorflow版本，多为tf.concat和tf.unstack的问题

  1. 首先创建字符词典，由于是加法，所以字符词典的键值为[0,1,2,3,4,5,6,7,8,9,+]
  2. encode函数，将算式转化为独热编码的矩阵，如35+35，即第一行第4个为1，第二行第6个为1，第三行最后一个为1……其余全为0，共5行，之后设置了最大长度为7行，之后将添加全0的两行凑成7行（用于两个三位数相加）
  3. decode函数，是encode的逆过程
  4. 之后生成算式数据，随机生成两个位数随机的数字，encode成输入，计算出结果，encode成输出，输入拓展成7行，输出拓展成4行（适用于最高两个3位数相加）
  5. 按10%比例划分训练和测试集
  6. 训练模型，输出原始算式、正确结果和预测结果，模型如下表：

  layer	output_shape
  input	(None, 7, 12)
  LSTM	(None, 128)
  repeat_vector	(None, 4, 128)
  LSTM	(None, 4, 128)
  time_distributed	(None, 4, 12)
  activation(softmax)	(None, 4, 12)

  antirectifier.py

  创建一个自定义的层(layer)

  1. 创建一个类，这个类继承自layers.Layer，即class custom_layer(layers.Layer)
  2. 这个例子中重写了父类的compute_output_shape(self,input_shape)和call(self,inputs)函数，在连接层的时候，会调用前者去计算得到的shape，调用后者输出output。可以尝试查看layers.Layer的源代码，重写其他方法。
  3. 此处compute_output_shape将input的第二维乘以2输出output_shape，而call则先L2正则化，然后输出正和负的ReLU输出结果，将其连接，于是得到2倍长度的矩阵，可以当做正则化和激活函数使用。

  mnist_acgan.py

  判别器模型：

  layer	output_shape
  input	(None, 1, 28, 28)
  conv2d	(None, 32, 14, 14)
  LeakyReLU	-
  dropout	-
  conv2d	(None, 64, 14, 14)
  LeakyReLU	-
  dropput	-
  conv2d	（None, 128, 7, 7）
  LeakyReLU	-
  dropput	-
  conv2d	(None, 256, 7, 7)
  LeakyReLU	-
  dropput	-
  flatten	(None, 12544)
  输出1: fake	输出2： auxiliary
  output1: fake	Dense(1, activation=”sigmoid”)
  output2: aux	Dense(10, activation=”softmax”)

  • 判别器return:
  • Input(用于feed image数据): shape为(1, 28, 28)
  • Output(用于feed label数据用以训练，或predict得到结果): [fake(shape=(None, 1)), aux(shape=(None, 10))]，fake是真假布尔值，aux是对应的手写数字预测的数字标签(one-hot)

  生成器模型： 例子中的参数，latent_size = 100

  layer	output_shape
  input	(None, 100)
  dense	(None, 1024)
  dense	(None, 128 x 7 x 7=6272)
  reshape	(None, 128, 7, 7)
  upsampling	(None, 128, 14, 14)
  conv2d	(None, 256, 14, 14)
  upsampling	(None, 256, 28, 28)
  conv2d	(None, 128, 28, 28)
  cond2d	(None, 1, 28, 28)

  • 生成器return：
  • Input(用于feed随机数数据): shape为(None, 100)的随机数，shape为(1，None)的手写数字标签(非one-hot)。
  • Output(用于feed图片数据用以训练，或predict生成假图片数据): fake_image(shape=(None, 1, 28, 28))

  过程

  1. 设定参数，依照模型建立损失函数
  2. 设置placeholder作为生成器的输入（100长度的随机数以及1个长度的label），得到生成后的假图片；之后将假图片作为输入进判别器中，得到fake和auxiliary
  3. combine生成和判别模型，合成一个模型，输入100长度随机数和1长度的label，输出是否为真的布尔值以及auxiliary
  4. 接着准备原始手写输入数据，用生成器基于100个(-1, 1)的浮点随机数以及1个(0, 10)的整数，生成假图片，然后混入原始图片中
  5. 设置真假标签y，真实图片的fake=1，生成的图片fake=0,
  6. 设置识别标签aux，真实图片aux为对应的label，生成的图片aux为对应生成图片的随机数
  7. 将原始图片数据，随机数生成的假图片数据作为image，真假标签y作为fake，识别标签aux作为aux，一同喂入鉴别器中进行训练，此时是在训练鉴别器鉴别真假的能力
  8. 之后将两随机数，以及全为1的fake布尔值和对应的标签，一同喂入3中所述组成的生成-判别模型，进行训练，为的就是训练生成模型，使其生成的图片能够让判别模型得出的fake布尔值为1，并且生成的图片被判别器识别出的数字，和一开始输入的随机整数相同(也就是训练给定一个100位的随机数以及1个数字，生成这个数字的手写图像)
  9. 上述的GAN训练完成之后，混入真实数据进行测试，计算loss，并输出生成的图片进行显示

  理解

  • 我们可以这样理解这种监督学习的训练过程：给定输入输出，使网络自行调整以符合输入输出，比如输入真实图片的label为1，虚假图片label为0，就是训练辨别能力
  • 而输入虚假图片，又使判别器输出为1，还要使判别器对于虚假图片对应的手写数字的判别与初始的随机数相同，这就是在训练使其能够达成以假乱真的效果
  • 每次训练判别器会得到加强，而生成器也会得到加强，相互拮抗，都能够得到进步

  cifar10_cnn.py

  利用卷积神经网络训练cifar10数据集

  layer	output_shape
  input	(None, 32, 32, 3)
  conv2d	(None, 32, 32, 32)
  activation	-
  conv2d	(None, 30, 30, 32)
  activation	(None, 30, 30, 32)
  maxpooling	(None, 15, 15, 32)
  dropout	-
  conv2d	(None, 15, 15, 64)
  activation	-
  conv2d	(None, 13, 13, 64)
  activation	-
  maxpooling	(None, 6, 6, 64)
  dropout	-
  flatten	(None, 6 x 6 x 64 = 2304)
  dense	(None, 512)
  activation	-
  dropout	-
  dense	(None, 10)
  activation	-

  优化：RMSprop loss函数：categorical_crossentropy

  minst_transfer_cnn.py

  迁移卷积神经网络：一篇有关迁移学习的论文提到，只要改变最后的全连接层（之前的都为瓶颈层）即可实现迁移学习，可以快速收敛。本例子是利用手写数字前5位数训练模型，之后冻结全连接层前的所有层，将模型应用于后5位数字的训练

  1. 准备手写数据
  2. 将模型、训练集的输入及其标签作为形参，构建损失函数和优化器，并输出accuracy
  3. 将手写数据分成两部分，第一部分所有图片及标签是0-4，第二部分为5-9
  4. 构建瓶颈层网络，构建最后的全连接层网络
  5. 用model = Sequential(layer1 + layer2)连接网络，之后用0~4的手写数字集进行训练
  6. (l.trainable = False for l in layers)冻结瓶颈层
  7. 用5中连接后的模型再次训练5~9的手写数字，由于只有全连接层可以训练，所以参数大大减少，很快就可以收敛

  迁移学习保留瓶颈层，是因为瓶颈层是在进行特征提取，而全连接层进行特征的组合。对于某些监督学习，特征差异较大，可以之后再连接可训练的卷积层（而不是像本例中只连接可训练的全连接层）进行

  • 模型

  layer	output_shape
  input	(None, 28, 28, 1)
  conv2d	(None, 26, 26, 32)
  activation	-
  conv2d	(None, 24, 24, 32)
  activation	-
  maxpooling	(None, 12, 12, 32)
  dropout	-
  flatten	(None, 12 x 12 x 32 = 4608)
  以上为瓶颈层	以下为迁移学习后可训练层
  dense	(None, 128)
  activation	-
  dropout	-
  dense	(None, 5)
  activation	-

  deep_dream.py

  用keras实现deep dream的效果，一开始需要下载模型的权重数据

  1. 设置命令行参数，分别为图片地址和转换结果的文件名
  2. 用路径名载入图片数据，转为numpy array的格式，并进行预处理转换(像素除以255，减去0.5，乘以2)
  3. 用model = inception_v3.InceptionV3(…)载入模型
  4. 用dream = model.input设置数据的输入点
  5. 用from keras import backend as K， loss = K.variable(0.)创建一个浮点数占位变量，之后在每一层的输出中，计算均方差，其和记为loss
  6. 用K.gradients(loss, dream)计算根据loss得到的梯度，并正则化，将这些计算封装为函数，之后使用。设置一个resize_img函数，对图片进行缩放，成为指定大小的图片
  7. 设置梯度上升函数，这是deepdream的关键，当loss大于某个值之前，将梯度增加在图片上（正好是图像识别训练的逆过程，梯度下降，并在loss足够小后结束）
  8. loss足够大时结束，输出图片

  这样的一个过程相当于把模型的权重（即分析图片得到的特征）返回到图片上，是训练的逆过程，所以会产生非常奇异的结果

  Read All

  ---