def estimate_cij(triangle, fjs, cijs_ferguson, i, j):
"""
Estima :math:`C_{i, j}` mediante el modelo Hovinen entendido como
el monto por concepto de incurridos en el período :math:`i` reportados
hasta :math:`j` períodos después.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param fjs: Array de tamaño :math:`J` donde el :math:`j`-ésimo elemento corresponde con el valor
estimado del factor de desarrollo :math:`f_j`.
:param cijs_ferguson: Matriz de tamaño :math:`I \\times J` donde la entrada :math:`i, j` corresponde
con la estimación de :math:`C_{i, j}` por parte del modelo Ferguson.
:param int i: Período en el que sucedió el siniestro. Toma valores desde 0 hasta :math:`I`.
:param int j: Cantidad de períodos transcurridos después de sucedido el siniestro hasta que fue reportado.
Toma valores desde 0 hasta :math:`J`.
:return: Si :math:`i+j \\leq I`, devuelve la posición :math:`i, j` de la matriz triangle. Si no, retorna
:math:`C_{i, j}^{Hov} = C_{i, I-i} + (1-\\beta_{I-i})C_{i, j}^{Fer}`
donde
:math:`\\beta_j=\\prod_{k=j}^{J-1}\\frac{1}{f_k}`,
:math:`C_{i, j}^{Hov}` es la estimación mediante el modelo Hovinen de :math:`C_{i, j}`,
y :math:`C_{i, j}^{Fer}` es la estimación mediante el modelo Ferguson de :math:`C_{i, j}`.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`i` no es un valor entero entre 0 e I.
+ El parámetro :math:`j` no es un valor entero entre 0 y J.
+ No se han calculado los suficientes valores de :math:`f_j`.
"""
I, J = get_matrix_dimensions(triangle)
assert i in range(I + 1), "Período de incurrido a estimar inválido"
assert j in range(J + 1), "Período de reportado a estimar inválido"
assert len(
fjs) + 1 > j, "Se requieren más fj's calculados para estimar cij"
if i + j <= I:
return triangle[i, j]
beta = prod(1.0 / fjs[I - i:J])
return triangle[i, I - i] + (1 - beta) * cijs_ferguson[i, j]
def estimate_hovinen(triangle, nus, variances):
"""
Estimación mediante el modelo Hovinen de :math:`C_{i, j}`.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param np.array nus:
Estimación *a priori* del parámetro :math:`\\nu_i`. Es una lista de tamaño :math:`J`, donde la :math:`i`-ésima entrada
es la estimación *a priori* por parte de un experto de :math:`C_{i, J}` (pago de siniestros incurridos en el período :math:`i`
reportados en el período :math:`J`) para :math:`i=I-J, I-J+1, \\cdots, I` .
:return: Salida estándar tal y como se describe en la sección :ref:`general_output`.
:Posibles errores:
+ La estimación es **NaN**: Las entradas requeridas de la matriz para estimar :math:`f_j` son cero (o casi todas cero).
"""
nus = np.array(nus, dtype=float)
variances = np.array(variances, dtype=float)
I, J = get_matrix_dimensions(triangle)
scale_factor, triangle = scale_triangle(triangle)
nus *= 1.0 / scale_factor
variances /= 1.0 * scale_factor**2
assert I == J, "Aún no se soportan matrices rectangulares."
assert len(
nus
) >= I, "Insuficientes estimaciones a priori para llevar a cabo la estimación con Ferguson"
fjs = np.array([fj(triangle, j) for j in range(J)])
cijs_ferguson = np.array([[
estimate_cij_ferguson(triangle, fjs, i_, j_, nus)
for j_ in range(J + 1)
] for i_ in range(I + 1)])
cijs = np.array([[
estimate_cij(triangle, fjs, cijs_ferguson, i, j) for j in range(J + 1)
] for i in range(I + 1)])
sigma_squares = np.array(
[sigma_square(triangle, fjs, j) for j in range(J)])
sjs = np.array([sj(triangle, j) for j in range(J)])
cijs_deviations_mack = np.array([[
cij_deviation_mack(cijs, fjs, sigma_squares, i, j)
for j in range(J + 1)
] for i in range(I + 1)])
est_errors_mack = np.array([
estimation_error_mack(triangle, fjs, sjs, sigma_squares, i, J)
for i in range(I + 1)
])
deviations_cijs = np.array([[
cij_deviation(cijs_deviations_mack, fjs, i, j) for j in range(J + 1)
] for i in range(I + 1)])
msep_mack = msep(est_errors_mack, cijs_deviations_mack[:, -1])
msep_ferguson = compute_ferguson_msep(triangle, fjs, nus, variances)
hovinen_msep = np.array([
msep_hovinen(fjs, msep_ferguson, msep_mack, deviations_cijs, i, I, J)
for i in range(I + 1)
])
estimation_errors_last = np.sqrt(hovinen_msep - deviations_cijs[:, -1]**2)
estimation_errors = np.empty((
I + 1,
J + 1,
))
estimation_errors[:, :-1] = np.nan
estimation_errors[:, -1] = estimation_errors_last
return gen_standard_output(scale_factor * cijs, fjs,
scale_factor * deviations_cijs)
def estimate_cij(triangle, fjs_, i, j):
"""
Estimador de :math:`C_{i, j}` interpretado como el pago acumulado de siniestros incurridos en el período :math:`i`
reportados hasta :math:`j` períodos después.
:param np.ndarray fjs_: Estimación de los factores de desarrollo :math:`f_j`. La lista fjs\_ debe
contener las entradas computadas de los parámetros :math:`f_j` desde 0 hasta :math:`j-1`, donde
se asume que la :math:`j`-ésima entrada de fjs\_ corresponde con :math:`f_j` (:math:`\\text{fjs_[j]} = f_j`).
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param int i: Período en el que sucedió el siniestro. Toma valores desde 0 hasta :math:`I`.
:param int j: Cantidad de períodos transcurridos después de sucedido el siniestro hasta que fue reportado.
Toma valores desde 0 hasta :math:`J`.
:return: Cuando :math:`i+j > I`, devuelve
:math:`C_{i,j} = C_{i, I-i}f_{I-i}\\cdots f_{j-1}`.
Cuando :math:`i+j \\leq I`, devuelve la posición :math:`i, j` de la matriz triangle.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`i` no es un valor entero entre 0 e I.
+ El parámetro :math:`j` no es un valor entero entre 0 y J.
+ No se han calculado los suficientes valores de :math:`f_j`.
+ La estimación es **NaN**: Las entradas requeridas de la matriz para estimar :math:`f_j` son cero (o casi todas cero).
"""
I, J = get_matrix_dimensions(triangle)
assert i in range(I + 1), "Período de incurrido a estimar inválido"
assert j in range(J + 1), "Período de reportado a estimar inválido"
assert len(
fjs_) + 1 > j, "Se requieren más fj's calculados para estimar cij"
if i + j <= I:
return triangle[i, j]
fjs = fjs_[I - i:j]
cij = triangle[i, I - i]
return prod(fjs) * cij
def single_payments_from_triangle(triangle):
"""
Calcula la matriz :math:`X` donde la entrada :math:`X_{i, j}` denota el pago por siniestros
incurridos en el período :math:`i` reportados :math:`j` períodos después. Mas información sobre la definición
de :math:`X_{i, j}` en la sección :ref:`notación <notacion>`. Esta función esta pensada para
calcular la matriz de pagos simples a partir de la matriz triángulo de datos, por lo que las entradas
desconocidas :math:`i+j > I` continuan siendo desconocidas y son cero.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:return: Matriz :math:`X` donde la :math:`i, j`-ésima entrada :math:`X_{i, j}` corresponde con
Si :math:`i+j\\leq I`, retorna
:math:`X_{i, j} = C_{i, j} - C_{i, j-1}`.
Si :math:`i+j > I`, retorna 0.
:Posibles errores:
+ **AssertionError**:
"""
I, J = get_matrix_dimensions(triangle)
triangle_shift = np.zeros(triangle.shape)
triangle_shift[:, 1:] = triangle[:, :-1]
xijs = triangle - triangle_shift
for i in range(I+1):
for j in range(J+1):
if i + j > I:
xijs[i, j] = 0
return xijs
def xijs_deviation(cijs, sigma_squares, fjs, deviations_cijs, i, j):
"""
Estima la desviación de :math:`X_{i,j}`.
:param np.ndarray cijs: Matriz del mismo tamaño que el :ref:`triángulo inicial <triangle_format>`
pero con los valores restantes ya estimados, y donde cada entrada corresponde con :math:`C_{i, j}`.
Como :math:`C_{i, j}` para :math:`i+j \leq I` son valores ya dados, estas entradas deben
ser iguales en ambas matrices (cijs y el :ref:`triángulo inicial <triangle_format>` ).
:param np.ndarray sigma_squares: Lista de tamaño :math:`J` de parámetros :math:`\\sigma_j`
para :math:`j = 0, 1\\cdots J-1` ya estimados.
:param np.ndarray fjs: Estimación de :math:`f_j`. La lista fjs debe
contener las entradas computadas de los parámetros :math:`f_j` desde 0 hasta j-1, donde
se asume que la :math:`j`-ésima entrada de fjs corresponde con :math:`f_j` (:math:`\\text{fjs[j]} = f_j`).
:param np.ndarray deviations_cijs: Matriz del mismo tamaño que la matriz cijs donde la entrada :math:`i, j` corresponde
con la desviación del parámetro :math:`C_{i, j}`
:param int i: Índice que indica el período de incurridos al cual se le va a estimar la desviación de :math:`x_{i, j}`.
Toma valores :math:`i=0, \cdots I`.
:param int j: Índice que indica el período de reportados al cual se le va a estimar la desviación de :math:`x_{i, j}`.
Toma valores :math:`j=0, \cdots J`.
:return: Cálculo de
:math:`\\text{desviación de } X_{i, j} = \\sqrt{\\sigma_{j-1}^2 C_{i, j-1} + (f_{j-1}-1)\\text{var}(C_{i, j-1})}`
"""
I, J = get_matrix_dimensions(cijs)
if i + j > I:
return np.sqrt(sigma_squares[j - 1] * cijs[i, j - 1] +
((fjs[j - 1] - 1) * deviations_cijs[i, j - 1])**2)
else:
return 0
def estimate_ferguson(triangle, nus, variances):
"""
Estima :math:`C_{i,j}` para :math:`i+j > I` con el modelo teórico Ferguson y los errores asociados a
la estimación.
Esta función primero estima los parámetros requeridos para estimar la matriz con los :math:`C_{i, j}` y los
errores asociados. Finalmente, llama a la función estimate_ferguson (respectivamente a las que estiman el error)
para estimar :math:`C_{i,j}`.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param nus: Estimación de parámetros :math:`\\nu_i` estimados a priori por un experto. La lista nus debe
contener las entradas computadas de los parámetros :math:`\\nu_i` desde 0 hasta :math:`I`, donde
se asume que la :math:`i`-ésima entrada de nus corresponde con :math:`\\nu_i` (:math:`\\text{nus[j]} = \\nu_j`).
:param variances: Estimación de varianzas :math:`\\text{var}_i` , una por cada elemento de la lista nus. El :math:`i`-ésimo elemento
de variances es interpretado como el error cometido por el experto al estimar la :math:`i`-ésima componente
de la lista nus.
:return: Salida estándar tal y como se describe en la sección :ref:`general_output`.
:Posibles errores:
+ La estimación es **NaN**: Las entradas requeridas de la matriz para estimar :math:`f_j` son cero (o casi todas cero).
"""
nus = np.array(nus, dtype=float)
variances = np.array(variances, dtype=float)
I, J = get_matrix_dimensions(triangle)
scale_factor, triangle = scale_triangle(triangle)
nus *= 1.0/scale_factor
variances /= 1.0*scale_factor**2
standard_triangle_check(triangle)
assert I == J, "Aún no se soportan matrices rectangulares."
assert len(nus) >= I, "Insuficientes estimaciones a priori para llevar a cabo la estimación con Ferguson"
assert len(variances) >= I, "No se han especificado los suficientes errores para las estimaciones a priori"
single_payments_matrix = single_payments_from_triangle(triangle)
fjs = np.array([fj(triangle, j) for j in range(J)])
cijs = np.array([[estimate_cij(triangle, fjs, i_, j_, nus) for j_ in range(J + 1)] for i_ in range(I + 1)])
gammas = np.array([gamma(fjs, j, J) for j in range(J + 1)])
calc_mus = np.array([calc_mu(triangle, fjs, i) for i in range(I + 1)])
mijs = np.array([[mij(gammas, calc_mus, i_, j_) for j_ in range(J + 1)] for i_ in range(I + 1)])
d_ = d(I)
phi_ = phi(single_payments_matrix, d_, mijs)
h1s = np.array([h1(phi_, gammas, calc_mus, i, I) for i in range(I + 1)])
h2s = np.array([h2(phi_, gammas, calc_mus, j, I) for j in range(I + 1)])
param_h3_comb = [(j, l) for j in range(J) for l in range(J) if j != l]
h3s = np.array([h3(phi_, gammas, calc_mus, j_, l, I) for j_, l in param_h3_comb])
try:
fisher_matrix_ = fisher_matrix(phi_, h1s, h2s, h3s, I)
fisher_matrix_inverse = np.linalg.inv(fisher_matrix_)
g_matrix_ = g_matrix(fisher_matrix_inverse, I)
except np.linalg.linalg.LinAlgError as err:
if 'Singular matrix' in err.message:
g_matrix_ = np.empty((I + 1, I + 1))
g_matrix_[:] = np.nan
else:
raise
deviations_cijs = np.array([[cij_deviation(phi_, gammas, i, j, I, nus) for j in range(J + 1)] for i in range(I + 1)])
deviations_xijs = np.array([[xijs_deviation(mijs, phi_, i, j) for j in range(J+1)] for i in range(I+1)])
est_errors = np.array([[estimation_error(gammas, g_matrix_, i, j, I, nus, variances) for j in range(J + 1)] for i in range(I + 1)])
prediction_errors = np.array([[prediction_error(deviations_cijs, est_errors, i, j) for j in range(J + 1)] for i in range(I + 1)])
estimation_error_norm = vco_matrix(est_errors, cijs)
process_error_norm = vco_matrix(prediction_errors, cijs)
salida = gen_standard_output(scale_factor*cijs, fjs, scale_factor*deviations_cijs, scale_factor*deviations_xijs, scale_factor*est_errors)
return salida
def estimate_cij(triangle, fjs_, i, j, nus):
"""
Estimación de :math:`C_{i, j}` mediante el modelo Ferguson interpretado como el pago acumulado de los siniestros
incurridos en el período :math:`i` reportados hasta :math:`j` períodos después.
El modelo Ferguson requiere de una estimación *a priori* por parte de un experto
de :math:`C_{i, J}` (:math:`J` es el último período de desarrollo).
En otras palabras se requiere de una estimación de los pagos acumulados de siniestros
incurridos en cada período y reportados el último período de registro, en este caso, :math:`J`.
Esta estimación se denota por :math:`\\nu_i = C_{i, J}`.
:param np.array fjs_: Estimación de los factores de desarrollo :math:`f_j`. La lista fjs\_ debe
contener las entradas computadas de los parámetros :math:`f_j` desde 0 hasta :math:`j-1`, donde
se asume que la :math:`j`-ésima entrada de fjs\_ corresponde con :math:`f_j` (:math:`\\text{fjs_[j]} = f_j`).
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param int i: Período en el que sucedió el siniestro. Toma valores desde 0 hasta :math:`I`.
:param int j: Cantidad de períodos transcurridos después de sucedido el siniestro hasta que fue reportado.
Toma valores desde 0 hasta :math:`J`.
:param np.array nus:
Estimación *a priori* del parámetro :math:`\\nu_i`. Es una lista de tamaño :math:`I`, donde la :math:`i`-ésima entrada
es la estimación *a priori* por parte de un experto de :math:`C_{i, J}` (pago de siniestros incurridos en el período :math:`i`
reportados en el período :math:`J`).
:return:
Cuando :math:`i+j>I`, se calcula mediante la fórmula
:math:`C_{i, j} = \\beta_jC_{i, J}`
donde
:math:`C_{i, J} = C_{i, I-i} + (1- \\beta_{I-i})\\nu_i`
y donde :math:`\\beta_j=\\prod_{k=j}^{J-1}\\frac{1}{f_k}`.
Cuando :math:`i+j \\leq I`, devuelve la posición :math:`i, j` de la matriz triangle.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`i` no es un valor entero entre 0 e I.
+ El parámetro :math:`j` no es un valor entero entre 0 y J.
+ No se han calculado los suficientes valores de :math:`f_j`.
+ La lista :math:`\\mu_i` debe tener longitud al menos de i+1.
"""
I, J = get_matrix_dimensions(triangle)
assert i in range(I+1), "Período de incurrido a estimar inválido"
assert j in range(J+1), "Período de reportado a estimar inválido"
assert len(fjs_)+1 > j, "Se requieren más fj's calculados para estimar cij"
assert len(nus) > i, "se requieren mas estimacion es de ciJ para calcular cij"
if i+j <= I:
return triangle[i, j]
beta_I_i = prod(1.0 / fjs_[I - i: J])
ciJ = triangle[i, I - i] + (1 - beta_I_i) * nus[i]
betaj = prod(1.0 / fjs_[j: J])
return betaj * ciJ
def estimate_mack(triangle):
"""
Estima :math:`C_{i,j}` para :math:`i+j > I` con el modelo teórico Mack y los errores asociados a
la estimación. Finalmente genera un reporte estándar tal y como se detalla en :ref:`el output general <general_output>`.
Esta función primero estima los parámetros requeridos para estimar la matriz con los :math:`C_{i, j}` y los
errores asociados. Finalmente, llama a la función estimate_mack (respectivamente a las que estiman el error)
para estimar :math:`C_{i,j}`.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:return: Salida estándar tal y como se describe en la sección :ref:`output general <general_output>`.
:Posibles errores:
+ La estimación es **NaN**: Las entradas requeridas de la matriz para estimar :math:`f_j` son cero (o casi todas cero).
"""
I, J = get_matrix_dimensions(triangle)
scale_factor, triangle = scale_triangle(triangle)
standard_triangle_check(triangle)
fjs = np.array([fj(triangle, j) for j in range(J)])
sjs = np.array([sj(triangle, j) for j in range(J)])
cijs = np.array(
[[estimate_cij(triangle, fjs, i_, j_) for j_ in range(J + 1)]
for i_ in range(I + 1)])
sigma_squares = np.array(
[sigma_square(triangle, fjs, j) for j in range(J)])
deviations_cijs = np.array(
[[cij_deviation(cijs, fjs, sigma_squares, i, j) for j in range(J + 1)]
for i in range(I + 1)])
deviations_xijs = np.array([[
xijs_deviation(cijs, sigma_squares, fjs, deviations_cijs, i, j)
for j in range(J + 1)
] for i in range(I + 1)])
est_errors = np.array([[
estimation_error(triangle, fjs, sjs, sigma_squares, i, j)
for j in range(J + 1)
] for i in range(I + 1)])
prediction_errors = np.array([[
prediction_error(deviations_cijs, est_errors, i, j)
for j in range(J + 1)
] for i in range(I + 1)])
estimation_error_norm = vco_matrix(est_errors, cijs)
process_error_norm = vco_matrix(prediction_errors, cijs)
salida = gen_standard_output(scale_factor * cijs, fjs,
scale_factor * deviations_cijs,
scale_factor * deviations_xijs,
scale_factor * est_errors)
return salida
def sj(triangle, j):
"""
Estimador del parámetro :math:`s_j` requerido para calcular el error de estimación.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param int j: Entero con valor entre 0 y :math:`J-1` (incluyendo) donde :math:`J` es el número de columnas
de la matriz triangle.
:return: Para :math:`j=0,1,\cdots, J`, donde :math:`J` el número de columnas de la matriz triangle, devuelve
:math:`s_j = \\sum_{k=0}^{I-j-1}C_{k, j}`.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`j` no es un valor entero entre 0 y J
"""
I, J = get_matrix_dimensions(triangle)
assert j in range(J+1), "j debe ser un valor entero entre 0 y J, donde J es el número de columnas" \
" de la matriz trángulo menos 1."
# Todo: Si toda la columna es cero, hacer value error, hacerlo desde la función main.
return sum(triangle[:I - j, j])
def xijs_deviation(mijs, phi, i, j):
"""
Estima la desviación de :math:`X_{i,j}`.
:param mijs: Matriz de tamaño :math:`I\\times I` donde la :math:`i, j`-ésima entrada corresponde con el parámetro
:math:`m_{i, j}` (:math:`\\text{mij[i, j]} = m_{i, j}`).
:param phi: Parámetro :math:`\\phi`.
:param int i: Índice que indica el período de incurridos al cuál se le va a estimar la desviación de :math:`x_{i, j}`.
Toma valores :math:`i=0, \cdots I`.
:param int j: Índice que indica el período de reportados al cuál se le va a estimar la desviación de :math:`x_{i, j}`.
Toma valores :math:`j=0, \cdots J`.
:return: Cálculo de
:math:`\\text{desviación de } X_{i, j} = \\phi m_{i, j}`
"""
I, J = get_matrix_dimensions(mijs)
if i+j > I:
return np.sqrt(phi*mijs[i, j])
else:
return 0
def calc_mu(triangle, fjs_, i):
"""
Estimador del parámetro :math:`\\mu_i` requerido para la calcular el error de estimación.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param np.array fjs_: Estimación de los factores de desarrollo :math:`f_j`. La lista fjs\_ debe
contener las entradas computadas de los parámetros :math:`f_j` desde 0 hasta :math:`I-1`, donde
se asume que la :math:`j`-ésima entrada de fjs\_ corresponde con :math:`f_j` (:math:`\\text{fjs_[j]} = f_j`).
:param int i: Entero con valor entre 0 e :math:`I-1` (incluyendo 0 e :math:`I-1`).
:return: :math:`\\mu_i = C_{i, I-i}\\prod_{k=I-i}^{I-1}f_k`.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`i` no es un valor entero entre 0 e I.
+ No se han calculado los suficientes valores de :math:`f_j`.
"""
I, J = get_matrix_dimensions(triangle)
assert i in range(I+1), "Período de incurrido a estimar inválido"
assert len(fjs_) >= I, "Se requieren más fj's calculados para estimar cij"
return triangle[i, I - i] * prod(fjs_[I - i: I])
def phi(xijs_, d, mijs_):
"""
Estimador del parámetro :math:`\\phi`.
:param xijs_: Matriz :math:`X` donde la entrada :math:`X_{i, j}` denota el pago por siniestros
incurridos en el período :math`i` reportados :math:`j` períodos después. Mas información en
la sección :ref:`notación <notacion>`.
:param d: Cómputo de :math:`d`.
:param mijs_: Matriz de tamaño :math:`I\\times I` donde la :math:`i, j`-ésima entrada corresponde con el parámetro
:math:`m_{i, j}` (:math:`\\text{mij_[i, j]} = m_{i, j}`).
:return: :math:`\\phi = \\frac{1}{d}\\sum_{i+j\\leq I}\\frac{(X_{i, j} - m_{i, j})^2}{m_{i, j}}`
:Posibles errores:
+ **AssertionError**:
"""
I, J = get_matrix_dimensions(xijs_)
assert mijs_.shape == xijs_.shape, "Las matrices xijs y mijs deben tener el mismo tamaño"
comb = [(i, j) for i in range(I + 1) for j in range(J + 1) if i + j <= I and abs(mijs_[(i, j)]) > 0.00001]
xij = np.array([xijs_[a] for a in comb])
mij = np.array([mijs_[a] for a in comb])
return (1.0/d)*sum(((xij - mij) ** 2)*1.0/mij)
def cij_deviation(cijs_deviations_mack, fjs, i, j):
"""
Desviación de :math:`C_i, j` con el modelo Hovinen.
:param np.ndarray cijs_deviations_mack: Matriz donde la :math:`i, j`-ésima entrada corresponde con
la desviación de :math:`C_{i, j}` según Mack.
:param np.array fjs: Lista donde la :math:`j`-ésima entrada corresponde con el
factor de desarrollo :math:`f_j`.
:param i: Período de ocurrencia en el que se va a calcular la desviación. Puede tomar
valores :math:`i=0, \\cdots, I`
:param j: Período de reporte en el cuál se va a calcular la desviación. Puede tomar
valores :math:`i=0, \\cdots, J`.
:return: :math:`(1-\\beta_{I-i})\\beta_{I-i}C_{i, j}^{CL}`
donde :math:`\\beta_j=\\prod_{k=j}^{J-1}\\frac{1}{f_k}`.
"""
I, J = get_matrix_dimensions(cijs_deviations_mack)
if i + j <= I:
return 0.0
beta = prod(1.0 / fjs[I - i:J])
return ((1 - beta) * beta) * cijs_deviations_mack[i, j]
def cij_deviation(cijs_, fjs_, sigma_squares_, i, j):
"""
Estimador de la desviación de :math:`C_{i, j}` para el modelo Mack, identificado tambien como el cuadrado del error del modelo.
:param np.ndarray cijs_: Matriz (numpy array) de tamaño :math:`I \\times J`
donde la entrada :math:`i, j` con :math:`i+j \\leq I` es la entrada :math:`i, j` de
la :ref:`matriz de datos <triangle_format>`. Para :math:`i+j > I` la entrada :math:`i, j` es el valor estimado
de :math:`C_{i, j}` con el modelo Mack.
:param np.ndarray fjs_: Estimación de los factores de desarrollo :math:`f_j`. La lista fjs\_ debe
contener las entradas computadas de los parámetros :math:`f_j` desde 0 hasta j-1, donde
se asume que la :math:`j`-ésima entrada de fjs\_ corresponde con :math:`f_j` (:math:`\\text{fjs_[j]} = f_j`).
:param sigma_squares_: Estimación de :math:`\\sigma_j`. La lista sigma_squares\_ debe
contener las entradas computadas de los parámetros :math:`\sigma_j` desde 0 hasta j-1, donde
se asume que la :math:`j`-ésima entrada de sigma_squares\_ corresponde con :math:`\sigma_j` (:math:`\\text{sigma_squares_[j]} = f_j`).
:param int i: Período en el que sucedió el siniestro. Toma valores desde 0 hasta :math:`I`.
:param int j: Cantidad de períodos transcurridos después de sucedido el siniestro hasta que fue reportado.
Toma valores desde 0 hasta :math:`J`.
:return: Cuando :math:`i+j > I`, devuelve:
:math:`\\sqrt{\\text{variance}} = \\sigma = \\sqrt{C_{i, j}^2\\sum_{k=I-i}^{I-1}\\frac{{\\sigma_k^2}/{f_k^2}}{C_{i, k}}}`
donde :math:`C_{i, j}` es la entrada :math:`i, j` de la matriz cijs\_. Cuando :math:`i+j \\leq I`, devuelve 0.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`i` no es un valor entero entre 0 e I
+ El parámetro :math:`j` no es un valor entero entre 0 y J.
+ No se han calculado los suficientes valores de :math:`f_j`.
:return: Cálculo de
:math:`\\text{desviación de } C_{i, j} = \\sqrt{C_{i, j}^2\\sum_{k=I-i}^{j}\\frac{\\sigma_k^2/f_k^2}{C_{i, k}}}`
"""
I, J = get_matrix_dimensions(cijs_)
assert i in range(I + 1), "Período de incurrido a estimar inválido"
assert j in range(
cijs_.shape[1]), "Período de reportado a estimar inválido"
assert len(
fjs_) + 1 > j, "Se requieren más fj's calculados para estimar cij"
if i + j <= I:
return 0.0
cij = cijs_[i, j]
cij_l = cijs_[i, I - i:j]
fj_l = fjs_[I - i:j]
sigma_sq = sigma_squares_[I - i:j]
return np.sqrt((cij**2) * sum((sigma_sq * 1.0 / fj_l**2) * 1.0 / cij_l))
def estimation_error(triangle, fjs_, sjs_, sigma_squares_, i, j):
"""
Error de estimación para el modelo Mack.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param np.ndarray fjs_: Estimación de :math:`f_j`. La lista fjs\_ debe
contener las entradas computadas de los parámetros :math:`f_j` desde 0 hasta j-1, donde
se asume que la :math:`j`-ésima entrada de fjs\_ corresponde con :math:`f_j` (:math:`\\text{fjs_[j]} = f_j`).
:param np.ndarray sjs_: Estimación de :math:`s_j`. La lista sjs\_ debe
contener las entradas computadas de los parámetros :math:`s_j` desde 0 hasta j-1, donde
se asume que la :math:`j`-ésima entrada de sjs\_ corresponde con :math:`s_j` (:math:`\\text{sjs_[j]} = s_j`).
:param sigma_squares_: Estimación de :math:`\sigma_j`. La lista sigma_squares\_ debe
contener las entradas computadas de los parámetros :math:`\sigma_j` desde 0 hasta j-1, donde
se asume que la :math:`j`-ésima entrada de sigma_squares\_ corresponde con :math:`\sigma_j` (:math:`\\text{sigma_squares_[j]} = f_j`).
:param int i: Período en el que sucedió el siniestro. Toma valores desde 0 hasta :math:`I`.
:param int j: Cantidad de períodos transcurridos después de sucedido el siniestro hasta que fue reportado.
Toma valores desde 0 hasta :math:`J`.
:return: Cuando :math:`i+j > I`, devuelve:
:math:`\\text{error estimación}_{i, j} = C_{i, I-i}^2\\left( \\prod_{k=I-i}^{j-1}\\left(f_k^2 + \\frac{\\sigma_k^2}{s_k}\\right) - \\prod_{k=I-i}^{j-1}f_k^2 \\right)`
Cuando :math:`i+j \\leq I`, devuelve 0.
:Posibles errores:
+ **AssertionError**:
+ El parámetro :math:`i` no es un valor entero entre 0 e I.
+ El parámetro :math:`j` no es un valor entero entre 0 y J.
+ No se han calculado los suficientes valores de :math:`f_j`.
"""
I, J = get_matrix_dimensions(triangle)
assert i in range(I + 1), "Período de incurrido a estimar inválido"
assert j in range(J + 1), "Período de reportado a estimar inválido"
assert len(
fjs_) + 1 > j, "Se requieren más fj's calculados para estimar cij"
if i + j <= I:
return 0.0
cij = triangle[i, I - i]
fj_ = fjs_[I - i:j]
sj_ = sjs_[I - i:j]
sigma_sq = sigma_squares_[I - i:j]
square_fjs = fj_**2
partial_res = prod(square_fjs + sigma_sq * 1.0 / sj_) - prod(square_fjs)
return np.sqrt((cij**2) * partial_res)
def compute_ferguson_msep(triangle, fjs, nus, variances):
"""
Calcula el msep (mean square error prediction) mediante el modelo Ferguson.
:param np.ndarray triangle: Matriz de información. Véase la sección :ref:`preparación de los datos de entrada <triangle_format>`
para más información.
:param fjs: Factores de desarrollo. Es una lista con :math:`J` elementos donde el
:math:`j`-ésimo elemento corresponde con :math:`f_j`.
:param np.array nus:
Estimación *a priori* del parámetro :math:`\\nu_i`. Es una lista de tamaño :math:`J`, donde la :math:`i`-ésima entrada
es la estimación *a priori* por parte de un experto de :math:`C_{i, J}` (pago de siniestros incurridos en el período :math:`i`
reportados en el período :math:`J`) para :math:`i=I-J, I-J+1, \\cdots, I` .
"""
I, J = get_matrix_dimensions(triangle)
single_payments_matrix = single_payments_from_triangle(triangle)
gammas = np.array([gamma(fjs, j, J) for j in range(J + 1)])
calc_mus = np.array([calc_mu(triangle, fjs, i) for i in range(I + 1)])
mijs = np.array([[mij(gammas, calc_mus, i_, j_) for j_ in range(J + 1)]
for i_ in range(I + 1)])
d_ = d(I)
phi_ = phi(single_payments_matrix, d_, mijs)
h1s = np.array([h1(phi_, gammas, calc_mus, i, I) for i in range(I + 1)])
h2s = np.array([h2(phi_, gammas, calc_mus, j, I) for j in range(I + 1)])
param_h3_comb = [(j, l) for j in range(J) for l in range(J) if j != l]
h3s = np.array(
[h3(phi_, gammas, calc_mus, j_, l, I) for j_, l in param_h3_comb])
fisher_matrix_ = fisher_matrix(phi_, h1s, h2s, h3s, I)
fisher_matrix_inverse = np.linalg.inv(fisher_matrix_)
g_matrix_ = g_matrix(fisher_matrix_inverse, I)
est_errors_ferguson = np.array([
estimation_error_ferguson(gammas, g_matrix_, i, J, I, nus, variances)
for i in range(I + 1)
])
deviations_cijs_ferguson = np.array([[
cij_deviation_ferguson(phi_, gammas, i, j, I, nus)
for j in range(J + 1)
] for i in range(I + 1)])
msep_ferguson = msep(est_errors_ferguson, deviations_cijs_ferguson[:, -1])
return msep_ferguson
def estimate_mack_manual(triangle, fjs):
"""
Estima :math:`C_{i,j}` para :math:`i+j > I` con el modelo manual donde el experto especifica los par?metros de
desarrollo. Finalmente genera un reporte est?ndar tal y como se detalla en :ref:`el output general <general_output>`.
:param np.ndarray triangle: Matriz de informaci?n. V?ase la secci?n :ref:`preparaci?n de los datos de entrada <triangle_format>`
para m?s informaci?n.
:param np.ndarray fjs: Factores de desarrollo :math:`f_j` preestimados por un experto. La lista fjs\_ debe
contener las entradas computadas de los par?metros :math:`f_j` desde 0 hasta :math:`j-1`, donde
se asume que la :math:`j`-?sima entrada de fjs\_ corresponde con :math:`f_j` (:math:`\\text{fjs_[j]} = f_j`).
:return: Salida est?ndar tal y como se describe en la secci?n :ref:`output general <general_output>`.
:Posibles errores:
+ La estimaci?n es **NaN**: Las entradas requeridas de la matriz para estimar :math:`f_j` son cero (o casi todas cero).
"""
I, J = get_matrix_dimensions(triangle)
scale_factor, triangle = scale_triangle(triangle)
standard_triangle_check(triangle)
cijs = np.array(
[[estimate_cij_mack(triangle, fjs, i_, j_) for j_ in range(J + 1)]
for i_ in range(I + 1)])
deviations_cijs = np.empty((I + 1, J + 1))
deviations_cijs[:] = np.NaN
salida = gen_standard_output(scale_factor * cijs, fjs, deviations_cijs)
return salida
