with open('params', 'r') as f_in:

params = json.load(f_in)

global micro_dim

global num_hidden

global inc_bias

global momentum

global weight_decay

global momentum

global max_iterations

global num_epochs

global snapshot

micro_dim = int(params['micro_dim'])

num_hidden = params['num_hidden']

shapes = [(micro_dim, num_hidden[0])]

for i in range(1, len(num_hidden)-1):

shapes.append((num_hidden[i], num_hidden[i+1]))

shapes.append((num_hidden[-1], 3))

inc_bias = bool(params['inc_bias'])

momentum = float(params['momentum'])

weight_decay = float(params['weight_decay'])

max_iterations = int(params['max_iterations'])

num_epochs = int(params['num_epochs'])

with open(filename, 'r') as f:

lines = f.read().splitlines(True)[1:]

for line in lines:

cells = line.split(',')

label = int(cells[1])

microarray = [float(i) for i in cells[3:]]

load_params()

#import dataset

ds = ClassificationDataSet(micro_dim, 1, nb_classes=num_classes)

extract_data(data_file, ds)

tr, val = ds.splitWithProportion(2/3.)

#softmax output layer

tr._convertToOneOfMany()

val._convertToOneOfMany()

#build network

layer_sizes = [tr.indim]

for layer_size in num_hidden:

layer_sizes.append(layer_size)

layer_sizes.append(tr.outdim)

if save_file == '':

ann = buildNetwork(layer_sizes, hiddenclass=SigmoidLayer, recurrent=False, outclass=SoftmaxLayer, bias=inc_bias)

iteration = 0

else:

ann = NetworkReader.readFrom(save_file)

match = re.search('([0-9]+)_(?:[0-9]{1,3}).xml', save_file)

if match == None:

print 'Net save files should be named I_E.xml, where I is the iteration and E is the rounded error from 0-100'

exit(1)

else:

iteration = int(match.group(1)) + 1

#training

trainer = BackpropTrainer(ann, dataset=tr, momentum=momentum, weightdecay=weight_decay)

done = False

errors, variations = [], []

testing_errors, testing_variations = [], []

while(not done):

trainer.trainEpochs(num_epochs)

# visualize iteration

if vis_matrix or vis_graph:

vertices, edges = vertsEdges(ann)

if vis_matrix:

matrixVisualizer(edges)

if vis_graph:

graphVisualizer(vertices, edges, iteration)

# calculate and print error info

training_error, testing_error, training_variation, testing_variation = trainer.testOnData(), trainer.testOnData(dataset=val), calcVariation(trainer), calcVariation(trainer, dataset=val)

errors.append(training_error)

variations.append(training_variation)

testing_errors.append(testing_error)

testing_variations.append(testing_variation)

fig, ax1 = plt.subplots()

iterations = range(iteration+1)

ax1.plot(iterations, map(log10, errors), 'r-')

ax1.plot(iterations, map(log10, testing_errors), 'b-')

ax1.set_xlabel('iteration')

ax1.set_ylabel('log mean squared error (red=train, blue=test)')

for tick in ax1.get_yticklabels():

tick.set_color('b')

ax2 = ax1.twinx()

ax2.plot(iterations, map(log10, variations), 'r--')

ax2.plot(iterations, map(log10, testing_variations), 'b--')

ax2.set_ylabel('log variation (L1 error) (red=train, blue=test)')

for tick in ax2.get_yticklabels():

tick.set_color('r')

plt.savefig('error-3layer-48.pdf')

plt.close()

print 'iter %d, training error %f, testing error %f, training variation %f, testing variation %f' % (iteration, training_error, testing_error, training_variation, testing_variation)

#save every <snapshot> iterations

if iteration % snapshot == -1:

file_data = (iteration, int(errors[-1]*100))

print 'Saving model %d_%d.xml...' % file_data

NetworkWriter.writeToFile(ann, '%d_%d.xml' % file_data)

# go to the next iteration if not done

iteration = iteration + 1

if iteration >= max_iterations:

done = True

#testing

val_errors, val_variations = [], []

for i in range(5):

val_error, val_variation = trainer.testOnData(dataset=val), calcVariation(trainer, dataset=val)

print 'error %f, variation %f' % (val_error, val_variation)

val_errors.append(val_error)

val_variations.append(val_variation)

tr, val = ds.splitWithProportion(0.9)

val._convertToOneOfMany()

print 'average error %f, average variation %f' % (np.average(val_errors), np.average(val_variations))

#plotting

iterations = range(max_iterations)

fig, ax1 = plt.subplots()

ax1.plot(iterations, map(log10, errors), 'b-')

ax1.set_xlabel('iteration')

ax1.set_ylabel('log mean squared error')

for tick in ax1.get_yticklabels():

tick.set_color('b')

ax1.set_title('error for validation dataset: %f, variation for validation dataset: %f' % (val_error, val_variation))

ax2 = ax1.twinx()

ax2.plot(iterations, map(log10, variations), 'r-')

ax2.set_ylabel('log variation (L1 error)')

for tick in ax2.get_yticklabels():

tick.set_color('r')

num_layers = len(num_hidden) + 2

nodes = []

for i in range(num_layers):

nodes.append([])

for c in ann.connections:

index = -1

if c._name == 'in':

index = 0

elif c._name[:-1] == 'hidden':

index = 1 + int(c._name[-1])

elif c._name == 'out':

index = num_layers - 1

if index >= 0:

nodes[index] = c.inputbuffer.tolist()

edges = []

for i in range(num_layers - 1):

edges.append([])

for mod in ann.modules:

for conn in ann.connections[mod]:

layer1, layer2 = mod.name, conn.outmod.name

if layer1 == 'in' and layer2[:-1] == 'hidden':

index = 0

elif layer1[:-1] == 'hidden' and layer2 == 'out':

index = num_layers - 2

elif layer1 != 'bias':

index = int(layer1[-1])

if layer1 != 'bias':

print index, shapes, shape(array(conn.params))

edges[index] = array(conn.params).reshape(shapes[index]).tolist()

f, axs = plt.subplots(1, len(edges), sharey=True)

for i in range(len(edges)):

axs[i].imshow(edges[i], interpolation='none', shape=shapes[i])

g = Graph(directed=False)

vpos = g.new_vertex_property("vector<float>")

vsize = g.new_vertex_property("float")

vcolor = g.new_vertex_property("vector<float>")

ecolor = g.new_edge_property("vector<float>")

ewidth = g.new_edge_property("float")

layers_vertices = []

for i in range(len(vertices)):

layer = vertices[i][0]

layer_vertices = []

offset = len(layer) / 2.0

for j in range(len(layer)):

vertex = g.add_vertex()

layer_vertices.append(vertex)

vpos[vertex] = [i * 10, j - offset]

vsize[vertex] = layer[j] * 3

vcolor[vertex] = [0, 105/255.0, 62/255.0, 1]

layers_vertices.append(layer_vertices)

for i in range(len(edges)):

matrix = edges[i]

for j in range(len(matrix)):

vector = matrix[j]

for k in range(len(vector)):

edge = g.add_edge(layers_vertices[i][j], layers_vertices[i+1][k])

shade = 1 - vector[k]

ecolor[edge] = [shade, shade, shade, 1]

ewidth[edge] = 2

if dataset == None:

dataset = trainer.ds

dataset.reset()

out = []

targ = []

for seq in dataset._provideSequences():

trainer.module.reset()

for input, target in seq:

res = trainer.module.activate(input)

out.append(argmax(res))

targ.append(argmax(target))

if dataset == None:

dataset = trainer.ds

dataset.reset()

errors = []

for seq in dataset._provideSequences():

trainer.module.reset()

for input, target in seq:

res = trainer.module.activate(input)

error_sum = 0.

for i in range(len(res)):

error_sum += abs(res[i] - target[i])

errors.append(error_sum)