screenlog.m3_64

5/
master10@etse-75-51:~/scene-classificator$ ls
data     modelMLP.png  partial_out.txt  Pipfile.lock  results      screenlog.m3_64  session5.log
LICENSE  old_data      Pipfile          README.md     screenlog.0  session4.log     source
master10@etse-75-51:~/scene-classificator$ lsmv screenlog.m3_64 results/session5/[1@0 results/session5/
master10@etse-75-51:~/scene-classificator$ nanonano source/session5.
session5.log  session5.py   
master10@etse-75-51:~/scene-classificator$ nano source/session5.py 
[?1049h(B[?7h[?1h=[?1h=[?1h=[?25l(B(B[ Leyendo archivo ]
(B(B[ 261 líneas leídas ]
(B[?12l[?25h(B  GNU nano 2.5.3                  Archivo: source/session5.py                                            (Bimport(B getpass
(Bimport(B logging
(Bimport(B os
(Bimport(B sys
(Bimport(B time
(B# Set python path to allow acceding to the modules inside /source without need
# to specify 'from source ...'
(Bsys.path.append(os.path.dirname(os.path.dirname(__file__)))
(B# Config to run on one GPU
#os.environ["CUDA_VISIBLE_DEVICES"] = getpass.getuser()[-1]
#os.environ["CUDA_VISIBLE_DEVICES"] = '0,1,2,3'
(Bos.environ[(B"CUDA_VISIBLE_DEVICES"(B] = (B'5,6,7,9'
from(B GPyOpt.methods (Bimport(B BayesianOptimization
(Bfrom(B keras (Bimport(B Input, optimizers
(Bfrom(B keras.layers (Bimport(B Dropout
(Bfrom(B keras.layers (Bimport(B Dense
(Bfrom(B keras.layers (Bimport(B Flatten
(B^G(B Ver ayuda   (B^O(B Guardar     (B^W(B Buscar(B^K(B Cortar Texto(B^J(B Justificar  (B^C(B Posición    (B^Y(B Pág. ant.
(B^X(B Salir(B^R(B Leer fich.  (B^\(B Reemplazar  (B^U(B Pegar txt   (B^T(B Corrector   (B^_(B Ir a línea  (B^V(B Pág. sig.
(BModificado
(Bos.environ[(B"CUDA_VISIBLE_DEVICES"(B] = getpass.getuser()[-1] 

(Bfrom(B keras.layers (Bimport(B MaxPooling2D

(Bfrom(B keras.layers (Bimport(B Conv2D
(BNombre del archivo a escribir: source/session5.py                                                        (B      (BM-D(B Format DOS       (BM-A(B Añadir           (BM-B(B Respald fich(BC(B Cancelar          (BM-M(B Format Mac       (BM-P(B Anteponer        (B^T(B A Ficheros[?25l(B (B[ 259 líneas escritas ](B
[?12l[?25h(B          ^O(B Guardar     (B^W(B Buscar      (B^K(B Cortar Texto(B^J(B Justificar  (B^C(B Posición    (B^Y(B Pág. ant.(BX(B Salir       (B^R(B Leer fich.  (B^\(B Reemplazar  (B^U(B Pegar txt   (B^T(B Corrector   (B^_(B Ir a línea  (B^V(B Pág. sig.
os.environ[(B"CUDA_VISIBLE_DEVICES"(B] = getpass.getuser()[-1]
(Bfrom(B GPyOpt.methods (Bimport(B BayesianOptimization
(Bfrom(B keras (Bimport(B Input, optimizers
(Bfrom(B keras.layers (Bimport(B Dropout
(Bfrom(B keras.layers (Bimport(B Dense
(Bfrom(B keras.layers (Bimport(B Flatten
(Bfrom(B keras.layers (Bimport(B MaxPooling2D
(Bfrom(B keras.layers (Bimport(B Conv2D
(Bfrom(B keras.models (Bimport(B Model
(Bimport(B numpy (Bas(B np
(Bimport(B matplotlib
(B# Force matplotlib to not use any Xwindows backend. If you need to import
# pyplot, do it after setting `Agg` as the backend.
(Bmatplotlib.use((B'Agg'(B)
source (Bimport(B TEST_PATHsource (Bimport(B VALIDATION_PATH   source (Bimport(B TRAIN_PATH  
(Bimport(B matplotlib
(B# Force matplotlib to not use any Xwindows backend. If you need to import
# pyplot, do it after setting `Agg` as the backend.
(Bmatplotlib.use((B'Agg'(B)
source (Bimport(B TEST_PATHsource (Bimport(B VALIDATION_PATH   source (Bimport(B TRAIN_PATH  
(Bfrom(B CNN (Bimport(B CNN
(B# Create a file logger
(Blogger = logging.getLogger((B'session5'(B)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter((B'%(asctime)s %(levelname)s %(message)s'(B)
file_handler = logging.FileHandler((B'session5.log'(B)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
78console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
(B# Do cross-validation to find best parameters
(Bcross_validate = True
(B# Load pre-trained model or generate from scratch
(Bload_model = False
(B# select number of epochs
(B78n_epochs = 50
(Bdef get_model(B(model_id, image_size): (B # type: (int, int) -> Model""" Gets a model by its id.
     Args:
         model_id: model id
         image_size: dimension of the image in pixels in width or height
            (squared images are expected)
     """
(B78(Bdef _model1(B():main_input = Input(shape=(image_size, image_size, 3),dtype=(B'float32'(B,name=(B'main_input'(B)x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv1'(B)(main_input)x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv2'(B)(x)x = MaxPooling2D(pool_size=(4, 4), padding=(B'valid'(B, name=(B'pool'(B)(x)x = Flatten()(x)x = Dense(256, activation=(B'relu'(B, name=(B'fc1'(B)(x)
78x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)x = Dropout(0.5)(x)main_output = Dense(units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)(B # Compile the modelreturn(B Model(inputs=main_input, outputs=main_output, name=(B'model1'(B)(Bdef _model2(B():main_input = Input(shape=(image_size, image_size, 3),
main_output = Dense(units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)(B # Compile the model(B(Breturn(B Model(inputs=main_input, outputs=main_output, name=(B'model1'(B)
(Bdef _model2(B():main_input = Input(shape=(image_size, image_size, 3), dtype=(B'float32'(B, name=(B'main_input'(B)x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv1'(B)(main_input)x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool1'(B)(x)x = Conv2D(16, (3, 3), activation=(B'relu'(B, name=(B'conv2'(B)(x)x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool2'(B)(x) x = Flatten()(x)   x = Dense(256, activation=(B'relu'(B, name=(B'fc1'(B)(x)x = Dropout(0.5)(x)    x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)x = Dropout(0.5)(x)
x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv1'(B)(main_input)x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool1'(B)(x)x = Conv2D(16, (3, 3), activation=(B'relu'(B, name=(B'conv2'(B)(x)x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool2'(B)(x)x = Flatten()(x)x = Dense(256, activation=(B'relu'(B, name=(B'fc1'(B)(x)x = Dropout(0.5)(x)x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)x = Dropout(0.5)(x)(B23(B64
(B # Compile the modelreturn(B Model(inputs=main_input, outputs=main_output, name=(B'model2'(B)(Bdef _model3(B():main_input = Input(shape=(image_size, image_size, 3),dtype=(B'float32'(B,name=(B'main_input'(B)6432
x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool2'(B)(x) x = Flatten()(x)   x = Dense(256, activation=(B'relu'(B, name=(B'fc1'(B)(x)x = Dropout(0.5)(x)    x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)x = Dropout(0.5)(x)main_output = Dense(units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)
(B # Compile the model(B(Breturn(B Model(inputs=main_input, outputs=main_output, name=(B'model3'(B)
(Breturn(B {1: _model1(),2: _model2(),3: _model3()}.get(model_id)
(Bdef get_optimizer(B(optimizer_id,
78learning_rate): (B # type: (int, int) -> optimizer""" Gets a optimizer by its id.
     Args:
         optimizer_id: optimizer id
         learning_rate: learning rate of the optimizer
    """if(B optimizer_id == 1:optimizer = optimizers.SGD(lr=learning_rate)(Belif(B optimizer_id == 2:
78optimizer = optimizers.RMSprop(lr=learning_rate)(Belif(B optimizer_id == 3:optimizer = optimizers.Adam(lr=learning_rate)(Belse(B:optimizer = optimizers.Adadelta(lr=learning_rate)(Breturn(B optimizer
(Bdef do_cross_validation(B():(B # Random Search
(B78(B # Note the batch size is going to be multiplied cause of data-augmentation(Bbounds = [{(B'name'(B: (B'model_id'(B, (B'type'(B: (B'discrete'(B,(B'domain'(B: (3,)},{(B'name'(B: (B'image_size'(B, (B'type'(B: (B'discrete'(B,(B'domain'(B: (256,)},{(B'name'(B: (B'batch_size'(B, (B'type'(B: (B'discrete'(B,(B'domain'(B: (64,)},(B # {'name': 'batch_size', 'type': 'discrete', #  'domain': (16, 32, 64)},(B{(B'name'(B: (B'optimizer_id'(B, (B'type'(B: (B'discrete'(B,
(BModificado(B6256,)},4256,)},
(BNombre del archivo a escribir: source/session5.py                                                        (B      (BM-D(B Format DOS       (BM-A(B Añadir           (BM-B(B Respald fich(BC(B Cancelar          (BM-M(B Format Mac       (BM-P(B Anteponer        (B^T(B A Ficheros[?25l(B (B[ 259 líneas escritas ](B[?12l[?25h(B          ^O(B Guardar     (B^W(B Buscar      (B^K(B Cortar Texto(B^J(B Justificar  (B^C(B Posición    (B^Y(B Pág. ant.(BX(B Salir       (B^R(B Leer fich.  (B^\(B Reemplazar  (B^U(B Pegar txt   (B^T(B Corrector   (B^_(B Ir a línea  (B^V(B Pág. sig.{(B'name'(B: (B'model_id'(B, (B'type'(B: (B'discrete'(B, (B'domain'(B: (3,)},{(B'name'(B: (B'image_size'(B, (B'type'(B: (B'discrete'(B,(B'domain'(B: (64,)},    {(B'name'(B: (B'batch_size'(B, (B'type'(B: (B'discrete'(B,(B'domain'(B: (64,)},(B # {'name': 'batch_size', 'type': 'discrete',(B (B #  'domain': (16, 32, 64)},(B {(B'name'(B: (B'optimizer_id'(B, (B'type'(B: (B'discrete'(B, (B'domain'(B: (4,)},   (B # {'name': 'optimizer_id', 'type': 'discrete', #  'domain': (1, 2, 3, 4)},(B{(B'name'(B: (B'lr'(B, (B'type'(B: (B'discrete'(B,(B # 'domain': (1, 0.1, 0.01, 0.001, 0.0001)}](B1,)}] 
optimizer = BayesianOptimization(f=train_and_validate, domain=bounds,  verbosity=True)optimizer.run_optimization(max_iter=1,optimizer = optimizers.Adam(lr=learning_rate)(Belse(B:optimizer = optimizers.Adadelta(lr=learning_rate)(Breturn(B optimizer
(Bdef do_cross_validation(B():(B # Random Search # Note the batch size is going to be multiplied cause of data-augmentation(Bbounds = [
78
(B'domain'(B: (4,)},(B # {'name': 'optimizer_id', 'type': 'discrete', #  'domain': (1, 2, 3, 4)},(B{(B'name'(B: (B'lr'(B, (B'type'(B: (B'discrete'(B,(B # 'domain': (1, 0.1, 0.01, 0.001, 0.0001)}]'domain'(B: (1,)}]optimizer = BayesianOptimization(f=train_and_validate,domain=bounds,verbosity=True)optimizer.run_optimization(max_iter=1,
(BModificado(B,5,
(B    """(B
(Bif(B optimizer_id == 1:optimizer = optimizers.SGD(lr=learning_rate)(Belif(B optimizer_id == 2:optimizer = optimizers.RMSprop(lr=learning_rate)(Belif(B optimizer_id == 3: optimizer = optimizers.Adam(lr=learning_rate)(Belse(B:optimizer = optimizers.Adadelta(lr=learning_rate)
(Breturn(B optimizer
(Bdef do_cross_validation(B():(B # Random Search # Note the batch size is going to be multiplied cause of data-augmentation(Bbounds = [{(B'name'(B: (B'model_id'(B, (B'type'(B: (B'discrete'(B, (B'domain'(B: (3,)},
(B # Compile the model(B    (Breturn(B Model(inputs=main_input, outputs=main_output, name=(B'model3'(B)
(Breturn(B {1: _model1(),    2: _model2(),3: _model3()}.get(model_id)
(Bdef get_optimizer(B(optimizer_id,learning_rate): (B # type: (int, int) -> optimizer""" Gets a optimizer by its id.
(B(B     Args:(B
(B         optimizer_id: optimizer id(B
(B         learning_rate: learning rate of the optimizer
    """(B
(B # Compile the model(B (Breturn(B Model(inputs=main_input, outputs=main_output, name=(B'model2'(B)
(Bdef _model3(B():    main_input = Input(shape=(image_size, image_size, 3), dtype=(B'float32'(B, name=(B'main_input'(B)x = Conv2D(64, (3, 3), activation=(B'relu'(B, name=(B'conv1'(B)(main_input)    x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool1'(B)(x)x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv2'(B)(x)x = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool2'(B)(x) x = Flatten()(x)x = Dense(256, activation=(B'relu'(B, name=(B'fc1'(B)(x)    x = Dropout(0.5)(x)x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x) x = Dropout(0.5)(x) main_output = Dense( units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)
(B # Compile the model
(B
(B12(B3216(Breturn(B Model(inputs=main_input, outputs=main_output, name=(B'model2'(B)



(B1(B324, 4x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)
(B1
(Blogger.addHandler(console_handler)
(B# Do cross-validation to find best parameters(B
cross_validate = True
(B# Load pre-trained model or generate from scratch
(Bload_model = False
(B# select number of epochs(B
n_epochs = 50
(Bdef get_model(B(model_id, image_size): (B # type: (int, int) -> Model""" Gets a model by its id.(B
(B     Args:
         model_id: model id(B 
(B         image_size: dimension of the image in pixels in width or height
            (squared images are expected)
     """(B
(Bdef _model1(B():
(Bfrom(B source (Bimport(B TEST_PATH
(Bfrom(B source (Bimport(B VALIDATION_PATH
(Bfrom(B source (Bimport(B TRAIN_PATH
(Bfrom(B CNN (Bimport(B CNN
(BCreate a file logger(B   
logger = logging.getLogger((B'session5'(B)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter((B'%(asctime)s %(levelname)s %(message)s'(B)
file_handler = logging.FileHandler((B'session5.log'(B)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)  
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
(B# Config to run on one GPU(B  
os.environ[(B"CUDA_VISIBLE_DEVICES"(B] = getpass.getuser()[-1]
(Bfrom(B GPyOpt.methods (Bimport(B BayesianOptimizationkeras (Bimport(B Input, optimizers
(Bfrom(B keras.layers (Bimport(B Dropout
(Bfrom(B keras.layers (Bimport(B Dense
(Bfrom(B keras.layers (Bimport(B Flatten
(Bfrom(B keras.layers (Bimport(B MaxPooling2D
(Bfrom(B keras.layers (Bimport(B Conv2D
(Bfrom(B keras.models (Bimport(B Model
(Bimport(B numpy (Bas(B np
(Bimport(B matplotlib
(B# Force matplotlib to not use any Xwindows backend. If you need to import
# pyplot, do it after setting `Agg` as the backend.
(Bmatplotlib.use((B'Agg'(B)
(Bfrom(B source (Bimport(B TEST_PATH
(Bfrom(B source (Bimport(B VALIDATION_PATH
78(Bfrom(B source (Bimport(B TRAIN_PATH
(Bfrom(B CNN (Bimport(B CNN
(B# Create a file logger
(Blogger = logging.getLogger((B'session5'(B)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter((B'%(asctime)s %(levelname)s %(message)s'(B)
file_handler = logging.FileHandler((B'session5.log'(B)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
78logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
(B# Do cross-validation to find best parameters
(Bcross_validate = True
(B# Load pre-trained model or generate from scratch
(Bload_model = False
78(B# select number of epochs
(Bn_epochs = 50
(Bdef get_model(B(model_id, image_size): (B # type: (int, int) -> Model""" Gets a model by its id.
     Args:
         model_id: model id
         image_size: dimension of the image in pixels in width or height
            (squared images are expected)
(B01000
(BNombre del archivo a escribir: source/session5.py                                                        (B      (BM-D(B Format DOS       (BM-A(B Añadir           (BM-B(B Respald fich(BC(B Cancelar          (BM-M(B Format Mac       (BM-P(B Anteponer        (B^T(B A Ficheros[?25l(B (B[ 259 líneas escritas ](B[?12l[?25h(B          ^O(B Guardar     (B^W(B Buscar      (B^K(B Cortar Texto(B^J(B Justificar  (B^C(B Posición    (B^Y(B Pág. ant.(BX(B Salir       (B^R(B Leer fich.  (B^\(B Reemplazar  (B^U(B Pegar txt   (B^T(B Corrector   (B^_(B Ir a línea  (B^V(B Pág. sig.0
(B         image_size: dimension of the image in pixels in width or height
            (squared images are expected)
     """(B
(Bdef _model1(B(): main_input = Input(shape=(image_size, image_size, 3), dtype=(B'float32'(B, name=(B'main_input'(B)
 x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv1'(B)(main_input) x = Conv2D(32, (3, 3), activation=(B'relu'(B, name=(B'conv2'(B)(x)x = MaxPooling2D(pool_size=(4, 4), padding=(B'valid'(B, name=(B'pool'(B)(x)x = Flatten()(x) x = Dense(256, activation=(B'relu'(B, name=(B'fc1'(B)(x)    x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)x = Dropout(0.5)(x)
 main_output = Dense( units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)
MM units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)
 (B # Compile the modelreturn(B Model(inputs=main_input, outputs=main_output, name=(B'model1'(B)(B2(Bx = MaxPooling2D(pool_size=(2, 2), padding=(B'valid'(B, name=(B'pool1'(B)(x)162, 2(B2'(B)(x)x = Dense(128, activation=(B'relu'(B, name=(B'fc2'(B)(x)x = Dropout(0.5)(x) main_output = Dense(units=8, activation=(B'softmax'(B, name=(B'predictions'(B)(x)
Mmain_output = Dense((B23(B6432
Mx = Dropout(0.5)(x)(B3return(B {1: _model1(),2: _model2(),3: _model3()}.get(model_id)
(Bdef get_optimizer(B(optimizer_id, learning_rate): (B # type: (int, int) -> optimizer""" Gets a optimizer by its id.
(B(B     Args:(B
(B         optimizer_id: optimizer id
(B(B     Args:(B
(B         optimizer_id: optimizer id
         learning_rate: learning rate of the optimizer(B
(B    """
(B(Bif(B optimizer_id == 1:optimizer = optimizers.SGD(lr=learning_rate)(Belif(B optimizer_id == 2:optimizer = optimizers.RMSprop(lr=learning_rate)(Belif(B optimizer_id == 3:optimizer = optimizers.Adam(lr=learning_rate)(Belse(B:optimizer = optimizers.Adadelta(lr=learning_rate)
    (Breturn(B optimizer
(Bdef do_cross_validation(B():
   (B # Random Search
(B   (B # Note the batch size is going to be multiplied cause of data-augmentation
(B   (B # Random Search
(B   (B # Note the batch size is going to be multiplied cause of data-augmentation
(B    bounds = [ {(B'name'(B: (B'model_id'(B, (B'type'(B: (B'discrete'(B,(B'domain'(B: (3,)},    {(B'name'(B: (B'image_size'(B, (B'type'(B: (B'discrete'(B, (B'domain'(B: (64,)},    {(B'name'(B: (B'batch_size'(B, (B'type'(B: (B'discrete'(B, (B'domain'(B: (64,)},   (B # {'name': 'batch_size', 'type': 'discrete', #  'domain': (16, 32, 64)},(B    {(B'name'(B: (B'optimizer_id'(B, (B'type'(B: (B'discrete'(B, (B'domain'(B: (4,)},(B # {'name': 'optimizer_id', 'type': 'discrete',(B   (B #  'domain': (1, 2, 3, 4)},(B{(B'name'(B: (B'lr'(B, (B'type'(B: (B'discrete'(B,(B # 'domain': (1, 0.1, 0.01, 0.001, 0.0001)}](B (B'domain'(B: (1,)}] 
 optimizer = BayesianOptimization(f=train_and_validate,
78domain=bounds,verbosity=True)optimizer.run_optimization(max_iter=5,verbosity=True,report_file=(B'optimizer_results.txt'(B)logger.info((B'optimized parameters: {}'(B.format(optimizer.x_opt))logger.info((B'optimized accuracy: {}'(B.format(optimizer.fx_opt))
(Bdef train_and_validate(B(bounds):b = bounds.astype(np.int64)
78model_id, image_size, batch_size, optimizer_id, lr = \b[:, 0][0], b[:, 1][0], b[:, 2][0], b[:, 3][0], b[:, 4][0]logger.info((B'Bounds in action {}'(B.format(bounds))timestamp = int(time.time())MODEL_PATH = (B'results/session5/CNN_{}_{}.h5'(B.format(model_id, timestamp)neural_network = CNN(logger,train_path=TRAIN_PATH,validation_path=VALIDATION_PATH,test_path=TEST_PATH,model_fname=MODEL_PATH)
 model_fname=MODEL_PATH)
(B # Hyper-parameters selection(Bneural_network.set_batch_size(batch_size)neural_network.set_model(model=get_model(model_id=model_id, image_size=image_size))neural_network.set_optimizer(get_optimizer(optimizer_id, lr))
    neural_network.set_loss_function((B'categorical_crossentropy'(B)neural_network.set_metrics([(B'accuracy'(B])
(B # Configure and build the NN(Bneural_network.configure()neural_network.build()
(B # Train(Bneural_network.train_CNN_model(n_epochs=n_epochs, steps_per_epoch_multiplier=10, validation_steps_multiplier=1)
neural_network.plot_history(
neural_network.plot_history( (B'results/session5/CNN_{}_{}'(B.format(model_id, timestamp))plot_results(    (B'results/session5/CNN_{}_{}'(B.format(model_id, timestamp))
score, evaluator = neural_network.get_results()(Breturn(B np.array(evaluator.accuracy, dtype=np.float64)
(Bif(B __name__ == (B"__main__"(B:init = time.tim
(B # Train and validate the model optimizing hyper-parameters(B (Bif(B cross_validate:    do_cross_validation()
(B # Load the model if exists, train otherwise(B(Belse(B:    MODEL_PATH = (B'results/session5/my_CNN.h5'
(B    (Belse(B:    MODEL_PATH = (B'results/session5/my_CNN.h5'(Bneural_network = CNN(logger, train_path=TRAIN_PATH, validation_path=VALIDATION_PATH,test_path=TEST_PATH, model_fname=MODEL_PATH)
(Bif(B load_model:neural_network.load_CNN_model() (Belse(B: (B # Hyper-parameters selection(Bneural_network.set_batch_size(16) neural_network.set_model( model=get_model(model_id=2, image_size=64))    neural_network.set_optimizer(optimizers.Adadelta(lr=0.1))neural_network.set_loss_function((B'categorical_crossentropy'(B) neural_network.set_metrics([(B'accuracy'(B])
    neural_network.configure()
    neural_network.configure()    neural_network.build()  
neural_network.train_CNN_model(n_epochs=n_epochs steps_per_epoch_multiplier=8, validation_steps_multiplier=1)    neural_network.plot_history((B'results/session5/my_CNN'(B)
neural_network.plot_results((B'results/session5/my_CNN'(B)
end = time.time()logger.info((B'Everything done in {} secs.\n'(B.format(str(end - init)))
[?1049l
[?1l>master10@etse-75-51:~/scene-classificator$ exit