生成对抗网络在推荐系统中落地Generative Adversarial Networks

GAN思想

生成对抗网络 – GAN 是最近2年很热门的一种无监督算法，它能生成出非常逼真的照片，图像甚至视频。深度学习最特别最厉害的地方就是能够自己学习特征提取。

生成对抗网络（GAN）由2个重要的部分构成：

生成器(Generator)：通过机器生成数据（大部分情况下是图像），目的是“骗过”判别器

判别器(Discriminator)：判断这张图像是真实的还是机器生成的，目的是找出生成器做的“假数据”

训练过程：

第一阶段：固定「判别器D」，训练「生成器G」

第二阶段：固定「生成器G」，训练「判别器D」

第三阶段：循环阶段一和阶段二

通过不断的循环，「生成器G」和「判别器D」的能力都越来越强。

最终我们得到了一个效果非常好的「生成器G」，我们就可以用它来生成我们想要的图片了。

GAN全称对抗生成网络，顾名思义是生成模型的一种，而它的训练则是处于一种对抗博弈状态中的。

生成Mnist手写体图像

加载真实mnist数据集

from keras.datasets import mnist
from keras.layers import Dense, Dropout, Input
from keras.models import Model,Sequential
from keras.layers.advanced_activations import LeakyReLU
from keras.optimizers import Adam
from tqdm import tqdm
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from google.colab import drive
  
# Load the dataset
def load_data():
  (x_train, y_train), (_, _) = mnist.load_data()
  x_train = (x_train.astype(np.float32) - 127.5)/127.5

  # Convert shape from (60000, 28, 28) to (60000, 784)
  x_train = x_train.reshape(60000, 784)
  return (x_train, y_train)

X_train, y_train = load_data()
print(X_train.shape, y_train.shape)

用最简单MLP全连接层来构建生成器（用卷积层当然更好，在这里先不考虑

def build_generator():
    model = Sequential()

    model.add(Dense(units=256, input_dim=100))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Dense(units=512))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Dense(units=1024))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Dense(units=784, activation='tanh'))

    model.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5))
    return model

generator = build_generator()
generator.summary()

然后建一个判别器，也是一个MLP全连接神经网络：

def build_discriminator():
    model = Sequential()

    model.add(Dense(units=1024 ,input_dim=784))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Dense(units=512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Dense(units=256))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Dense(units=1, activation='sigmoid'))

    model.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5))
    return model

discriminator = build_discriminator()
discriminator.summary()

建立一个GAN网络，由discriminator和generator组成：

def build_GAN(discriminator, generator):
    discriminator.trainable=False
    GAN_input = Input(shape=(100,))
    x = generator(GAN_input)
    GAN_output= discriminator(x)
    GAN = Model(inputs=GAN_input, outputs=GAN_output)
    GAN.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5))
    return GAN

GAN = build_GAN(discriminator, generator)
GAN.summary()

写一个train函数，来训练GAN网络。在这里我们设置最大迭代次数400，每次迭代生成128张假图片：

def train_GAN(epochs=1, batch_size=128):

  #Loading the data
  X_train, y_train = load_data()

  # Creating GAN
   # 建立一个GAN网络，GAN由两个神经网络（generator, discriminator）连接而成
  generator= build_generator()
  discriminator= build_discriminator()
  GAN = build_GAN(discriminator, generator)

  for i in range(1, epochs+1):
    print("Epoch %d" %i)

    for _ in tqdm(range(batch_size)):
      # 生成呈高斯分布的噪声，利用generator，来生成batch_size（128张）图片。每张图片的输入就是一个1*100的噪声矩阵
      # Generate fake images from random noiset
      noise= np.random.normal(0,1, (batch_size, 100))
      fake_images = generator.predict(noise)

      # Select a random batch of real images from MNIST
      real_images = X_train[np.random.randint(0, X_train.shape[0], batch_size)]

      # Labels for fake and real images
      # 从Mnist数据集中随机挑选128张真实图片。我们给真实图片标注1，给假图片标注0，然后将256张真假图片混合在一起
      label_fake = np.zeros(batch_size)
      label_real = np.ones(batch_size) 

      # Concatenate fake and real images 
      X = np.concatenate([fake_images, real_images])
      y = np.concatenate([label_fake, label_real])

      # Train the discriminator
      discriminator.trainable=True
      discriminator.train_on_batch(X, y)

      # Train the generator/chained GAN model (with frozen weights in discriminator) 
      discriminator.trainable=False
      GAN.train_on_batch(noise, label_real)

    # Draw generated images every 15 epoches     
    if i == 1 or i % 10 == 0:
      draw_images(generator, i)
train_GAN(epochs=400, batch_size=128)

Generator利用自己最新的权重，生成了一堆假图片。

Discrminator根据真假图片的真实label，不断训练更新自己的权重，直到可以顺利鉴别真假图片。

此时discriminator权重被固定，不再发生变化。generator利用最新的discrimintor，苦苦思索，不断训练自己的权重，最终使discriminator将假图片鉴定为真图片。

DCGAN模型

DCGAN模型的生成网络包含10层，它使用跨步转置卷积层来提高张量的分辨率，输入形状为 (batchsize, 100) ，输出形状为 (batchsize, 64, 64, 3)。换句话说，生成网络接受噪声向量，然后经过不断变换，直到生成最终的图像。

判别网络也包含10层，它接收 (64, 64, 3) 格式的图片，使用2D卷积层进行下采样，最后传递给全链接层进行分类，分类结果是 1 或 0，即真与假。

DCGAN 模型的训练过程大致可以分为三个子过程。首先， Generator 网络以一个随机数作为输入，生成一张『假』图片；接下来，分别用『真』图片和『假』图片训练 Discriminator 网络，更新参数；最后，更新 Generator 网络参数。

GAN模型推荐系统落地

CFGAN算法提出了“vector-wise”的方式，对于给定的用户，生成器一次生成其购买向量（Fake Purchase Vectors）；而判别器则用来判别输入的向量是真实的数据还是生成器“伪造”的向量。

在CFGAN中，G生成的是向量称其为购买向量purchase vector。假设我们有基于隐式反馈得到的用户-物品购买矩阵，那么从用户角度来说，购买向量便是矩阵中的一行，若用户与物品有过购买(其实不一定是购买，也可以认为是有过交互），该位置为1，如果没有购买，该位置是空（不是0），从物品角度来说，购买向量便是矩阵中的一列，若物品被用户购买过，该位置为1，如果没有购买过，该位置是空（不是0）。

生成器G的设计
生成器的输入包含两部分，一是用户向量c，另一个是噪声向量z。经过生成器的多层神经网络后，输出用户购买向量。向量中每一个值代表用户与物品交互的概率。这里对输出的购买向量增加了一个mask，mask向量eu中，用户交互过的地方为1，没有交互过的地方为0。用用户购买过的地方去训练，随后预测用户对未购买过的物品的评分。

判别器D的设计
判别器将用户真实的购买向量和G生成的购买向量进行混合，尽可能地将真实向量识别成real，将生成的向量识别成fake。这里同样需要输入用户向量c。

模型训练
生成器的损失函数为：

判别器的损失函数为：

eu指定u是购买了每一项i（eui=1）或没有（eui=0），⊙代表元素乘法。通过这样做，只有G在购买物品上的输出才有助于G和D的学习，换句话说，“丢弃”了与非购买物品相对应的G的输出节点。

通过负采样的技术，增加一定的负样本。即在每次训练迭代过程中，我们随机选择每个用户的未购买过物品的一部分，将其假设为负样本，然后在训练生成器生成购买向量的时候，使其对应的负样本的值接近0

IRGAN和GraphGAN的方法都存在discrete item index generation的问题，同一个物品，它有可能既被标记为真实数据（real），又被标记为生成数据（fake）