def convnet_simple_lion_keras(image_dims):
model = keras.models.Sequential()
model.add(core.Lambda(lambda x: (x / 255.0) - 0.5, input_shape=image_dims))
model.add(
convolutional.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(convolutional.MaxPooling2D(pool_size=(2, 2)))
model.add(
convolutional.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(convolutional.MaxPooling2D(pool_size=(2, 2)))
model.add(
convolutional.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(convolutional.MaxPooling2D(pool_size=(2, 2)))
model.add(core.Flatten())
model.add(core.Dense(512, activation='relu'))
model.add(core.Dropout(0.5))
model.add(core.Dense(1024, activation='relu'))
model.add(core.Dropout(0.5))
model.add(core.Dense(6, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
return model
def __init__(self, img_size, nb_classes):
batch_size = 128
img_rows, img_cols = img_size
nb_filters_1 = 32 # 64
nb_filters_2 = 64 # 128
nb_filters_3 = 128 # 256
nb_conv = 3
cnn = models.Sequential()
cnn.add(conv.Convolution2D(nb_filters_1, nb_conv, nb_conv, activation="relu", input_shape=(img_rows, img_cols, 1),
border_mode='same'))
cnn.add(conv.Convolution2D(nb_filters_1, nb_conv, nb_conv, activation="relu", border_mode='same'))
cnn.add(conv.MaxPooling2D(strides=(2, 2)))
cnn.add(conv.Convolution2D(nb_filters_2, nb_conv, nb_conv, activation="relu", border_mode='same'))
cnn.add(conv.Convolution2D(nb_filters_2, nb_conv, nb_conv, activation="relu", border_mode='same'))
cnn.add(conv.MaxPooling2D(strides=(2, 2)))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.MaxPooling2D(strides=(2,2)))
cnn.add(core.Flatten())
cnn.add(core.Dropout(0.2))
cnn.add(core.Dense(128, activation="relu")) # 4096
cnn.add(core.Dense(nb_classes, activation="softmax"))
cnn.summary()
cnn.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
self.cnn = cnn
def create_simple_model(num_classes, layer1_filters=32, layer2_filters=64):
epochs = 5
n_conv = 2
model = models.Sequential()
# First layer
model.add(conv.ZeroPadding2D(
(1, 1),
input_shape=(1, IMG_COLS, IMG_ROWS),
))
model.add(
conv.Convolution2D(layer1_filters, n_conv, n_conv, activation="relu"))
model.add(conv.MaxPooling2D(strides=(2, 2)))
# Second layer
model.add(conv.ZeroPadding2D((1, 1)))
model.add(
conv.Convolution2D(layer2_filters, n_conv, n_conv, activation="relu"))
model.add(conv.MaxPooling2D(strides=(2, 2)))
model.add(core.Flatten())
model.add(core.Dropout(0.2))
model.add(core.Dense(128, activation="relu"))
model.add(core.Dense(num_classes, activation="softmax"))
model.summary()
model.compile(loss="categorical_crossentropy",
optimizer="adadelta",
metrics=["accuracy"])
return model, epochs
def main(n_filters,
conv_size,
pool_size,
dropout,
patch_size,
n_astro=7,
out_path=None):
# Imports must be in the function, or whenever we import this module, Keras
# will dump to stdout.
import keras.layers.core as core
from keras.layers import Input, Dense, Concatenate
import keras.layers.convolutional as conv
import keras.layers.merge
from keras.models import Model
im_in = Input(shape=(1, patch_size, patch_size))
astro_in = Input(shape=(n_astro, ))
# 1 x 32 x 32
conv1 = conv.Convolution2D(filters=n_filters,
kernel_size=(conv_size, conv_size),
border_mode='valid',
activation='relu',
data_format='channels_first')(im_in)
# 32 x 28 x 28
pool1 = conv.MaxPooling2D(pool_size=(pool_size, pool_size),
data_format='channels_first')(conv1)
# 32 x 14 x 14
conv2 = conv.Convolution2D(filters=n_filters,
kernel_size=(conv_size, conv_size),
border_mode='valid',
activation='relu',
data_format='channels_first')(pool1)
# 32 x 10 x 10
pool2 = conv.MaxPooling2D(pool_size=(pool_size, pool_size),
data_format='channels_first')(conv2)
# 32 x 5 x 5
conv3 = conv.Convolution2D(filters=n_filters,
kernel_size=(conv_size, conv_size),
border_mode='valid',
activation='relu',
data_format='channels_first')(pool2)
# 32 x 1 x 1
dropout = core.Dropout(dropout)(conv3)
flatten = core.Flatten()(dropout)
conc = Concatenate()([astro_in, flatten])
lr = Dense(1, activation='sigmoid')(conc)
model = Model(inputs=[astro_in, im_in], outputs=[lr])
model.compile(loss='binary_crossentropy', optimizer='adadelta')
model_json = model.to_json()
if out_path is not None:
with open(out_path, 'w') as f:
f.write(model_json)
return model_json
def test_maxpooling_2d_dim_ordering():
stack_size = 3
input = np.random.random((1, stack_size, 10, 10))
layer = convolutional.MaxPooling2D((2, 2),
input_shape=input.shape[1:],
dim_ordering='th')
layer.input = K.variable(input)
out_th = K.eval(layer.get_output(False))
input = np.transpose(input, (0, 2, 3, 1))
layer = convolutional.MaxPooling2D((2, 2),
input_shape=input.shape[1:],
dim_ordering='tf')
layer.input = K.variable(input)
out_tf = K.eval(layer.get_output(False))
assert_allclose(out_tf, np.transpose(out_th, (0, 2, 3, 1)), atol=1e-05)
def Simple_Convo(train, nb_classes):
batch_size = 128
img_rows, img_cols = 56, 56
nb_filters_1 = 32 # 64
nb_filters_2 = 64 # 128
nb_filters_3 = 128 # 256
nb_conv = 3
# train = np.concatenate([train, train], axis=1)
trainX = train[:, 1:].reshape(train.shape[0], 28, 28, 1)
trainX = trainX.astype(float)
trainX /= 255.0
trainX = np.concatenate([trainX, np.roll(trainX, 14, axis=1)], axis=1)
trainX = np.concatenate([trainX, np.fliplr(np.roll(trainX, 7, axis=2))], axis=2)
print(trainX.shape)
cnn = models.Sequential()
cnn.add(conv.Convolution2D(nb_filters_1, nb_conv, nb_conv, activation="relu", input_shape=(img_rows, img_cols, 1),
border_mode='same'))
cnn.add(conv.Convolution2D(nb_filters_1, nb_conv, nb_conv, activation="relu", border_mode='same'))
cnn.add(conv.MaxPooling2D(strides=(2, 2)))
cnn.add(conv.Convolution2D(nb_filters_2, nb_conv, nb_conv, activation="relu", border_mode='same'))
cnn.add(conv.Convolution2D(nb_filters_2, nb_conv, nb_conv, activation="relu", border_mode='same'))
cnn.add(conv.MaxPooling2D(strides=(2, 2)))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu", border_mode='same'))
# cnn.add(conv.MaxPooling2D(strides=(2,2)))
cnn.add(core.Flatten())
cnn.add(core.Dropout(0.2))
cnn.add(core.Dense(128, activation="relu")) # 4096
cnn.add(core.Dense(nb_classes, activation="softmax"))
cnn.summary()
return cnn
def test_maxpooling_2d():
nb_samples = 9
stack_size = 7
input_nb_row = 11
input_nb_col = 12
pool_size = (3, 3)
input = np.ones((nb_samples, stack_size, input_nb_row, input_nb_col))
for strides in [(1, 1), (2, 2)]:
layer = convolutional.MaxPooling2D(strides=strides,
border_mode='valid',
pool_size=pool_size)
layer.input = K.variable(input)
for train in [True, False]:
K.eval(layer.get_output(train))
layer.get_config()
def test_maxpooling_2d(self):
nb_samples = 9
stack_size = 7
input_nb_row = 11
input_nb_col = 12
poolsize = (3, 3)
input = np.ones((nb_samples, stack_size, input_nb_row, input_nb_col))
for ignore_border in [True, False]:
for stride in [None, (2, 2)]:
layer = convolutional.MaxPooling2D(stride=stride, ignore_border=ignore_border, poolsize=poolsize)
layer.input = theano.shared(value=input)
for train in [True, False]:
layer.get_output(train).eval()
config = layer.get_config()
def cpg_layers(params):
layers = []
if params.drop_in:
layer = kcore.Dropout(params.drop_in)
layers.append(('xd', layer))
nb_layer = len(params.nb_filter)
w_reg = kr.WeightRegularizer(l1=params.l1, l2=params.l2)
for l in range(nb_layer):
layer = kconv.Convolution2D(nb_filter=params.nb_filter[l],
nb_row=1,
nb_col=params.filter_len[l],
activation=params.activation,
init='glorot_uniform',
W_regularizer=w_reg,
border_mode='same')
layers.append(('c%d' % (l + 1), layer))
layer = kconv.MaxPooling2D(pool_size=(1, params.pool_len[l]))
layers.append(('p%d' % (l + 1), layer))
layer = kcore.Flatten()
layers.append(('f1', layer))
if params.drop_out:
layer = kcore.Dropout(params.drop_out)
layers.append(('f1d', layer))
if params.nb_hidden:
layer = kcore.Dense(params.nb_hidden,
activation='linear',
init='glorot_uniform')
layers.append(('h1', layer))
if params.batch_norm:
layer = knorm.BatchNormalization()
layers.append(('h1b', layer))
layer = kcore.Activation(params.activation)
layers.append(('h1a', layer))
if params.drop_out:
layer = kcore.Dropout(params.drop_out)
layers.append(('h1d', layer))
return layers
def model_main(
nc: int,
nf_l: int,
nt_l: int,
nf_h: int,
nt_h: int,
*,
mw=False,
preload_weights: str = None,
opti="adam",
noise=False,
noise_amp=0.2,
) -> krm.Model:
if mw:
pre_shape: ty.Tuple[int, ...] = (3, )
else:
pre_shape = ()
i_x_l = klc.Input(shape=pre_shape + (nc, nf_l, nt_l), name="input.lo")
i_x_h = klc.Input(shape=pre_shape + (nc, nf_h, nt_h), name="input.hi")
conv_stack_h = [
kcv.Conv2D(8, (3, 3), name="conv_h.0.0", activation="elu"),
kcv.Conv2D(8, (3, 3), name="conv_h.0.1", activation="elu"),
kcv.MaxPooling2D((2, 2)),
kcv.Conv2D(8, (3, 3), name="conv_h.1.0", activation="elu"),
kcv.Conv2D(8, (3, 3), name="conv_h.1.1", activation="elu"),
kcv.MaxPooling2D((2, 2)),
klc.Flatten(name="conv_h.flatten"),
]
conv_stack_l = [
kcv.Conv2D(8, (3, 3), name="conv_l.0.0", activation="elu"),
kcv.Conv2D(8, (3, 3), name="conv_l.0.1", activation="elu"),
kcv.MaxPooling2D((2, 2)),
klc.Flatten(name="conv_l.flatten"),
]
if mw:
conv_stack_h = [
klc.Permute((1, 4, 2, 3)),
klc.Reshape((-1, nc, nf_h), input_shape=(3, nc, nf_h, nt_h)),
klc.Permute((2, 1, 3)),
] + conv_stack_h
conv_stack_l = [
klc.Permute((1, 4, 2, 3)),
klc.Reshape((-1, nc, nf_l), input_shape=(3, nc, nf_l, nt_l)),
klc.Permute((2, 1, 3)),
] + conv_stack_l
if noise:
conv_stack_h = [kno.GaussianNoise(noise_amp, name="inoise_h")
] + conv_stack_h
conv_stack_l = [kno.GaussianNoise(noise_amp, name="inoise_l")
] + conv_stack_l
conv_l = i_x_l
for layer in conv_stack_l:
conv_l = layer(conv_l)
conv_h = i_x_h
for layer in conv_stack_h:
conv_h = layer(conv_h)
dn_suff = ".mw" if mw else ""
merged_conv = concatenate([conv_l, conv_h])
dense_stack = [
klc.Dense(24, name="dense.0" + dn_suff, activation="elu"),
klc.Dropout(0.5),
klc.Dense(24, name="dense.1" + dn_suff, activation="elu"),
]
y = merged_conv
for layer in dense_stack:
y = layer(y)
y = klc.Dense(6, name="y" + dn_suff, activation="softmax")(y)
m = krm.Model(inputs=[i_x_l, i_x_h], outputs=y)
m.compile(optimizer=opti, loss="categorical_crossentropy")
if preload_weights and mw:
m.load_weights(preload_weights, by_name=True)
return m
trainX = trainX.astype(float)
trainX /= 255.0 # preprocess the data
trainY = kutils.to_categorical(train[:, 0])
nb_classes = trainY.shape[1]
cnn = models.Sequential()
cnn.add(conv.ZeroPadding2D(
(1, 1),
input_shape=(1, 48, 48),
))
cnn.add(conv.Convolution2D(32, 3, 3, activation="relu"))
cnn.add(conv.ZeroPadding2D((1, 1)))
cnn.add(conv.Convolution2D(32, 3, 3, activation="relu"))
cnn.add(conv.MaxPooling2D(strides=(2, 2)))
cnn.add(conv.ZeroPadding2D((1, 1)))
cnn.add(conv.Convolution2D(64, 3, 3, activation="relu"))
cnn.add(conv.ZeroPadding2D((1, 1)))
cnn.add(conv.Convolution2D(64, 3, 3, activation="relu"))
cnn.add(conv.MaxPooling2D(strides=(2, 2)))
# cnn.add(conv.ZeroPadding2D((1, 1)))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu"))
# cnn.add(conv.ZeroPadding2D((1, 1)))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu"))
# cnn.add(conv.ZeroPadding2D((1, 1)))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu"))
# cnn.add(conv.ZeroPadding2D((1, 1)))
# cnn.add(conv.Convolution2D(nb_filters_3, nb_conv, nb_conv, activation="relu"))
trainX = trainX.astype(float)
trainX /= 255.0
trainY = kutils.to_categorical(train[:, 0])
nb_classes = trainY.shape[1]
cnn = models.Sequential()
cnn.add(conv.ZeroPadding2D(
(1, 1),
input_shape=(1, img_rows, img_cols),
))
cnn.add(conv.Convolution2D(filters[0], kernel, kernel))
cnn.add(core.Activation('relu'))
cnn.add(conv.MaxPooling2D(strides=(pool, pool)))
cnn.add(conv.ZeroPadding2D((1, 1)))
cnn.add(conv.Convolution2D(filters[1], kernel, kernel))
cnn.add(core.Activation('relu'))
cnn.add(conv.MaxPooling2D(strides=(pool, pool)))
cnn.add(conv.ZeroPadding2D((1, 1)))
cnn.add(core.Flatten())
cnn.add(core.Dropout(0.5))
cnn.add(core.Dense(128))
cnn.add(core.Activation('relu'))
cnn.add(core.Dense(nb_classes))
cnn.add(core.Activation('softmax'))
def convnet_alexnet_lion_keras(image_dims):
# model = Sequential()
# model.add(Lambda(lambda x: (x / 255.0) - 0.5, input_shape=image_dims))
NR_CLASSES = 6
input = layers.Input(shape=image_dims, name="Input")
conv_1 = convolutional.Convolution2D(96,
11,
11,
border_mode='valid',
name="conv_1",
activation='relu',
init='glorot_uniform')(input)
pool_1 = convolutional.MaxPooling2D(pool_size=(3, 3),
name="pool_1")(conv_1)
zero_padding_1 = convolutional.ZeroPadding2D(padding=(1, 1),
name="zero_padding_1")(pool_1)
conv_2 = convolutional.Convolution2D(256,
3,
3,
border_mode='valid',
name="conv_2",
activation='relu',
init='glorot_uniform')(zero_padding_1)
pool_2 = convolutional.MaxPooling2D(pool_size=(3, 3),
name="pool_2")(conv_2)
zero_padding_2 = keras.layers.convolutional.ZeroPadding2D(
padding=(1, 1), name="zero_padding_2")(pool_2)
conv_3 = convolutional.Convolution2D(384,
3,
3,
border_mode='valid',
name="conv_3",
activation='relu',
init='glorot_uniform')(zero_padding_2)
conv_4 = convolutional.Convolution2D(384,
3,
3,
border_mode='valid',
name="conv_4",
activation='relu',
init='glorot_uniform')(conv_3)
conv_5 = convolutional.Convolution2D(256,
3,
3,
border_mode='valid',
name="conv_5",
activation='relu',
init='glorot_uniform')(conv_4)
pool_3 = convolutional.MaxPooling2D(pool_size=(3, 3),
name="pool_3")(conv_5)
flatten = core.Flatten(name="flatten")(pool_3)
fc_1 = core.Dense(4096,
name="fc_1",
activation='relu',
init='glorot_uniform')(flatten)
fc_1 = core.Dropout(0.5, name="fc_1_dropout")(fc_1)
output = core.Dense(4096,
name="Output",
activation='relu',
init='glorot_uniform')(fc_1)
output = core.Dropout(0.5, name="Output_dropout")(output)
fc_2 = core.Dense(NR_CLASSES,
name="fc_2",
activation='softmax',
init='glorot_uniform')(output)
return models.Model([input], [fc_2])
# convert to 2D images
x_train = np.reshape(ds.train.x, (ds.train.N, 1, 16, 16))
x_test = np.reshape(ds.test.x, (ds.test.N, 1, 16, 16))
model = kmodel.Sequential()
model.add(
kconv.Convolution2D(nb_filter=4,
nb_row=5,
nb_col=5,
input_shape=(1, 16, 16),
border_mode='valid'))
model.add(klcore.Activation('tanh'))
# instead of average pooling, we use max pooling
model.add(kconv.MaxPooling2D(pool_size=(2, 2)))
# the 12 feature maps in this layer are connected in a specific pattern to the below layer, but it is not possible
# do this in keras easily. in fact, I don't know how keras connects the feature maps in one layer to the next.
model.add(kconv.Convolution2D(nb_filter=12, nb_row=5, nb_col=5))
model.add(klcore.Activation('tanh'))
model.add(kconv.MaxPooling2D(pool_size=(2, 2)))
model.add(klcore.Flatten())
model.add(klcore.Dense(output_dim=10))
model.add(klcore.Activation('softmax'))
model.compile(optimizer='sgd', loss='categorical_crossentropy')
model.fit(x=x_train,
y=ds.train.y,
trainX = trainX.astype(float)
trainX /= 255.0
trainY = kutils.to_categorical(trainData[:, 0])
nb_classes = trainY.shape[1]
cnn = models.Sequential()
cnn.add(
conv.Convolution2D(nb_filters,
nb_conv,
nb_conv,
border_mode="valid",
input_shape=(1, 28, 28),
activation="relu"))
cnn.add(conv.Convolution2D(nb_filters, nb_conv, nb_conv, activation="relu"))
cnn.add(conv.MaxPooling2D())
cnn.add(core.Dropout(0.25))
cnn.add(core.Flatten())
cnn.add(core.Dense(128, activation="relu"))
cnn.add(core.Dropout(0.15))
cnn.add(core.Dense(64, activation="relu"))
cnn.add(core.Dropout(0.15))
cnn.add(core.Dense(nb_classes, activation="softmax"))
sgd = optm.sgd(lr=0.01, momentum=0.9, decay=1e-6, nesterov=True)
cnn.compile(
loss="mean_squared_error",
optimizer="adadelta",
)
cnn.fit(trainX,
pass
conv_model = MODELS.Sequential()
loc_model = MODELS.Sequential()
model = MODELS.Sequential()
if conv1:
conv_model.add(
CONV.Convolution2D(conv1_filters,
conv1_filter_size,
conv1_filter_size,
subsample=(conv1_stride, conv1_stride),
border_mode='valid',
input_shape=(prev_frames, image_size, image_size)))
if pool1:
conv_model.add(CONV.MaxPooling2D(pool_size=(pool1_size, pool1_size)))
conv_model.add(CORE.Activation(conv1_act))
conv_model.add(CORE.Flatten())
conv_model.add(CORE.Dense(fc1_size))
conv_model.add(CORE.Activation(fc1_act))
loc_model.add(CORE.Dense(fc1_size, input_shape=(prev_frames * 4, )))
loc_model.add(CORE.Activation(fc1_act))
#model.add(CONV.Convolution2D(conv2_filters, conv2_filter_size, conv2_filter_size, border_mode='valid'))
#model.add(CONV.MaxPooling2D(pool_size=(pool2_size, pool2_size)))
#model.add(CORE.Activation(conv2_act))
model.add(CORE.Merge([conv_model, loc_model], mode='concat'))
model.add(CORE.Dense(4, init='zero'))
model.add(CORE.Activation(fc2_act))
print 'Building bouncing MNIST generator'
