def run_aft(possible_widths, pool_size, max_layers, cand_epochs, final_epochs,
iteration=''):
data = Datasets.mnist()
comp = 0.0
model = AutoForwardThinking(possible_widths, pool_size, max_layers, data)
stats = model.train(final_epochs=final_epochs, cand_epochs=cand_epochs,
batch_size=128, stopping_comp=comp)
for key in stats.keys():
print(key, len(stats[key]))
# save training stats
df = pd.DataFrame(stats)
comments = list(df['comments'])[0]
df['min_width'] = min(possible_widths)
df['max_width'] = max(possible_widths)
df['pool_size'] = pool_size
df['max_layers'] = max_layers
df['cand_epochs'] = cand_epochs
df['final_epochs'] = final_epochs
df['compensation'] = comp
layers = comments.split(']')[0].replace('[', '')
df['n_layers'] = layers.count(',') + 1
df['layers'] = layers
comments = comments.split(']')[1].strip(',').strip()
df['hid_act'] = comments.split(',')[0].strip()
df['out_act'] = comments.split(',')[1].strip()
df['optimizer'] = comments.split(',')[-1].replace('prop', '').strip()
df = df.drop(columns='comments')
fname = 'aft_min{}_max{}_p{}_maxl{}_canep{}_finep{}_comp{}_{}.csv'.format(
min(possible_widths), max(possible_widths), pool_size,
max_layers, cand_epochs, final_epochs,
str(comp).replace('.', '-'),
iteration
)
while os.path.exists(fname):
fname = fname.replace('.csv', '_.csv')
df.to_csv(fname)
K.clear_session()
def __init__(self,
layers,
data,
optimizer,
hid_act='tanh',
out_act='softmax',
dropout=None,
wdecay=None,
loss='categorical_crossentropy',
metrics=['accuracy']):
"""Builds a feedforward neural network. Uses stochastic gradient
descent for optimization.
Parameters:
layers list, number of hidden units in each layer
data data tuple: (x_train, y_train), (x_test, y_test)
Optional:
hid_act hidden activation function
out_act output activation function
dropout dropout value
loss what loss function to use
metrics what metrics to use for evaluation
"""
# check input
assert len(layers) > 0
# preprocess optimizer
if isinstance(optimizer, str):
if optimizer == 'sgd':
optimizer = SGD(lr=0.01,
decay=1e-6,
momentum=0.9,
nesterov=True)
elif optimizer == 'rms':
optimizer = RMSprop()
else:
raise ValueError('Invalid optimizer')
# preprocess data
if isinstance(data, str):
if data == 'mnist':
data = Datasets.mnist()
# save parameters
self.hid_act = hid_act
self.out_act = out_act
self.loss = loss
self._layers = layers.copy()
# load the data
(self.x_train, self.y_train), (self.x_test, self.y_test) = data
input_dim = self.x_train.shape[1]
output_dim = self.y_train.shape[1]
# preprocess the layers
if dropout:
layers = [int(e / dropout) for e in layers]
# create the model
self.model = Sequential()
# add first hidden layer
layer = Dense(layers[0], activation=hid_act, input_dim=input_dim)
if wdecay:
layer.kernel_regularizer = keras.regularizers.l2(wdecay)
self.model.add(layer)
if dropout:
dropout_layer = Dropout(dropout)
self.model.add(dropout_layer)
# add subsequent layers
for i in range(1, len(layers)):
layer = Dense(layers[i], activation=hid_act)
self.model.add(layer)
if dropout:
dropout_layer = Dropout(dropout)
self.model.add(dropout_layer)
# add output layer
output_layer = Dense(output_dim, activation=out_act)
self.model.add(output_layer)
# setup optimizer
self.optimizer = optimizer
# compile model
self.model.compile(loss=loss,
optimizer=self.optimizer,
metrics=metrics)
