-
Notifications
You must be signed in to change notification settings - Fork 2
/
model.py
100 lines (70 loc) · 4.14 KB
/
model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
from keras.models import Model
from keras.layers import Bidirectional, Input, Concatenate, Cropping3D, Dense, Flatten, TimeDistributed, ConvLSTM2D, LeakyReLU
from keras.layers.core import Dropout, Activation, Reshape
from keras.layers.convolutional import Conv2D, MaxPooling2D, UpSampling2D, Cropping2D, SeparableConv2D
from keras.layers.normalization import BatchNormalization
from keras.layers.merge import concatenate
import keras.backend as K
def conv_layer(layer, depth, size):
conv = TimeDistributed(Conv2D(depth, size, padding='same'))(layer)
conv = LeakyReLU(0.2)(conv)
return TimeDistributed(BatchNormalization())(conv)
def lstm_layer(layer, depth, size):
conv = Bidirectional(ConvLSTM2D(depth, size, padding='same', return_sequences=True), merge_mode='sum')(layer)
return TimeDistributed(BatchNormalization())(conv)
def Generator(input_shape, output, kernel_depth, pixels, kernel_size=5):
input = Input(shape=input_shape)
conv_seperable = TimeDistributed(SeparableConv2D(2 * kernel_depth, kernel_size, padding='same'))(input)
conv_seperable = Activation('tanh')(conv_seperable)
conv_seperable = TimeDistributed(BatchNormalization())(conv_seperable)
conv_128 = conv_layer(conv_seperable, 2 * kernel_depth, kernel_size)
pool_64 = TimeDistributed(MaxPooling2D())(conv_128)
conv_64 = conv_layer(pool_64, 2 * kernel_depth, kernel_size)
pool_32 = TimeDistributed(MaxPooling2D())(conv_64)
conv_32 = conv_layer(pool_32, 4 * kernel_depth, kernel_size)
pool_16 = TimeDistributed(MaxPooling2D())(conv_32)
conv_16 = conv_layer(pool_16, 8 * kernel_depth, kernel_size)
pool_8 = TimeDistributed(MaxPooling2D())(conv_16)
conv_8 = lstm_layer(pool_8, 8 * kernel_depth, kernel_size)
up_16 = concatenate([TimeDistributed(UpSampling2D())(conv_8), conv_16])
up_conv_16 = conv_layer(up_16, 8 * kernel_depth, kernel_size)
up_32 = concatenate([TimeDistributed(UpSampling2D())(up_conv_16), conv_32])
up_conv_32 = conv_layer(up_32, 4 * kernel_depth, kernel_size)
up_64 = concatenate([TimeDistributed(UpSampling2D())(up_conv_32), conv_64])
up_conv_64 = conv_layer(up_64, 2 * kernel_depth, kernel_size)
up_128 = concatenate([TimeDistributed(UpSampling2D())(up_conv_64), conv_128])
up_conv_128 = conv_layer(up_128, kernel_depth, kernel_size)
final = TimeDistributed(Conv2D(output, 1))(up_conv_128)
final = Reshape((pixels, output))(final)
final = Activation('softmax')(final)
model = Model(input, final, name="Generator")
return model
def Discriminator(input_shape, generator_shape, kernel_depth, kernel_size=5):
real_input = Input(shape=input_shape)
generator_input = Input(shape=generator_shape)
input = Concatenate()([real_input, generator_input])
conv_seperable = TimeDistributed(SeparableConv2D(kernel_depth, kernel_size, padding='same'))(input)
conv_seperable = Activation('tanh')(conv_seperable)
conv_seperable = TimeDistributed(BatchNormalization())(conv_seperable)
conv_128 = conv_layer(conv_seperable, kernel_depth, kernel_size)
pool_64 = TimeDistributed(MaxPooling2D())(conv_128)
conv_64 = conv_layer(pool_64, 2 * kernel_depth, kernel_size)
pool_32 = TimeDistributed(MaxPooling2D())(conv_64)
conv_32 = conv_layer(pool_32, 2 * kernel_depth, kernel_size)
pool_16 = TimeDistributed(MaxPooling2D())(conv_32)
conv_16 = conv_layer(pool_16, 4 * kernel_depth, kernel_size)
pool_8 = TimeDistributed(MaxPooling2D())(conv_16)
conv_8 = lstm_layer(pool_8, 4 * kernel_depth, kernel_size)
x = Flatten()(conv_8)
x = Dense(2, activation="softmax")(x)
model = Model([real_input, generator_input], x, name="Discriminator")
return model
def Combine(gen, disc, input_shape, new_sequence):
input = Input(shape=input_shape)
generated_image = gen(input)
reshaped = Reshape(new_sequence)(generated_image)
DCGAN_output = disc([input, reshaped])
DCGAN = Model(inputs=[input],
outputs=[generated_image, DCGAN_output],
name="Combined")
return DCGAN