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

#PRIMERO----> EJECUTAMOS LA LECTURA DE LAS lx DE DIFERENTES TABLAS import pandas as pd…

  1. User

    #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 pandas as pd
    
    class ActuarialTable:
        def __init__(self, qx: pd.Series, i: float, l0: int = 100000):
            self.qx = qx
            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 _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
    
    
    #Puedes    crear    una    instancia    de    ActuarialTable    y    pasarle    la    columna    relevante    del DataFrame    que
    #contiene    las    qx    y    la    tasa    de    interés:
    
    # Supongamos que PERF2020_COL_1 es un DataFrame con una columna ‘qx’ que tiene las probabilidades de muerte.
    qx_serie = PERF2020_COL_1["qx base 2012 en tanto por mil"].astype(float) / 1000  # Convierte a la forma qx/1000 si está en porcentajes.
    tasa_interes = 0.03  # Tasa de interés del 3%.
    
    actuarial_table = ActuarialTable(qx_serie, tasa_interes)
    
    # Ahora puedes acceder a los valores calculados:
    print(actuarial_table.qx)  # Originales
    print(actuarial_table.lx)  # Número de supervivientes al comienzo de cada edad
    print(actuarial_table.dx)  # Número de muertes
    print(actuarial_table.ex)  # Expectativas de vida
    # … y así sucesivamente para Dx, Nx, etc.
    

    ya tengo este código importando tablas y generando variables con las mismas, ahora necesito generar a partir de las tablas generacionales que las tengo importadas con q en año base 2012, otras tablas en base a esas que varian en función del año de naciomiento en base a esta fórmula                                 q( x ) = q base ( x ) * exp( -lambda ( x ) * ( Año nacimiento + x - Año base ) la lambda ya la tengo importada en el mismo frame que la qx de cada tabla

  2. Assistant

    Para calcular las nuevas probabilidades de muerte modificadas por el año de nacimiento utilizando la fórmula que has proporcionado, necesitarás hacer algunas modificaciones en tu código y asegurarte de que los datos necesarios están disponibles.

    Aquí hay una guía paso a paso de cómo podrías hacerlo:

    1. Asegúrate de que, además de las probabilidades de muerte (qx) ya importadas, también tienes importados los valores de lambda para cada edad (x) correspondientes a las mismas tablas.

    2. Identifica cuál es el "Año base" que se está utilizando para tus cálculos (por ejemplo, 2012) y decide el "Año de nacimiento" para el cual quieres calcular las nuevas probabilidades de muerte.

    3. Itera a través de las edades calculando las nuevas probabilidades de muerte (q(x)) usando la fórmula proporcionada.

    Aquí hay un ejemplo de código que muestra cómo podrías hacer estos cálculos:

    # Asumimos que tienes un DataFrame llamado df que tiene las siguientes columnas:
    # 'qx base 2012' y 'lambda', donde 'qx base 2012' están en porcentaje y 'lambda' en la unidad correcta.
    Año_base = 2012
    Año_nacimiento = 1990  # por ejemplo
    
    # Calcula el nuevo qx para cada edad x
    df['q(x)'] = df.apply(lambda row: row['qx base 2012 en tanto por mil'] * np.exp(-row['lambda'] * (Año_nacimiento + df.index - Año_base)), axis=1)
    

    Ahora, un factor importante a tener en cuenta es que tu DataFrame debe tener un índice numérico que represente las edades x. Si las edades no están en el índice, puedes adaptar el código para utilizar la columna de edad apropiada.

    Otro apunte es que el código df.index asume que las edades están en el índice del DataFrame y que comienzan en 0. Si las edades no comienzan en 0 o no están en el índice, debes ajustar el código para que coincida con la estructura de tu DataFrame.

    Finalmente, si 'qx base 2012' está en por mil como el ejemplo original, tendrás que dividirlo por 1000 antes de aplicar la fórmula, como ya hiciste en un paso anterior:

    df['qx base 2012 en tanto por mil'] = df['qx base 2012 en tanto por mil'].astype(float) / 1000
    

    Aplica este código para cada DataFrame que quieras ajustar, asegurándote de utilizar los valores correctos para 'lambda' en cada caso.

  3. User

    si quiero mejorar lo anterior y cuando vaya a utilizar las tablas generacionales, me obligue a darle un año de nacimiento para que las genere?

  4. Assistant

    Para obligarte a proporcionar un año de nacimiento al utilizar las tablas generacionales, puedes modificar la clase ActuarialTable para que acepte un año de nacimiento como un parámetro obligatorio y luego utilice ese valor para calcular las nuevas probabilidades q(x) según la fórmula dada. También tendrás que pasar la serie de valores lambda para cada edad.

    Aquí tienes un ejemplo de cómo puedes hacer estos cambios:

    import numpy as np
    import pandas as pd
    
    class ActuarialTable:
        def __init__(self, qx: pd.Series, lambda_values: pd.Series, birth_year: int, base_year: int, i: float, l0: int = 100000):
            self.qx_base = qx  # Probabilidades básicas qx del año base
            self.lambda_values = lambda_values  # Valores de lambda por edad
            self.birth_year = birth_year  # Año de nacimiento proporcionado por el usuario
            self.base_year = base_year  # Año base de las probabilidades qx
            self.i = i  # Tasa de interés anual efectiva
            self.l0 = l0  # Población inicial de lx
            # ... otras propiedades como en la versión original de ActuarialTable ...
    
            # Calculamos las qx ajustadas con el año de nacimiento antes de calcular las variables actuariales
            self.qx = self.adjust_qx_by_birth_year()
            self._calculate_actuarial_variables()
    
        def adjust_qx_by_birth_year(self):
            # Asumimos que las edades están en el índice de self.qx_base y self.lambda_values
            adjusted_qx = self.qx_base.astype(float).copy() / 1000  # Asumiendo que qx_base es en por mil
            for age in self.qx_base.index:
                lambda_value = self.lambda_values.loc[age]
                adjusted_qx.loc[age] *= np.exp(-lambda_value * (self.birth_year + age - self.base_year))
            return adjusted_qx
    
        # El resto del método _calculate_actuarial_variables() como antes...
    
    # Supongamos que tienes variables para qx y lambda_values ya importadas
    qx_serie = PERF2020_COL_1["qx base 2012 en tanto por mil"]  # Asumiendo que esto es una pd.Series con el índice correcto
    lambda_values = PERF2020_COL_1["lambda"]  # Asumiendo que esto es una pd.Series con el mismo índice que qx_serie
    
    # Tasa de interés del 3%.
    tasa_interes = 0.03
    
    # Ahora, al crear una instancia, debes proporcionar el año de nacimiento
    año_nacimiento_usuario = 1990  # Este valor lo proporcionaría el usuario
    año_base = 2012  # Año base de las probabilidades qx
    
    actuarial_table = ActuarialTable(qx_serie, lambda_values, año_nacimiento_usuario, año_base, tasa_interes)
    
    # Ahora puedes acceder a los valores calculados:
    print(actuarial_table.qx)  # Ajustados por el año de nacimiento
    # ... y así sucesivamente para lx, dx, etc.
    

    Con estas modificaciones, cuando intentes crear una instancia de ActuarialTable sin proporcionar un año de nacimiento, obtendrás un error que te recordará que debes proporcionarlo. Esto te obliga a tener en cuenta el año de nacimiento en tus cálculos actuariales.

  5. User

    se podría combinar el código que acabas de formular, con el código que ya tenía hecho con el calculo de lx, mx, etc... para que cuando genere las tablas, ya lo haga con todas las variables en función del año nacimiento?

  6. Assistant

    Claro, puedes combinar los códigos de tal manera que primero ajustes las probabilidades de muerte (q(x)) basadas en el año de nacimiento y luego utilices esas probabilidades ajustadas para calcular todas las variables actuariales (lx, dx, mx, etc.). Aquí tienes un ejemplo de código que combina ambos procesos en la clase ActuarialTable:

    import numpy as np
    import pandas as pd
    
    class ActuarialTable:
        def __init__(self, qx_base: pd.Series, lambda_values: pd.Series, birth_year: int, base_year: int, interest_rate: float, l0: int = 100000):
            self.qx_base = qx_base / 1000  # Asumiendo que qx_base está en tanto por mil
            self.lambda_values = lambda_values
            self.birth_year = birth_year
            self.base_year = base_year
            self.interest_rate = interest_rate
            self.l0 = l0
            # Realiza el ajuste de qx en función del año de nacimiento antes de los cálculos actuariales
            self.qx = self.adjust_qx_by_birth_year()
            self.lx = [self.l0]
            self.dx = []
            self.Nx = []
            self.Cx = []
            self.Dx = []
            self.Mx = []
            self.ex = []
            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):
            for x in range(1, len(self.qx) + 1):
                lx_previous = self.lx[x - 1]
                qx = self.qx.iloc[x - 1] if x - 1 < len(self.qx) else 0
                dx = lx_previous * qx
                self.dx.append(dx)
                lx = lx_previous - dx
                self.lx.append(lx)
                
                self.Nx.append(sum(self.lx[x:]))  # Nx es la suma de todos los lx a partir del actual
                self.Dx.append(lx / ((1 + self.interest_rate) ** x))  # Dx es el valor actual de lx
                self.Cx.append(dx / ((1 + self.interest_rate) ** (x - 0.5)))  # Cx es el valor actual de dx centrado
            
            self.Mx = np.cumsum(reversed(self.Cx))[::-1]  # Mx es la suma acumulada reversa de Cx
            self.ex = self.Nx / self.lx[:-1]  # Calculamos ex quitando el último elemento, que siempre será 0
    
    # Usamos el mismo ejemplo de los DataFrames qx_serie y lambda_values
    qx_serie = ...
    lambda_values = ...
    
    # Tasa de interés del 3%.
    interest_rate = 0.03
    # Año base y nacimiento para el ajuste
    base_year = 2012
    birth_year = 1990  # Este valor lo proporcionaría el usuario
    
    # Creamos la tabla actuarial
    actuarial_table = ActuarialTable(qx_serie, lambda_values, birth_year, base_year, interest_rate)
    
    # Ahora las propiedades de la instancia contienen los valores de las variables actuariales ajustados según el año de nacimiento
    print(actuarial_table.lx)  # Lista de lx ajustada
    # ... y así para dx, Cx, Dx, Mx, y ex.
    

    Este código combina el proceso de ajustar las probabilidades de muerte por el año de nacimiento con el cálculo de las variables actuariales. Se han incluido las propiedades de Nx, Dx, Cx, Mx, y ex aplicando directamente la teoría actuarial a las qx ajustadas.

    Es importante tener en cuenta que este es un código de ejemplo y hay que ajustarlo en función de la estructura exacta de tus DataFrames y del rango de edades que cubren tus tablas. Asegúrate de que tanto qx_base como lambda_values tienen el mismo índice y ese índice representa las edades de manera correcta para los cálculos de lx, dx, etc.

  7. User

    puedes ajustar el último código diferenciando tablas que son generacionales (y necesitan el año nacimiento) y otras que no?

  8. Assistant

    Para adaptar la clase ActuarialTable para manejar tanto tablas generacionales (que requieren el año de nacimiento) como tablas que no son generacionales, se puede incorporar una condición que determine si se aplicará el ajuste basado en el año de nacimiento.

    Aquí está el código revisado con esa capacidad:

    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.dx = []
            self.Nx = []
            self.Cx = []
            self.Dx = []
            self.Mx = []
            self.ex = []
            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):
            for x in range(1, len(self.qx) + 1):
                lx_previous = self.lx[x - 1]
                qx = self.qx.iloc[x - 1] if x - 1 < len(self.qx) else 0
                dx = lx_previous * qx
                self.dx.append(dx)
                lx = lx_previous - dx
                self.lx.append(lx)
    
                # Continue with the calculations for Nx, Cx, etc.
                # ...
    
            # Calculate ex and the rest of the values
            # ...
    
    # 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)
    

    En este código, he añadido un parámetro opcional lambda_values y valores de año opcionales birth_year y base_year. Si lambda_values no se proporciona, o si falta cualquiera de los años requeridos para el ajuste generacional, la tabla se tratará como no generacional y se utilizarán las probabilidades de muerte base qx_base. Si todos estos valores se proporcionan, se realiza el ajuste y se utiliza la fórmula de ajuste generacional.

    Al crear instancias de ActuarialTable, se determina automáticamente si es generacional o no según los parámetros suministrados. Esto permite a la clase manejar ambos tipos de tablas de manera flexible.

    Asegúrate de adaptar el código para calcular las variables correctas (Nx, Cx, Dx, Mx, y ex) según las necesidades de tus cálculos actuariales y la estructura exacta de tus DataFrames. También debes manejar correctamente si las edades están en el índice de qx_base y lambda_values.

  9. User

    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

  10. Assistant

    El error NameError: name 'non_generational_qx' is not defined indica que Python no puede encontrar una definición para la variable non_generational_qx. Esto normalmente ocurre cuando se hace referencia a una variable que no ha sido definida o importada adecuadamente. Asegúrate de que has definido non_generational_qx antes de intentar crear la instancia de ActuarialTable.

    Aquí tienes un ejemplo de cómo deberías definir non_generational_qx antes de usarlo para crear una instancia de ActuarialTable:

    # Digamos que tienes un DataFrame llamado non_generational_df que incluye una sola columna con 'qx' para una tabla no generacional
    non_generational_df = pd.DataFrame({'qx base': [0.01, 0.02, 0.03, ...]})
    non_generational_qx = non_generational_df['qx base']
    
    # Ahora puedes crear una instancia de ActuarialTable para una tabla no generacional como esta:
    non_generational_actuarial_table = ActuarialTable(non_generational_qx)
    
    # Del mismo modo, para una tabla generacional, asegúrate de que tienes definidas las variables para 'qx', 'lambda', 'birth_year' y 'base_year':
    generational_df = pd.DataFrame({
        'qx base': [0.01, 0.02, 0.03, ...],
        'lambda': [0.005, 0.006, 0.007, ...]
    })
    generational_qx = generational_df['qx base']
    lambda_values = generational_df['lambda']
    birth_year = 1990  # Año de nacimiento que proporciona el usuario
    base_year = 2012  # Año base para las probabilidades de 'qx'
    
    # Ahora puedes crear una instancia de ActuarialTable para una tabla generacional así:
    generational_actuarial_table = ActuarialTable(generational_qx, lambda_values, birth_year, base_year)
    

    Recuerda reemplazar los puntos suspensivos (...) con los valores reales de tu tabla de mortalidad. Además, dependiendo de cómo estén estructurados tus datos, es posible que necesites personalizar la forma en que extraes los datos de tu DataFrame para que coincida con estos ejemplos.

    Para resolver el problema específico que encuentras, necesitarás definir la variable non_generational_qx (y posiblemente otras variables también, como generational_qx y lambda_values) con los datos apropiados de tu DataFrame antes de pasarla a la clase ActuarialTable. Asegúrate de que todos los DataFrames y las Series que vas a usar en tu código ya estén definidos y contengan los datos esperados.