jupyternotebook实现原理（Notebook并运行对抗神经网络）
jupyternotebook实现原理（Notebook并运行对抗神经网络）运行安装命令：source venv/bin/activate之前创建的虚拟环境中下面说一下安装的流程。建议在安装的时候进入之前创建的虚拟环境中安装，同时运行的时候也是在虚拟环境中运行，这样就可以直接使用tensorflow的环境了。进行环境：
在上一篇文章中已经介绍了在ubuntu20.04中安装了python3.8和tensorflow2.2.0，需要看的朋友可以到上文中观看：
https://www.toutiao.com/i6915983671610638859/
然而上文中只是安装了基本环境而已，要想更友好地开发python代码，还是要安装jupyter notebook，这样对代码运行结果的可视化会比较好。Jupyter Notebook是基于网页的用于交互计算的应用程序，其可被应用于全过程计算：开发、文档编写、运行代码和展示结果。官方文档为：
https://jupyter-notebook.readthedocs.io/en/stable/notebook.html
安装完成后如下图：
本文为详细介绍怎么安装jupyter notebook，及运行一个对抗神经网络。
下面说一下安装的流程。
一、jupyter notebook安装（1）使用pip安装建议在安装的时候进入之前创建的虚拟环境中安装，同时运行的时候也是在虚拟环境中运行，这样就可以直接使用tensorflow的环境了。
进行环境：
source venv/bin/activate
之前创建的虚拟环境中
运行安装命令：
pip install jupyter
安装中
安装完成
如果安装失败可以执行如下升级
pip install --upgrade pip（2）运行jupyter notebook
注意：运行的时候也是在虚拟环境中运行，以便使用虚拟环境中的tensorflow软件包
jupyter notebook
运行成功
在运行成功的图里可以知道，是会自动打开了一个页面：
http://localhost:8888/tree?#running
运行页面
这个时候就可以在右上角新建，进行写代码了。
二、运行对抗神经网络生成对抗网络（GANs）是当今计算机科学领域最有趣的想法之一。两个模型通过对抗过程同时训练。一个生成器（“艺术家”）学习创造看起来真实的图像，而判别器（“艺术评论家”）学习区分真假图像。可以在官网看具体的详细，如下：
https://tensorflow.google.cn/tutorials/generative/dcgan
下面是我运行的一个结果，只是运行了5次而已。
对抗神经网络生成字体
先新建一个GANs.ipynb文件，在里面填入相关的内容就可以了。
GANs.ipynb文件
具体的内容可以在tensorflow的官网可以看到。
当然大家想看我的也是可以的，我导出来了如下，内容比较多，不想看的，可以跳过：
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import tensorflow as tf
# In[2]:
tf.__version__
# In[3]:
import glob
import imageio
import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
from tensorflow.keras import layers
import time
from IPython import display
# In[4]:
(train_images train_lables) (_ _) = tf.keras.datasets.mnist.load_data()
# In[5]:
train_images.shape
# In[6]:
train_images = train_images.reshape(train_images.shape[0] 28 28 1).astype('float32')
train_images = (train_images - 127.5) / 127.5 # 将图片标准化到 [-1 1] 区间内
# In[7]:
BUFFER_SIZE = 60000
BATCH_SIZE = 256
# In[8]:
# 批量化和打乱数据
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
# In[9]:
def make_generator_model():
model = tf.keras.Sequential()
model.add(layers.Dense(7*7*256 use_bias=False input_shape=(100 )))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Reshape((7 7 256)))
assert model.output_shape == (None 7 7 256) # 注意：batch size 没有限制
model.add(layers.Conv2DTranspose(128 (5 5) strides=(1 1) padding='same' use_bias=False))
assert model.output_shape == (None 7 7 128)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Conv2DTranspose(64 (5 5) strides=(2 2) padding='same' use_bias=False))
assert model.output_shape == (None 14 14 64)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Conv2DTranspose(1 (5 5) strides=(2 2) padding='same' use_bias=False activation='tanh'))
assert model.output_shape == (None 28 28 1)
return model
# In[10]:
generator = make_generator_model()
noise = tf.random.normal([1 100])
generated_image = generator(noise training=False)
plt.imshow(generated_image[0 : : 0] cmap='gray')
# In[11]:
def make_discriminator_model():
model = tf.keras.Sequential()
model.add(layers.Conv2D(64 (5 5) strides=(2 2) padding='same'
input_shape=[28 28 1]))
model.add(layers.LeakyReLU())
model.add(layers.Dropout(0.3))
model.add(layers.Conv2D(128 (5 5) strides=(2 2) padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.Dropout(0.3))
model.add(layers.Flatten())
model.add(layers.Dense(1))
return model
# In[12]:
discriminator = make_discriminator_model()
decision = discriminator(generated_image)
print (decision)
# In[13]:
# 该方法返回计算交叉熵损失的辅助函数
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
# In[14]:
def discriminator_loss(real_output fake_output):
real_loss = cross_entropy(tf.ones_like(real_output) real_output)
fake_loss = cross_entropy(tf.zeros_like(fake_output) fake_output)
total_loss = real_loss fake_loss
return total_loss
# In[15]:
def generator_loss(fake_output):
return cross_entropy(tf.ones_like(fake_output) fake_output)
# In[16]:
generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)
# In[17]:
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir "ckpt")
checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer
discriminator_optimizer=discriminator_optimizer
generator=generator
discriminator=discriminator)
# In[29]:
EPOCHS = 50
noise_dim = 100
num_examples_to_generate = 16
# 我们将重复使用该种子（因此在动画 GIF 中更容易可视化进度）
seed = tf.random.normal([num_examples_to_generate noise_dim])
# In[30]:
# 注意 `tf.function` 的使用
# 该注解使函数被“编译”
@tf.function
def train_step(images):
noise = tf.random.normal([BATCH_SIZE noise_dim])
with tf.GradientTape() as gen_tape tf.GradientTape() as disc_tape:
generated_images = generator(noise training=True)
real_output = discriminator(images training=True)
fake_output = discriminator(generated_images training=True)
gen_loss = generator_loss(fake_output)
disc_loss = discriminator_loss(real_output fake_output)
gradients_of_generator = gen_tape.gradient(gen_loss generator.trainable_variables)
gradients_of_discriminator = disc_tape.gradient(disc_loss discriminator.trainable_variables)
generator_optimizer.apply_gradients(zip(gradients_of_generator generator.trainable_variables))
discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator discriminator.trainable_variables))
# In[31]:
def train(dataset epochs):
for epoch in range(epochs):
start = time.time()
for image_batch in dataset:
train_step(image_batch)
# 继续进行时为 GIF 生成图像
display.clear_output(wait=True)
generate_and_save_images(generator
epoch 1
seed)
# 每 15 个 epoch 保存一次模型
if (epoch 1) % 15 == 0:
checkpoint.save(file_prefix = checkpoint_prefix)
print ('Time for epoch {} is {} sec'.format(epoch 1 time.time()-start))
# 最后一个 epoch 结束后生成图片
display.clear_output(wait=True)
generate_and_save_images(generator
epochs
seed)
# In[32]:
def generate_and_save_images(model epoch test_input):
# 注意 training` 设定为 False
# 因此，所有层都在推理模式下运行（batchnorm）。
predictions = model(test_input training=False)
fig = plt.figure(figsize=(4 4))
for i in range(predictions.shape[0]):
plt.subplot(4 4 i 1)
plt.imshow(predictions[i : : 0] * 127.5 127.5 cmap='gray')
plt.axis('off')
plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
plt.show()
# 调用上面定义的 train() 方法来同时训练生成器和判别器。注意，训练 GANs 可能是棘手的。
# 重要的是，生成器和判别器不能够互相压制对方（例如，他们以相似的学习率训练）。
# 在训练之初，生成的图片看起来像是随机噪声。随着训练过程的进行，生成的数字将越来越真实。
# 在大概 50 个 epoch 之后，这些图片看起来像是 MNIST 数字。使用 Colab 中的默认设置可能需要大约 1 分钟每 epoch。
# In[ ]:
get_ipython().run_cell_magic('time' '' 'train(train_dataset EPOCHS)')
# In[ ]:
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
# In[ ]:
# 使用 epoch 数生成单张图片
def display_image(epoch_no):
return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))
# In[ ]:
display_image(EPOCHS)
# In[ ]:
anim_file = 'dcgan.gif'
with imageio.get_writer(anim_file mode='I') as writer:
filenames = glob.glob('image*.png')
filenames = sorted(filenames)
last = -1
for i filename in enumerate(filenames):
frame = 2*(i**0.5)
if round(frame) > round(last):
last = frame
else:
continue
image = imageio.imread(filename)
writer.append_data(image)
image = imageio.imread(filename)
writer.append_data(image)
import IPython
if IPython.version_info > (6 2 0 ''):
display.Image(filename=anim_file)
# In[ ]:
try:
from google.colab import files
except ImportError:
pass
else:
files.download(anim_file)
# In[ ]:
# In[ ]:
本文的介绍已完。如需要更多深度学习的东西 ，可以在评论区，留言给我。多谢大家花时间观看！
