def olliNetwork(self):
self.model = models.Sequential()
self.model.add(
layers.Conv2D(64, (5, 5),
activation='relu',
input_shape=(48, 48, 1)))
self.model.add(layers.Conv2D(64, (5, 5), activation='relu'))
self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
self.model.add(layers.Dropout(0.25))
self.model.add(layers.Conv2D(64, (5, 5), activation='relu'))
self.model.add(layers.Conv2D(64, (5, 5), activation='relu'))
self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
self.model.add(layers.Dropout(0.25))
self.model.add(layers.Conv2D(128, (4, 4), activation='relu'))
self.model.add(layers.MaxPooling2D(pool_size=(2, 2)))
self.model.add(layers.Dropout(0.25))
self.model.add(layers.Flatten())
self.model.add(layers.Dense(3072, activation='relu'))
self.model.add(layers.Dropout(0.5))
self.model.add(layers.Dense(128, activation='relu'))
self.model.add(layers.Dropout(0.5))
self.model.add(layers.Dense(3, activation='softmax'))
def classifier_model():
model = models.Sequential()
model.add(
layers.Conv2D(NUM_FILTERS_1, [3, 3],
strides=(2, 2),
padding='same',
activation='relu',
input_shape=(28, 28, 1),
kernel_initializer=initializers.glorot_normal(),
bias_initializer=initializers.Zeros()))
model.add(
layers.Conv2D(NUM_FILTERS_2, [3, 3],
strides=(2, 2),
padding='same',
activation='relu',
kernel_initializer=initializers.glorot_normal(),
bias_initializer=initializers.Zeros()))
model.add(layers.Flatten())
model.add(
layers.Dense(NUM_CLASSES,
kernel_initializer=initializers.glorot_normal(),
bias_initializer=initializers.Zeros()))
return model
def model_definition(self):
self.model = models.Sequential()
self.model.add(
layers.Conv2D(64, (5, 5),
activation='relu',
input_shape=self.input_shape))
self.model.add(layers.Conv2D(64, (5, 5), activation='relu'))
self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
self.model.add(layers.Dropout(0.25))
self.model.add(layers.Conv2D(64, (5, 5), activation='relu'))
self.model.add(layers.Conv2D(64, (5, 5), activation='relu'))
self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
self.model.add(layers.Dropout(0.25))
self.model.add(layers.Conv2D(128, (3, 3), activation='relu'))
self.model.add(layers.AveragePooling2D())
self.model.add(layers.Conv2D(128, (1, 1), activation='relu'))
self.model.add(layers.MaxPooling2D(pool_size=(2, 2)))
self.model.add(layers.Dropout(0.25))
self.model.add(layers.Flatten())
self.model.add(layers.Dense(3072, activation='relu'))
self.model.add(layers.Dropout(0.5))
self.model.add(layers.Dense(128, activation='relu'))
self.model.add(layers.Dropout(0.5))
self.model.add(layers.Dense(3, activation='softmax'))
adam = optimizers.Adamax()
self.model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['acc'])
def VGG6(inputs, n_class=10):
# Block 1
x = layers.Conv2D(32, (3, 3),
activation='relu',
padding='same',
name='block1_conv1')(inputs)
x = layers.Conv2D(32, (3, 3),
activation='relu',
padding='same',
name='block1_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = layers.Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block2_conv1')(x)
x = layers.Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block2_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
x = layers.Flatten(name='flatten')(x)
x = layers.Dense(512, activation='relu', name='fc1')(x)
features = layers.Dense(512, activation='relu', name='fc2')(x)
outputs = layers.Dense(n_class, activation='softmax',
name='predictions')(features)
return outputs
def create_model(dropout_rate):
model = models.Sequential()
conv_base = applications.VGG16(include_top=False,
input_shape=(150, 150, 3),
weights='imagenet')
conv_base.trainable = False
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dropout(dropout_rate))
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
return model
def create_model(dropout_rate):
model = models.Sequential()
model.add(
layers.Conv2D(32, (3, 3), activation='relu',
input_shape=(150, 150, 3)))
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(dropout_rate))
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
return model
def classifier_model(): #Building of the CNN
model = models.Sequential()
model.add(
layers.Conv2D(1, [2, 40],
input_shape=(1, 40, 173),
strides=(1, 1),
padding='valid',
activation='relu'))
#
#model.add(layers.MaxPool1D(pool_size=2, strides=2, padding='valid'))
#
model.add(
layers.Conv2D(1, [2, 20],
strides=(1, 1),
padding='valid',
activation='relu',
kernel_initializer=initializers.glorot_normal(),
bias_initializer=initializers.Zeros()))
#
# model.add(layers.MaxPool1D(pool_size=2, strides=2, padding='valid'))
#
#
model.add(
layers.Conv2D(1, [2, 10],
strides=(3, 3),
padding='valid',
activation='relu',
kernel_initializer=initializers.glorot_normal(),
bias_initializer=initializers.Zeros()))
#
# model.add(layers.MaxPool1D(pool_size=2, strides=2, padding='valid'))
#
model.add(layers.Flatten())
#
model.add(
layers.Dense(1,
kernel_initializer=initializers.glorot_normal(),
bias_initializer=initializers.Zeros()))
print(model.summary())
return model
def generate_model():
conv_base = tf.contrib.keras.applications.VGG16(include_top=False,
weights='imagenet',
input_shape=(IMG_WIDTH,
IMG_HEIGHT,
3))
conv_base.trainable = True
model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(
layers.Dense(HIDDEN_SIZE,
name='dense',
kernel_regularizer=regularizers.l2(L2_LAMBDA)))
model.add(layers.Dropout(rate=0.3, name='dropout'))
model.add(
layers.Dense(NUM_CLASSES, activation='softmax', name='dense_output'))
model = multi_gpu_model(model, gpus=NUM_GPUS)
print(model.summary())
return model
def classifier_model(): #Building of the CNN
model = models.Sequential()
model.add(
layers.Conv2D(1, [2, 10],
input_shape=(40, 44, 1),
strides=(1, 1),
padding='valid',
activation='relu',
data_format='channels_last'))
model.add(
layers.MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None))
model.add(
layers.Conv2D(1, [2, 6],
strides=(1, 1),
padding='valid',
activation='relu'))
model.add(
layers.MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None))
model.add(
layers.Conv2D(1, [2, 3],
strides=(1, 1),
padding='valid',
activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(1))
print(model.summary())
return model
def classifier_model(): # linear stack of
################################################################################
############################ YOUR CODE HERE ################################
# Define a Sequential model
model = models.Sequential()
# The first two layers are convolutional layers. For the first layer, we must specify the input shape.
model.add(
layers.Conv2D(
NUM_FILTERS_1,
3,
strides=(2, 2),
activation='relu',
padding='same',
input_shape=(28, 28, 1))) # we have to add 2d convolutional layer
# a conv layer is defined by the number of filters
# second dimension we have to choose a stride of 2 : amount of shift that we are using for shift
# papdding same = output is cropped , output should be 28*28
# specify the kind of activate : RELU
# first layer of input dimension
# we initialize the biases to 0
# we set kernel initializer
model.add(
layers.Conv2D(NUM_FILTERS_2,
3,
strides=(2, 2),
activation='relu',
padding='same'))
# also a convolutional layer
# 3x3 filters , 2x2 strides
# we don't specify the input shape
# The final layer is a dense, 1 dimensional layer. We must therefore first flatten the result of the
# previous layer
model.add(
layers.Flatten()
) # we want to reduce to 1 dimension to be able to have a dense layer of 1 dim
# convert 2-3 layer dimension into a vextor
model.add(layers.Dense(10))
return model
def _create_discriminator(self):
inputs = layers.Input(shape=(HEIGHT, WIDTH, CHANNELS))
x = layers.Conv2D(128, kernel_size=3)(inputs)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(128, kernel_size=4, strides=2)(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(128, kernel_size=4, strides=2)(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(128, kernel_size=4, strides=2)(x)
x = layers.LeakyReLU()(x)
x = layers.Flatten()(x)
x = layers.Dropout(self.args.dropout)(x)
outputs = layers.Dense(1, activation='sigmoid')(x)
discriminator = models.Model(inputs, outputs)
return discriminator
###############################
### 使用keras API开始定义模型 ###
###############################
model = models.Sequential()
# 向模型中添加层
model.add(
layers.Conv2D(
32,
kernel_size=(5, 5), # 添加卷积层，深度32，过滤器大小5*5
activation=tf.nn.relu, # 使用relu激活函数
input_shape=(img_rows, img_cols, 1))) # 输入的尺寸就是一张图片的尺寸(28,28,1)
model.add(layers.MaxPooling2D(pool_size=(2, 2))) # 添加池化层，过滤器大小是2*2
model.add(layers.Conv2D(64, (5, 5), activation=tf.nn.relu)) # 添加卷积层，简单写法
model.add(layers.MaxPooling2D(pool_size=(2, 2))) # 添加池化层
model.add(layers.Flatten()) # 将池化层的输出拉直，然后作为全连接层的输入
model.add(layers.Dense(500, activation=tf.nn.relu)) # 添加有500个结点的全连接层，激活函数用relu
model.add(layers.Dense(10,
activation=tf.nn.softmax)) # 输出最终结果，有10个，激活函数用softmax
# 定义损失函数、优化函数、评测方法
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.SGD(),
metrics=['accuracy'])
# 自动完成模型的训练过程
model.fit(
X_train,
Y_train, # 训练集
batch_size=128, # batchsize
epochs=10, # 训练轮数
for stage in range(1, nb_res_stages+1):
x = residual_layer(x,
nb_in_filters=sz_ly0_filters,
nb_bottleneck_filters=nb_res_filters,
filter_sz=sz_res_filters,
stage=stage,
reg=0.0)
# Complete last resnet layer
x = layers.BatchNormalization(axis=-1, name='bnF')(x)
x = layers.Activation('relu', name='reluF')(x)
# Final layer
x = layers.AveragePooling2D((16, 16), name='avg_pool')(x)
x = layers.Flatten(name='flat')(x)
x = layers.Dense(10, activation='softmax', name='fc1')(x)
model1 = models.Model(inputs=img_input, outputs=x)
model1.summary()
my_datagen = preprocessing.image.ImageDataGenerator()
# Augmentation for training
train_datagen = preprocessing.image.ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)
def create_network(**kwargs):
model_input = L.Input(shape=(17, 9, 9))
print model_input
convolution_path = L.Convolution2D(
input_shape=(),
filters=64,
kernel_size=3,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(model_input)
print convolution_path
convolution_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.Activation('relu')(convolution_path)
convolution_path = L.Convolution2D(
input_shape=(),
filters=128,
kernel_size=3,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.Activation('relu')(convolution_path)
print '------------- value -------------------'
# policy head
policy_path = L.Convolution2D(
input_shape=(),
filters=2,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print policy_path
policy_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(policy_path)
policy_path = L.Activation('relu')(policy_path)
print policy_path
policy_path = L.Flatten()(policy_path)
print policy_path
policy_path = L.Dense((9 * 9) + 1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(policy_path)
policy_output = L.Activation('softmax')(policy_path)
print 'policy_output', policy_output
print '------------- policy -------------------'
# value head
value_path = L.Convolution2D(
input_shape=(),
filters=1,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print value_path
value_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(value_path)
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Flatten()(value_path)
print value_path
value_path = L.Dense(256,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Dense(1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_output = L.Activation('tanh')(value_path)
print value_path
return M.Model(inputs=[model_input],
outputs=[policy_output, value_output])
def create_model(self, img_shape, num_class):
concat_axis = 3
inputs = layers.Input(shape=img_shape)
conv1 = layers.Conv2D(32, (3, 3),
activation='relu',
padding='same',
name='conv1_1')(inputs)
conv1 = layers.Conv2D(32, (3, 3), activation='relu',
padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu',
padding='same')(pool4)
# conv5 = layers.concatenate([conv5, conv5_2], axis=concat_axis)
conv5 = layers.Conv2D(512, (3, 3), activation='relu',
padding='same')(conv5)
flat = layers.Flatten()(conv5)
dense0 = layers.Dense(4096)(flat)
# dense1=layers.Dropout(0.5)(dense0)
dense = layers.Dense(4096)(dense0)
out1 = layers.Dense(4, )(dense)
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = self.get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch, cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(up6)
conv6 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = self.get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch, cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = self.get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch, cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = self.get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch, cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu',
padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu',
padding='same')(conv9)
ch, cw = self.get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0],
cw[1])))(conv9)
conv10 = layers.Conv2D(num_class, (1, 1))(conv9)
model = models.Model(inputs=inputs, outputs=[conv10, out1])
return model
# sys.exit()
# scarica ed utilizza i pesi da imagenet per vgg16, questa è la base convoluzionale
conv_base = tf.contrib.keras.applications.InceptionV3(
include_top=False,
weights='imagenet',
input_shape=(IMG_WIDTH, IMG_HEIGHT, 3) # 3 per i canali RGB
)
conv_base.summary()
# stampa info sulla base conv
# RETE
# Layer finali per la vgg
model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(
layers.Dense(512,
name='dense_1',
kernel_regularizer=regularizers.l2(L2_LAMBDA)))
model.add(layers.Activation(activation='relu', name='activation_1'))
model.add(layers.Dense(NUM_CLASSES, activation='softmax', name='dense_output'))
model.summary()
conv_base.trainable = False
model.summary()
def load_batch(file_list):
def create_network(**kwargs):
"""construct a convolutional neural network with Residual blocks.
Arguments are the same as with the default CNNPolicy network, except the default
number of layers is 20 plus a new n_skip parameter
Keword Arguments:
- input_dim: depth of features to be processed by first layer (default 17)
- board: width of the go board to be processed (default 19)
- filters_per_layer: number of filters used on every layer (default 256)
- layers: number of residual blocks (default 19)
- filter_width: width of filter
Must be odd.
"""
defaults = {
"input_dim": 17,
"board": 9,
"filters_per_layer": 64,
"layers": 9,
"filter_width": 3
}
# copy defaults, but override with anything in kwargs
params = defaults
params.update(kwargs)
# create the network using Keras' functional API,
model_input = L.Input(shape=(params["input_dim"], params["board"], params["board"]))
print model_input
# create first layer
convolution_path = L.Convolution2D(
input_shape=(),
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(model_input)
print convolution_path
convolution_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.Activation('relu')(convolution_path)
def add_resnet_unit(path, **params):
block_input = path
# add Conv2D
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
print path
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
print path
path = L.Activation('relu')(path)
print path
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
print path
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
print path
path = L.Add()([block_input, path])
print path
path = L.Activation('relu')(path)
print path
return path
# create all other layers
for _ in range(params['layers']):
convolution_path = add_resnet_unit(convolution_path, **params)
print '------------- policy -------------------'
# policy head
policy_path = L.Convolution2D(
input_shape=(),
filters=2,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print policy_path
policy_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(policy_path)
policy_path = L.Activation('relu')(policy_path)
print policy_path
policy_path = L.Flatten()(policy_path)
print policy_path
policy_path = L.Dense(
params["board"]*params["board"]+1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(policy_path)
policy_output = L.Activation('softmax')(policy_path)
print 'policy_output', policy_output
print '-------------value -------------------'
# value head
value_path = L.Convolution2D(
input_shape=(),
filters=1,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print value_path
value_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(value_path)
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Flatten()(value_path)
print value_path
value_path = L.Dense(
256,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Dense(
1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_output = L.Activation('tanh')(value_path)
print value_path
return M.Model(inputs=[model_input], outputs=[policy_output, value_output])
