Actuarial Models

Source: Statistics Canada. Table 39-10-0007-01 Life expectancy and other elements of the life table, Canada and provinces

 

 


• Projecting Life Expectancy from Death Probability
• Excel Model .xlsx file  
• MATLAB Model File
• C#
• VB.Net
• R
• Python Model .py file   

 

 

    ■        ■       ■       ■   

 

 



 


• Non-Life Insurance Loss Frequency and Severity Simulation
(Frequency: Negative Binomial Discrete Distribution)
(Severity: Log-Normal Continous Distribution)
• Excel Model .xlsx file  
• MATLAB Model File
• C#
• VB.Net
• R
• Python Model .py file   

• Machine Learning Regression Techniques for a Kaggle Project
• Python File Coming Soon   
  Kaggle Project: House Prices Prediction
  ML Models & Techniques Applied: Lasso Regression , Ridge Regression , Elastic Net , XGBoost Regression , Light GBM , Random Forest Regressor ,
                                                            Stacking Regressors by Ensemble Learning , GridSearchCV & RandomizedSearchCV (hyper-parameters tuning),

 

 

    ■        ■       ■       ■   

 

 



• Artificial Neural Network from Scratch (without using any Machine Learning Libraries) for MNIST Handwritten Digits  Recognition
  • Python Model .py file   
  
  ▼     Notes on the Algo

  The above draft note demonstrates the feedforward process for one image:

  Each grayscale handwritten digit image has 28 (width) × 28 (height) × 1 (color) pixels; this information is translated into a 784 × 1 vector (shown on the left left-hand of the draft note)
  
  Perform matrix multiplication between the first weight matrix W₁ and the input vector (which is 784 × 1) and add the first bias vector b₁, then transform the resulting vector by an activation function (some popular activation functions include: Rectified Linear Unit ReLu, Sigmoid function, Softplus function)
  
  Z₁ = W₁ × Input Vector + b₁
  Activation₁ = σ₁ (Z₁)， where σ₁(*) is the activation function for the first hidden layer, and the operation performs element-wise.
  Activation₁ is the output of the first hidden layer which will be the input of the second hidden layer.
  
  Z₂ = W₂ × Activation₁ + b₂
  Activation₂ = σ₂ (Z₂)， where σ₂(*) is the activation function for the second hidden layer, which does not need to be the same as σ₁(*).
  Activation₂ is the output of the second hidden layer which will be the input of the third hidden layer.
  

  ... ...

  Z_last = W_last × Activation_last-1 + b_last
  W_last is the last weight matrix , b_last is the last bias vector
  Activation_last = σ_last (Z_last-1)
  Activation_last is the output layer which is a 10 × 1 vector, this vector dimension is due to there are total 10 digits (from 0 to 9).
  

  • ......
  • ......

 

 

    ■        ■       ■       ■   

 

 


• Decision Tree from Scratch (without using any Machine Learning Libraries)
  Detailed explanation is on the notes of the python file
  • Python Model .py file   
  
  ▼     Notes on the Algo

  The first graph demonstrates the framework of a decision tree:

  1. The algorithm first goes through each of the columns / features.
  
  
  2. Within each column, the algorithm sorts the rows / observations in ascending order of the column values. Sorting is expensive. But the idea behind the sorting is to avoid repeated scoring calculations (which will be discussed below). Therefore, sorting can save run time when there are many observations with the same column value.
  
  
  3. It then treats each row of the column as a split point which separates observations. Observations that have feature values less than the current split point are placed into the left node; and those greater than the current split point are placed into the right node.
  
  
  4. It calculates two scores for both the left node and the right node. The score measures the amount of variation of the dependent variable y's within the node. Potential candidates for the score measurement include the Gini impurity and the information entropy. The python code above uses standard deviation as the measurement. All these score measurements provide similar end results. They measure the dispersion of the dependent variables within the node.
  
  
  5. The algorithm then calculates a weighted average of the two scores obtained in step 4. The weighting is based on the number of observations in each node. And this weighted score is the score for this particular split point.
  
  
  6. Repeat step 2 - 5 for all columns / features and for rows / observations to find the best split point that has the lowest score. A lower score indicates lower amount of variation of the dependent variable y's within the node. Then the algorithm memorizes two best nodes correspond to the best split point.
  
  
  7. Apply the same method to the best left node, and split the observations into new (and deeper in depth) left node and new right node. The two new nodes are the children of the best left node. Do the same for the best right node. This is how we grow a decision tree.
  
  
  8. The algorithm keeps growing the tree until the number of observations within a node is less than the minimum required (this is a hyper-parameter). Also, it stops growing the tree until it reaches the maximum depth allowed (this is another hyper-parameter).

  
  

  One of the main weaknesses of the decision tree algorithm is that it tends to overfit the data. An overfitted model predicts out-of-sample observations poorly:

  That is why, when growing a decision tree, it is important to fine-tune the Min_Leave_Sample (which specifies the minimum numbers of observations required in a node) and Max_Depth (which specifies the maximum level of depths allowed for a tree) hyper-parameters.
  
  As we can see from the second graph, when the maximum depth allowed is larger, the tree is more complex, and it tends to overfit the data and provides a poorer out of sample prediction. The out of sample predicting ability is measured by the out of sample MAE.
  
  I used the UCI's Student Performance Data Set to test the algorithm and generate the above graph. A cleanup version of the CSV data can be found: here
  
  For this particular dataset when we limit the maximum allowed depth of the tree to be 20, the model provides the best out of sample prediction.

  • When the max_depth is too low, the model is not sophisticated enough to explain the variation of the data.
  • When the max_depth is too large, the model overfits the training data.

   

   

      ■        ■       ■       ■   

   

   

  

   

  
• Compare stochastic learning strategies for scikit-learn's Multi-layer Perceptron classifier
  This analysis extends from this
  • Google Colab .ipynb file   
  
  ▼     Analysis
  This report visualizes in-sample training loss curves and out-sample accuracy for different stochastic learning strategies, including SGD and Adam. The datasets used in the analysis are small, and Limited-memory BFGS (L-BFGS) might be more suitable. The analysis shown here seems to be able to generalize to larger datasets, however.
  
  Let's first go over some frequently used optimization strategies for deep learning:
  
  

  Plain Stochastic Gradient Descent (SGD) updates the weight matrix W and the bias b vector:

  Updating: W(t) = W(t-1) - constant_learning_rate × dW(t)

  Updating: b(t) = b(t-1) - constant_learning_rate × db(t)

  where dW and db are the gradients of the weight matrix W and the bias b vector

  
  

  SGD with momentum smooths out the learning proccess, avoids overshooting the target and prevents divergence

  velocity[dW(t)] = momentum_β₁ × velocity[dW(t-1)] + (1 - momentum_β₁) × dW(t)

  velocity[dW(t)] is an exponentially weighted moving average of dW

  Updating: W(t) = W(t-1) - constant_learning_rate × velocity[dW(t)], with v[dW(0)] = 0

  velocity[db(t)] = momentum_β₁ × velocity[db(t-1)] + (1 - momentum_β₁) × db(t)

  velocity[db(t)] is an exponentially weighted moving average of db

  Updating: b(t) = b(t-1) - constant_learning_rate × velocity[db(t)], with v[db(0)] = 0

  A commonly used value for the hyperparameter momentum_β₁ is 0.9, which allows velocity[dW(t)] and velocity[db(t)] calculate the averages based on the lastest 1/(1-momentum_β₁) = 10 dW's and db's.

  An exponentially weighted moving average allows more weights to be given to the more recent data. And the weight decays exponentially when we go back in time.

  
  

  SGD with Nesterov momentum pushes the weight matrix W and the bias b vector to look ahead when calculating their gradients. Nesterov momentum lowers the chance of overshooting the target when the optimization is close to its target. The idea of looking ahead allows the gradians (on W's and b's) to be more forward-looking for the updates and allows faster convergence.

  W(t)_look_ahead = W(t) - momentum_β₁ × v[dW(t-1)]

  W(t)_look_ahead is the proximate future position of W(t), and is where it improves from the plain momentum method

  v[dW(t)] = momentum_β₁ × v[dW(t-1)] + (1-momentum_β₁) × dW(t)_look_ahead

  The gradient is calculate on dW(t)_look_ahead instead of dW(t) as in the plain momentum method

  Updating: W(t) = W(t-1) - constant_learning_rate × v[dW(t)]

  b(t)_look_ahead = b(t) - momentum_β₁ × v[db(t-1)]

  b(t)_look_ahead is the proximate future position of b(t), and is where it improves from the plain momentum method

  v[db(t)] = momentum_β₁ × v[db(t-1)] + (1-momentum_β₁) × db(t)_look_ahead

  The gradient is calculate on db(t)_look_ahead instead of db(t) as in the plain momentum method

  Updating: b(t) = b(t-1) - constant_learning_rate × v[db(t)]

  
  

  The Adaptive Moment Estimation (Adam) is a widely used optimization algorithm in many deep learning applications. It combines plain momentum with the Root Mean Square Propagation (RMSProp).

  v[dW(t)] = momentum_β₁ × v[dW(t-1)] + (1 - momentum_β₁) × dW(t)

  v[dW] is an exponentially weighted moving average of dW

  v[dW]_bias_corrected = v[dW] / (1 - momentum_β₁^epoch_number)

  s[dW(t)] = momentum_β₂ × s[dW(t-1)] + (1 - momentum_β₂) × dW(t) ² , where dW(t) ² squares the vector elements, is performed element-wise

  s[dW(t)] captures the information in the second moment, and is an exponentially weighted moving average of dW(t) ²

  s[dW(t)]_bias_corrected = s[dW(t)] / (1 - momentum_β₂^epoch_number))

  Updating: W(t) = W(t-1) - constant_learning_rate × v[dW]_bias_corrected / [( s[dW(t)]_bias_corrected + Ɛ)^0.5]

  s[dW(0)] = 0, s[dW(0)] = 0

  This algorithm is similar for updating the bias vector.

  A commonly used value for the hyperparameter momentum_β₂ is 0.999, which allows s[dW(t) ² ] and s[db(t) ² ] calculate the averages based on the lastest 1/(1 - momentum_β₂) = 1000 dW ² 's and db ² 's.

  The hyperparameter Ɛ is to prevent dividing by 0, a commonly used value for epsilon = 10^-8

  
  

  A learning rate decay algorithm allows the learning rate to decrease over time. When the weight matrix W and the bias b vector come close to the optimal solution, the needed learning rate will be smaller than the initial learning rate.

  There is a decay learning rate method in scikit-Learn named Inverse Scaling "invscaling"

  effective_learning_rate(t) = initial_learning_rate / t ^power_t

  where power_t is a hyperparameter with a default value of 0.5

  
  This report examines seven stochastic learning strategies to see their training loss and testing accuracy. From the above graphs, we see that Adam is a star performer consistently across datasets, in both training sets and testing sets. However, SGD with only a decay learning rate consistently performs the worst across the board. It is worth noting, this strategy performs even worse than the plain SGD with a constant learning rate. SGD with plain momentum performs similarly compared to Nesterov momentum; they are not the best performers; but in some cases, they can perform better than Adam.

   

   

      ■        ■       ■       ■   

   

   

  
• Receiver Operating Characteristic (ROC) and Area under the Curve (AUC) with Repeated Stratified K-Fold Cross-Validation in scikit-learn
  The above presents the out-sample (cross-validated) RoC's across three unoptimized classifiers: Artificial Neural Network ANN (left), Support Vector Machine (mid), Decision Tree (right)
  This analysis extends from this
  • Google Colab .ipynb file   

   

   

   

  · · · · · ·

   

   

   

  Other Fun Stuff

   

   

   

      ■        ■       ■       ■   

   

   

   

  • Bivariate Gaussian Simulation
  The Cholesky decomposition was applied in the Monte Carlo method with correlation coefficient ρ(X,Y) = .025

   

   

   

      ■        ■       ■       ■   

   

   

   

  
  Data Sources: Statistics Canada. Table 39-10-0007-01 Life expectancy and other elements of the life table, Canada and provinces
                         The Centers for Disease Control and Prevention (CDC) of the United States. United States Life Tables, 2017
  • Human Life Prophet
  • VB.Net .rar file  
    VB.Net Windows Form Application .exe File Deployment Instructions
  Codes written using Microsoft VisualStudio2019 Community Version Free Download  

   

   

   

      ■        ■       ■       ■   

   

   

   

  Do you want to play tennis against your browser?
  You are on the left, your browser is on the right!

   

   

   

      ■        ■       ■       ■   

   

   

   

  

  Real Time Foreign Exchange Rate Calculator

  Choose the currency and the amounts to get the exchange rate

  AED ARS AUD BGN BRL BSD CAD CHF CLP CNY COP CZK DKK DOP EGP EUR FJD GBP GTQ HKD HRK HUF IDR ILS INR ISK JPY KRW KZT MXN MYR NOK NZD PAB PEN PHP PKR PLN PYG RON RUB SAR SEK SGD THB TRY TWD UAH USD UYU VND ZAR

  Swap

  AED ARS AUD BGN BRL BSD CAD CHF CLP CNY COP CZK DKK DOP EGP EUR FJD GBP GTQ HKD HRK HUF IDR ILS INR ISK JPY KRW KZT MXN MYR NOK NZD PAB PEN PHP PKR PLN PYG RON RUB SAR SEK SGD THB TRY TWD UAH USD UYU VND ZAR
  Source: ExchangeRate-API

   

   

   

  · · · · · ·

   

   

   

  Bonus Content 🎁

  Astronomy Story of the Day from NASA

  
  

  
  

  
  NASA Astronomy Story of the Day:  
  

  Archieved Stories: Year: Month: January February March April May June July August September October November December Day:
  
  

   

   

   

  Thank you for visiting my website!

  · · · · · ·

   

   

   

  

  Yaokun Lin

  Fellow of the Society of Actuaries FSA, Quantitative Finance and Investment Fellowship Track
  Fellow of the Canadian Institute of Actuaries FCIA
  Chartered Enterprise Risk Management Actuary CERA
  
  

  I am excited when Actuarial Science sparks with Technology.

   

   

   

  

  TheActuarialDirectory

   Views
  This website started on October 3, 2020
  Unique Visitors