Slowness when training multiple Convolutional Networks within a for loop

[muriloasouza]

I am training several Keras models inside a for loop. Check the following code:

import os
import time
import pandas as pd
import tensorflow as tf
import numpy as np
import unicodedata
from keras.models import Sequential
from keras.layers import InputLayer
from keras.layers import Conv1D
from keras.layers import MaxPooling1D
from keras.layers import Flatten
from keras.layers import Dense
from keras.callbacks import ModelCheckpoint
from keras.callbacks import EarlyStopping
import keras.backend as K
from openpyxl.styles import PatternFill


class vazao:
    def __init__(self, modelo='M1', rede='Conv1D', opcao=4):
        self.dir_usuario = os.getcwd()
        self.tipo = 'VAZAO'
        self.caminho_vazao = f'{self.dir_usuario}\\{self.tipo}'
        self.caminho_deck_ons_dados_abertos = f'{self.caminho_vazao}\\DECK_ONS_DADOS_ABERTOS\\'
        self.caminho_deck_ons_sintegre = f'{self.caminho_vazao}\\DECK_ONS_SINTEGRE'
        self.caminho_psats = f'{self.caminho_deck_ons_sintegre}\\PSATS\\'
        self.caminho_psats_previsao = f'{self.caminho_deck_ons_sintegre}\\PSATS_PREVISAO\\'
        self.caminho_resultados_previsao = f'{self.dir_usuario}\\RESULTADOS PREVISAO\\{self.tipo}'
        self.caminho_deck_dessem_destino = f'{self.dir_usuario}\\RESULTADOS PREVISAO\\DECK_DESSEM'
        self.df_reservatorios = pd.read_excel(f'{self.caminho_deck_ons_dados_abertos}\\RESERVATORIOS.xlsx')
        renomear_postos = {'EMBORCAÇÃO':'EMBORCACAO', 'C.BRANCO-1':'CAPIM BRANC1', 'C.BRANCO-2':'CAPIM BRANC2', 'SÃO SIMÃO':'SAO SIMAO', 'TRÊS MARIAS': 'TRES MARIAS', 
                           'B. BONITA': 'BARRA BONITA', 'PROMISSÃO':'PROMISSAO', 'N. AVANHANDAVA':'NAVANHANDAVA', 'TAQUARUÇU':'TAQUARUCU', 'TRÊS IRMÃOS':'TRES IRMAOS',
                           'PORTO PRIMAVERA':'P. PRIMAVERA', 'M. MORAES':'M. DE MORAES', 'CORUMBA':'CORUMBA I', 'SERRA DA MESA':'SERRA MESA', 'SANTO ANTONIO':'STO ANTONIO',
                           'PEIXE ANGICAL':'PEIXE ANGIC', 'NILO PEÇANHA':'NILO PECANHA', 'PEREIRA PASSOS':'P. PASSOS', 'SANTA CECILIA':'STA CECILIA', 'C. DOURADA':'CACH.DOURADA',
                           'PORTO ESTRELA':'P. ESTRELA', 'G. B. MUNHOZ':'G.B. MUNHOZ', 'G. P. SOUZA':'G.P. SOUZA', 'SANTA CLARA-PR':'STA CLARA PR', 'FUNDÃO':'FUNDAO', 'SALTO SANTIAGO':'SLT.SANTIAGO',
                           'ITÁ':'ITA', 'PONTE DE PEDRA':'PONTE PEDRA', 'P. AFONSO 1,2,3':'P.AFONSO 123', 'P. AFONSO 4':'P.AFONSO 4', 'BOA ESPERANÇA':'B. ESPERANCA',
                           'PEDRA DO CAVALO':'P. CAVALO', 'COARACY NUNES':'COARACY NUNE', 'CACHOEIRA CALDEIRAO':'CACH.CALDEIR', 'STA.CLARA-MG':'STA CLARA MG', 'SUIÇA':'SUICA',
                           'S.R.VERDINHO':'SLT VERDINHO', 'QUEBRA QUEIXO':'QUEBRA QUEIX', 'CORUMBA-3':'CORUMBA III', 'CORUMBA-4':'CORUMBA IV', 'B.COQUEIROS':'B. COQUEIROS',
                           'FOZ DO RIO CLARO':'FOZ R. CLARO', 'S.DO FACÃO':'SERRA FACAO', 'PASSO SAO JOAO':'PASSO S JOAO', 'STO ANTONIO DO JARI':'STO ANT JARI',
                           'FERREIRA GOMES':'FERREIRA GOM', 'GUILM. AMORIM':'GUILMAN-AMOR', 'SALTO GRANDE CM': 'SALTO GRANDE', 'SALTO GRANDE CS': 'L.N. GARCEZ'}
        remover_postos = ['ITAPARICA', 'MOXOTO', 'P.AFONSO 123', 'P.AFONSO 4', 'XINGO',
                          'STA CECILIA', 'ITUTINGA', 'FONTES', 'P. PASSOS', 'NILO PECANHA',
                          'SIMPLICIO', 'SANTONIO CM', 'P. ESTRELA', 'BELO MONTE', 'ITIQUIRA II',
                          'HENRY BORDEN', 'CANASTRA', 'SUICA']
        self.df_reservatorios['nom_reservatorio'].replace(renomear_postos, inplace=True)
        self.df_reservatorios = self.df_reservatorios[~self.df_reservatorios['nom_reservatorio'].isin(remover_postos)]
        self.df_reservatorios.loc[self.df_reservatorios['nom_reservatorio'] == 'SUICA', 'cod_resplanejamento'] = 145
        df_reservatorios = self.df_reservatorios.copy()
        df_reservatorios = df_reservatorios[['nom_reservatorio', 'nom_bacia','nom_rio','val_latitude','val_longitude']]        
        self.df_config = pd.read_excel(f'{self.caminho_deck_ons_sintegre}\\Configuracao.xlsx')
        lista_df = []
        arquivos = os.listdir(self.caminho_deck_ons_dados_abertos)
        for arquivo in arquivos:
            if 'DADOS' in arquivo:
                df_ano = pd.read_csv(f'{self.caminho_deck_ons_dados_abertos}{arquivo}', sep=';', index_col=None, header=0)
                lista_df.append(df_ano)
        self.df_vazao = pd.concat(lista_df, axis=0, ignore_index=True)
        self.df_vazao['id_subsistema'].replace(to_replace='SE', value='SECO', inplace=True)
        self.df_vazao['nom_reservatorio'].replace(renomear_postos, inplace=True)
        ultimo_ano = pd.to_datetime(self.df_vazao['din_instante']).dt.year.max()
        self.df_vazao_ultimo_ano_completo = self.df_vazao[pd.to_datetime(self.df_vazao['din_instante']).dt.year == ultimo_ano]
        self.df_vazao_ultimo_ano_completo = self.df_vazao_ultimo_ano_completo[~self.df_vazao_ultimo_ano_completo['nom_reservatorio'].isin(remover_postos)]
        self.df_vazao_ultimo_ano_completo.loc[self.df_vazao_ultimo_ano_completo['nom_reservatorio'] == 'SUICA', 'cod_usina'] = 145
        self.dic_par_postos_jusante_montante = {
                    'DARDANELOS': '',
                    'SAMUEL': '',
                    'PORTO ESTRELA': 'SALTO GRANDE CM',
                    'ESPORA': '',
                    'BILLINGS': 'GUARAPIRANGA',
                    'GUARAPIRANGA': '',
                    'SOBRADINHO': 'TRES MARIAS',
                    'BALBINA': '',
                    'STO ANTONIO DO JARI': '',
                    'COARACY NUNES': 'CACHOEIRA CALDEIRAO',
                    'FERREIRA GOMES':'COARACY NUNES',
                    }
        self.modelo = modelo
        self.rede = rede
        self.opcao = opcao
        self.lista_subs = ['SECO', 'S', 'NE', 'N']
        self.lista_horizontes = ['dM1', 'dM2', 'dM3', 'dM4', 'dM5', 'dM6', 'dM7', 'dM8', 'dM9']
        # self.lista_horizontes = ['dM1', 'dM9']
        self.lista_modelos = ['M1', 'M3']
        self.lista_redes = ['Conv1D', 'MLP']
        self.lista_modelos_previ_precipit = ['ECMWF', 'ETA40', 'GEFS']
        self.associacoes_df = pd.read_csv(f'{self.caminho_vazao}\\associacoes_usina_posto.csv')
        self.df_precipitacoes = pd.read_csv(f'{self.caminho_vazao}\\precipitacoes.csv')
        self.df_correlacao_reservatorio_psat = pd.read_csv(f'{self.caminho_vazao}\\correlacao_usina_psat.csv')


    def consulta_postos_em_bacias(self, subs, bacia):
        caminho = f'{self.caminho_vazao}\\SUBS_{subs}\\{bacia}'
        pastas = os.listdir(caminho)
        return pastas

    def treinamento(self, tela = False, pb = 0, progresso = 'text', subs='', bacia='', reservatorio='', epocas=500, es=250, num_inic=10, erro=''):
        
        def remover_acentos(texto):
            texto_sem_acento = ''.join(c for c in unicodedata.normalize('NFD', texto) if unicodedata.category(c) != 'Mn')
            texto_sem_acento = texto_sem_acento.replace(' ', '_')
            texto_sem_acento = texto_sem_acento.replace(',','.')
            return texto_sem_acento
    
        def conv1d():
            nome_rede = f'{subs}_{bacia}_{reservatorio}_{self.modelo}_{self.rede}_{horizonte}_inicializacao_{inicializacao}'
            nome_rede = remover_acentos(nome_rede)
            # K.clear_session() # DID NOT WORK
            rede_conv1d = Sequential(name=nome_rede)
            rede_conv1d.add(InputLayer((timesteps, input_dim), name='Camada_Entrada'))
            rede_conv1d.add(Conv1D(filters=64, kernel_size=4, activation=funcao, name='Camada_Conv_1'))
            rede_conv1d.add(MaxPooling1D(pool_size=1))
            rede_conv1d.add(Conv1D(filters=64, kernel_size=4, activation=funcao, name='Camada_Conv_2'))
            rede_conv1d.add(MaxPooling1D(pool_size=1))
            rede_conv1d.add(Flatten())
            rede_conv1d.add(Dense(units=72, activation=funcao, name='Dense_1'))
            rede_conv1d.add(Dense(units=neuronios_saida, activation=funcao, name='Camada_Saida'))
            return rede_conv1d
        
        tf.config.set_visible_devices([], 'GPU') # Disable GPU
        input_dim = 1
        val_size = 0.2
        amostras_antes = 15
        # amostras_depois = 1
        funcao = 'tanh'    
        inicializacoes = num_inic
        if self.opcao == 1:
            pass
        elif self.opcao == 2:
            pass
        elif self.opcao == 3:
            reservatorios_na_bacia = self.consulta_postos_em_bacias(subs=subs, bacia=bacia)
            for reservatorio in reservatorios_na_bacia:
                df_treinamento = pd.read_csv(f'{self.caminho_vazao}\\SUBS_{subs}\\{bacia}\\{reservatorio}\\{reservatorio}_Dados_Treinamento_Norm.csv', index_col='din_instante')
                diretorio_result_treinamento =  f'{self.caminho_vazao}\\SUBS_{subs}\\{bacia}\\{reservatorio}\\AGREGADO\\Resultados Treinamento'
                diretorio_elia = f'{self.caminho_vazao}\\SUBS_{subs}\\{bacia}\\{reservatorio}\\AGREGADO\\ELIA'
                if not os.path.exists(diretorio_result_treinamento):
                    os.makedirs(diretorio_result_treinamento)
                if not os.path.exists(diretorio_elia):
                    os.makedirs(diretorio_elia)
                if len(df_treinamento) != 0:
                    writer = pd.ExcelWriter(f'{diretorio_result_treinamento}\\{subs}_{bacia}_{reservatorio}_MSE_{self.modelo}_{self.rede}.xlsx')
                    writer_loss = pd.ExcelWriter(f'{diretorio_result_treinamento}\\{subs}_{bacia}_{reservatorio}_Treinamento_{self.modelo}_{self.rede}.xlsx')
                    for horizonte in self.lista_horizontes:
                        horiz = int(horizonte[-1])
                        x_train = []
                        y_train = []
                        if self.modelo == 'M1':
                            for i in range(0, len(df_treinamento), 1):
                                final_x = i + amostras_antes
                                final_y = final_x + horiz
                                if final_y > len(df_treinamento):
                                    break
                                previsor_vazao = df_treinamento['val_vazaoincremental'][i:final_x]
                                previsor_sen = pd.Series(df_treinamento['Seno'].loc[df_treinamento.index[final_y-1]])
                                previsor_cos = pd.Series(df_treinamento['Cosseno'].loc[df_treinamento.index[final_y-1]])
                                previsor_concat = pd.concat([previsor_vazao,
                                                              previsor_sen,
                                                              previsor_cos]).values
                                x_train.append(previsor_concat)
                                y_train.append(df_treinamento['val_vazaoincremental'][final_y - 1])
                        else:
                            melhor_lag_pearson = self.df_correlacao_reservatorio_psat.loc[self.df_correlacao_reservatorio_psat['nom_reservatorio'] == reservatorio, 'melhor_lag'].values[0]
                            if -melhor_lag_pearson > amostras_antes:
                                for i in range(-melhor_lag_pearson-amostras_antes, len(df_treinamento), 1):
                                    final_x = i + amostras_antes
                                    final_y = final_x + horiz
                                    if final_y > len(df_treinamento):
                                        break
                                    previsor_vazao = df_treinamento['val_vazaoincremental'][i:final_x]
                                    previsor_precipitacao = pd.Series(df_treinamento['precipitacao'].loc[df_treinamento.index[final_y + melhor_lag_pearson - 1]])
                                    previsor_sen = pd.Series(df_treinamento['Seno'].loc[df_treinamento.index[final_y - 1]])
                                    previsor_cos = pd.Series(df_treinamento['Cosseno'].loc[df_treinamento.index[final_y - 1]])
                                    previsor_concat = pd.concat([previsor_vazao,
                                                                  previsor_precipitacao,
                                                                  previsor_sen,
                                                                  previsor_cos]).values
                                    x_train.append(previsor_concat)
                                    y_train.append(df_treinamento['val_vazaoincremental'][final_y - 1])
                            else:
                                for i in range(0, len(df_treinamento), 1):
                                    final_x = i + amostras_antes
                                    final_y = final_x + horiz
                                    if final_y > len(df_treinamento):
                                        break
                                    previsor_vazao = df_treinamento['val_vazaoincremental'][i:final_x]
                                    previsor_precipitacao = pd.Series(df_treinamento['precipitacao'].loc[df_treinamento.index[final_y + melhor_lag_pearson - 1]])
                                    previsor_sen = pd.Series(df_treinamento['Seno'].loc[df_treinamento.index[final_y - 1]])
                                    previsor_cos = pd.Series(df_treinamento['Cosseno'].loc[df_treinamento.index[final_y - 1]])
                                    previsor_concat = pd.concat([previsor_vazao,
                                                                  previsor_precipitacao,
                                                                  previsor_sen,
                                                                  previsor_cos]).values
                                    x_train.append(previsor_concat)
                                    y_train.append(df_treinamento['val_vazaoincremental'][final_y - 1])
                        x_train = np.array(x_train)
                        y_train = np.array(y_train)
                        y_train = np.reshape(y_train, (y_train.shape[0], 1))
                        df_mse_train = pd.DataFrame(index=pd.RangeIndex(inicializacoes), columns=['mse treinamento'])
                        df_mse_val = pd.DataFrame(index=pd.RangeIndex(inicializacoes), columns=['mse validação'])
                        df_tempo = pd.DataFrame(index=pd.RangeIndex(inicializacoes), columns=['tempo (minutos)'])
                        df_melhor_epoca = pd.DataFrame(index=pd.RangeIndex(inicializacoes), columns=['melhor época'])
                        df_earlystop = pd.DataFrame(index=pd.RangeIndex(inicializacoes), columns=['época parou'])
                        num_amostras = x_train.shape[0]
                        timesteps = x_train.shape[1]
                        x_train = x_train.reshape(num_amostras, timesteps, input_dim)
                        melhor_historico = None
                        menor_loss_validacao = float('inf')
                        neuronios_saida = y_train.shape[1]
                        for inicializacao in range(inicializacoes):
                            if self.rede == 'Conv1D':
                                rede_ = conv1d()       
                            rede_.compile(optimizer='adam', loss='mean_squared_error')
                            cp = ModelCheckpoint(
                                filepath=f'{diretorio_elia}\\{subs}_{bacia}_{reservatorio}_{self.modelo}_{self.rede}_{horizonte}_inicializacao_{inicializacao}.hdf5',
                                monitor='val_loss',
                                verbose=1,
                                save_best_only=True,
                                mode='min')
                            earlystop = EarlyStopping(monitor='val_loss',
                                                    patience=es,
                                                    verbose=1,
                                                    mode='min',
                                                    restore_best_weights=True)
                            t = time.time()
                            treinando = rede_.fit(x_train, y_train, batch_size=32,
                                        epochs=epocas, verbose=2,
                                        callbacks=[cp, earlystop],
                                        validation_split=val_size, shuffle=True)
                            tempo_modelo = round((time.time() - t) / 60, 4)
                            # del rede_ # DID NOT WORK
                            # gc.collect() # DID NOT WORK
                            tempo_modelo = round((time.time() - t) / 60, 4)
                            menor_loss_validacao_inicializacao = min(treinando.history['val_loss'])
                            if menor_loss_validacao_inicializacao < menor_loss_validacao:
                                menor_loss_validacao = menor_loss_validacao_inicializacao
                                melhor_historico = treinando.history
                            df_mse_train.iloc[inicializacao] = treinando.history['loss'][np.argmin(treinando.history['val_loss'])]
                            df_mse_val.iloc[inicializacao] = min(treinando.history['val_loss'])
                            df_tempo.iloc[inicializacao] = tempo_modelo
                            df_melhor_epoca.iloc[inicializacao] = np.argmin(treinando.history['val_loss'])
                            df_earlystop.iloc[inicializacao] = earlystop.stopped_epoch          
                        df_loss = pd.DataFrame.from_dict(melhor_historico)
                        df_loss.index.names = ['Época']
                        df_loss.to_excel(writer_loss, sheet_name=f'{horizonte}', index=True)
                        df_mse_train.loc['Media'] = df_mse_train.mean()
                        df_mse_train.loc['Desv_Pad'] = df_mse_train.std(ddof=0)
                        df_mse_val.loc['Media'] = df_mse_val.mean()
                        df_mse_val.loc['Desv_Pad'] = df_mse_val.std(ddof=0)
                        df_tempo.loc['Total (minutos)'] = df_tempo.sum()
                        melhor_inicializacao = np.argmin(df_mse_val[:-2])
                        linha_excel =  melhor_inicializacao + 3
                        df_resultados = pd.concat([df_mse_train, df_mse_val, df_earlystop, df_melhor_epoca, df_tempo], axis=1)
                        df_resultados.index.names = ['Inicialização']
                        df_resultados.to_excel(writer, sheet_name=f'{horizonte}', index=True, startrow=1)
                        aba = writer.sheets[f'{horizonte}']
                        # Color best initialization
                        for col_num in range(1, aba.max_column + 1):
                            cell = aba.cell(row=linha_excel, column=col_num)
                            fill = PatternFill(start_color="00FF00", end_color="00FF00", fill_type="solid")
                            cell.fill = fill
                
                        for inicializacao in range(inicializacoes):
                            if inicializacao != melhor_inicializacao:
                                if os.path.exists(f'{diretorio_elia}\\{subs}_{bacia}_{reservatorio}_{self.modelo}_{self.rede}_{horizonte}_inicializacao_{inicializacao}.hdf5'):
                                    os.remove(f'{diretorio_elia}\\{subs}_{bacia}_{reservatorio}_{self.modelo}_{self.rede}_{horizonte}_inicializacao_{inicializacao}.hdf5')
                                else:
                                    print('Arquivo não existe')
                            else:
                                nome_antigo = f'{diretorio_elia}\\{subs}_{bacia}_{reservatorio}_{self.modelo}_{self.rede}_{horizonte}_inicializacao_{inicializacao}.hdf5'
                                nome_novo = f'{diretorio_elia}\\{subs}_{bacia}_{reservatorio}_{self.modelo}_{self.rede}_{horizonte}.hdf5'
                                if os.path.exists(nome_novo):
                                    os.remove(nome_novo)
                                    os.rename(nome_antigo, nome_novo)
                                else:
                                    os.rename(nome_antigo, nome_novo)
                    writer._save()
                    writer_loss._save()
        else:
            pass
        
        return None

if __name__ == "__main__":
    vazao(modelo='M1', rede='Conv1D', opcao=3).treinamento(subs='SECO', bacia='SAO FRANCISCO')

When the train starts, each epoch takes around 280ms. But as trains go on, each epoch lasts around 3s. I have tried to solve this problem using clear_session(), but nothing changed. I also have tried to delete the model when it finishes the .fit and also use gc.collect(), but none worked.

This increase in training time only happens if i use the Conv1D network. If i use the MLP, the training time is constant at around 90ms and does not increase. What is happening here? What is causing this increase in training time for the Conv1D? Any ideas how to fix this?

Here some examples:

At the very start:

Epoch 3: val_loss improved from 0.00015 to 0.00007, saving model to C:\Users\ldsp_\SIPREDVS\VAZAO\SUBS_SECO\SAO FRANCISCO\QUEIMADO\AGREGADO\ELIA\SECO_SAO FRANCISCO_QUEIMADO_M1_Conv1D_dM1_inicializacao_0.hdf5
164/164 - 0s - loss: 3.6645e-04 - val_loss: 7.4710e-05 - 284ms/epoch - 2ms/step
Epoch 4/500

After 10 minutes of training:

Epoch 392: val_loss did not improve from 0.00005
164/164 - 0s - loss: 2.2052e-04 - val_loss: 7.2596e-05 - 318ms/epoch - 2ms/step
Epoch 393/500


After 40 minutes of training:

Epoch 13: val_loss improved from 0.00025 to 0.00022, saving model to C:\Users\ldsp_\SIPREDVS\VAZAO\SUBS_SECO\SAO FRANCISCO\QUEIMADO\AGREGADO\ELIA\SECO_SAO FRANCISCO_QUEIMADO_M1_Conv1D_dM2_inicializacao_5.hdf5
164/164 - 0s - loss: 6.5353e-04 - val_loss: 2.2064e-04 - 450ms/epoch - 3ms/step
Epoch 14/500

[Kxrma47]

The timings shown suggest accumulation across many model fits, rather than one Conv1D model gradually becoming slower: the later example is epoch 13 of a different horizon/initialization after the process has already created many models.

Three things are worth separating:

1. Keras/TensorFlow state and retracing. Clear the session after each initialization, once you have copied out the history you need. Drop references to the model, callbacks, and History object first. If input shapes change between reservoirs/horizons, TensorFlow may also build additional concrete functions.
2. Checkpoint I/O. ModelCheckpoint writes an HDF5 model whenever validation improves. On Windows, filesystem and antivirus scanning can become a visible part of short epochs. Time a run without checkpointing, then try save_weights_only=True with a .weights.h5 path.
3. Process-level resources. TensorFlow owns thread pools and native allocations that Python garbage collection cannot fully reset. If a long sweep still slows down, run each reservoir/horizon or initialization in a fresh worker process. Process exit is the reliable hard cleanup boundary.

A cleanup block should be placed inside the initialization loop:

history_dict = {k: list(v) for k, v in history.history.items()}
del history, model, checkpoint, early_stopping
keras.backend.clear_session()
gc.collect()

Also move tf.config.set_visible_devices([], "GPU") to program startup, before TensorFlow initializes devices.

Before changing the model, profile one early and one late epoch with checkpointing disabled. If batch computation stays constant but the epoch boundary grows, the cause is callbacks/I/O. If individual training steps grow, isolate runs in subprocesses and compare fixed input shapes to changing ones.