Yesterday I assisted to the second lesson of the course “Deep Learning with PyTorch: Zero to GANs” offered by Jovian.ml in collaboration with FreeCodeCamp (click on this article to read about the first lesson).

This time we focused our attention on using images to train a Logistic Regression model which can read handwritten digits, this is what we were able to achieve by the end of the lecture.

The assignment I received required me to create and train a model on my own, using what I learned from the lesson, to accurately predict healthcare expenses from a few informations like age, BMI and smoking habits of each subject, here you can view my final submission.

While working on the data outside the assignment scope I found out some interesting results, for example, have you ever considered how much smoking can affect your insurance cost?

Overall I consider the subject really stimulating, knowing an estimate of your future expenditure can have a very meaningful impact on how you decide to manage your finances, so I decided to go further and find what else I can discover using statistics and Machine Learning.

While exploring various datasets to decide what argument to tackle next I came across the WHO Life Expectancy data on Kaggle that caught my attention, I immediately set out to get other valuable insights and try constructing a machine learning model that can predict how many years a person can expect to live.

Exploring The Data

Let’s start approaching the dataset, it consists of 22 Columns and 2938 rows and contains information from 193 countries, spanning over the course of 15 years and detailing features like alcohol consumption, health care expenditure, BMI, and of course life expectancy.

The data type for each column is appropriate, but unfortunately several values seem to be missing, 15% of rows under the GDP column are empty, and it’s even worse for the Population one, that arrives at 22%.
Using Pandas interpolate function I filled the empty rows where possible and dropped them otherwise.

Now that the data is clean let’s see how our target value is distributed inside the dataset, as well as its mean and range.

The mean is 69 years, the minimum value is as low as 36 and the maximum reaches 89, from these we can calculate the range to be of 53 years.

How does each feature Affect Life Expectancy?

To maintain the model simple and consistent I decided to build it using only the columns that have the strongest correlation with the value I want to predict.

To begin with, the country you live in strongly affects the number of years you can expect to live, not surprisingly first world country citizens live on average 79 years while for developing countries the number is 66 years.

After comparing how the other factors relate to life expectancy I found four of them, besides country status, that have a very strong correlation, these are each country GDP, adult mortality, years spent in school and income composition of resources (read about the Human Development Index for more details on the last factor).

And now here is what the dataframe, that includes these five variables which will be used to train and evaluate the model, looks like:

Creating The Model

I began by converting the collected data into tensors and splitting 15% of them into validation data that will be used only for testing purposes and defined a function that feeds the model a batch of 512 items randomly chosen from the training pool.

For a simple problem like this linear regression is more than adequate, I created a class called LifeModel that contains all the basic components of the model and initialized it, right now this is its loss value:

Having used the l1 Smooth Loss function to calculate this value means that any prediction made using the model will be off by 1933.5 years on average, we are definitely not close to the result we want to achieve!

Training

The function called fit is responsible for training and logging the progress of the loss value a definite number of times.

After one thousand iterations with the chosen learning rate the model is drastically better but the overall linear improvement rate seems to suggest that the learning rate is a bit small and can be increased to approach the minimum faster.
Ahead is represented the improvement for this first training cycle.

After other two thousand iterations with different learning rates it finally reached a good accuracy level, the model now is off only by six years on average when making a prediction.

Making a Prediction

Now that the model has completed the training phase it can be used for making a prediction using the values saved in the validation dataset, I provided already a couple of examples.

Improving The Model

Update: I was challenged to improve the model and try different architectures and features to see how they would affect the results.

Firstly I tried to introduce more layers to the model but that didn’t seem to improve the accuracy, maybe the model is simple enough that using non-linear functions ends up being superfluous.

After I decided that if expanding the model ‘depth’ didn’t work out then maybe increasing his ‘width’, by adding one or more column to the input layer, coming back to the dataset I realized that HIV is a great candidate to be used in the model.

This attempt actually ended up providing the best result with an accuracy of 91.5%, confirming that HIV affects life expectancy substantially.

Another try consisted of using every feature in the dataset as input, but that actually led to a slightly worse outcome due to some columns not having a relevant correlation with the target we want to predict.

The last attempt involving using other techniques like Learning rate scheduling, that allowed me to achieve a comparable result with less than half the time the other models needed.

Overall the model didn’t improve drastically but I learned a lot about different architectures and ways to do machine learning, so it can definitely be called a successful experiment.

I collected the parameters used as well as the results obtained during the various iterations of the project, here are them visualized using Jovian’s ‘compare versions’ feature.

Conclusions

I was genuinely proud when this blogpost was featured in the course third lesson, I really appreciate Aakash for taking the time to read it and evaluate and for the shoutout as well, it means a lot to me.

At this point nothing stops us from using the model with more recent data, the dataset stops in 2015, or if you are daring enough even using your personal details to have a peek of what your own life expectancy is estimated to be.

Thanks again to Jovian for their wonderful course and to you for reaching the end of the article, this is the notebook it is based on, feel free to use it to experiment with this model or build your own!

Yesterday I took part in the first lesson from the course “Deep Learning with PyTorch: Zero to GANs” kindly offered by Jovian.ml in collaboration with FreeCodeCamp, to help the community to become proficient with machine learning tools and techniques and empower ourselves with this newly acquired knowledge.

The course is composed of six lectures that will be transmitted live on FreeCodeCamp’s YouTube channel during the course of six weeks, together with various individual assignments and projects.
Even if you missed the first lesson you can catchup by watching the vod and submit the first assignment to join the other students and be eligible for a certificate of completion if you finish the course!

The lesson held yesterday was about how to use Jupyter Notebooks and the Jovian platform itself, that will be used to showcase our work, the fundamentals of PyTorch like tensors, and an introduction to some ML techniques like Linear Regression and how to apply it to real world problem using PyTorch.

My assignment from the lesson

The first assignment given to us was getting comfortable with analyzing the Pytorch library on our own by exploring five random functions of our choice and writing a notebook explaining them in short detail.

I will provide a little recap ahead but you are welcome to check my Jupyter Notebook hosted on Jovian for more examples and insights, as well as the official documentation.

Function 1 — torch.ones

Returns a tensor of the specified size filled only with ones:

The type is going to be float by default but we can change it with an optional argument.

Function 2 — torch.abs

Computes the absolute value of every element contained inside the given input tensor:

This is the output when the function is tested with a simple array of integers.

Function 3 — torch.allclose

Compares the size of two tensors and their content, and confirm if those values are the same, within a certain margin of tolerance, by returning a Boolean value:

Two tensors of the same size and containing the same values will give a True output.

Function 4 — torch.numel

Returns the total number of elements in the input tensor:

Of course an array of length three will contain three elements.

Function 5 — torch.max

Returns the maximum value/s of all elements in the input tensor in the form of a new tensor:

A simple example with integers in an array returns a scalar.

Thanks a lot for reading my first blogpost!

If you are interested in reading more submissions from the Jovian community please visit the forum!

I also want to add an heartfelt thank you to Jovian and Aakash N S for providing this brilliant learning opportunity!