Python Deep Learning 18-DeepTraum vom generativen Deep Learning

​Einführung in DeepDream

DeepDream ist eine künstlerische Bildmodifikationstechnologie, die hauptsächlich auf dem trainierten Faltungs-Neuronalen Netzwerk CNN zur Bilderzeugung basiert.

Beim Generieren von Bildern wird das neuronale Netzwerk eingefroren, dh die Gewichte des Netzwerks werden nicht mehr aktualisiert, sondern nur die Eingabebilder müssen aktualisiert werden. Zu den häufig verwendeten vorab trainierten Faltungsnetzwerken gehören Googles Inception, das VGG-Netzwerk und das ResNet-Netzwerk usw.

Grundlegende Schritte von DeePDream:

• Erhalten Sie das Eingabebild.
• Geben Sie das Bild in das Netzwerk ein und erhalten Sie den Ausgabewert des Neurons, das Sie visualisieren möchten.
• Berechnen Sie den Gradienten des Neuronenausgabewerts zu jedem Pixel des Bildes
• Verwenden Sie den Gradientenabstieg, um das Bild kontinuierlich zu aktualisieren.

Wiederholen Sie die Schritte 2, 3 und 4, bis die festgelegten Bedingungen erfüllt sind Holen Sie sich das Testbild

In [1]:

# ---------------
from tensorflow import keras
import matplotlib.pyplot as plt
%matplotlib inline

base_image_path = keras.utils.get_file(
"coast.jpg", 
origin="https://img-datasets.s3.amazonaws.com/coast.jpg")

plt.axis("off")
plt.imshow(keras.utils.load_img(base_image_path))
plt.show()

Das Obige ist ein Bild der Küste, die mit Keras geliefert wird. Hier sind die Änderungen an diesem Bild.

Bereiten Sie das vorab trainierte Modell InceptionV3 vor ]:

# 使用Inception V3实现
from keras.applications import inception_v3

# 使用预训练的ImageNet权重来加载模型
model = inception_v3.InceptionV3(weights="imagenet", # 构建不包含全连接层的Inceptino 
 include_top=False)
Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/inception_v3/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5
87916544/87910968 [==============================] - 74s 1us/step
87924736/87910968 [==============================] - 74s 1us/step

In [5]:

model.summary()

Out[5]:

# 层的名称 + 系数：该层对需要最大化的损失的贡献大小

layer_settings = {"mixed4":1.0, 
"mixed5":1.5,
"mixed6":2.0,
"mixed7":2.5}

outputs_dict = dict(
[
(layer.name, layer.output) # 层的名字 + 该层的输出
for layer in [model.get_layer(name) for name in layer_settings.keys()]
]
)

outputs_dict

Berechnungsverlust

In [6]:

{'mixed4': <KerasTensor: shape=(None, None, None, 768) dtype=float32 (created by layer 'mixed4')>,
 'mixed5': <KerasTensor: shape=(None, None, None, 768) dtype=float32 (created by layer 'mixed5')>,
 'mixed6': <KerasTensor: shape=(None, None, None, 768) dtype=float32 (created by layer 'mixed6')>,
 'mixed7': <KerasTensor: shape=(None, None, None, 768) dtype=float32 (created by layer 'mixed7')>}

Gradientenaufstiegsprozess

In [7]:

# 特征提取

feature_extractor = keras.Model(inputs=model.inputs, outputs=outputs_dict)
feature_extractor

Bild. Generation

n p. expand_dims-Verwendung (persönliche Ergänzung)

In [8]:

<keras.engine.functional.Functional at 0x15b5ff0d0>

Out[8]:

def compute_loss(image):
features = feature_extractor(image)# 特征提取
loss = tf.zeros(shape=())# 损失初始化

for name in features.keys():# 遍历层
coeff = layer_settings[name] # 某个层的系数
activation = features[name]# 某个层的激活函数
#为了避免出现边界伪影，损失中仅包含非边界的像素
loss += coeff * tf.reduce_mean(tf.square(activation[:, 2:-2, 2:-2, :])) # 将该层的L2范数添加到loss中；
return loss

In [9]:

import tensorflow as tf

@tf.function
def gradient_ascent_step(image, lr): # lr--->learning_rate学习率
with tf.GradientTape() as tape:
tape.watch(image)
loss = compute_loss(image)# 调用计算损失方法
grads = tape.gradient(loss, image)# 梯度更新
grads = tf.math.l2_normalize(grads)
image += lr * grads
return loss, image

def gradient_ascent_loop(image, iterations, lr, max_loss=None):
for i in range(iterations):
loss, image = gradient_ascent_step(image, lr)
if max_loss is not None and loss > max_loss:
break
print(f"第{i}步的损失值是{loss:.2f}")

return image

Out[9]:

import numpy as np

array = np.array([[1,2,3],
[4,5,6]]
)
array

In [10]:

array([[1, 2, 3],
 [4, 5, 6]])

Out[ 10] :

array.shape

In [11]:

(2, 3)

Out[11]:

array1 = np.expand_dims(array,axis=0)
array1

In [12]:

array([[[1, 2, 3],
[4, 5, 6]]])

Out[12]:

array1.shape

In [13]:

(1, 2, 3)

Out[13] :

array2 = np.expand_dims(array,axis=1)
array2

In [14]:

array([[[1, 2, 3]],

 [[4, 5, 6]]])

Out[14]:

array2.shape

In [15]:

(2, 1, 3)

Out[15]:

array3 = np.expand_dims(array,axis=-1)
array3

np.clip-Funktion (persönliche Ergänzung)

array([[[1],
[2],
[3]],

 [[4],
[5],
[6]]])

In [16 ]:

array3.shape

Out[16]:

(2, 3, 1)

In [17]:

np.clip(
array, 
min(array), 
max(array), 
out=None):

Out[17]:

array = np.array([1,2,3,4,5,6])

np.clip(array, 2, 5)# 输出长度和原数组相同

In [18]:

array([2, 2, 3, 4, 5, 5])

Out[18]:

array = np.arange(18).reshape((6,3))
array

Parametereinstellungen

In [19]:

array([[ 0,1,2],
 [ 3,4,5],
 [ 6,7,8],
 [ 9, 10, 11],
 [12, 13, 14],
 [15, 16, 17]])

Bildvorverarbeitung

In [20]:

np.clip(array, 5, 15)

generiertes Bild

In [21]:

array([[ 5,5,5],
 [ 5,5,5],
 [ 6,7,8],
 [ 9, 10, 11],
 [12, 13, 14],
 [15, 15, 15]])

In [22]:

step = 20.#梯度上升的步长
num_octave = 3# 运行梯度上升的尺度个数
octave_scale = 1.4# 两个尺度间的比例大小
iterations = 30# 在每个尺度上运行梯度上升的步数
max_loss = 15.# 损失值若大于15，则中断梯度上升过程

Das Ergebnis ist:

import numpy as np

def preprocess_image(image_path):# 预处理
img = keras.utils.load_img(image_path)# 导入图片
img = keras.utils.img_to_array(img)# 转成数组
img = np.expand_dims(img, axis=0)# 增加数组维度；见上面解释(x,y) ---->(1,x,y)
img = keras.applications.inception_v3.preprocess_input(img) 
return img


def deprocess_image(img):# 图片压缩处理
img = img.reshape((img.shape[1], img.shape[2], 3))
img /= 2.0
img += 0.5
img *= 255.
# np.clip：截断功能，保证数组中的取值在0-255之间
img = np.clip(img, 0, 255).astype("uint8")
return img

Gleichzeitig , ein neues Bild wird lokal generiert Bild, schauen Sie sich den Effekt an:

Schauen Sie sich noch einmal das Originalbild an: Im Vergleich dazu ist das neue Bild etwas verträumt!

Das obige ist der detaillierte Inhalt vonPython Deep Learning 18-DeepTraum vom generativen Deep Learning. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!