DEV Community: Muiz Alvi

AI 101 | Introduction to Artificial Intelligence

Muiz Alvi — Fri, 08 Jan 2021 06:00:25 +0000

Introduction

If you are someone who is intrigued by self-driving cars, androids that can converse fluently or software that can diagnose tens of thousands of patients in a matter of minutes then artificial intelligence is the field for you!

This post covers basic components of the field, goes over the optimal learning path to take and includes a number of resources to help get you started. So no need to worry about all those complicated terms, super lengthy videos and numerous courses available online. Just follow this post and observe as we simplify AI for you!

About this Post
Learning Objectives
What is Artificial Intelligence?
The Power & Uses of AI
Components of AI
Python Learning Resources
Logic & Rules-Based Approach
Intro to Machine Learning
First AI Classifier (hands-on)
Classic Machine Learning
Intro to Deep Learning
Machine Learning vs. Deep Learning
More on Deep Learning
Theoretical & Hands-on Notebooks
Problems with ML & DL
Cloud Services: Microsoft Azure
Conclusion

About this Post

This post covers content discussed in the AI 101 | Introduction to Artificial Intelligence hands-on online workshop conducted by Microsoft Learn Student Ambassadors - Islamabad, Student Ambassadors Club - Karachi and NUST ACM Student Chapter.

If you prefer watching the recording for the session, it is available here.

Note: You do not need to watch the recording to understand this post, the link has only been provided for learning purposes.

Learning Objectives

Understanding the applications of AI
Understanding & differentiating AI components
Implementing a Basic AI classifier (Hands-on)
Discussing Learning Paths & Resources
Understanding Cloud Technologies in AI
Discussing Opportunities in AI

What is Artificial Intelligence?

We are living in the modern age of problem solving where we have based entire fields on ideas of science and mathematics to identify and solve problems. Artificial Intelligence, although an extremely broad term, can be thought of as a means of using Computers to solve problems or make automated decisions for tasks that, when done by humans, typically require intelligence.

A classic example would be shape identification. The following picture contains a few shapes that can easily be identified by a toddler.

So this task requires some degree of intelligence and hence if a computer program were able to do it, we could say it does so using artificial intelligence!

The Power & Uses of AI

Shape identification was pretty impressive back in the 1990s, but the applications of AI have grown ever since that time. Decades of research and technology have allowed us to do things that were once considered impossible! Let us dive into the vast capabilities of this field.

The following is a short video of a humanoid robot called Sophia being interviewed by the Stylist Magazine.

Now a lot of people have this confusion that AI refers to such robots (like Sophia) that can, to an extent, mimic human brain functionality to produce abstract thought. When this is entirely false. Robots, like Sophia, make use of an AI backend that allow them to indulge in conversation, this is regardless of a humanoid exterior.

So what exactly are the applications of AI other than robotics? Well, here are a few to help you get started:

Data Processing & Cleaning

Corporate giants maintain tens of thousands of customers' data on a daily basis. Now this task can be both tedious and prone to error if assigned to employees, instead they opt for an AI solution to learn certain patterns and trends overtime to clean or process incorrect, incomplete, irrelevant, duplicated, or improperly formatted customer data.

Speech Recognition

Ever used Siri, Alexa, Google Assistant or any voice-activated piece of technology? Ever wondered how a machine that communicates in binary (1's and 0's) is able to understand you? Well, the answer is the vast field of speech recognition. Here, an AI is trained to understand commands, phrases and even words! Speech recognition is used immensely and almost everywhere, from virtual assistants in our phones, to biometric verification for security purposes and even online banking!

Natural Language Processing

This powerful field of AI involves analyzing human language and deriving understanding based on language structure and context.

For example in the fill-in-the-blank: Man is to Woman what King is to ____, We as humans know that the most suitable replacement to the blank would be Queen, as it gives us a good analogy statement. This is what we are trying to teach our AI as well and can be done by training it on huge amounts of linguistic data.

Applications of this field include the predictive keyboard.

Image Processing & Transformation

Many amazing artworks have effortlessly been created with the help of AI in this field. Below is an example of convolving a picture of a dog with Vincent van Gogh's famous Starry Night.

For further clarity, an AI is needed to extract the essence of both pictures and put them together.

Computer Vision

This field makes use of the ideas behind object detection and identification in images to make applications like self-driving cars a reality.

As seen in the image above, an AI has successfully identified each object and can now make decisions based on this. Incase of a self driving car, it will either go or stop depending on the number and position of people on the street.

Components of AI

Artificial Intelligence has been around for a while now and modern breakthroughs in technology have allowed for greater advancements in this field. Using ideas of Machine Learning and Deep Learning, we are now able to achieve the extraordinary. As you can observe in the diagram below, Machine Learning, or ML, and Deep Learning, or DL, are simply the subfields of AI, which will be discussed to some extend in this post.

So how should one go about studying this field? Maybe you are someone who wants to start with AI, maybe you are stuck on ML or perhaps confused as to where to go when done with DL? Should you start with DL, then go to ML and only then learn about the broader field of AI? With so much content out there, one can get quite confused about which learning path to take. So to make things easier, I'll be sharing my learning path here. It may not be the best path to take but it will give you a structure while studying for AI.

Recommended Learning Path

Learn Python
Study Classic Machine Learning Examples
Make use of Deep Learning Libraries
Implement Cloud Technology Practices

Note: Key-elements of this learning path will be discussed throughout this post.

Python Learning Resources

Python is a powerful programming language that will allow us to create our AI models. We choose python because it allows us to make use of many Deep Learning libraries that can make programming much more easier. More on that when we talk about Deep Learning.

Follow these resources to get command on this language in no time! Also, if you are someone that is proficient in another language like C, C++, Java etc. then the learning process will be easier for you.

Resource 1: Watch Python in Action

The following is a video by howCode and goes over all the basics of Python in just 5 minutes!

Resource 2: Signup for HackerRank

Programming requires practice and this website has a ton of python-related problems for you to solve and help improve your skills for free.

You can signup here.

Resource 3: Python Repository

The following GitHub repository contains python problems taken from HackerRank along with solutions. You can make use of the code here for learning and evaluation purposes.

MuizAlvi / Python_Programs

Solved programming problems using Python

Sample Python problem solutions

List of Problems:

Sock Merchant: https://www.hackerrank.com/challenges/sock-merchant/problem
Counting Valleys: https://www.hackerrank.com/challenges/counting-valleys/problem
Jumping on the Clouds: https://www.hackerrank.com/challenges/jumping-on-the-clouds/problem
Repeating Strings: https://www.hackerrank.com/challenges/repeated-string/problem
Pyramid Problem: Create a simple program that takes the number of rows as input and prints out an astrisks pyramid.
2D Array - DS: https://www.hackerrank.com/challenges/2d-array/problem
Arrays - Left Rotation: https://www.hackerrank.com/challenges/ctci-array-left-rotation/problem
Anagram: https://www.hackerrank.com/challenges/anagram/problem
Jack and the Skyscrapers: https://www.hackerrank.com/challenges/jim-and-the-skyscrapers/problem
Simple Chess Engine: https://www.hackerrank.com/challenges/simplified-chess-engine/problem
King Richard's Knights: https://www.hackerrank.com/challenges/king-richards-knights/problem

View on GitHub

Logic & Rules-Based Approach

Remember this diagram?

You've already been made familiar with the Machine Learning and Deep Learning subsets of this field, but what about the portion of AI that is not enclosed by either subset? Well, that is the part of AI that makes use of a logical and rules-based approach, and by that we simply mean if-else statements!

There was this meme that circulated back in 2014:

So how accurate is this statement anyways? can we create AI using simple if-else statements? Well the answer is yes, we can do that but this comes with a lot of limitations.

First of all, to program an AI like Sophia one would have to write about 50,000 such statements, which is quite laborious. Secondly, it would take a processor quite a lot of time to execute such a code, making it quite inefficient as well.

So is there a way to make use of this approach? Yes! Some Deep Learning models make use of this method by combining if-else statements with Object Oriented Programming. Here is a sample code to help your understanding:

if (road.people == None):
   car.move()
else:
   car.stop()

In this program, the car only moves when people are not seen on the road.

So in conclusion, If-else Statements are a very limited approach to solving AI problems.

Intro to Machine Learning

Now let us move towards a more refined version of AI, known as Machine Learning. In this subfield, we make use of algorithms that find patterns in data and infer rules on their own. So what do we mean by learning through data? Well let's first look at the way us humans learn. Consider the picture below:

In this image, we are able to identify the animal on the left as a 'dog' and on the right as a 'cat'. Ever wondered how we were able to do this? Well chances are that you have seen multiple cats and dogs in real life, books or on television etc. and are now able to identify them with ease. Machine Learning works in a similar way, we give a program some data and tell it to learn features (like whiskers, ear size etc.) it then adjusts its learnable parameter(s) according to this data and only then is made able to produce a desired output. More on learnable parameters in the following example.

First AI Classifier (hands-on)

Now let us try to build our first AI classifier. Read the problem statement below to understand what we are trying to build:

Problem Statement:

A computer is given a dataset of 'labeled' animal heights to help train its learnable parameter 'x'. Once trained, the computer will be given a height value and will have to determine whether this height belongs to a 'cat' or 'dog'

Algorithm: When the computer receives a height value greater than x, it outputs 'dog' and if less than or equal to x then it outputs 'cat'

Dataset:

Now before moving towards the code, you should first try to figure out the unknown label for the 50 cm height on your own. (Hint: It will help to write down all heights and labels in ascending order). Once done, follow the steps below to create your first AI classifier:

Step 1: Create Data Variables & Lists:

data = [20, 60, 25, 18, 40] 
label = ['cat', 'dog', 'cat', 'cat', 'dog']

The code above is our training data taken from the table in the problem statement. Each data and label has been placed in a list in respective order. Our program will learn from this data.

x = 0 # learning parameter
H = 50

We have now initialize our learnable parameter 'x'. The program will set the value of x according to our data. The variable 'H' is the height of the animal we need to classify.

Step 2: Train the Program

The code snippet below simply sets a value for 'x' on the basis of our data and labels being used.

for i in range(0, len(data)): 
    if (data[i] > x) & (label[i] == 'cat'): x = data[i]

When you are done running this code, the optimum value of 'x' will have been set.

Step 3: Test the Program

This is a simple if-else statement that compares 'H' with 'x' and determines whether the animal is a 'cat' or 'dog' based on its height.

if x <= H: print('dog') 
else: print ('cat')

Based on the data the output should be dog.

Ands that's it! you have successfully built, trained and tested your first AI classifier! Now the learning outcome here is that a model extracts features from data and sets its learnable parameter according to these features. It then uses its learnable parameter to predict outcomes on test data.

Full Code

This is what the final form of your code should look like after completing all the steps. I have added comments as well for better understanding.


# Training

data = [20, 60, 25, 18, 40] # Training dataset 
label = ['cat', 'dog', 'cat', 'cat', 'dog'] # Training dataset labels

x = 0 # initial value for x
H = 50 # Test data

for i in range(0, len(data)): 
    if (data[i] > x) & (label[i] == 'cat'): x = data[i]

# Testing

if x <= H: print('dog') 
else: print ('cat')

Classic Machine Learning

Machine Learning has been around for quite sometime now. We know that Deep Learning is a subset of ML, so let us discuss the part of ML that does not fall in the DL category. Namely the 'Classic' version of ML.

I would now like to ask you a question. Was the above AI classifier an example of Classic Machine Learning?

The answer is no. This is because of Tom Mitchell's modern definition of ML: "A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E." In our classifier, the program lacks a performance measure and so is not an example of Machine Learning. It was only presented to give you an idea about how computers learn.

Classic Machine Learning follows the same principles: it extracts features from data, adjusts its learnable parameters (i.e. weight and bias) but also accounts for performance. In layman's terms this means that our program is learning through its mistakes. We will not go into how this works or, the math behind this learning, as it is beyond the scope of this post, this is an introductory post after all, but I hope the example gave you some basic intuition about how ML works.

Applications

There are many applications of Classic Machine Learning. Cooperate giants make use of spam filters that train on spam emails, learn words like 'Nigerian prince' or 'free survey' overtime and filter out such emails. Allowing for a cleaner workspace.

Another application is image classification, which will be discussed in detail later in this post.

Resources

The best way to start with ML would be with a course by Andrew NG available on Coursera. This is a free course and covers topics related to ML extensively. You can check it out here.

For people already done with ML courses and wish to strengthen their ML concepts with some intro to DL, there's this DeepLizard playlist covering fundamentals for both ML and DL. You can find this playlist here.

Intro to Deep Learning

Deep Learning is a sub-field of Machine Learning that allows for us to overcome limitations of Classic Machine Learning and train powerful models with revolutionary applications. This field makes use of Neural Networks (shown below) for calculations and is quite GPU intensive.

In the diagram above, each circle represents a node and each column of nodes represent a layer. Check out the Build your first Neural Network with the Keras API tutorial to learn all about Neural Networks and their implementation.

Machine Learning vs. Deep Learning

If you are someone who understands the concepts of ML and DL but aren't exactly aware of the technical differences between both. Then this section is just for you! Let us look at the differences between the approach taken by both subfields by the help of an image classification example. The following is a picture of me taken a few weeks ago. Our models will try to train themself on this image.

Machine Learning Approach

An ML model will first extract features, for instance face shape and distance between pupils relative to distance between forehead and chin.

The model will then adjust its learnable parameter according to these features.

Deep Learning Approach

A DL model, on the other hand, takes the image as a whole and passes it through a Neural Network. The Neural Net for our problem looks like this:

This Network has been programmed to slice up an image and take each slice as an input for each input node (nodes on the left most side). The image will be split as follows:

Now each input node will extract some feature from each slice on its own and pass it to the next node to find out another feature and so on. The nodes are learning the features on their own. These features could be anything, like hair color, eye shape, lip shape and so on. This is exactly why DL is GPU intensive, as each node is carrying out complex calculations to extract and learn features. This is also why DL models are far more accurate as compared to ML models.

More on Deep Learning

The applications of DL include self-driving cars, object detection algorithms (like the one discussed above) and Deepfakes.

The most efficient way for you to create DL models is simply by implementing certain Python libraries in your code. These libraries make it super easy to build, train, validate and test your Deep Learning models. Examples of such libraries are tensorflow, keras, pytorch and fast.ai.

Resources

You can access these libraries and many more using Anaconda. You can learn all about acquiring Anaconda and installing DL libraries in the Setting up Python environments using Anaconda tutorial.

You can also check out the Deep Learning Specialization course by Andrew NG available on Coursera. This is a powerful five-course specialization that covers DL in great detail. However it is not free but you can apply for financial aid if necessary. Check out the course here.

Another recommended course would be a video series by fast.ai that covers the use of the fast.ai python library. This series has eight videos and you can check them out here

Deep Learning Models

The following GitHub repository contains a number of DL Models that you can make use of according to your liking. I have created this repo for people studying math intensive DL courses to be able to see the programs in action. It contains actual image classifiers made with python libraries.

MuizAlvi / Machine_Learning_and_Deep_Learning_models

Repository containing models based on ideas of Machine learning and Deep learning

Machine_Learning_and_Deep_Learning_models

Repository containing models based on ideas of Machine learning and Deep learning. List of files:

Simple Sequential Model
- Uses randomly generated trainin set (10% of which is used in validation set) and test data
- Shows final predictions in a confusion matrix
Cat and Dog Classifier - Convolution Neural Network
- Uses a data set of 1300 images (1000 for training set, 200 for validation set, 100 for test set) randomly picked out of a larger data set of 25000 images
- Image Data: https://www.kaggle.com/c/dogs-vs-cats/data (25000 images of cats and dogs)
- Model experiences overfitting and needs to be improved
- Model has not been tested for now due to overfitting on the training set
Cat and Dog Classifier 2.0 [using existing model] - Convolution Neural Network
- Trains existing model VGG16 (with some alterations)
- Uses data prepeartion used in the previous upload (Cat and Dog Classifier - Convolution Neural Network)
- Highly accurate model with…

View on GitHub

Theoretical & Hands-on Notebooks

Although videos, books and courses are a great source of learning, fields like AI require a more hands-on approach. The following repository contains a number of jupyter notebooks to help further your understanding of ML and DL. It also includes the code to the AI classifier example along with a number of resources to guide you on the path of Artificial Intelligence.

MuizAlvi / AI101

Repository containing guidance material for participants attending the AI101 Workshop

AI101

Repository containing hands-on, open-source, practise notebooks for participants attending the AI 101: Introduction to Artificial Intelligence Workshop.

List of files:

Workshop Resources
- Resources.txt
Workshop Example:
- Feature Classifier Example
For Machine Learning:
- 01 - Data Exploration
- 02 - Regression
- 03 - Classification
- 04 - Clustering
For Deep Learning:
- 05a - Deep Neural Networks (PyTorch)
- 05a - Deep Neural Networks (TensorFlow)
- 05b - Convolutional Neural Networks (PyTorch)
- 05b - Convolutional Neural Networks (Tensorflow)
- 05c - Transfer Learning (PyTorch)
- 05c - Transfer Learning (Tensorflow)

View on GitHub

Note: Please do make use of these notebooks as they will improve your understanding and learning.

Problems with ML & DL

Classic Machine Learning comes with a number of limitations. These limitations are highlighted in the image classification problem discussed above as well.

The problem with Deep Learning is that it is GPU intensive (as mentioned several times above), requires huge amounts of training data and has a very complicated code.

Cloud Services: Microsoft Azure

Microsoft Azure is your one-stop-shop solution to all the above mentioned problems.

Azure provides:

Virtual Machines that do complex computations for you!
Cloud storage space to store your models and datasets
Open datasets that you can use to train your models
Automated ML (drag and drop), so you don't event have to code anything!

Now a lot of individuals hesitate to use this platform because it's a paid service, but there is a way around this!

Azure Free Credits

I will be listing down two ways to obtain free Azure credits to help you get started on the platform:

You can get $200 worth of free Azure credits simply by signing up for an Azure account here.
You can obtain $100 worth of free Azure credits and much more by applying for the GitHub Student Developer Pack here.

Budgeting

Now the question you're probably asking yourself is how much can be done with this amount of free credits? Well to answer your question, I built, trained, tested and deployed an ML and a DL model on Azure and that only cost me $0.64! You can see the details below:

So either package is more than enough to for learning purposes.

Conclusion

AI is a powerful field with immense research and implementation opportunity. You should now have a good idea about this field, its subfields and the possible path to take when it comes to learning. If you are someone starting out with AI then please feel free to make use of the provided resources as they will help you on your journey immensely. I would also urge you to share this post in your circle as well, as it addresses a lot of issues faced by people in the AI learning process. It's all here, we just need to get the word out.

The picture above is reference to Andrew NG's Deep Learning Specialization course where he tells us that DL is no less than a super power and it is our job to make the best use of it.

I hope the post was clear and covered everything. Please use the discussion/comment section to let me know if you faced any difficulty or have any questions.

Thank you for taking the time to read this article!

Build your first Neural Network with the Keras API

Muiz Alvi — Tue, 29 Dec 2020 17:12:37 +0000

Objective

This tutorial will help programmers build, train and test their first Neural Network using the powerful Keras python library.

Introduction
About Neural Networks and Keras
Github code
Problem Statement
Generating Dataset
Building a Sequential Model
Training the Model
Testing the Model using Predictions
Plotting Predictions using Confusion Matrix
Final Code
Conclusion

Introduction

In pursuit of learning about the field of artificial intelligence, many come across the term 'Neural Networks'. They realize the importance of these algorithms and their application in the field of deep learning, however face difficulty building their own.

This tutorial will not only show you how to build a neural network from scratch, but will also walk you over the code for training and testing your model. All while solving an actual deep learning problem in the process!

Note: The Keras API along with 10,000 other such python libraries can be accessed from the Anaconda Navigator. You can learn all about acquiring Anaconda and installing the Keras API in the Setting up Python environments using Anaconda tutorial.

About Neural Networks and Keras

Artificial Neural Networks, ANNs or Neural Networks are a series of algorithms that are modeled after the biological activity of the human brain. Neural Networks compose of layers. Each layer consists of nodes (also called neurons).

You can learn more about Neural Networks from the following video created by DeepLizard:

This video is part of the Machine Learning & Deep Learning Fundamentals playlist and has been taken from the DeepLizard YouTube channel.

Keras is a python library that uses Tensorflow as its back-end. This library allows us to build, train and test models effectively. It also allows us to make use of its own pre-existing models. You can learn more about the deep learning API from the Keras website.

Github Code

The following problem statement along with the code for this blog are all available on my Github profile and compiled in a Jupyter Notebook titled First Neural Network with Keras API. You can view and make use of the code to your liking. I will encourage you to read through this blog as well for better explanation of the written code.

Problem Statement

An experimental drug was tested on 2100 individual in a clinical trail. The ages of participants ranged from thirteen to a hundred. Half of the participants were under the age of 65 years, the other half were 65 years or older.

Ninety five percent patients that were 65 years or older experienced side effects. Ninety five percent patients under 65 years of age experienced no side effects.

You have to build a program that takes the age of a participant as input and predicts whether this patient has suffered from a side effect or not.

Steps:

Generate a random dataset that adheres to these statements
Divide the dataset into Training (90%) and Validation (10%) set
Build a Simple Sequential Model
Train and Validate the Model using the dataset
Randomly choose 20% data from dataset as Test set
Plot predictions made by the Model on the Test set

Generating Dataset

First we import some of the libraries needed for generating the dataset.

import numpy as np
from random import randint
from sklearn.utils import shuffle
from sklearn.preprocessing import MinMaxScaler

We are importing numpy as all our variables are n dimensional arrays. Rest of the libraries will be used for randomizing, shuffling and scaling data respectively.

Next we initialize the empty lists for training samples along with their labels.

train_labels = []
train_samples = []

The train_samples list includes participant age and train_label includes whether they have suffered from side effects (denoted by '1') or not (denoted by 'zero').

We now move towards randomly generating values for both lists.

for i in range(50):
    # The 5% of younger individuals who did experience side effects
    random_younger = randint(13, 64)
    train_samples.append(random_younger)
    train_labels.append(1)

    # The 5% of older individuals who did not experience side effects
    random_older = randint(65, 100)
    train_samples.append(random_older)
    train_labels.append(0)


for i in range(1000):
    # The 95% of younger individuals who did not experience side effects
    random_younger = randint(13, 64)
    train_samples.append(random_younger)
    train_labels.append(0)

    # The 95% of older individuals who did experience side effects
    random_older = randint(65, 100)
    train_samples.append(random_older)
    train_labels.append(1)

The first 50 iterations generate random ages for participants younger than 65 that did suffer from side effects (labeled
'1') and participants 65 and older that did not suffer from side effects (labeled '0'). The random age is generated, placed inside the random_younger or random_older variable and then appended into the train_samples list. A value for the label is also appended into the train_label list. For the next 1000 iterations, a similar approach is taken but for the participants younger than 65 that did not suffer from side effects (labeled
'0') and participants 65 and older that did suffer from side effects (labeled '1').

Once the iterations are complete, the lists are converted to arrays. The data of these arrays are also shuffled.

train_labels = np.array(train_labels)
train_samples = np.array(train_samples)
train_labels, train_samples = shuffle(train_labels, train_samples)

The conversion is required as calculations are done on n dimensional arrays and not lists. The shuffling is done to remove any order imposed on the data set during the creation process.

The next step requires us to transform and scale data in order to pass it through our model.

scaler = MinMaxScaler(feature_range = (0, 1))
scaled_train_samples = scaler.fit_transform(train_samples.reshape(-1,1))

In the first line we specify the range for the imported MinMaxScalar function and in the next line, we are scaling the values of the train_samples according to the specified range whilst also reshaping the n dimensional array to a shape appropriate for our model.

Building a Sequential Model

Now we move towards building our Neural Network. The first step is to import the Tensorflow and Keras library, along with certain parameters required for our model. These parameters are all being imported from within Keras that is using a Tensorflow backend.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy

Our model is a simple sequential model, meaning that the layers are linearly stacked, hence we are importing Sequential. From layers we are importing the fully-connected or Dense layer along with the type of activation function needed for scaling data sent to nodes. Optimizers are also required to help minimize loss, which is a crucial step in a neural network's calculation. Finally categorical_crossentropy is the type of loss function that we will be using for our model.

If you are facing difficulty in understanding any of these terms then it is a good idea to check them out by clicking on them as this will take you directly to the documentation. However there is no need to worry as these things do take time and improve with practice.

Let us now build our model. I am creating a model with one input (with 16 units), one hidden (with 32 units) and one output (with 2 units) layer. Deciding the number of layers and units to set differ from problem to problem and can be improved overtime through practice.

model = Sequential([
    Dense(units = 16, input_shape = (1,), activation = 'relu'), 
    Dense(units = 32, activation = 'relu'), 
    Dense(units = 2, activation = 'softmax')
])

This code is pretty simple, we are creating a sequential model with three dense layers. The input layer takes in a tuple of integers that matches the shape of the input data, hence (1,). 'relu' and 'softmax' are types of activation functions.

Here is what the summary of the model should look like:

Training the Model

To train our model we simple use the model.compile() function followed by the model.fit() function.

model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
model.fit(x = scaled_train_samples, y = train_labels, validation_split = 0.1, batch_size = 10, epochs = 30, shuffle = True, verbose = 2)

The compile function pieces our model together while the fit function begins the training process. We specified the 'accuracy' metric as we want to see the accuracy of our model during training. By using the validation_split parameter we are automatically splitting the dataset into training and validation sets. '0.1' here means that 10% goes to the validation set and the remaining 90% goes to the training set. The dataset is also being split into batches of 10 (batch_size) and will be passed through the model 30 times. Each cycle is referred to as an 'epoch'. 'Verbose' here refers to how detailed the training outputs would be and so we set that to '2' which is maximum detail.

Preprocessing Test Data

This is similar to the data scaling and transforming done for the training and validation data sets.

First we initialize the test lists.

test_labels = []
test_samples = []

One for ages and one for labels (if suffered from side effects (denoted as '1') or if not suffered from side effects (denoted as '0')).

Now we randomly generate values for both lists.

for i in range(10):
    # The 5% of younger individuals who did experience side effects
    random_younger = randint(13, 64)
    test_samples.append(random_younger)
    test_labels.append(1)

    # The 5% of older individuals who did not experience side effects
    random_older = randint(65, 100)
    test_samples.append(random_older)
    test_labels.append(0)


for i in range(200):
    # The 95% of younger individuals who did not experience side effects
    random_younger = randint(13, 64)
    test_samples.append(random_younger)
    test_labels.append(0)

    # The 95% of older individuals who did experience side effects
    random_older = randint(65, 100)
    test_samples.append(random_older)
    test_labels.append(1)

The first 10 iterations generate random ages for participants younger than 65 that did suffer from side effects (labeled
'1') and participants 65 and older that did not suffer from side effects (labeled '0'). The random age is generated, placed inside the random_younger or random_older variable and then appended into the test_samples list. A value for the label is also appended into the test_label list. For the next 200 iterations, a similar approach is taken but for the participants younger than 65 that did not suffer from side effects (labeled
'0') and participants 65 and older that did suffer from side effects (labeled '1').

We will now convert the lists to numpy arrays and shuffle, similar to what we did with the training/validation set.

test_labels = np.array(test_labels)
test_samples = np.array(test_samples)
test_labels, test_samples = shuffle(test_labels, test_samples)

We will also scale, transform and reshape our data to make it appropriate for our model. Again this is similar to the process done for the training/validation set.

scaled_test_samples = scaler.fit_transform(test_samples.reshape(-1,1))

Testing the Model using Predictions

In order to test our model we will make use of the predict() function, this will take each individual test age and take out the probability of it being part of either label. A rounding off function is then used to round off and keep the probability of the higher label only and discard the other label

predictions = model.predict(x = scaled_test_samples, batch_size = 10, verbose = 0)
rounded_predictions = np.argmax(predictions, axis = -1)

Plotting Predictions using Confusion Matrix

In order to plot the results, I have used a confusion matrix. The code can be found on the scikit-learn website here. Simply copy the code from the website and run it.

Now make use of appropriate labels and plot the matrix.

cm_plot_labels = ['no_side_effects', 'had_side_effects']
plot_confusion_matrix(cm = cm, classes = cm_plot_labels, title = 'Confusion Matrix')

Your output should look something like this:

And that's it! you've successfully created your first Neural Network that actually solves a real problem!

Final Code

Now that we're done with all the steps, your code should look something like this.

import numpy as np
from random import randint
from sklearn.utils import shuffle
from sklearn.preprocessing import MinMaxScaler

train_labels = []     # one means side effect experienced, zero means no side effect experienced
train_samples = []

for i in range(50):
    # The 5% of younger individuals who did experience side effects
    random_younger = randint(13, 64)
    train_samples.append(random_younger)
    train_labels.append(1)

    # The 5% of older individuals who did not experience side effects
    random_older = randint(65, 100)
    train_samples.append(random_older)
    train_labels.append(0)


for i in range(1000):
    # The 95% of younger individuals who did not experience side effects
    random_younger = randint(13, 64)
    train_samples.append(random_younger)
    train_labels.append(0)

    # The 95% of older individuals who did experience side effects
    random_older = randint(65, 100)
    train_samples.append(random_older)
    train_labels.append(1)

train_labels = np.array(train_labels)
train_samples = np.array(train_samples)
train_labels, train_samples = shuffle(train_labels, train_samples)  # randomly shuffles each individual array, removing any order imposed on the data set during the creation process

scaler = MinMaxScaler(feature_range = (0, 1)) # specifying scale (range: 0 to 1)
scaled_train_samples = scaler.fit_transform(train_samples.reshape(-1,1)) # transforms our data scale (range: 13 to 100) into the one specified above (range: 0 to 1), we use the reshape fucntion as fit_transform doesnot accept 1-D data by default hence we need to reshape accordingly here

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy

model = Sequential([
    Dense(units = 16, input_shape = (1,), activation = 'relu'), 
    Dense(units = 32, activation = 'relu'), 
    Dense(units = 2, activation = 'softmax')
])

model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

model.fit(x = scaled_train_samples, y = train_labels, validation_split = 0.1, batch_size = 10, epochs = 30, shuffle = True, verbose = 2)

test_labels = []
test_samples = []

for i in range(10):
    # The 5% of younger individuals who did experience side effects
    random_younger = randint(13, 64)
    test_samples.append(random_younger)
    test_labels.append(1)

    # The 5% of older individuals who did not experience side effects
    random_older = randint(65, 100)
    test_samples.append(random_older)
    test_labels.append(0)


for i in range(200):
    # The 95% of younger individuals who did not experience side effects
    random_younger = randint(13, 64)
    test_samples.append(random_younger)
    test_labels.append(0)

    # The 95% of older individuals who did experience side effects
    random_older = randint(65, 100)
    test_samples.append(random_older)
    test_labels.append(1)

test_labels = np.array(test_labels)
test_samples = np.array(test_samples)
test_labels, test_samples = shuffle(test_labels, test_samples)

scaled_test_samples = scaler.fit_transform(test_samples.reshape(-1,1))

scaled_test_samples = scaler.fit_transform(test_samples.reshape(-1,1))

rounded_predictions = np.argmax(predictions, axis = -1)

from sklearn.metrics import confusion_matrix
import itertools
import matplotlib.pyplot as plt

cm = confusion_matrix(y_true = test_labels, y_pred = rounded_predictions)

# This function has been taken from the website of scikit Learn. link: https://scikit-learn.org/0.18/auto_examples/model_selection/plot_confusion_matrix.html
def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    """
    This function prints and plots the confusion matrix.
    Normalization can be applied by setting `normalize=True`.
    """
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        print("Normalized confusion matrix")
    else:
        print('Confusion matrix, without normalization')

    print(cm)

    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, cm[i, j],
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

cm_plot_labels = ['no_side_effects', 'had_side_effects']
plot_confusion_matrix(cm = cm, classes = cm_plot_labels, title = 'Confusion Matrix')

This code is also available on my Github profile and compiled in a Jupyter Notebook titled First Neural Network with Keras API. From there you can make use of this code to your liking and suggest improvements there as well.

Conclusion

You should now have a good idea about how Neural Networks are built, trained, validated and tested. You can also check out other cool deep learning models in the following GitHub repository:

MuizAlvi / Machine_Learning_and_Deep_Learning_models

Repository containing models based on ideas of Machine learning and Deep learning

Machine_Learning_and_Deep_Learning_models

Repository containing models based on ideas of Machine learning and Deep learning. List of files:

Simple Sequential Model
- Uses randomly generated trainin set (10% of which is used in validation set) and test data
- Shows final predictions in a confusion matrix
Cat and Dog Classifier - Convolution Neural Network
- Uses a data set of 1300 images (1000 for training set, 200 for validation set, 100 for test set) randomly picked out of a larger data set of 25000 images
- Image Data: https://www.kaggle.com/c/dogs-vs-cats/data (25000 images of cats and dogs)
- Model experiences overfitting and needs to be improved
- Model has not been tested for now due to overfitting on the training set
Cat and Dog Classifier 2.0 [using existing model] - Convolution Neural Network
- Trains existing model VGG16 (with some alterations)
- Uses data prepeartion used in the previous upload (Cat and Dog Classifier - Convolution Neural Network)
- Highly accurate model with…

View on GitHub

I hope the tutorial was clear and covered everything, please use the discussion/comment section to let me know if you faced any difficulty or if any step is unclear. Thank you for taking out the time to read this article!

Setting up Python environments using Anaconda

Muiz Alvi — Fri, 13 Nov 2020 19:10:01 +0000

Objective

This tutorial will help programmers setup their first python-based environment using a powerful open-source distribution known as Anaconda.

Introduction
Acquiring Anaconda
Creating a new Environment
Adding packages to your Environment
Activating your Environment
Testing your Environment
Conclusion

Introduction

Students starting out with advanced data science fields, especially deep learning, often struggle with code implementation while making use of libraries. I have often observed programmers install a number of libraries each time they build a solution, only to reinstall these libraries whenever they restart their builder or system. This is slow, inefficient and quite an irritable process. Anaconda is a powerful open-source distribution that not only provides over 10,000 python libraries at a user's disposal but the feature of compartmentalizing and preloading any number of library packages in the form of environments. A user can now simply build an environment, download the libraries to this environment and use them whenever.

Acquiring Anaconda

Anaconda is free for individual use but if you have a company of over 200 employees then it is recommended to purchase a commercial license. Below is a two-step guide for downloading and installing Anaconda.

Step 1: Download

For this step, simply visit the Anaconda website and select the Individual Edition tab under the products dropdown.

or simply click this link

Now click the Download button

This will navigate you to the lower part of the tab where you can choose an installer according to your device.

Clicking a link will download the installer.

Step 2: Install

Clicking the downloaded file will start the installation wizard. The installation is fairly simple and the installation wizard will walk you through this process with ease.

Incase of any difficulty with this step you can view the official documentation for installing Anaconda here.

Once on this page, you can choose the guide for your operating system from a number of given hyperlinks.

Creating a new Environment

Navigate to where you installed Anaconda. You will see a variety of Anaconda related applications there. Windows users can simply view all this from the start menu.

Once in the desired folder or menu, open the Anaconda Navigator

In the navigator, click on the Environments tab. On the left you will see a list of environments and on the right you can see the python packages included in each environment.

Click on the Create button in the lower part of the list of environments, this will open a prompt.

Inside this prompt, give an appropriate name for your environment and click the create button. Now wait for your environment to be created.

Adding packages to your Environment

Now that you have successfully created an environment, it is important to install some python packages to this environment. These packages can then be accessed using any IDE or solution builder being used by your environment, more on this later.

To add packages, simply click on your environment (my environment is called irisproject) and view the installed packages on the right side.

Notice how you are viewing the installed packages.

From the drop down select not installed and use the search packages bar to search for a package. I will be installing Keras (you can learn more about this library here).

Now select the package or packages you wish to install and click apply on the lower right of the screen.

You have now successfully installed a package to your environment.

Note: You should also install Jupyter Notebook, Spyder and/or any other IDE using the steps mentioned above. These are all categorized as packages and are installed to an environment using the same steps I have used to install Keras.

Activating your Environment

You can access and make use of your environment in a variety of different ways. However, I will show you the fastest and simplest method of activating your environment. Simply open the Anaconda Prompt.

Once the prompt opens, type in the activate command followed by the name of your environment (this name is case sensitive).

Now you can see that the environment updated from base to your environment.

You have successfully activated your custom environment!

Testing Your Environment

Now let's see if we can make use of the packages we installed in one of the previous steps. Use the Anaconda Prompt to open an IDE, if you haven't installed an IDE in your environment then do it now using the same steps for adding packages to your environment. I will be using Jupyter Notebook. Simply type in the name of the IDE to open it.

Create a new notebook or workspace (depending on the IDE you're using) and then import a package as I've done below.

As you can see, the package has been imported successfully and now we have an ideal solution environment that does not require us to install libraries each time it is used. You can now install new packages to the navigator and use them with ease.

Note: You do not have to create a new environment each time you wish to install a new package, simply add said package to the environment using the Anaconda Navigator.

Conclusion

You should now be able to create and modify your own environment(s) using Anaconda. I hope the tutorial was clear and covered everything, please use the discussion/comment section to let me know if you faced any difficulty or if any step is unclear.

DEV Community: Muiz Alvi

AI 101 | Introduction to Artificial Intelligence

Introduction

Table of Contents

About this Post

Learning Objectives

What is Artificial Intelligence?

The Power & Uses of AI

Data Processing & Cleaning

Speech Recognition

Natural Language Processing

Image Processing & Transformation

Computer Vision

Components of AI

Recommended Learning Path

Python Learning Resources

Resource 1: Watch Python in Action

Resource 2: Signup for HackerRank

Resource 3: Python Repository

MuizAlvi / Python_Programs

Solved programming problems using Python

Sample Python problem solutions

List of Problems:

Logic & Rules-Based Approach

Intro to Machine Learning

First AI Classifier (hands-on)

Problem Statement:

Step 1: Create Data Variables & Lists:

Step 2: Train the Program

Step 3: Test the Program

Full Code

Classic Machine Learning

Applications

Resources

Intro to Deep Learning

Machine Learning vs. Deep Learning

Machine Learning Approach

Deep Learning Approach

More on Deep Learning

Resources

Deep Learning Models

MuizAlvi / Machine_Learning_and_Deep_Learning_models

Repository containing models based on ideas of Machine learning and Deep learning

Machine_Learning_and_Deep_Learning_models

Theoretical & Hands-on Notebooks

MuizAlvi / AI101

Repository containing guidance material for participants attending the AI101 Workshop

AI101

Problems with ML & DL

Cloud Services: Microsoft Azure

Azure Free Credits

Budgeting

Conclusion

Build your first Neural Network with the Keras API

Objective

Table of Contents

Introduction

About Neural Networks and Keras

Github Code

Problem Statement

Generating Dataset

Building a Sequential Model

Training the Model

Preprocessing Test Data

Testing the Model using Predictions

Plotting Predictions using Confusion Matrix

Final Code

Conclusion

MuizAlvi / Machine_Learning_and_Deep_Learning_models

Repository containing models based on ideas of Machine learning and Deep learning

Machine_Learning_and_Deep_Learning_models

Setting up Python environments using Anaconda

Objective

Table of Contents

Introduction

Acquiring Anaconda

Step 1: Download

Step 2: Install

Creating a new Environment

Adding packages to your Environment