使用神经网络生成抽象随机艺术

http://blog.itpub.net/29829936/viewspace-2636099/

随着深度神经网络作为分类或回归模型变得非常流行，这些模型也可以用作生成模型来创建人工数据，例如创建新图像甚至文本数据。

下面是使用抽象艺术生成算法完成的生成的图像：

生成的RGB图像（512x512）

这个实现是在python NumPy中实现的，并解释了图像生成的工作方式。

随机训练神经网络时，初始化权重矩阵“Wi，i=1，....，nl+1”，其中nl为神经网络的隐藏层数。

在这个实现中，权重将通过绘制标准正态分布 N（μ=0，σ2=1）来初始化，如下面的代码所示：

import seaborn as sns
import warnings
warnings.filterwarnings("ignore")
import argparse
import sys
import os
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import time
### Draw a large vector of random numbers by standard normal distribution
random_numbers = np.random.normal(loc=0.0, scale=1.0, size=2000)
### Now suppose we wanted to approximate the density function of those random numbers, we suppose
### the kernel density estimate to look like the standard normal distribution
sns.set_style("whitegrid")
sns.kdeplot(random_numbers, bw=0.5)

<matplotlib.axes._subplots.AxesSubplot at 0x9a66550>

随机艺术算法是如何工作的

神经网络主要用作分类或回归模型。

假设我们有一些输入数据Xi，想要预测结果Yi，其中Xi是维度p的向量，Yi是维度k的向量。

在这种情况下，我们有一个预测可能的类k的分类问题。

对于生成的艺术，取决于我们想要选择的颜色模式（RGB、灰度、CMYK和HSL（HSV）），在输出层中我们有3个、1个、4个或3个输出神经元。

由于（对于float数据类型）这些“ colour-values ”（颜色值）的范围是[0，1]，因此每个输出神经元的“ weighted_input ”（加权输入）将被转换为一个sigmoid激活函数，如下所示：

x = np.arange(-10, 10, 0.1)
sigmoid = 1 / (1 + np.exp(-x))
plt.plot(x, sigmoid)
plt.xlabel("weighted_input")
plt.ylabel("color-value")
plt.show()

对于隐藏层激活，可以选择不同的激活函数，但是由于我们通过sigmoid映射weighted_input并希望colour-values大约在0.25-0.75范围之间创建。因此对于每个隐藏层，tanh激活将如下所示。注意，这个实现在默认情况下选择默认激活函数。在后面我写了一个NeuralNet类，它可以通过输入参数列表layers_dims和activations_fnc来选择不同的隐藏层神经元和层激活（但对于输出层，请确保激活函数映射到范围[0，1]）。

x = np.arange(-10, 10, 0.1)
tanh = np.tanh(x)
plt.plot(x, tanh)
plt.xlabel("x")
plt.ylabel("tanh(x)")
plt.show()

该算法还组合了alpha通道，alpha通道是一个8位的灰度通道，该通道记录图像中的透明度信息，定义为透明、不透明和半透明。当一种颜色(源图)与另一种颜色(背景图)混合时，例如，当一幅图像被叠加到另一幅图像上时，源图颜色的alpha值用于确定最终的颜色。如果alpha值不透明，源图颜色将覆盖目标颜色；如果是透明的，源图颜色是不可见的，显示背景图颜色。如果alpha值介于两者之间，则生成的颜色具有不同程度的前后背景混合颜色，从而创建半透明效果。

输出层中的颜色值将通过计算输入数据的前向传递来生成。因此，很容易实现一个NeuralNet类及其所需的方法，在这种情况下：

class NeuralNet:def __init__(self, layers_dims, activations_fnc, type_="classif"):self.type_ = type_self.W = [None] * (len(layers_dims)-1)self.b = [None] * (len(layers_dims)-1)self.out = [None] * (len(layers_dims)-1)self.layers_dims = layers_dimsself.activations_fnc = activations_fncfor i in range(len(layers_dims)-1):self.b[i] = np.random.randn(layers_dims[i+1]).reshape(1, layers_dims[i+1])self.W[i] = np.random.randn(layers_dims[i], layers_dims[i+1])def sigmoid(self, x):return 1.0 / (1.0 + np.exp(-x))def tanh(self, x):return np.tanh(x)def relu(self, x):return np.maximum(x, 0)def identity(self, x):return xdef softsign(self,x):return x / (1 + np.abs(x))def sin(self, x):return np.sin(x)def cos(self, x):return np.cos(x)def softmax(self, x):exp_scores = np.exp(x)out = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)return outdef activation(self, x, t):t = t.lower()if t == "sigmoid":return self.sigmoid(x)elif t == "tanh":return self.tanh(x)elif t == "relu":return self.relu(x)elif t == "identity":return self.identity(x)elif t == "softsign":return self.softsign(x)elif t == "sin":return self.sin(x)elif t == "cos":return self.cos(x)elif t == "softmax":return self.softmax(x)else:raise Exception("Non-supported activation function {}".format(t))def multiply(self, x, W):m = np.dot(x, W)return mdef add(self, m, b):return m + bdef forward(self, x):input_ = xfor i, activation in enumerate(self.activations_fnc) :weighted_sum = self.multiply(x=input_, W=self.W[i])weighted_sum = self.add(m=weighted_sum, b=self.b[i])input_ = self.out[i] = self.activation(x=weighted_sum, t=activation)

注意，权重初始化是用np.random.randn()函数和定义类方法forward()完成的计算从上一层到下一层的正向传播。仅实现这些类方法就足够了。这个类不包括反向传播和训练神经网络分类/回归模型所需的任何东西，因为这里的目的在于理解艺术生成过程。

为随机艺术生成输入参数

由于用户必须定义生成的图像的大小，因此image_height和image_width是必需的。

此外，必须定义使用哪种颜色模式以及是否应该使用alpha通道。

对于输出图像，将使用numpy.ndarray来表示图像。图像的形状将是（ img_height, img_width, 4 ）。如果您熟悉图像处理或卷积神经网络，通常会看到形状（ img_height, img_width, 3 ）。如果我们有一个灰度图像，图像实际上是一个2D-tensor。对于灰度图像，我们只需将初始灰度的每个值复制到RGB图像第三轴的每个维数中，即可得到RGB形状，例如通过np.resize：

到目前为止还没有问题。但是我们生成的图像在三维中有4个通道。这来自于alpha通道的建模。默认情况下，我们只创建这个定义的图像形状，但如果我们不想包含图像中每个像素的alpha-channel-random-modelling，输出的alpha值将是1（意思是完全不透明度）。RGBA变成了RGB。

对于“CMYK”、“HSV”、“HSL”（输出范围均为[0，1]）的颜色模式，这些值将转换为RGB格式，因为对于图像显示和保存，我们假设是RGB图像，python实现如下。

def init_image(rows, cols):img = np.zeros(shape=(rows, cols, 4))return img

def hsv_to_rgb(h, s, v):## hsw are between 0 and 1## returns rgb between 0 and 1## from: https://bgrins.github.io/TinyColor/docs/tinycolor.htmlh *= 6i = np.floor(h)f = h-i p = v*(1-s)q = v*(1-f*s)t = v*(1-(1-f)*s)mod = int(i % 6)r = [v, q, p, p, t, v][mod]g = [t, v, v, q, p, p][mod]b = [p, p, t, v, v, q][mod]return r,g,b
def hsl_to_rgb(h, s, l):## hsl are between 0 and 1## returns rgb between 0 and 1def hue_to_rgb(p, q, t):if t < 0:t += 1if t > 1:t -= 1if t < 1/6:return p+(q-p)*6*tif t < 1/2:return qif t < 2/3:return p+(q-p)*(2/3-t)*6if s==0:r = g = b = l #achromaticelse:if l < 0.5:q = l*(1+s)else:q = l+s-l*sp = 2*l-qr = hue_to_rgb(p, q, h + 1/3)g = hue_to_rgb(p, q, h)b = hue_to_rgb(p, q, h - 1/3)return r,g,b

神经网络架构

网络参数和输入

对于神经网络，我们需要定义输入维度、层数和激活函数。

作为输入，我们有一个5维向量。假设我们有一个大小为(256,256)的图像，把它看作一个二维矩阵。该算法对每个像素p_{i，j}计算r,g,b,a的值。

因此，在为生成的图像中的每个像素生成r、g、b、a值作为输入时（计算2-nested循环）我们取：

其中“factor=min（imgheight，imgwidth）”从而得到“inputi，j=（x，y，r，z1，z2）”。

将嵌套for循环中的x，y，r的值进行映射，从而创建结果图像中输入数据的相互依赖和相关性：

注意，通过嵌套循环，x和y将是相互依赖的，如果生成的图像是正方形（ img_height=img_width ），则输入数据组件x和y始终小于1。

现在为生成艺术做layers和activation_fnc列表做准备工作。

注意，这也可以写成硬编码，而不是通过prep_nnet_arch函数定义：

def prep_nnet_arch(n_depth, n_size, activation, colormode, alpha):layers = [5] #x, y, r, z1, z2for i in range(n_depth):layers.append(n_size)colormode = colormode.lower()### Output layer. Append number of output neurons depending on which colormode is selectedif colormode in ["rgb", "hsv", "hsl"] : #RGBif not alpha:layers.append(3)else:layers.append(4)elif colormode == "cmyk":if not alpha:layers.append(4)else:layers.append(5) elif colormode == "bw":if not alpha: layers.append(1)else:layers.append(2)else:print("Inserted colormode '{}' is not part ob supported ones: [rgb, bw, cmyk, hsv, hsl]".format(colormode))raise Exception("Non-supported colormode {}".format(colormode))possibles = ["sigmoid", "tanh", "relu", "identity", "softsign", "sin", "cos", "softmax"]if not activation.lower() in possibles:print('defined activation {} not supported in {}'.format(activation, str(possibles)))return Noneactivations_fnc = [activation] * (len(layers)-2)activations_fnc.append("sigmoid")return layers, activations_fnc

如果执行以下代码：

n_depth = 4
n_size = 10
activation = "tanh"
colormode = "rgb"
alpha = True
layers, activations_fnc = prep_nnet_arch(n_depth, n_size, activation, colormode, alpha)
print("layers: {}".format(str(layers)))
print("activations: {}".format(str(activations_fnc)))

将生成以下神经网络：

用R，G，B，A的值填充图像

def get_color_at(nnet, x, y, r, z1, z2, colormode, alpha):input_ = np.array([x, y, r, z1, z2], dtype=np.float32).reshape(1, 5)nnet.forward(input_)colormode = colormode.lower()if colormode == "rgb": ## Output via sigmoid activation mapped into range [0,1]r = nnet.out[len(nnet.out)-1][0][0]g = nnet.out[len(nnet.out)-1][0][1]b = nnet.out[len(nnet.out)-1][0][2]a_index = 3elif colormode == "bw":r=g=b = nnet.out[len(nnet.out)-1][0][0]a_index = 1elif colormode == "cmyk":c = nnet.out[len(nnet.out)-1][0][0]m = nnet.out[len(nnet.out)-1][0][1]y = nnet.out[len(nnet.out)-1][0][2]k = nnet.out[len(nnet.out)-1][0][3]r = (1-c)*kg = (1-m)*kb = (1-y)*ka_index = 4elif colormode == "hsv":h = nnet.out[len(nnet.out)-1][0][0]s = nnet.out[len(nnet.out)-1][0][1]v = nnet.out[len(nnet.out)-1][0][2] r, g, b = hsv_to_rgb(h, s, v)a_index = 3elif colormode == "hsl":h = nnet.out[len(nnet.out)-1][0][0]s = nnet.out[len(nnet.out)-1][0][1]l = nnet.out[len(nnet.out)-1][0][2] r, g, b = hsl_to_rgb(h, s, l)a_index = 3else:print("Inserted colormode '{}' is not part ob supported ones: [rgb, bw, cmyk, hsv, hsl]".format(colormode))raise Exception("Non-supported colormode {}".format(colormode))if alpha: # Since non blackmode [rgb, cmyk, hsv, hsl] values are mapped onto [0,1] the alpha channel is also between [0,1].#0=transparency, 1=opaque wrt. to overlayinga = 1-abs(2*nnet.out[len(nnet.out)-1][0][a_index]-1)a = 0.25 + 0.75*aelse:a = 1.0return r, g, b, a

生成图像函数

函数的要点：

1、初始化输出图像

2、初始化网络参数（层和激活）

3、从图像中遍历行和列以填充r、g、b、a的值

def generate_image(img_height, img_width, n_depth, n_size, activation, colormode, alpha, z1, z2,fname="netart.png", nnet_dict=None, save=False, show=False):factor = min(img_height, img_width)if nnet_dict is None:layers, activations_fnc = prep_nnet_arch(n_depth, n_size, activation, colormode, alpha)else:try:layers = nnet_dict["layers"]activations_fnc = nnet_dict["activations_fnc"]assert len(activations_fnc) == len(layers)-1assert layers[0] == 5assert activations_fnc[-1].lower() in ["sigmoid", "softmax"] except Exception as e:print(e)nnet = NeuralNet(layers, activations_fnc) img = init_image(img_height, img_width)for i in range(img_height):for j in range(img_width):x = i/factor - 0.5y = j/factor - 0.5r_ = np.sqrt(x*x + y*y)#Get RGBA valuesr, g, b, a = get_color_at(nnet, x=x, y=y, r=r_,z1=z1, z2=z2, colormode=colormode, alpha=alpha)#Populate the imageimg[i, j, 0] = rimg[i, j, 1] = gimg[i, j, 2] = bimg[i, j, 3] = aif not show:matplotlib.use("Agg")plt.figure() fig = plt.imshow(img, interpolation="bilinear", aspect="auto")plt.axis("off")fig.axes.get_xaxis().set_visible(False)fig.axes.get_yaxis().set_visible(False)if show:plt.show()if save:plt.imsave("{}".format(fname), img, format="png")return img

使用随机设置运行算法：

## This is fix
img_height = img_width = 256
activation = "tanh"def randomize_configs():n_size = int(np.random.randint(low=12, high=20, size=1))n_depth = int(24 - n_size)colormode = np.random.choice(a=["rgb", "bw", "cmyk", "hsl", "hsv"], size=1)[0]alpha = bool(np.random.choice(a=[True, False], size=1))z1 = float(np.round(np.random.uniform(low=-1.0, high=1.0, size=1), decimals=5))z2 = float(np.round(np.random.uniform(low=-1.0, high=1.0, size=1), decimals=5))return n_size, n_depth, colormode, alpha, z1, z2
n_images = 10
if not os.path.exists("nb_output"):os.makedirs("nb_output")

使用随机配置运行算法10次，并将结果保存在nb_output子目录中：

for i in range(n_images):n_size, n_depth, colormode, alpha, z1, z2 = randomize_configs()print("Settings:")print("n_size: {}".format(n_size))print("n_depth: {}".format(n_depth))print("colormode: {}".format(colormode))print("alpha: {}".format(alpha))print("z1: {}".format(z1))print("z2: {}".format(z2))print("--------")fname = "nb_output/generated_{}_{}.png".format(colormode, i+1)print("Generated image: {}".format(i+1))start_time = time.time()generate_image(img_height, img_width, n_depth, n_size, activation, colormode, alpha, z1, z2,show=True, nnet_dict=None, fname=fname, save=True)delta = time.time() - start_timeprint("Generating image {} took {} seconds".format(i+1, delta))

设置:
n_size: 13
n_depth: 11
colormode: hsv
alpha: True
z1: -0.84136
z2: 0.97109
--------
生成图像: 1

生成图像1耗时4.51595664024353秒

设置:
n_size: 13
n_depth: 11
colormode: rgb
alpha: True
z1: -0.72624
z2: -0.19368
--------
生成图像: 2

生成图像2耗时4.032962322235107秒

设置:
n_size: 14
n_depth: 10
colormode: bw
alpha: False
z1: 0.14255
z2: -0.38622
--------
生成图像: 3

生成图像3耗时3.508967638015747秒

设置:
n_size: 12
n_depth: 12
colormode: rgb
alpha: True
z1: -0.39475
z2: -0.67197
--------
生成图像: 4

生成图像4耗时4.089961051940918秒

设置:
n_size: 12
n_depth: 12
colormode: hsl
alpha: True
z1: 0.95898
z2: -0.00935
--------
生成图像: 5

生成图像5耗时4.7219579219818115秒

设置:
n_size: 18
n_depth: 6
colormode: bw
alpha: False
z1: 0.30633
z2: 0.09442
--------
生成图像: 6

生成图像6耗时2.670975923538208秒

设置:
n_size: 19
n_depth: 5
colormode: bw
alpha: True
z1: 0.91837
z2: -0.34998
--------
生成图像: 7

生成图像7耗时2.580977201461792秒

设置:
n_size: 15
n_depth: 9
colormode: hsl
alpha: True
z1: -0.385
z2: 0.92596
--------
生成图像: 8

生成图像8耗时4.372961521148682秒

设置:
n_size: 18
n_depth: 6
colormode: bw
alpha: False
z1: 0.72774
z2: -0.89946
--------
生成图像: 9

生成图像9耗时2.6779751777648926秒

设置:
n_size: 15
n_depth: 9
colormode: cmyk
alpha: True
z1: 0.14114
z2: 0.49769
--------
生成图像: 10

生成图像10耗时3.770965099334717秒

生成具有定义的网络参数的图像

如上所述，可以通过层列表来定义隐藏层尺寸和隐藏层内的神经元。

确保层列表的第一个元素是5(因为有5个输入值)。因此层[0]= 5。

在CMYK颜色模式的情况下，输出神经元的大小应该是4。因此层[-1]= 4。

对于RGB、B&W、HSV、HSL等颜色模式，输出神经元均为3。因此层[-1]= 3。

如果alpha通道也被使用，输出层需要被1填充。因此层[-1] +=1。

img_height = img_width = 512
colormode = "cmyk"
alpha = False
activations_fnc = ["tanh", "softsign", "identity", "tanh", "sigmoid"]
layers = [5, 10, 8, 18, 13, 4]
if alpha:layers[-1] += 1
nnet_dict = {"layers":layers, "activations_fnc":activations_fnc}
z1 = -0.99
z2 = 0.85start_time = time.time()
generate_image(img_height=img_height, img_width=img_width,n_depth=None, n_size=None, activation=None,colormode=colormode, alpha=alpha, z1=z1, z2=z2,nnet_dict=nnet_dict,show=True, save=False)
delta = time.time() - start_time
print("Generating image took {} seconds".format(delta))

生成图像耗时9.125910997390747秒

img_height = img_width = 512
colormode = "hsv"
alpha = True
activations_fnc = ["tanh", "softsign", "relu", "tanh", "sigmoid"]
layers = [5, 10, 20, 18, 25, 3]
if alpha:layers[-1] += 1
nnet_dict = {"layers":layers, "activations_fnc":activations_fnc}
z1 = -0.45
z2 = 0.66start_time = time.time()
generate_image(img_height=img_height, img_width=img_width,n_depth=None, n_size=None, activation=None,colormode=colormode, alpha=alpha, z1=z1, z2=z2,nnet_dict=nnet_dict,show=True, save=False)
delta = time.time() - start_time
print("Generating image took {} seconds".format(delta))

生成图像耗时11.697889804840088秒

img_height = img_width = 512
colormode = "bw"
alpha = False
activations_fnc = ["tanh", "softsign", "softsign", "tanh", "sigmoid"]
layers = [5, 10, 30, 40, 50, 3]
if alpha:layers[-1] += 1
nnet_dict = {"layers":layers, "activations_fnc":activations_fnc}
z1 = 0.255
z2 = 0.900start_time = time.time()
generate_image(img_height=img_height, img_width=img_width,n_depth=None, n_size=None, activation=None,colormode=colormode, alpha=alpha, z1=z1, z2=z2,nnet_dict=nnet_dict,show=True, save=False)
delta = time.time() - start_time
print("Generating image took {} seconds".format(delta))

生成图像耗时9.826904296875秒

img_height = img_width = 512
colormode = "hsl"
alpha = False
activations_fnc = ["tanh", "sin", "cos", "tanh", "sigmoid"]
layers = [5, 20, 10, 30, 40, 3]
if alpha:layers[-1] += 1
nnet_dict = {"layers":layers, "activations_fnc":activations_fnc}
z1 = 0.255
z2 = 0.900start_time = time.time()
generate_image(img_height=img_height, img_width=img_width,n_depth=None, n_size=None, activation=None,colormode=colormode, alpha=alpha, z1=z1, z2=z2,nnet_dict=nnet_dict,show=True, save=False)
delta = time.time() - start_time
print("Generating image took {} seconds".format(delta))

生成图像耗时9.72290325164795秒

使用神经网络生成抽象随机艺术相关推荐

通过深层神经网络生成音乐
作者|Ramya Vidiyala 编译|VK 来源|Towards Data Science 深度学习改善了我们生活的许多方面,无论是明显的还是微妙的.深度学习在电影推荐系统.垃圾邮件检测和计算机视 ...
图像对抗生成网络 GAN学习01：从头搭建最简单的GAN网络，利用神经网络生成手写体数字数据（tensorflow）
图像对抗生成网络 GAN学习01:从头搭建最简单的GAN网络,利用神经网络生成手写体数字数据(tensorflow) 文章目录图像对抗生成网络 GAN学习01:从头搭建最简单的GAN网络,利用神经网 ...
天啊，你要的智商已下线——用我们的IQ测试题研究测量神经网络的抽象推理能力...
来源| Deep Mind 译者 | Linstancy 编辑 | 姗姗出品 | 人工智能头条(公众号ID:AI_Thinker) [导读]聚焦 ICML -- Deep Mind 今天在 I ...
Nat. Mach. Intell. | 利用条件循环神经网络生成特定性质分子
作者 | 陆丰庆今天给大家介绍瑞士知名药企阿斯利康和伯尔尼大学的 Esben Jannik Bjerrum团队在Nature Machine Intelligence上的一篇论文.该研究提出基于分子 ...
AI也能「抽象派」作画，圆形+方块组合，可微2D渲染下生成抽象人脸
来源:机器之心本文约2500字,建议阅读5分钟本文介绍了AI条件下,抽象派作画. 有人将一张方块图.圆形图的组合生成了抽象的人脸!还有人将帆布油画<阿尼埃尔的浴场>还原为直线. 绘画, ...
Paper：RNN之《Generating Sequences With Recurrent Neural Networks用循环神经网络生成序列》的翻译和解读
Paper:<Generating Sequences With Recurrent Neural Networks>的翻译和解读目录 Generating Sequences With ...
shields 徽标_神经网络生成超级英雄徽标
shields 徽标 Machine Learning is a superpower in the computer science world. We can use it to predict ...
python3.9 执行python3.6生成的随机森林模型model.pkl报错，警告版本不一致
python3.9 执行python3.6生成的随机森林模型model.pkl报错 UserWarning: Trying to unpickle estimator RandomForestClas ...
生成一个随机100内小数，转换为保留两位小数的字符串，不考虑四舍五入的问题。
生成一个随机100内小数,转换为保留两位小数的字符串,不考虑四舍五入的问题.`` public class Demo02 {public static void main(String[] args) ...

使用神经网络生成抽象随机艺术

使用神经网络生成抽象随机艺术相关推荐

最新文章

热门文章