#PRIMERO----> EJECUTAMOS LA LECTURA DE LAS lx DE DIFERENTES TABLAS import pandas as pd…
- 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 dfif 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
- 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:
-
Asegúrate de que, además de las probabilidades de muerte (
qx) ya importadas, también tienes importados los valores delambdapara cada edad (x) correspondientes a las mismas tablas. -
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.
-
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.indexasume 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) / 1000Aplica este código para cada DataFrame que quieras ajustar, asegurándote de utilizar los valores correctos para 'lambda' en cada caso.
-
- 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?
- Assistant
Para obligarte a proporcionar un año de nacimiento al utilizar las tablas generacionales, puedes modificar la clase
ActuarialTablepara que acepte un año de nacimiento como un parámetro obligatorio y luego utilice ese valor para calcular las nuevas probabilidadesq(x)según la fórmula dada. También tendrás que pasar la serie de valoreslambdapara 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
ActuarialTablesin 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. - 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?
- 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 claseActuarialTable: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, yexaplicando directamente la teoría actuarial a lasqxajustadas.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_basecomolambda_valuestienen el mismo índice y ese índice representa las edades de manera correcta para los cálculos delx,dx, etc. - User
puedes ajustar el último código diferenciando tablas que son generacionales (y necesitan el año nacimiento) y otras que no?
- Assistant
Para adaptar la clase
ActuarialTablepara 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_valuesy valores de año opcionalesbirth_yearybase_year. Silambda_valuesno 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 baseqx_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, yex) 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 deqx_baseylambda_values. - 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
- Assistant
El error
NameError: name 'non_generational_qx' is not definedindica que Python no puede encontrar una definición para la variablenon_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 definidonon_generational_qxantes de intentar crear la instancia deActuarialTable.Aquí tienes un ejemplo de cómo deberías definir
non_generational_qxantes de usarlo para crear una instancia deActuarialTable:# 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, comogenerational_qxylambda_values) con los datos apropiados de tu DataFrame antes de pasarla a la claseActuarialTable. 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.