from keras import layers,models

from keras import optimizers

from keras.preprocessing.image import ImageDataGenerator

import os,sys

def get_normal_network_CD(conv_layers,dense_layers,input_shape=(150,150,3)):

return model

def train_comparison_networks_CD(conv_layers,dense_layers,train_generator,validation_generator,nbr_epochs=80,network_name="CD_normal",path="",input_shape=(150,150,3)):

return "Success"

def create_growing_conv_network(input_shape = (28,28,1),conv_base_dim=32,number_of_outputs=1):

return network

def create_growing_dense_network(input_size=64,layer_size=64,output_size=10):

return network

def add_conv_layer(old_network,new_layer_output_size=32,number_of_outputs=1):

return new_network

def get_mnist_data_flattened(type=0):

return train_images,train_labels,test_images,test_labels

def dense_mnist_LBL(nbr_of_layers=50,epochs=5,results_path="",save_models=False,models_path=""):

return network

def dense_mnist_normal(nbr_of_layers=50,epochs=5,results_path="",save_models=False,models_path=""):

return network_traditional

def grow_network_mnist(old_network,new_layer_size=32,output_size=10):

return new_network

def get_partial_output(network,training_data,offset=2):

return output

# def grow_conv_network(conv_layers, dense_layers,train_generator,validation_generator,output_size = 1,nbr_epochs=20):

# """

# function for creating, training and growing a conv network.

# Input :

# training data, size of and number of convolutional and dense layers

# Output :

# A conv net trained using the growing technique on the train images

# """

# final_network = models.Sequential() # final grown network

# nbr_conv_layers = len(conv_layers)

# nbr_dense_layers = len(dense_layers)

# offset = 2

#

#

# ### Create and train conv network base

#

# for i in range(nbr_conv_layers):

#

# # Create and train "single" conv layer network

# # network_a and network_b temporary networks used during training

# if(i==0):

# network_a = create_growing_conv_network(input_shape=(150, 150, 3),conv_base_dim=conv_layers[0],number_of_outputs=output_size)

# # network_b = add_conv_layer(network_a,new_layer_output_size=conv_layers[1],number_of_outputs=output_size)

# # del(network_a)

# # network_a=network_b

# # for l in range(len(network_a.layers)):

# # network_a.layers[l].trainable=True

# # del(network_b)

# network_a.compile(loss='binary_crossentropy',

# optimizer=optimizers.RMSprop(lr=1e-4),

# metrics=['acc'])

# else:

# network_b = add_conv_layer(network_a,new_layer_output_size=conv_layers[i],number_of_outputs=output_size)

# del(network_a)

# network_a=network_b

# del(network_b)

# network_a.summary()

# history = network_a.fit_generator(

# train_generator,

# steps_per_epoch=100,

# epochs=nbr_epochs,

# validation_data=validation_generator,

# validation_steps=50)

#

# ### Add conv & pooling layers to final model

# # speed up if there is no reflow of data thorugh model

# print(network_a.layers[-4].name)

# final_network.add(network_a.layers[-4])

# conv_name = 'conv_layer_'+str(i)

# final_network.layers[-1].name=conv_name# names may not be the same

#

# final_network.add(network_a.layers[-3])

# pooling_name = 'pooling_layer_'+str(i)

# final_network.layers[-1].name=pooling_name

#

# # Transfer also flatten layer if we are at the last iteration

# if(i==nbr_conv_layers-1):

# final_network.add(network_a.layers[2])

# offset = 1# want to get the flatten output

# print("final_network:")

# final_network.summary()

# offset=1

#

# ### Add and train the dense top

# for i in range(nbr_dense_layers):

# print(output_size)

# network_a = create_growing_dense_network(

# input_size=input_shape,

# layer_size=dense_layers[i],

# output_size=output_size)

# network_a.summary()

# network_a.fit(prev_output, train_labels, epochs=nbr_epochs, batch_size=64)

# ### Add dense layer to final model

# final_network.add(network_a.layers[0])

# dense_name = 'dense_layer_'+str(i)

# final_network.layers[-1].name=dense_name# names may not be the same

# if(i==nbr_dense_layers-1):

# final_network.add(network_a.layers[1])

# prev_output = get_partial_output(network_a,prev_output,offset=offset)

# input_shape = prev_output.shape[1:] #shape may change

#

# final_network.summary()

# final_network.compile(loss='binary_crossentropy',

# optimizer=optimizers.RMSprop(lr=1e-4),

# metrics=['acc'])

# return final_network

def LBL_network_classification(

return model,final_layers_list

def print_results_to_file(network,history,file_name,model_name,path=""):

np.save(np_filname,np_results)

def get_small_CD_data_generators(augument_data=False):

return train_generator,validation_generator