timeseries-experiments/funciones.py

import glob
import json
import warnings
import os
import sys
import pathlib
import errno


import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from typing import Tuple
from scipy.signal import savgol_filter
from tqdm import tqdm
from siml.detect_peaks import *
from IPython.display import display
import dagshub


LOCAL_PATH = os.path.abspath(os.getcwd())

def best_metrics_every_experiment(experiment: str, path: str, axis: int, top: int) -> pd.DataFrame:

    '''
    Crea un DataFrame que muestra los top modelos más frecuentes 
    para cada experimento realizado


    Parameters
    ----------

    experiment: str
        Nombre del experimento. También es el nombre de la carpeta en la que se encuentra.

    path: str
        Path de la carpeta donde se encuentran los archivos metrics_best_model_frequency.csv y 
        results_best_model_frequency.csv. La carpeta que se encuentran estos archivos puede 
        ser el experimento con o sin separar las clases.

    axis: int
        Indica el tipo de archivo con el que se está trabajando. Metrics es equivalente 
        a axis = 1 y Results axis = 0.

    top: int
        Indica el top de modelos a imprimir. Ejemeplo: si se quiere el top 2 mejores modelos
        para la métrica, top = 2.
    
    Returns
    -------

    df_by_metric: pd.Dataframe
        Dataframe que contiene el top de mejores modelos para todas las métrica trabajadas.


    '''

    if axis == 1:
        path_best_metrics = path + "/" + "metrics_best_model_frequency.csv"
    if axis == 0:
        path_best_metrics = path + "/" + "results_best_model_frequency.csv"

    df = pd.read_csv(path_best_metrics,index_col=0)
    total = df.sum()
    df = df/total
    df_by_metric = pd.DataFrame()

    for metrics in df.columns:
        # models = df.idxmax("rows")
        # df_by_metric = pd.DataFrame()
        if top > len(df.index):
            df_sorted = df[metrics].sort_values(ascending=False)
        if top <= len(df.index):
            df_sorted = df[metrics].sort_values(ascending=False).head(top)
        columns = []
        data = []

        for top_metrics in range(top):
            if len(df_sorted.index) >= top_metrics + 1:
                column_name = "Top " + str(top_metrics + 1) + " most frequent model " + metrics.split()[-1]
                columns.append(column_name)
                data.append(df_sorted.index[top_metrics])
                column_name = "Top " + str(top_metrics + 1) + " percentage appearance " + metrics.split()[-1]
                columns.append(column_name)
                data.append(df_sorted[top_metrics])

            else:
                column_name = "Top " + str(top_metrics + 1) + " most frequent model " + metrics.split()[-1]
                columns.append(column_name)
                data.append("")
                column_name = "Top " + str(top_metrics + 1) + " percentage appearance " + metrics.split()[-1]
                columns.append(column_name)
                data.append(0)

        column_name = "Comparation points " + metrics.split()[-1]
        columns.append(column_name)
        data.append(total[metrics])

        df_by_metric_temp = pd.DataFrame([data], columns=columns)
        df_by_metric = pd.concat([df_by_metric,df_by_metric_temp],axis=1)

    df_by_metric = df_by_metric.set_index(pd.Series([experiment]))

    return df_by_metric


def save_best_metrics_global(df_best_metrics: pd.DataFrame, axis: int, save_path: str):

    '''
    Guarda el top de modelos segun las diferentes metricas en diferentes carpetas

    Parameters
    ----------
    df_best_metrics: pd.DataFrame
        Dataframe que contiene el top de los modelos con todas las metricas.
    
    axis: int
        Indica el tipo de archivo con el que se está trabajando. Metrics es equivalente 
        a axis = 1 y Results axis = 0.
    
    save_path: str
        Indica el path donde se crearán las carpetas para guardar el top de modelos según
        la métrica.


    '''

    i_partida = 0
    columns = df_best_metrics.columns
    same_metric = columns[i_partida].split()[-1]

    for i in range(len(columns)):
        if same_metric != columns[i].split()[-1]:
            df = df_best_metrics.iloc[:,i_partida:i]
            width = -len(same_metric)-1
            rename = {column: column[:width] for column in df.columns}
            df = df.rename(columns=rename)
            df = df.sort_index()

            try:
                os.mkdir(save_path)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise

            save_path_metric = save_path + "/" + same_metric


            # Crea la carpeta para la metrica 
            try:
                os.mkdir(save_path_metric)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise

            if axis == 1:
                path_to_save = save_path_metric + "/metrics_global.csv"
            if axis == 0:
                path_to_save = save_path_metric + "/results_global.csv"
            df.to_csv(path_to_save)

            # Sigue con la siguiente metrica
            i_partida = i
            same_metric = columns[i].split()[-1]
    df = df_best_metrics.iloc[:,i_partida:]
    width = -len(same_metric)-1
    rename = {column: column[:width] for column in df.columns}
    df = df.rename(columns=rename)
    df = df.sort_index()

    try:
        os.mkdir(save_path)
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

    save_path_metric = save_path + "/" + same_metric

    try:
        os.mkdir(save_path_metric)
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

    if axis == 1:
        path_to_save = save_path_metric + "/metrics_global.csv"
    if axis == 0:
        path_to_save = save_path_metric + "/results_global.csv"
    df.to_csv(path_to_save)

def save_best_metrics(df: pd.DataFrame, save_path: str, axis: int):

    '''
    Guarda un dataframe la frecuencia con que cada modelo se consideró el mejor según 
    la métrica objetivo.

    Parameters
    ----------
    df: pd.DataFrame
        Dataframe que contiene todos los valores de los modelos y sus respectivas métricas
    
    axis: int
        Indica el tipo de archivo con el que se está trabajando. Metrics es equivalente 
        a axis = 1 y Results axis = 0.
    
    save_path: str
        Indica el path donde se guardarán la frecuancia de los mejores modelos según las metricas.


    '''

    df_best_model_metric, best_values = best_result_by_metric(df, axis = axis)
    count_models_by_metrics = count_models_by_metric(df_best_model_metric)
    if axis == 1:
        save_metrics_count = save_path + "/metrics_best_model_frequency.csv"
        save_best_values = save_path + "/metrics_best_values.csv"
    if axis == 0:
        save_metrics_count = save_path + "/results_best_model_frequency.csv"
        save_best_values = save_path + "/results_best_values.csv"

    count_models_by_metrics.to_csv(path_or_buf=save_metrics_count)
    best_values.to_csv(path_or_buf=save_best_values, index=False)

def divide_by_class(df: pd.DataFrame, path_item: str, save_path: str, axis: int):

    '''
    Divide el dataframe de resultados en las diferentes clasificaciones (Lumpy, Smooth, 
    Erratic o Intermittent).

    Parameters
    ----------

    df: pd.DataFrame
        Dataframe que contiene todos los valores de los modelos y sus respectivas métricas
    
    path_item: str
        Dirección donde se encuentra el csv item_classes.csv donde se clasifican las series de tiempo
    
    save_path: str
        Dirección se crearán las carpetas donde se guardarán los dataframes divididos 
        por clase.

    axis: int
        Indica el tipo de archivo con el que se está trabajando. Metrics es equivalente 
        a axis = 1 y Results axis = 0.
    

    '''

    item_class_path = path_item + "/item_classes.csv"
    df_item_classes = pd.read_csv(item_class_path)
    path_to_save = save_path + "/_Results_by_class"

    classes = np.unique(df_item_classes['class'])

    try:
        os.mkdir(path_to_save)
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

    for item_class in classes:


        item_list_by_class = df_item_classes[df_item_classes['class'] == item_class]['item'].to_numpy()
        bool_list = np.array([False for i in range(len(df.index))])

        for item_by_class in item_list_by_class:

            # Se obtiene la lista de bools para cada item
            bool_list_item = (df['item'] == item_by_class).to_numpy()
            bool_list |= bool_list_item
        
        df_by_class = df[bool_list]

        class_path_folder = path_to_save + "/" + item_class
        class_path_save = class_path_folder + ".csv"

        # Se crea una carpeta para cada resultado por clase
        try:
            os.mkdir(class_path_folder)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        df_by_class.to_csv(class_path_save, index=False)

        # Se guardan las mejores metricas
        save_best_metrics(df_by_class, class_path_folder, axis = axis)

def evaluate_metric(metric: str, lista: list) -> int:
    '''
    Evalua una lista de valores según cada métrica
    
    Parameters
    ----------
    metric: str
        Métrica que se utiliza para comparar
    
    lista: list
        Lista de valores a evaluar según cada métrica
    
    Returns
    -------

    pos_best_metric: int
        Posición de la columna del mejor valor según cada métrica
    '''

    if metric == 'rmse' or metric == 'smape':
        pos_best_metric = np.argmin(lista)
    return pos_best_metric

def search_metrics_by_row_metrics(columns: list, df: pd.DataFrame, distance_between_same_metrics: int):

    '''

    Busca por las metricas a utilizar del archivo metrics_merged.csv

    Parameters
    ----------

    columns: list
        Lista de columnas
    
    df: pd.DataFrame
        Dataframe original que se está evaluando

    distance_between_same_metrics: int
        Distancia entre las métricas
        
    Returns
    -------

    list_best_model_metric_result: list
        Lista con los mejores modelos por fila

    list_name_metric:
        Nombre de las métricas consideradas   
'''

    list_name_metric = []
    list_best_model_metric_result = []
    list_best_model_metric_result_temp = []
    list_best_model_value_result = []
    list_best_model_value_result_temp = []

    # Nos aseguramos que los nombres value de las columnas sean los unicos que se consideren

    value_to_value = 0 
    
    while columns[value_to_value].split()[0] != columns[-1].split()[0]:
        value_to_value+=1

# Se iterará por columna del Dataframe
    for metric_row in range(len(df.index)):
        metric = df['metric'].iloc[metric_row]

        if metric == 'rmse' or metric == 'smape':

            if metric_row < distance_between_same_metrics:
                list_name_metric.append(metric)

            lista_metrics = df.iloc[metric_row][value_to_value:]
            #Aqui se debe poner una funcion para definir la mejor métrica, se pone de ejemplo la rmse con ser menor
            pos_best_metric_result = evaluate_metric(metric, lista_metrics)
            model_best_metric_result_col = columns[pos_best_metric_result + value_to_value]
            model_best_metric_result = columns[pos_best_metric_result + value_to_value].split()[-1]
            model_best_value_result = df[model_best_metric_result_col].iloc[metric_row]
            list_best_model_metric_result_temp.append(model_best_metric_result)
            list_best_model_value_result_temp.append(model_best_value_result)

        if distance_between_same_metrics != 0:
            if ((metric_row + 1)%distance_between_same_metrics) == 0:
                list_best_model_metric_result.append(list_best_model_metric_result_temp)
                list_best_model_value_result.append(list_best_model_value_result_temp)

                list_best_model_metric_result_temp = []
                list_best_model_value_result_temp = []

        if distance_between_same_metrics == 0:
            if metric == 'rmse' or metric == 'smape':
                list_name_metric.append(metric)
            if metric_row + 1 == len(df.index):
                list_best_model_metric_result.append(list_best_model_metric_result_temp)
                list_best_model_value_result.append(list_best_model_value_result_temp)


    return list_best_model_metric_result,list_name_metric,list_best_model_value_result

def search_metrics_by_row_result(columns: list, row: pd.DataFrame, distance_between_same_metrics: int):
    
    '''

    Busca por las metricas a utilizar del archivo results_merged.csv

    Parameters
    ----------

    columns: list
        Lista de columnas
    
    row: pd.DataFrame
        Fila del dataframe original que se está evaluando

    distance_between_same_metrics: int
        Distancia entre las métricas
        
    Returns
    -------

    list_best_model_metric_result: list
        Lista con los mejores modelos por fila

    list_name_metric:
        Nombre de las métricas consideradas   
    '''

    
    column_width = len(columns)
    list_name_metric = []
    list_best_model_metric_result = []
    list_best_model_value_result = []

    for pos_metric in range(distance_between_same_metrics):

        # Se crea la lista para obtener la posición y obtener el modelo
        lista_metrics = []
        distance_traveled = distance_between_same_metrics

        metric = columns[-pos_metric-1].split()[0]


        # Se deja abierta a la posibilidad de usar las demás métricas
        if metric == 'rmse' or metric == 'smape':
            
            value_metric = row[-pos_metric-1]
            lista_metrics.append(value_metric)

            # Se define igual a la priemra para ocupar la condicion del while
            next_metric = metric

            while metric == next_metric and distance_traveled + pos_metric + 1 < column_width:
                next_metric = columns[-distance_traveled-pos_metric-1].split()[0]
                value_next_metric = row[-distance_traveled-pos_metric-1] 
                distance_traveled += distance_between_same_metrics             
                lista_metrics.append(value_next_metric)
            
            #Aqui se debe poner una funcion para definir la mejor métrica, se pone de ejemplo la rmse con ser menor
            pos_best_metric_result = evaluate_metric(metric, lista_metrics)
            model_best_metric_result_col = columns[-distance_between_same_metrics*pos_best_metric_result-pos_metric-1]
            model_best_metric_result = columns[-distance_between_same_metrics*pos_best_metric_result-pos_metric-1].split()[-1]
            model_best_value_result = row[model_best_metric_result_col]
            list_name_metric.append(metric)
            list_best_model_metric_result.append(model_best_metric_result)
            list_best_model_value_result.append(model_best_value_result)

    return list_best_model_metric_result,list_name_metric, list_best_model_value_result

def best_result_by_metric(df: pd.DataFrame, axis: int) -> pd.DataFrame:

    '''
    Parameters
    ----------
    
    df: pd.DataFrame
        Dataframe original que se está evaluando
    
    axis: int
        Indica el tipo de archivo con el que se está trabajando. Metrics es equivalente 
        a axis = 1 y Results axis = 0.
    
    Returns
    -------
    df_best_model_metric: pd.DataFrame
        Dataframe con el mejor modelo según cada punto de comparación.
    '''

    columns = df.columns
    model_list = []
    values_list = []

    distance_between_same_metrics = distance_between_metrics(df, axis)

    if axis == 0: #Results
        for rows in range(len(df.index)):
            row = df.iloc[rows]
            best_model_by_row, name_metric,best_value = search_metrics_by_row_result(columns=columns, row=row, distance_between_same_metrics=distance_between_same_metrics)
            model_list.append(best_model_by_row)
            values_list.append(best_value)
            items = df['item'].to_numpy()
    

    if axis == 1: #Metrics
        model_list,name_metric,values_list = search_metrics_by_row_metrics(columns=columns, df=df, distance_between_same_metrics=distance_between_same_metrics)
        unique_items = np.unique(df['item'])
        items_num = (len(df.index)//len(unique_items))//len(np.unique(df['metric']))
        items = []
        for item in unique_items:
            items.extend([item]*items_num)

    df_best_model_metric = pd.DataFrame(data=model_list, columns=name_metric)
    df_best_values_metric = pd.DataFrame(data=values_list, columns=name_metric)
    df_best_values_metric['item'] = items

    return df_best_model_metric, df_best_values_metric


def count_models_by_metric(df_best_model_metric: pd.DataFrame) -> pd.DataFrame:
    '''
    Calcula la cantidad de aparaciones como mejor modelo de cada métrica

    Parameters
    ----------

    df_best_model_metric: pd.DataFrame
        Dataframe con el mejor modelo según cada punto de comparación.
    
    Returns
    -------
    count_models_by_metrics: pd.DataFrame
        Dataframe que entrega la frecuencia de los mejores modelos según cada métrica

    '''


    columns = df_best_model_metric.columns

    assert len(columns) > 0

    # Lo hacemos porque sirve para hacer el indice de los modelos usados
    first_metric = columns[0]
    column_name = "model count by metric " + first_metric
    model, num = np.unique(df_best_model_metric[first_metric], return_counts=True)
    index = pd.Series(model)
    count_models_by_metrics = pd.DataFrame(data = num, columns=[column_name]).set_index(model)

    for column in range(1,len(columns)):
        metric = columns[column]
        column_name = "model count by metric " + metric
        count_models_by_metrics[column_name] = 0
        model, num = np.unique(df_best_model_metric[metric], return_counts=True)
        
        # HAy que revisar que la cantidad de métricas sean menores o iguales
        if len(model) <= len(count_models_by_metrics.index):

            for i in range(len(num)):
                count_models_by_metrics[column_name].loc[model[i]] = num[i]
        
        else: # Como la cantidad de modelos es mayor hay que agregarlo

            # Lista de modelos que no fueron añadidos anteriormente
            new_models = [new_model for new_model in model if new_model not in count_models_by_metrics.index]
            
            for new_model in new_models:
                count_models_by_metrics.loc[new_model] = 0
            
            # Luego se repite el proceso de agregar los datos
            for i in range(len(num)):
                count_models_by_metrics[column_name].loc[model[i]] = num[i]

    return count_models_by_metrics

def distance_between_metrics(df: pd.DataFrame, axis: int) -> int:

    '''
    Parameters
    ----------

    df: DataFrame
    Dataframe con las metricas a evaluadas

    axis: int
        Indica el tipo de archivo con el que se está trabajando. Metrics es equivalente 
        a axis = 1 y Results axis = 0.

    Returns
    -------

    distance_between_metrics: int
        Distancia entre las métricas
    '''
    if axis == 0: #Results
        # Se asume que la ultimas columnas son métricas unicamente
        column_list = df.columns
        metric = column_list[-1].split()[0]
        next_metric = ""
        distance_between_metrics = 0

        while metric != next_metric:
            distance_between_metrics+=1
            next_metric = column_list[-distance_between_metrics-1].split()[0]

    if axis == 1: # Metrics
        # Se asume que la ultimas columnas son métricas unicamente
        rows_list = df['metric']
        metric = rows_list.iloc[-1]

        next_metric = ""
        distance_between_metrics = 0

        while metric != next_metric:
            distance_between_metrics+=1
            if distance_between_metrics >= len(rows_list):
                distance_between_metrics = 0
                break 

            next_metric = rows_list.iloc[-distance_between_metrics-1]
    return distance_between_metrics

def merge_metrics_csv(path_directorio: str, save: bool = False, save_path: str = "") -> pd.DataFrame:
    
    '''
    
    Parameters
    ----------

    path_directorio: str
        Path del directorio donde se encuentran las sub carpetas con los diferentes modelos

    save: bool
        Booleano que indica si se quiere guardar el csv

    save_path: str
        Path del directorio donde se quiere guardar el arhcivo csv

    Returns
    -------
    df_merged: Dataframe
        Dataframe que contiene todas las métricas 

    '''

    directorios = pathlib.Path(path_directorio)
    inicial = True
    for carpeta in directorios.iterdir():
        carpeta = str(carpeta)

        if ("." not in carpeta) and ("_Results" not in carpeta):
            last_carpet = carpeta
            model = carpeta.split("/")[-1]
            value_model = "value " + model
            metric_path = carpeta + "/metrics.csv"
            df = pd.read_csv(metric_path)

            if inicial:
                df_merged = df[['item', 'metric']]
                inicial = False
            df_series_model = df.rename(columns={"value": value_model})[value_model]
            df_merged = pd.concat([df_merged,df_series_model], axis=1)

    if save:

        # Se guardan los datos originales
        save = save_path + "/metrics_merged.csv"
        df_merged.to_csv(path_or_buf=save, index=False)

        # Se guardan los datos a estudiar
        save_best_metrics(df_merged, save_path, axis = 1)
        divide_by_class(df_merged,last_carpet,save_path, axis = 1)
    
    return df_merged


def merge_results_csv(path_directorio: str, save: bool = False, save_path: str = "") -> pd.DataFrame:
    
    '''
    
    Parameters
    ----------

    path_directorio: str
        Path del directorio donde se encuentran las sub carpetas con los diferentes modelos

    save: bool
        Booleano que indica si se quiere guardar el csv

    save_path: str
        Path del directorio donde se quiere guardar el arhcivo csv

    Returns
    -------
    df_merged: Dataframe
        Dataframe que contiene todas las métricas 

    '''

    directorios = pathlib.Path(path_directorio)
    inicial = True
    
    for carpeta in directorios.iterdir():
        carpeta = str(carpeta)

        if ("." not in carpeta) and ("_Results" not in carpeta):
            last_carpet = carpeta
            model = carpeta.split("/")[-1]
            metric_path = carpeta + "/results.csv"
            df = pd.read_csv(metric_path)
            non_metrics_columns = ['date','item','model', 'units', 'lower', 'upper']
            metrics_columns = [metrics for metrics in df.columns if metrics not in non_metrics_columns]
            df = df.rename(columns={metrics: metrics + " " + model for metrics in metrics_columns})

            if inicial:
                df_merged = df[['date','item']]
                inicial = False
            df_series_model = df[[metrics + " " + model for metrics in metrics_columns]]
            df_merged = pd.concat([df_merged,df_series_model], axis=1)   

    df_merged = df_merged.dropna(axis=0,how = 'any')

    if save:

        # Se guardan los datos originales
        save = save_path + "/results_merged.csv"
        df_merged.to_csv(path_or_buf=save, index=False)

        # Se guardan los datos a estudiar
        save_best_metrics(df_merged, save_path, axis = 0)
        divide_by_class(df_merged,last_carpet,save_path, axis = 0)
    
    
    return df_merged

def dagshub_experiments_visualize(row_experiment_df: pd.DataFrame, from_csv: int, columns: list,tsa_class: str) -> None:
    nombre = row_experiment_df.name
    display(row_experiment_df.name)

    local_path_metrics = LOCAL_PATH + ("/Visualize dvc/%s/%s_metrics.csv" % (tsa_class,nombre))
    local_path_hparams = LOCAL_PATH + ("/Visualize dvc/%s/%s_metrics.yml" % (tsa_class,nombre))


    with dagshub.dagshub_logger(metrics_path=local_path_metrics, hparams_path=local_path_hparams) as logger:
        for column in columns:
            logger.log_metrics({column: row_experiment_df[column]})
        logger.log_hyperparams({'tsa_class': tsa_class})
        logger.log_hyperparams({'from_csv': from_csv})
        logger.save() 
        logger.close()


























def Git_path():
    path_data = os.path.abspath(os.getcwd())
    actual = 0
    while actual != -1:
        # Queremos conocer saber la ultima carpeta de timeseries-experiments en el GitHub
        hasta = actual    
        # Buscamos en el path el ultimo timeseries-experiments del GitHub
        actual = path_data[actual:].find("timeseries-experiments")
        if actual != -1:
            actual+= len("timeseries-experiments")
    # Obtenemos el path
    path_data = path_data[:hasta]
    return path_data

def obtencion_dataframes():
    '''
    Se leen todos los archivos csv por cada clase de cada dataset
    '''
    df_per_dataset = []
    git_path = Git_path()
    datasets_dir = glob.glob(git_path + "/datasets/*_dataset")
    len_dirs = len(datasets_dir)
    data_type = ['Lumpy','Smooth', 'Erratic','Intermittent']   
    
    for i in range(1,len_dirs+1,1):
        each_dataset = []
        path = git_path + "/datasets/%d_dataset/%d_data_classes/*.csv" %(i,i)
        csv_list_path = glob.glob(path)
        path = git_path + "/datasets/%d_dataset/%d_data_classes/" %(i,i)
        csv_list = [_path.split("/")[-1][:-4] for _path in csv_list_path]  
        for csv in range(len(data_type)):
            if data_type[csv] in csv_list:
                csv_path = path + data_type[csv] + ".csv"
                df = pd.read_csv(csv_path)
                each_dataset.append(df)
            else:
                df = pd.DataFrame()
                each_dataset.append(df)

        df_per_dataset.append(each_dataset)
    return df_per_dataset

def target_date_tsa():
    '''
    Se obtiene la variable objetivo de cada dataset
    '''
    target_tsa_list = []
    date_tsa_list = []
    git_path = Git_path()
    datasets_dir = glob.glob(git_path + "/datasets/*_dataset")
    len_dirs = len(datasets_dir)

    for i in range(1,len_dirs+1,1):
        path = git_path + "/datasets/%d_dataset/*.json" %i
        path = glob.glob(path)
        with open(path[0]) as dic:
            dic_json = json.load(dic)
        str_target = dic_json['state']['data']['input']['required']['transactional']['targets']
        str_date = dic_json['state']['data']['input']['required']['transactional']['date']
        target_tsa_list.append(str_target[0])
        date_tsa_list.append(str_date)
    return target_tsa_list, date_tsa_list

def sample_method(array_date):
    sampling_method = ["year","month","weekly"]
    date_1 = array_date.iloc[0]
    date_2 = array_date.iloc[1]

    sample_1 = np.array([int(date_1[0:4]),int(date_1[5:7]),int(date_1[8:10])])
    sample_2 = np.array([int(date_2[0:4]),int(date_2[5:7]),int(date_2[8:10])])
    sample_date = sample_2 - sample_1

    for time in reversed(range(len(sample_date))):
        if sample_date[time] != 0:
            method = sampling_method[time]
            break
    return method

def pd_date_fun(array_date):
    array_date.iloc[-1]
    month = int(array_date.iloc[-1][5:7]) + 1
    if month < 10:
        month = '0' + str(month)
    else:
        month = str(month)
    end_date = array_date.iloc[-1][0:5] + month + array_date.iloc[-1][7:]
    pd_date = pd.date_range(start = array_date.iloc[0], end= end_date, freq = 'M')
    return pd_date

def smoothing(model, target, date,smooth_level,smooth_trend):

    pd_date = pd_date_fun(date)

    data = pd.Series(np.array(target),pd_date)
    smooth = model(data, initialization_method="heuristic").fit(
        smoothing_level=smooth_level, optimized=False
    )
    smothing = np.array(smooth.fittedvalues)
    plt.plot(smothing)
    class_model = str(model)
    final = class_model.split(".")[4]
    legend = final[:-2]
    return legend

def matplot_tsa(df,type_tsa,target,date,i,smooth_level,smooth_trend,model_list):

    unique_item = np.unique(df['item'])

    for item in unique_item:
        df_unique = df[df['item'] == item]
        array_target = df_unique[target]
        array_date = df_unique[date]
        plt.figure(figsize=(10, 10))
        plt.xticks(rotation = 90)
        plt.plot(array_date,array_target)
        legenda = ['Original']
        for model in model_list:
            str_model = smoothing(model,array_target,array_date,smooth_level,smooth_trend)
            legenda.append(str_model)
        method = sample_method(array_date)
        plt.xlabel("Sample per " + method)
        title = "Comportamiento %s para el item %s dataset %d" %(type_tsa,item,i)
        plt.title(title)
        plt.legend(legenda)
        plt.show()

def plot_tsa(dataset_begin,dataset_end,types_tsa,smooth_level,smooth_trend,model_list):

    target_list,date_list = target_date_tsa()
    git_path = Git_path()

    for i in range(dataset_begin,dataset_end + 1,1):
        for type_tsa in types_tsa:
            path = git_path + "/datasets/%d_dataset/%d_data_classes/%s/*.csv" %(i,i,type_tsa)
            path_list = glob.glob(path)
            for paths in path_list:
                df = pd.read_csv(paths)
                target = target_list[i-1]
                date = date_list[i-1]
                matplot_tsa(df,type_tsa,target,date,i,smooth_level,smooth_trend,model_list)

def feature_extractor_tsfresh(df,target,date):
    features = extract_features(df[[target,'item',date]],column_id='item',column_sort=date)
    return features

def feature_extractor_kats(df,target_column):
    warnings.filterwarnings("ignore")
    model = TsFeatures()
    df['value'] = df[target_column]
    item_list = np.unique(df['item'])


    output_features = [model.transform(df[df['item'] == item]) for item in item_list]
    df_features = pd.DataFrame(output_features)
    df_features['item'] = item_list
    df_features = df_features.set_index('item')
    return df_features


def Fourier_transform(df_per_dataset, date_list, target_list, dataset_inicial,dataset_final, plot_data = True, visual_data = 1):
    '''
    df_per_dataset: list
    Contiene una lista de dataframes de cada dataset a predecir de cada empresa

    date_list: List
    Lista con los nombres de las columna donde se encuentran las fecha del dataset a predecir

    target_list: List
    Lista con los nombres de las columna donde se encuentran las variables objetivo del dataset a predecir

    dataset_inicial: Int
    Equivalente al i del i_dataset con el que se quiere empezar, es decir, si i = 1, se empieza por 1_dataset a iterar

    dataset_final: Int
    Equivalente al i del i_dataset con el que se quiere terminar, es decir, si i = 11, se termina en el 11_dataset

    Plot_data: bool
    Cuando es True, genera un plot con el dato que se quiera ver con visual_data

    visual_data: Int
    Indica la posición del item que se quiere plotear por cada tipo de serie de tiempo
    '''


    # Dataset para trabajar

    df_fft_per_dataset = []

    # Obtener ID

    lista_id = obtener_id()

    for i in tqdm(range(dataset_inicial,dataset_final+1), "Dataset transformados"):
        i_dataset = i

        # Tipo de serie

            # lumpy = 0
            # smooth = 1
            # erratic = 2
            # inttermitent = 3
        data_type = ['Lumpy','Smooth', 'Erratic','Intermittent']   
        # Dataframe a utilizar

        df_fft_i_dataset = pd.DataFrame(columns=['Date/frecuency', 'Item', 'Value', 'Type','ID'])


        for tsa_type in range(4):
            df = df_per_dataset[i_dataset-1][tsa_type]
            if len(df) > 0:
                df_type = data_type[tsa_type]
                df = df_per_dataset[i_dataset-1][tsa_type]
                df_date = date_list[i_dataset-1]
                df_target = target_list[i_dataset-1]
                item_list = np.unique(df['item'])

                df_fft_per_dataset_temporal = Fourier_transform_architecture(df, df_date, df_target, item_list, df_type, i_dataset, plot_data, visual_data, lista_id[i_dataset-1])
                df_fft_i_dataset = pd.concat([df_fft_i_dataset,df_fft_per_dataset_temporal])
        df_fft_per_dataset.append(df_fft_i_dataset)
        
        # Guardamos los datos
        nombre = "%d_dataset_timeseries_FFT_only" %i_dataset
        guardar_datos_csv(df_fft_i_dataset,nombre)


    return df_fft_per_dataset

def Fourier_transform_architecture(df, df_date, df_target, item_list, df_type, i_dataset, plot_data = True, visual_data = 1, id_from_list = ''):
    dato_actual = 0
    plot = False

    
    df_fft = pd.DataFrame(columns=['Date/frecuency', 'Item', 'Value', 'Type','ID'])

    for item in item_list:
        dato_actual+=1
        df_fft_temporal = pd.DataFrame(columns=['Date/frecuency', 'Item', 'Value', 'Type','ID'])
        
        df_dummy = df[df['item'] == item]
        target_df = df_dummy[df_target]
        fliter_target_values_trend = savgol_filter(target_df,11,1)
        fliter_target_values_detrend = target_df - fliter_target_values_trend  

        # Amplitud     
        y_fft_df = np.fft.fft(fliter_target_values_detrend)
        y_abs_fft_df = abs(y_fft_df[:len(fliter_target_values_detrend)//2])
        

        # Máximo peak arbitrario
        max_height_peak = (max(y_abs_fft_df) - min(y_abs_fft_df))//2
        max_height_peak_mean = (np.mean(y_abs_fft_df))//2

        # Frecuencia
        x_fft_df = np.fft.fftfreq(len(fliter_target_values_detrend))
        x_abs_fft_df = x_fft_df[:len(fliter_target_values_detrend)//2]

        # Detectar peaks
        indices_peaks = detect_peaks(y_abs_fft_df, mph=max_height_peak)
        indices_peaks_mean = detect_peaks(y_abs_fft_df, mph=max_height_peak_mean)
        
        

        # Rellenamos el data frame temporal
        df_fft_temporal['Date/frecuency'] = x_abs_fft_df
        df_fft_temporal['Item'] = item
        df_fft_temporal['Value'] = y_abs_fft_df
        df_fft_temporal['Type'] = df_type
        df_fft_temporal['ID'] = id_from_list
        




        df_fft = pd.concat([df_fft,df_fft_temporal])

        if plot_data:
            # Caso que se encuentra el dato que se quiere mostrar
            if dato_actual == visual_data:
                fft_plot(x_abs_fft_df, y_abs_fft_df, indices_peaks_mean, indices_peaks, i_dataset, df_type, item)
                plot = True

            # Caso que el largo es mayor
            if len(item_list) > visual_data and plot == False:
                fft_plot(x_abs_fft_df, y_abs_fft_df, indices_peaks_mean, indices_peaks, i_dataset, df_type, item)
                plot = True

    return df_fft

def fft_plot(x_abs_fft_df, y_abs_fft_df, indices_peaks_mean, indices_peaks, i_dataset, df_type, item):
    fig, ax = plt.subplots(figsize=(7,7))
    ax.plot(x_abs_fft_df,y_abs_fft_df)
    ax.scatter(x_abs_fft_df[indices_peaks_mean], y_abs_fft_df[indices_peaks_mean], color='blue',marker='D')
    ax.scatter(x_abs_fft_df[indices_peaks], y_abs_fft_df[indices_peaks], color='red',marker='D')
    # fig.legend(['FFT', 'Peak mean','peak range'])
    title = "Transformada de fourier %d_dataset_%s para item %s" %(i_dataset,df_type, item)
    plt.title(title)
    plt.xlabel("Frecuencia")
    plt.ylabel("Amplitud")
    
    
    for idx in indices_peaks:
        x,y = x_abs_fft_df[idx], y_abs_fft_df[idx]
        text = "  f = {:.2f}".format(x,y)
        ax.annotate(text, (x,y))
    
    for idx in indices_peaks_mean:
        x,y = x_abs_fft_df[idx], y_abs_fft_df[idx]
        text = "  f = {:.2f}".format(x,y)
        ax.annotate(text, (x,y))

def obtener_id():
    '''
    Se obtiene la variable objetivo de cada dataset
    '''
    id_tsa_list = []
    git_path = Git_path()
    datasets_dir = glob.glob(git_path + "/datasets/*_dataset")
    len_dirs = len(datasets_dir)

    for i in range(1,len_dirs+1,1):
        path = git_path + "/datasets/%d_dataset/*.json" %i
        path = glob.glob(path)
        with open(path[0]) as dic:
            dic_json = json.load(dic)
        str_id = dic_json['id']
        id_tsa_list.append(str_id)
    return id_tsa_list


def guardar_datos_csv(df_to_save,nombre):
    df_to_save.to_csv(nombre + ".csv")