The '!' behind the 0, is notation for something called a 'factorial'.

A factorial basically tells you to take the product of all integers and itself before it until you reach 1.

If that didn't make any sense, take a look at this example.

1! = 1 2! = 1 x 2 3! = 1 x 2 x 3 4! = 1 x 2 x 3 x 4

See what I am talking about?

Now before we go to why 0! = 1, let's take a look at something called exponents and some patterns in them which will help us later on.

𝑥ⁿ (read as "𝑥 to the power of n") basically tells you that 𝑥 is multiplied by itself 'n' times, like:

2² = 2 x 2 = 4 2³ = 2 x 2 x 2 = 8

Now what do you think 2⁰ will be?

You might think that 2 multiplied by itself 0 times should be 0, but as it turns out any number to the power of 0 = 1.

2⁰ = 1, but how?

That might not make sense on first glance, but let me show you why it is correct.

Here's a list of some of the powers of 2, you'll notice a pattern over here.

Each time you go up one level, you're essentially dividing by 2, what happens when you get to 2⁰?

You get 1, and now it all makes sense.

This is why every number to the power of 0 is 1.

(This also works for powers in negative numbers)

Factorials follow a similar pattern as you can see below, and as you can guess, 0! turns out to be 1 by this pattern!

Factorials aren't just about showing a neat pattern, they have real world use cases in combinatorics, a topic in math that deals with counting.

Let me explain.

You have 2 balls, one yellow and the other is blue.

In how many different ways can you arrange them?

There are 2 possible cases, now similarly can you guess how many ways can you arrange 3 balls?

There are 6 possible cases to arrange 3 balls.

As it turns out, the number of ways you can arrange n balls is n!

2 balls = 2! = 2 3 balls = 3! = 6

2! basically means "in how many ways can arrange 2 balls" which is 2.

Now what 0! tells you is how many ways can you arrange 0 balls, or basically nothing.

There is exactly one way to show nothing!

Which again proves why 0! is 1.

A store owner recently noticed an alarmingly high rate of shoplifting.

He develops a machine learning model that predicts if a customer has shoplifted or not and it is 95% accurate!

He deploys the model but a month later catches no shoplifters...

Why?

Let's dive deeper

Before we get into this problem it is important to understand what accuracy is.

Accuracy is the number of times you predicted something correctly divided by how many times you actually predicted it.

If you closely look at the dataset, you will notice that out of the 10,000 customers that entered the store, only 500 were shoplifters in that month.

Some quick math will tell you that 95% of customers are not shoplifters and the other 5% are.

If you basically said that everyone was not a shoplifter, you'd be correct in 95 out of 100 cases, which is what the model did.

You would be wrong in the other 5 cases, but who cares?

We're still 95% accurate, but this is clearly not what we are looking for.

This problem happens in 'imbalanced' datasets where the data is heavily skewed.

You're either a shoplifter, or you're not, and the former is significantly more present in the dataset.

Our model finds a shortcut to increase accuracy.

Moral of the story: Accuracy is not a suitable metric to use in situations where the data is skewed.

Then, how do we solve this problem?

Evaluate your model using a different metric, let us take a look at recall and precision, but first, it is important to understand some terminology.

This is a confusion matrix, it shows you all the possible scenarios of the predictions of a model Vs the ground truth.

Pretty confusing right? (No pun intended)

Let me simplify it.

This meme explains is better, the confusion matrix shows us the predictions of a model Vs the ground truth.

Consider the doctor to be the model and the patient to be the ground truth.

Let's co-relate this to our case of shoplifting.

• Case 1: Our model predicts someone shoplifted when they actually did (TP - True Positive)

• Case 2: Our model predicts someone shoplifted when they didn't (FP - False Positive)

• Case 3: Our model predicts someone did not shoplift when they did (FN - False Negative)

• Case 4: Our model predicts someone did not shoplift when they didn't (TN - True Negative)

Whenever you're confused, just refer to the above meme ;)

In formal terms, 'recall' is defined using this formula.

• What this metric basically does is tells us how good our model is at identifying relevant samples.

Or

• How good is our model at catching actual shoplifters?

TP: Shoplifters correctly identified FN: Shoplifters missed

Now if the model classifies no one as a shoplifter, it is going to have 0 recall.

This means it is "not good at all" if we are optimizing to have as high of recall as possible.

On the flip side, what if we label everyone as a shoplifter?

We'll have a recall of 100%, after all, recall just cares about not missing shoplifters, not about false accusations on customers (False Positive).

But there is a metric that does care about false accusations on customers, precision.

We basically replace False Negatives with False Positives in the denominator.

• Out of all the positive classes we have predicted correctly, how many are actually positive.

Or

• How good is our model at not making false accusations?

By this point, you might've guessed what problem we will encounter if we only optimize for high precision in our model.

The model can just call everyone not a shoplifter and have high precision.

Recall and precision are related such that high precision leads to low recall, and low precision leads to high recall.

We obviously want both to as high as possible, is there any metric that combines both precision and recall?

Say hello to the F₁ score.👋

The F₁ score is the harmonic mean of precision and recall.

The harmonic mean is a special type of mean(average) which is explained by this formula.

We use this mean instead of the normal mean because the normal punishes extreme values.

Now if we optimize our model to have an F₁ score, we can have high precision and recall.

This translates to our model being able to catch shoplifters and at the same time not falsely accuse innocent customers.

The model will be sure when it catches a shoplifter that it is actually a shoplifter and that brings this story to an end.

Over the next few months, I will be explaining even more evaluation metrics like the F₁ score.

If you enjoy such content, make sure to subscribe to my newsletter .

aᶜ=b (read as "a to the power of c equals b") is an exponent where a,b and c are numbers.

aᶜ=b just means that a multiplied by itself c amount of times is equal to b.

Here are some examples:

• 2² basically means 2 multiplied by itself 2 times which is 4
• 2³ basically means 2 multiplied by itself 3 times which is 8

So on and so forth.

Logarithms are basically a way of representing exponents in a different format.

Let me show you what I mean, both the formulas that you see below are equal.

logₐb = c is basically saying that "a to the power of c = b".

Dare I say, logarithms are exponents in disguise.

Here's a small exercise for you, what is the value of c in the below equations?

I've put them in logarithmic and exponential notation to make it easy for you.

Logarithms are used in all sorts of places, machine learning, computer science (time complexities)... you name it.

They are also a bunch of logarithmic properties that we can use to our advantage, but that is something I'll discuss in another blog post.

I really hope you enjoyed this blog post, you can also subscribe to my newsletter where I post bite-sized content like this.

Peace out!

It is a library using which we can develop real-time computer vision applications. It mainly focuses on image processing, video capture and analysis including features like face detection and object detection.

But before that....

A bit of backstory

When I was in 7th grade (3 years ago), I used to play with this photo editing software called " GIMP ". (short for GNU Image Manipulation Software)

Using a couple of clever techniques, I would make sketches out of images like what you saw in the thumbnail.

Let's see how this process works.

• You take an image

• Convert it to grayscale

• Invert the grayscaled image

• Blur the inverted image

• Subtract the grayscaled image from the blurred inverted image

et voilà !

I figured that I could automate this process using OpenCV, let see the code and how it works.

import cv2
# Importing the OpenCV libarary

img = cv2.imread('image.jpg')
#Reading the image

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#Converting the image to grayscale


img_invert = cv2.bitwise_not(img_gray)
#Inverting the grayscaled image

img_smoothing = cv2.GaussianBlur(img_invert, (21, 21),sigmaX=0, sigmaY=0)
#Blurring the inverted image

def dodge(x, y):
    return cv2.divide(x, 255 - y, scale=256)
final_img = dodge(img_gray, img_smoothing)
#Subtracting the blurred iamge from the orignal image

cv2.imwrite('img.jpg', final_img)
#Writing the final output to a a file

Just like that in 9 lines of code, you can easily create skteches using OpenCV and Python!

Here's the Github repository with this code .

If you don't know how to code or anything about what machine learning is, then this blog post is for you.

Step 1: Learn the basics of Python (~12 days)

Python is a programming language that you can use for machine learning.

Now, why do I recommend Python over any other language?

• It is easy to learn
• Has the largest community for machine learning
• Lots of learning resources

This 4 hour tutorial on FreeCodeCamp will help you get started with Python.

Some of the important topics covered in this tutorial are:

• Lists
• List Functions
• Tuples
• Functions
• Return Statement
• If Statements
• If Statements & Comparisons
• Dictionaries ... and lots more

Getting through this course will take you about 12 days if you spend an hour and a half on it each day. Take your time to understand every concept and ask for help online if needed.

Make sure you're consistent.

Step 2: Understand how machine learning works. (~3 days)

This video series by 3blue1brown will help you understand how neural networks work.

It will take you roughly 3 days to complete this series.

Neural networks are just one part of machine learning, there are many other "classical" machine learning algorithms as well.

However, to keep things simple, we'll only be focusing on neural networks.

Step 3: Get started with Machine Learning (~15 days)

Now it is time for you to dive into machine learning, this 10 part course will teach you the fundamentals of machine learning in TensorFlow.

You'll learn about:

• Neural Networks
• Computer Vision
• Overfitting
• Convolutions and pooling
• Image Augmentation
• Natural Language Processing

This roadmap will provide a solid foundation to your machine learning journey, cheers!

Before you leave, make sure to follow me on Twitter👇

@PrasoonPratham

However this is completely false!

You can pick the up the math as you go deeper into machine learning and one can comfortably start machine learning without it.

The point of this blog post is to help you get started with machine learning, not to proclaim that math is not important.

For this exercise you'll have to know basic programming knowledge in Python, that's it!

Here's what we are going to solve.

We are given data in which we are given the number of flats in a house and its corresponding price. Like a house with one flat is worth 10000, and 20000 for a house with two flats.

We can clearly tell that the price of the house increases by 10000 per extra flat however our computer does not know this and we won't it tell it about this, it'll have to figure things out on its own 🤫

Here's the code

( The link opens in Google colab, an online editor wherein your code runs on google's servers, no setup for Python or Tensorflow required on your PC! )

Let's try to understand what is going on here.

• We import TensorFlow and Keras which are frameworks for making neural nets

• Our Neural Net: This is where all the magic happens, for this exercise we need only one neuron.

Wait! What is a neural net?

Neural Networks are a digital imitation of the neurons you see in the human brain.

In these neural networks, data flows through them and each neuron (the circle) has a numerical value which will change.

The value of a neuron gets changes to something which is close to what we want each time the data passes through the neural network.

Think of the neurons as dials on a lock, you have to tune every dial to open the lock.

It is almost impossible for a human to tune thousands of dials like these, but a computer certainly can.

Once the dials are well tuned, you have a well trained neural network!

In this case we'll be able to predict the prices of houses based on how many flats they have.

Let's move on.

• Now we pass the data (flats and prices) through our neural network 500 times. (these loops are called epochs)

• Finally,we predict what the price of a house with 10 flats. (we should get something around 100,000)

And that's it! It was that easy.

Did we use any complex math? No!

This proves that you can get started with machine learning without any math.

What excuses do you have now?

Until...

This year when I across these free resources which helped me in a massive way!

Here's everything you need to know about math for machine learning and resources that you can learn from.

Before diving into the math, I suggest first having solid programming skills.

In Python, these are the concepts which you must know:

• Object oriented programming in Python : Classes, Objects, Methods
• List slicing
• String formatting
• Dictionaries & Tuples
• Basic terminal commands
• Exception handling

If you want to learn these concepts for python, these courses are freecodecamp could be of help to you.

You need to have really strong fundamentals in programming, because machine learning involves a lot of it.

It is 100% compulsory.

Another question that I get asked quite often is when do should you even start learning the math for machine learning?

Math for machine learning should come after you have worked on some projects, doesn't have to a complex one at all, but one that gives you a taste of how machine learning works in the real world.

Here's how I do it, I look at the math when I have a need for it.

For instance I was recently competing in a kaggle challenge.

I was brainstorming about which activation function to use in a part of my neural net, I looked up the math behind each activation function and this helped me to choose the right one.

One more thing before we look into the resources, I highly recommend that you take this course.

It goes over machine learning without any of the math, this will get you more comfortable with machine learning.

The topics of math you'll have to focus on

• Linear Algebra
• Calculus
• Trigonometry
• Algebra
• Statistics
• Probability

Now here are the math resources and a brief description about them.

Neural Networks

A series of videos that go over how neural networks work with approach visual, must watch.

Seeing Theory

This website gives you an interactive to learn statistics and probability

Gilbert Strang lectures on Linear Algebra (MIT)

They're 15 years old but still 100% relevant today! Despite the fact these lectures are for freshman college students ,I found it very easy to follow👌

Essence of Linear Algebra

A beautifully crafted set of videos which teach you linear algebra through visualisations in an easy to digest manner watch?

Essence of calculus

A beautiful series on calculus, makes everything seem super simple

The math for Machine learning e-book

This is a book aimed for someone who knows quite a decent amount of high school math like trignometry, calculus, I suggest reading this after having the fundamentals down on khan academy.

1.Measure time taken for a part of code to get executed

Sometimes, your application may be running slow and it can be really difficult to know what part of the code is causing the issue, to solve this you can look at the time taken by certain parts of the code by using this code snippet 👇

import time
startTime = time.time()

# write your code or functions calls

endTime = time.time()
totalTime = endTime - startTime

print("Time taken to execute code= ", totalTime)

2.View the memory taken by an Object

In Python you can use the sys.getsizeof function to check the memory consumed by an object in python, like Lists, Tuples, Dictionaries etc. Sometimes, it is good practice to check how much memory your data structure uses.

import sys

list1 = ['Value1', 'Value2', 'Value3']
print("size of list = ",sys.getsizeof(list1))

3.Switch the values of 2 variables: The efficient way

🚫 Don't do this 👇

a = 10
b = 20
a = b
b = c
c = a
print(a,b)

✅ Do this 👇

a = 10
b = 20
a,b=b,a
print(a,b)

4.Remove duplicates from a list

This is a neat trick, here we convert the list to a set. Sets are unordered data-structures of unique values and don’t allow copies.

listNumbers = [20, 22, 24, 26, 28, 28, 20, 30, 24]
print("Original List= ", listNumbers)

listNumbers = list(set(listNumbers))
print("After removing duplicate= ", listNumbers)

5.Combine 2 lists to form a dictionary

Here we use the zip function to combine the 2 lists into a dictionary

price = [54, 65, 76]
names = ["Pizza", "Pasta", "Burger"]

convertedDictionary = dict(zip(price, names))

print(convertedDictionary)

6.Find the largest and smallest values from a list of numbers

For extracting the largest and smallest values from a list, we can use the min and max functions.

list = [1,2,3,4,5,6] 

smallest = min(list)
print(smallest)

largest = max(list)
print(largest)

7.List comprehension

Let's say you want to make a list with even numbers from 0-20.

The typical approach would be:

A = [i for i in range(20)]

B = [x for x in A if x%2 == 0]

print (B)

The more efficient approach would be:

A = [x for x in range(20) if x%2 == 0]
print(A)

I hope you found these tips and tricks useful.

You can find me on Twitter Here

In this blog I'll explain how to crush these problems which I faced too, like a pro! Without further ado, let's begin:

1. I don't know where to start.

Solution:

Start from FreeCodeCamp Nothing else to say here

2. Problem: Setting up the environment is extremely difficult

Solution: Learn about

1. Using the command line interface :
   • Command Line Basics by FreeCodeCamp

2. System File structure :

   • Windows File structure

   • Linux File structure

   • MacOS File structure

3. Json,Yaml files :

   • Yaml explained

   • Json explained

4. Add variables to PATH:

   • Linux & MacOS

   • Windows

5. Learn to use package managers, like Pypi for Python, Npm for JavaScript, Flutter packages for you guessed it Flutter

3. Problem:You're unable to work on projects

Solution:

Your first project should be a simple one, if you still feel its overwhelming break your project into several smaller parts, then work on them, in case you still feel stuck, feel free to approach your friend google or the Twitter Dev community. Moreover you have hundreds of blog posts like these, put them to good use.

In addition to this, you may also get bugs As a Dev you will encounter bugs, the best way to deal with them is to READ THE ERROR MESSAGE, usually it will point to a line in the file which will help you fix the bug pretty efficiently, if not search it up on google.

Here are a few tricks on searching things on google by @frontenddude

4. Imposter syndrome (Lack of confidence)

Solution:

Firstly, you should know that this is normal. Fix it by don't comparing yourself to others, everyone has different learning speed.

5. I feel lazy

Solution:

Take some time off, think about new ideas and how to execute, this often helps rejuvenate the mind and generally makes you more productive. Being in a good mental state for coding is important.

Conclusion

Lastly, the bitter truth is that coding is tough, REALLY TOUGH. There are no 2 ways around it but if you have the passion and dedication then it is certainly possible to become a developer and you got this!

Wish you all the very best in your coding journey.

We knew this was going to be a challenging task, but we were certain we could do it.

That is why we decided to teach them in a way which most programmers learn:

1. The students would daily watch a video tutorial and follow instructions in it
2. They would then solve challenges curated by our team
3. Every weekend a doubt solving session was held wherein the concepts were quickly brushed upon and you guessed it, doubts were cleared

Now here are my main takeaways:

1. Teaching takes patience, A LOT OF PATIENCE!

Especially younger students require spoon-feeding at times. Resources which were given to them had to be boiled down enough for them to grasp it.

2. Having clear fundamentals is very important.

Basic things like knowing what is an integer, string, variable etc. are very important, otherwise programming at a later stage becomes very difficult.

3. You must keep your expectations low: Don't expect to make AAA games after just a month of programming.

To put it bluntly, programming is very very tough. Takes months of learning to get good at it and there is always something new to learn.

4. Having smaller more achievable goals helps in learning things faster.

This also makes you more confident.

5. Teach your students how to ask doubts and google things

Before asking doubts one must give a detailed explanation as to what they have tried and have they tried searching it up on the web?Bugs are inevitable and a coder must learn to google stuff when things don't work out

Conclusion

All went well and in the end we were able to help all the students to get a feel for what programming feels, our goal was not make full-stack 12-year-old prodigies who work at Facebook but to get them excited about programming and I feel we achieved our goal very well.

Hope you found this post insightful. Have an awesome day, Cheers.

Pictures from: Unsplash