Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· OpenAIAi2 WildChat-4.8M (AI2)

este código que escribo sirve para importar qx de diferentes tablas para después usarlas…

  1. User

    este código que escribo sirve para importar qx de diferentes tablas para después usarlas y calcular para cada una diferentes variables (siendo alguna de las tablas generacionales) PRIMERO----> EJECUTAMOS LA LECTURA DE LAS lx DE DIFERENTES TABLAS import pandas as pd

    class BiometricTableImporter: def init(self, file_path): self.file_path = file_path

    def import_table(self, sheet_name, usecols, skiprows, nrows):
        df = pd.read_excel(
            self.file_path,
            sheet_name=sheet_name,
            usecols=usecols,
            skiprows=skiprows,
            nrows=nrows
        )
        return df
    

    if name == "main": file_path = r"F:\1Assegurances\MUTUALITATS\MANUAL\2 NORMATIVA\5.-Taules actuarials\3bis.-Anexos Resolución de 17 de diciembre de 2020.xlsx"

    importer = BiometricTableImporter(file_path)
    
    # Parámetros para la primera tabla
    sheet_name1 = "Anexo 2.1"
    usecols1 = "C: E"
    skiprows1 = 7
    nrows1 = 121
    PERF2020_COL_1 = importer.import_table(sheet_name1, usecols1, skiprows1, nrows1)
    
    # Parámetros para la segunda tabla
    sheet_name2 = "Anexo 2.1"
    usecols2 = "G: I"
    skiprows2 = 7
    nrows2 = 121
    PERM2020_COL_1 = importer.import_table(sheet_name2, usecols2, skiprows2, nrows2)
    
    # Parámetros para la segunda tabla
    sheet_name3 = "Anexo 2.1"
    usecols3 = "M: O"
    skiprows3 = 7
    nrows3 = 121
    PERF2020_IND_1 = importer.import_table(sheet_name3, usecols3, skiprows3, nrows3)
    
    # Parámetros para la segunda tabla
    sheet_name4= "Anexo 2.1"
    usecols4 = "Q: S"
    skiprows4 = 7
    nrows4 = 121
    PERM2020_IND_1 = importer.import_table(sheet_name4, usecols4, skiprows4, nrows4)
    
    # Parámetros para la segunda tabla
    sheet_name5 = "Anexo 1.1"
    usecols5 = "C: D"
    skiprows5 = 7
    nrows5 = 121
    PERF2020_COL_2 = importer.import_table(sheet_name5, usecols5, skiprows5, nrows5)
    
    # Parámetros para la segunda tabla
    sheet_name6 = "Anexo 1.1"
    usecols6 = "E: F"
    skiprows6 = 7
    nrows6 = 121
    PERM2020_COL_2 = importer.import_table(sheet_name6, usecols6, skiprows6, nrows6)
    
    # Parámetros para la segunda tabla
    sheet_name7 = "Anexo 1.1"
    usecols7 = "H: I"
    skiprows7 = 7
    nrows7 = 121
    PERF2020_IND_2 = importer.import_table(sheet_name7, usecols7, skiprows7, nrows7)
    
    # Parámetros para la segunda tabla
    sheet_name8 = "Anexo 1.1"
    usecols8 = "J: K"
    skiprows8 = 7
    nrows8 = 121
    PERM2020_IND_2 = importer.import_table(sheet_name8, usecols8, skiprows8, nrows8)
    
    # Parámetros para la segunda tabla
    sheet_name9 = "Anexo 1.2 y Anexo 1.3"
    usecols9 = "B: B"
    skiprows9 = 7
    nrows9 = 121
    PASEF2020_GEN_2 = importer.import_table(sheet_name9, usecols9, skiprows9, nrows9)
    
    # Parámetros para la segunda tabla
    sheet_name10 = "Anexo 1.2 y Anexo 1.3"
    usecols10 = "C: C"
    skiprows10 = 7
    nrows10 = 121
    PASEM2020_GEN_2 = importer.import_table(sheet_name10, usecols10, skiprows10, nrows10)
    
    # Parámetros para la segunda tabla
    sheet_name11 = "Anexo 1.2 y Anexo 1.3"
    usecols11 = "E: E"
    skiprows11 = 7
    nrows11 = 121
    PASEF2020_DEC_2 = importer.import_table(sheet_name11, usecols11, skiprows11, nrows11)
    
    # Parámetros para la segunda tabla
    sheet_name12 = "Anexo 1.2 y Anexo 1.3"
    usecols12 = "F: F"
    skiprows12 = 7
    nrows12 = 121
    PASEM2020_DEC_2 = importer.import_table(sheet_name12, usecols12, skiprows12, nrows12)
    
    # Parámetros para la segunda tabla
    sheet_name13 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols13 = "B: B"
    skiprows13 = 7
    nrows13 = 121
    PASEF_REL_1 = importer.import_table(sheet_name13, usecols13, skiprows13, nrows13)
    
    # Parámetros para la segunda tabla
    sheet_name14 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols14 = "C: C"
    skiprows14 = 7
    nrows14 = 121
    PASEM_REL_1 = importer.import_table(sheet_name14, usecols14, skiprows14, nrows14)
    
    # Parámetros para la segunda tabla
    sheet_name15 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols15 = "E: E"
    skiprows15 = 7
    nrows15 = 121
    PASEF_NOREL_1 = importer.import_table(sheet_name15, usecols15, skiprows15, nrows15)
    
    # Parámetros para la segunda tabla
    sheet_name16 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols16 = "F: F"
    skiprows16 = 7
    nrows16 = 121
    PASEM_NOREL_1 = importer.import_table(sheet_name16, usecols16, skiprows16, nrows16)
    
    # Parámetros para la segunda tabla
    sheet_name17 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols17 = "H: H"
    skiprows17 = 7
    nrows17 = 121
    PASEF_DEC_1 = importer.import_table(sheet_name17, usecols17, skiprows17, nrows17)
    
    # Parámetros para la segunda tabla
    sheet_name18 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols18 = "I: I"
    skiprows18 = 7
    nrows18 = 121
    PASEM_DEC_1 = importer.import_table(sheet_name18, usecols18, skiprows18, nrows18)
    # Puedes continuar creando instancias para importar más tablas según sea necesario…
    
    # Y luego hacer algo con las tablas, como imprimir o procesarlas
    print(PERM2020_COL_1)
    print(PERF2020_COL_1)
    print(PERM2020_IND_1)
    print(PERF2020_IND_1)
    print(PERM2020_COL_2)
    print(PERF2020_COL_2)
    print(PERM2020_IND_2)
    print(PERF2020_IND_2)
    
    # Imprime los nombres de las columnas de PERF2020_COL_1
    print(PERF2020_COL_1.columns)
    
    # SEGUNDO-----> GENERAMOS TODAS LAS VARIABLES CON UNA TABLA DE LAS ANTERIORES
    import numpy as np
    import pandas as pd
    
    
    class ActuarialTable:
        def init(self, qx_base: pd.Series, lambda_values: pd.Series = None,
                 birth_year: int = None, base_year: int = None,
                 interest_rate: float = 0.03, l0: int = 100000):
            self.qx_base = qx_base / 1000  # qx_base should be in ‘per thousand’ unit
            self.is_generational = lambda_values is not None and birth_year is not None and base_year is not None
            self.interest_rate = interest_rate
            self.l0 = l0
    
            if self.is_generational:
                # Adjust based on birth year if it’s a generational table
                self.lambda_values = lambda_values
                self.birth_year = birth_year
                self.base_year = base_year
                self.qx = self.adjust_qx_by_birth_year()
            else:
                # Otherwise, use the base probabilities
                self.qx = self.qx_base
    
            self.lx = [self.l0]
            self.i = i  # Tasa de interés anual efectiva
            self.l0 = l0  # Población inicial de lx
            self.lx = [l0]  # Se inicializa con la población al inicio
            self.dx = [0.0] * len(self.qx)
            self.ex = [0.0] * len(self.qx)
            self.Dx = [0.0] * len(self.qx)
            self.Nx = [0.0] * len(self.qx)
            self.Cx = [0.0] * len(self.qx)
            self.Mx = [0.0] * len(self.qx)
            self.nEx = [0.0] * len(self.qx)
    
            # Llama al método que realiza los cálculos.
            self._calculate_actuarial_variables()
    
    
        def adjust_qx_by_birth_year(self):
            return self.qx_base * np.exp(-self.lambda_values * (self.birth_year + self.qx_base.index - self.base_year))
        def _calculate_actuarial_variables(self):
            n = len(self.qx)
    
            # Calcular lx y dx
            for x in range(1, n + 1):
                lx_previous = self.lx[x - 1]
                dx = lx_previous * self.qx[x - 1]
                self.dx[x - 1] = dx
                lx = lx_previous - dx
                self.lx.append(lx)
    
            # Calcular ex (expectativa de vida) para cada edad x
            self.ex[-1] = 0  # Última expectativa de vida es 0
            for x in reversed(range(n - 1)):
                lx_sum = sum(self.lx[x + 1:])
                self.ex[x] = lx_sum / self.lx[x]
    
            # Calcular Dx y Nx
            for x in range(n):
                if self.lx[x] > 0:
                    self.Dx[x] = self.lx[x] / ((1 + self.i) ** x)
            for x in range(n):
                self.Nx[x] = sum(self.Dx[x:])
    
            # Calcular Cx y Mx
            for x in range(n - 1):
                self.Cx[x] = self.dx[x] / ((1 + self.i) ** (x + 0.5))
            for x in range(n):
                self.Mx[x] = sum(self.Cx[x:])
    
            # Calcular nEx
            for x in range(n - 1):
                if self.Dx[x] > 0:
                    self.nEx[x] = self.Nx[x + 1] / self.Dx[x]
    
            # La última edad w es inicialmente desconocida, se calculará como 0 si lx es 0
            self.w = n + self.lx[n:].index(0) if 0 in self.lx[n:] else n
    
         
    
    
    # Create an instance for a non-generational table
    non_generational_actuarial_table = ActuarialTable(non_generational_qx)
    
    # Create an instance for a generational table (with birth year adjustment)
    generational_actuarial_table = ActuarialTable(generational_qx, lambda_values, birth_year, base_year)
    

    si lo ejecuto me da este error

    Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 248, in non_generational_actuarial_table = ActuarialTable(non_generational_qx) ^^^^^^^^^^^^^^^^^^^ NameError: name 'non_generational_qx' is not defined

  2. Assistant

    El error NameError: name 'non_generational_qx' is not defined indica que estás intentando crear una instancia de la clase ActuarialTable usando una variable llamada non_generational_qx que nunca fue definida o inicializada previamente en tu código. Similarmente, al final de tu código, también haces referencia a generational_qx, lambda_values, birth_year, y base_year, las cuales tampoco se definen en el fragmento de código proporcionado.

    Para resolver este error, necesitas definir e inicializar estas variables antes de usarlas para crear instancias de ActuarialTable. Por ejemplo, para arreglar el issue con non_generational_qx, necesitas obtener los datos qx relevantes de alguna de las tablas importadas y, seguramente, hacer algo similar para generational_qx, lambda_values, birth_year, y base_year dependiendo del contexto de tu trabajo. Esto podría ser a partir de los DataFrames que importaste anteriormente.

    Un ejemplo de esto podría ser (nota que este es solo un ejemplo y necesitarás ajustar los nombres de variables y operaciones a tus requisitos reales):

    # Suponiendo que 'PERF2020_COL_1' tiene los datos qx relevantes
    non_generational_qx = PERF2020_COL_1['qx_column_name']  # 'qx_column_name' debería ser reemplazado por el nombre verdadero de la columna
    
    # También debes definir las demás variables antes de intentar crear instancias de 'ActuarialTable'
    # Por ejemplo:
    lambda_values = None  # O tu valor real de lambda_values
    birth_year = None  # O tu valor real de birth_year
    base_year = None  # O tu valor real de base_year
    
    # Luego de que todas las variables requeridas estén definidas correctamente, puedes crear las instancias
    non_generational_actuarial_table = ActuarialTable(qx_base=non_generational_qx)
    
    # Y para una tabla generacional, asegúrate de tener los valores correctos en las variables antes de intentar esto
    generational_actuarial_table = ActuarialTable(qx_base=generational_qx, lambda_values=lambda_values, birth_year=birth_year, base_year=base_year)
    

    Por favor, ten en cuenta dos cosas importantes:

    1. Asegúrate de que los nombres de columnas utilizados (como 'qx_column_name') coincidan con los nombres reales de las columnas en tus DataFrames.

    2. Revisa la inicialización de ActuarialTable. En el código suministrado, el método __init__ está incorrectamente escrito como def init(self, ...). Debería ser def __init__(self, ...). Esto es crítico para que la inicialización de tu objeto funcione correctamente:

        def __init__(self, qx_base: pd.Series, lambda_values: pd.Series = None, 
                     birth_year: int = None, base_year: int = None, 
                     interest_rate: float = 0.03, l0: int = 100000):
            ...
    
  3. User

    ahora da este error Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 255, in non_generational_actuarial_table = ActuarialTable(qx_base=non_generational_qx) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 189, in init self.i = i # Tasa de interés anual efectiva

  4. Assistant

    El error que estás observando indica que en tu método __init__ de la clase ActuarialTable, intentas asignar un valor a self.i con self.i = i, pero el valor i no está definido en cualquier parte del método __init__ (ni se pasa como argumento al método). Este es un error bastante común cuando se olvida pasar variables o utilizar variables no definidas.

    Para solucionar este problema, necesitas asegurarte de que todas las variables que utilices dentro de __init__ y otros métodos sean definidas o pasadas correctamente. En este caso específico, parece que quisieras usar interest_rate en lugar de i, dado que interest_rate es un argumento del método __init__.

    Entonces, deberías reemplazar self.i = i por self.i = interest_rate, asumiendo que el objetivo es tener self.i como tu tasa de interés anual efectiva. Aquí te muestro el fragmento pertinente de código corregido:

    class ActuarialTable:
        def __init__(self, qx_base: pd.Series, lambda_values: pd.Series = None,
                     birth_year: int = None, base_year: int = None,
                     interest_rate: float = 0.03, l0: int = 100000):
            self.qx_base = qx_base / 1000  # qx_base debería estar en ‘por mil’
            self.is_generational = lambda_values is not None and birth_year is not None and base_year is not None
            self.i = interest_rate  # Corrección aquí: Usamos interest_rate en lugar de i
            # Resto del código...
    
    

    Asegúrate de revisar todo el código para otras posibles inconsistencias o lugares donde podrías estar usando variables incorrectas o no definidas. También es una buena práctica realizar la depuración paso a paso y el uso extensivo de impresiones (print statements) o un depurador para rastrear el flujo y los valores de tu código, especialmente cuando manejas varias variables y operaciones complejas.

  5. User

    ahora da este error Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\Lib\site-packages\pandas\core\indexes\base.py", line 3805, in get_loc return self._engine.get_loc(casted_key) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "index.pyx", line 167, in pandas._libs.index.IndexEngine.get_loc File "index.pyx", line 196, in pandas._libs.index.IndexEngine.get_loc File "pandas\_libs\hashtable_class_helper.pxi", line 7081, in pandas._libs.hashtable.PyObjectHashTable.get_item File "pandas\_libs\hashtable_class_helper.pxi", line 7089, in pandas._libs.hashtable.PyObjectHashTable.get_item KeyError: 'qx base 2019 en tanto por mil'

    The above exception was the direct cause of the following exception:

    Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 257, in non_generational_qx = PASEM_DEC_1["qx base 2019 en tanto por mil"] # en verde el título de la columna de las qx ~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\Lib\site-packages\pandas\core\frame.py", line 4090, in getitem indexer = self.columns.get_loc(key) ^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\Lib\site-packages\pandas\core\indexes\base.py", line 3812, in get_loc raise KeyError(key) from err KeyError: 'qx base 2019 en tanto por mil'

  6. Assistant

    El error KeyError: 'qx base 2019 en tanto por mil' que estás viendo indica que Pandas no puede encontrar una columna llamada 'qx base 2019 en tanto por mil' en el DataFrame PASEM_DEC_1. Esto suele suceder por varias razones, aquí te indico algunas y cómo podrías resolverlas:

    1. La columna no existe:

      • Verifica que el nombre de la columna sea exactamente igual al que aparece en tu DataFrame, incluidos espacios y mayúsculas. A veces, un espacio extra o una letra en mayúscula/minúscula donde no debe ser puede causar este error.
      • Utiliza print(PASEM_DEC_1.columns) para imprimir los nombres de columnas actuales del DataFrame y verificar cómo se llama exactamente la columna que intentas utilizar.
    2. Columnas no fueron correctamente importadas:

      • Si la columna 'qx base 2019 en tanto por mil' debería haberse importado de un archivo Excel, verifica que las opciones usecols, skiprows y demás parámetros en tu llamada a pd.read_excel() sean correctos para incluir dicha columna.
    3. El nombre de la columna contiene caracteres especiales o espacios adicionales:

      • A veces, el nombre de la columna en el DataFrame puede tener caracteres especiales o espacios al inicio/final que no son inmediatamente evidentes. Para manejar esto, es útil quitar espacios extras o verificar si hay caracteres inesperados.

    Si luego de revisar los puntos anteriores aún no logras identificar la causa del error, podrías intentar acceder a las columnas de manera diferente, por ejemplo, si tu columna está en la segunda posición podrías acceder a ella por índice en lugar de por nombre:

    non_generational_qx = PASEM_DEC_1.iloc[:, 1]  # Cambia '1' por el índice real de tu columna.
    

    Recuerda, siempre es buena idea verificar los datos que tienes importados antes de procesarlos. Puedes hacer un simple print(PASEM_DEC_1.head()) para ver las primeras filas de tu DataFrame y verificar que la estructura es la que esperas, incluyendo nombres de columnas.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.