<jupyter_start><jupyter_text>Pruebas<jupyter_code># # pruebas

# from sklearn import datasets
# from sklearn import svm

# X, y = datasets.load_iris(return_X_y=True)
# X.shape, y.shape

# from sklearn.model_selection import cross_val_score
# clf = svm.SVC(kernel='linear', C=1)
# scores = cross_val_score(clf, X, y, cv=5)
# scores
# # con datos de medusas

# X = pd.read_pickle('../pkls/dfAtributosNormalizado_0_dias_2_celdas.pkl')
# Y = pd.read_pickle('../pkls/dfAvistamientos.pkl')
# Y = np.ravel(Y)

# clf = svm.SVR(kernel='linear', C=1)
# scores = cross_val_score(clf, X, Y, cv=5)
# scores
# from sklearn.model_selection import KFold

# kf = KFold(n_splits=2)
# kf.get_n_splits(X)

# print(kf)

# for train_index, test_index in kf.split(X):
# #     print("TRAIN:", train_index, "TEST:", test_index)
#     X_train, X_test = X.loc[train_index], X.loc[test_index]
#     y_train, y_test = Y[train_index], Y[test_index]<jupyter_output><empty_output><jupyter_text>Algoritmos<jupyter_code># Carga datos

X = pd.read_pickle('../pkls/dfAtributosNormalizado_0_dias_2_celdas.pkl')
Y = pd.read_pickle('../pkls/dfAvistamientos.pkl')
Y = np.ravel(Y)
X.shape,Y.shape
# Validacion cruzada

from sklearn.model_selection import KFold

kf = KFold(n_splits=3)
kf.get_n_splits(X)<jupyter_output><empty_output><jupyter_text>Random forest<jupyter_code>from sklearn.ensemble import RandomForestRegressor
def forest(atributos,resultado,k_n):
    params = {'n_estimators': [100,500,1000],
            'max_depth': [None,10,50,100],
            'max_features': ['auto','sqrt', 'log2']}
    inicio = time()
    model_random = GridSearchCV(estimator=RandomForestRegressor(), 
                           cv=k_n,
                           param_grid =params,
                           n_jobs = -1)

    model_random.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para Random Forest: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_random.best_params_,model_random.best_score_), flush=True)
    
    return tiempo,model_random
# tiempo , modelo = forest(X,Y,3)<jupyter_output><empty_output><jupyter_text>Nearest Neighbor<jupyter_code>from sklearn.neighbors import KNeighborsRegressor
def vecino(atributos,resultado,k_n):

    # params = {'n_neighbors' : list(range(1,atributos.shape[1]))}
    maxx = int(((atributos.shape[1]-1)/k_n)*(k_n-1))
    params = {'n_neighbors' : random.sample(range(3, maxx), 10) ,
             'weights':['uniform', 'distance']}

    inicio = time()
    model_vecinos = GridSearchCV(estimator=KNeighborsRegressor(), 
                               cv=k_n,
                               param_grid=params,
                                n_jobs = -1)


    model_vecinos.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para nearest neighbor: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_vecinos.best_params_,model_vecinos.best_score_), flush=True)
    
    return tiempo,model_vecinos
# tiempo , modelo = vecino(X,Y,3)<jupyter_output><empty_output><jupyter_text>SVM<jupyter_code>from sklearn import svm
def SVR(atributos,resultado,k_n):

    params = {'kernel':('linear', 'rbf', 'poly', 'sigmoid'),
              'C' : [0.5,1.0,10,100],
              'gamma':['scale', 'auto'],
              'epsilon':[0.2]}

    inicio = time()

    model_SVR= GridSearchCV(estimator=svm.SVR(), 
                           cv=k_n,
                           param_grid=params,
                                n_jobs = -1)

    model_SVR.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para SVR: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_SVR.best_params_,model_SVR.best_score_), flush=True)
    
    return tiempo,model_SVR
# tiempo , modelo = SVR(X,Y,3)<jupyter_output><empty_output><jupyter_text>Arboles de decision<jupyter_code>from sklearn.tree import DecisionTreeRegressor
def arbol_decision(atributos,resultado,k_n):
    
    params = {'max_depth': random.sample(range(3, 200), 20),
              'max_features' : ['auto', 'sqrt', 'log2',None]}

    inicio = time()
    
    model_tree= GridSearchCV(estimator=DecisionTreeRegressor(), 
                           cv=k_n,
                           param_grid=params,
                            n_jobs = -1)


    model_tree.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para arbol decision: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_tree.best_params_,model_tree.best_score_), flush=True)
    
    return tiempo,model_tree
# tiempo , modelo = arbol_decision(X,Y,3)<jupyter_output><empty_output><jupyter_text>Boosting<jupyter_code>from sklearn.ensemble import GradientBoostingRegressor
def boosting(atributos,resultado,k_n):
    
    params = {'n_estimators': random.sample(range(3, 500), 5),
              'max_depth': random.sample(range(10, 200), 5)}

    inicio = time()
    
    model_boos= GridSearchCV(estimator=GradientBoostingRegressor(), 
                           cv=k_n,
                           param_grid=params,
                           n_jobs = -1)


    model_boos.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para boosting: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_boos.best_params_,model_boos.best_score_), flush=True)
    
    return tiempo,model_boos
# tiempo , modelo = boosting(X,Y,3)<jupyter_output><empty_output><jupyter_text>Adasboost<jupyter_code>from sklearn.ensemble import AdaBoostRegressor
def adaboost(atributos,resultado,k_n):
    
    params = {'n_estimators': random.sample(range(3, 500), 10),
              'loss': ['linear', 'square', 'exponential'],
             'random_state': [None,1,5,10]}

    inicio = time()
    
    model_boos= GridSearchCV(estimator=AdaBoostRegressor(), 
                           cv=k_n,
                           param_grid=params,
                           n_jobs = -1)


    model_boos.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para adaboost: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_boos.best_params_,model_boos.best_score_), flush=True)
    
    return tiempo,model_boos
# tiempo , modelo = adaboost(X,Y,3)<jupyter_output><empty_output><jupyter_text>GradientBoostingRegressor<jupyter_code>from sklearn.ensemble import GradientBoostingRegressor
def grad_boosting(atributos,resultado,k_n):
    
    params = {'n_estimators': random.sample(range(3, 50), 5),
              'max_depth': random.sample(range(3, 50), 10), 
              'max_features':['auto', 'sqrt', 'log2',None],
             'random_state': [None,1,5,10]}

    inicio = time()
    
    model_boos= GridSearchCV(estimator=GradientBoostingRegressor(), 
                           cv=k_n,
                           param_grid=params,
                           n_jobs = -1)


    model_boos.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para gradient boosting: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_boos.best_params_,model_boos.best_score_), flush=True)
    
    return tiempo,model_boos
# tiempo , modelo = grad_boosting(X,Y,3)<jupyter_output><empty_output><jupyter_text>MLP (red neuronal)<jupyter_code>from sklearn.neural_network import MLPRegressor
def MLP(atributos,resultado,k_n):

    params = {'alpha' : [0.00001,0.0001,0.001],
            'max_iter' : [1000,2000,5000],
            'random_state': [0,1,10]}

    inicio = time()

    model_MLP= GridSearchCV(estimator=MLPRegressor(), 
                           cv=k_n,
                           param_grid=params)


    model_MLP.fit(atributos, resultado)
    
    fin = time()
    tiempo = (fin - inicio)/60
    print('-Tiempo empleado para MLP: {} minutos'.format(tiempo), flush=True)
    print('Best_params: {}\nBest_score: {}'.format(model_MLP.best_params_,model_MLP.best_score_), flush=True)
    
    return tiempo,model_MLP
# tiempo , modelo = MLP(X,Y,3)<jupyter_output><empty_output><jupyter_text>Ejecutar todos los algoritmos con diferentes combinaciones<jupyter_code># df para guardar resultados
algoritmos  = ['random_forest','nearest_neighbor',
              'SVR','arbol_decision',
               'MLP','Boosting','Adasboost','GradientBoostingRegressor']
df = pd.DataFrame(index=algoritmos)

def reinicia_df():
    df = pd.DataFrame(index=algoritmos)
    df.to_pickle('resultadosStratKfold.pkl')

def guarda_resultado(alg,dias,celdas,split,resultado,params):
    df = pd.read_pickle('resultadosStratKfold.pkl')
    print(alg,dias,celdas,resultado,params)
    nombre_col = '{}_dias_{}_celdas_{}_splits'.format(dias,celdas,split)
    if not nombre_col in df.columns:
        df[nombre_col] = np.nan
        df[nombre_col + '_params'] = np.nan
    df.loc[alg,nombre_col] = resultado
    df.loc[alg,nombre_col + '_params'] = params
    df.to_pickle('resultadosStratKfold.pkl')
    df.to_excel('resultadosStratKfold.xlsx')

##
reinicia_df()
guarda_resultado('random_forest',1,2,0,3,'hola')
guarda_resultado('nearest_neighbor',1,2,0,4,'adios')
guarda_resultado('SVR',2,2,0,4,'salu2')
df = pd.read_pickle('resultadosStratKfold.pkl')
df
import os
import datetime

splits = [5,10,20]

res = ''
reinicia_df()
resultado = Y

tiempo_inicial = time()

listado_archivos = os.listdir('../pkls/')
df = pd.DataFrame(index=algoritmos)
for i in listado_archivos:
    for split in splits:
        if 'dfAtributosNormalizado' in i :
            atributos = pd.read_pickle('../pkls/{}'.format(i))
            dias,celdas = i[23:25],i[31:33]
            print('\n\n {} ///// {} \n'.format(i, split))

            # concateno y guardo en log
            res += str(datetime.datetime.now()) + ' --------- ' +  str(i) + '\n'

            tiempo,model_result = forest(atributos,resultado,split)
            guarda_resultado('random_forest',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> Random Forest ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)

            tiempo,model_result = vecino(atributos,resultado,split)
            guarda_resultado('nearest_neighbor',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> Vecino mas cercano ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)

            tiempo,model_result = SVR(atributos,resultado,split)
            guarda_resultado('SVR',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> SVR ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)

            tiempo,model_result = arbol_decision(atributos,resultado,split)
            guarda_resultado('arbol_decision',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> arbol_decision ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)
       
            tiempo,model_result = boosting(atributos,resultado,split)
            guarda_resultado('Boosting',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> Boosting ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)
            
            tiempo,model_result = adaboost(atributos,resultado,split)
            guarda_resultado('Adaboost',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> Adaboost ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)
            
            tiempo,model_result = grad_boosting(atributos,resultado,split)
            guarda_resultado('GradientBoostingRegressor',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> GradientBoostingRegressor ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)
            
            tiempo,model_result = MLP(atributos,resultado,split)
            guarda_resultado('MLP',dias,celdas,split,model_result.best_score_,str(model_result.best_params_))
            res += '--> MLP ' + str(model_result) + '\nTiempo empleado: ' + str(tiempo)


        f = open ('log.txt','wb')

        f.write(bytes(res, encoding='utf-8'))
        f.close()

f = open ('logStratKfold.txt','wb')

f.write(bytes('\n\nTiempo Total --> ' + str(time() - tiempo_inicial), encoding='utf-8'))
f.close()<jupyter_output>dfAtributosNormalizado_0_dias_0_celdas.pkl ///// 5 

Tiempo empleado para nearest neighbor: 0.027234443028767905 minutos
Best_params: {'n_neighbors': 15, 'weights': 'distance'}
Best_score: -4.12592785522622
nearest_neighbor 0_ _c -4.12592785522622 {'n_neighbors': 15, 'weights': 'distance'}
Tiempo empleado para SVR: 0.017613653341929117 minutos
Best_params: {'C': 100, 'epsilon': 0.2, 'gamma': 'auto', 'kernel': 'poly'}
Best_score: -0.06167039811094925
SVR 0_ _c -0.06167039811094925 {'C': 100, 'epsilon': 0.2, 'gamma': 'auto', 'kernel': 'poly'}
Tiempo empleado para arbol decision: 0.02971986134847005 minutos
Best_params: {'max_depth': 145, 'max_features': 'auto'}
Best_score: -1.1812000273025365
arbol_decision 0_ _c -1.1812000273025365 {'max_depth': 145, 'max_features': 'auto'}<jupyter_text>Voting regressor<jupyter_code>from sklearn.ensemble import VotingRegressor
from sklearn.linear_model import LinearRegression
# def voting(atributos,resultado,k_n):

#     inicio = time()
    
#     params = {}
    
#     reg1 = GradientBoostingRegressor(random_state=1, n_estimators=10)
#     reg2 = RandomForestRegressor(random_state=1, n_estimators=10)
#     reg3 = LinearRegression()
#     ereg = VotingRegressor(estimators=[('gb', reg1), ('rf', reg2), ('lr', reg3)])
    
#     grid = GridSearchCV(estimator=ereg, param_grid=params, cv=k_n)

#     ereg = grid.fit(atributos, resultado)
    
#     fin = time()
#     tiempo = (fin - inicio)/60
#     print('Tiempo empleado : {} minutos'.format(tiempo), flush=True)
    
#     return tiempo,ereg
# tiempo , modelo = voting(X,Y,3)
# modelo.best_score_<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13996380846325168, 'fraction_numerical': 0.026169265033407572, 'mean_word_length': 3.43077397471477, 'pattern_counts': {'":': 0, '<': 48, '<?xml version=': 0, '>': 57, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '406454', 'license': 'MIT', 'n_tokens_mistral': 5511, 'n_tokens_neox': 5241, 'n_words': 769, 'path': 'src/Avistamientos/GeneracionModelo/Modelos con (Stratified)KFold.ipynb', 'repo_name': 'dbo1001/UBU-TFG-Jellyfish_Forecast', 'size': '14368'}