We’ve all heard the terms Artificial Intelligence, Machine Learning, and Deep Learning as the concept of creating computers that can mimic human actions has become increasingly popular in today’s climate. These terms are even sometimes used interchangeably, seeming closely related to each other, despite the crucial differences between them. With this article, I will explain what each of these terms mean, along with some examples!

“Artificial intelligence is a set of algorithms and intelligence to try to mimic human intelligence. Machine learning is one of them, and deep learning is one of those machine learning techniques.” – Frank Chen

What is Artificial Intelligence?

Artificial Intelligence is a broad field, first coined in 1956 by a group of researchers, consisting of any technology that mimics human intelligence and is considered a branch of computer science. As Andrew Moore, Former-Dean of the School of Computer Science at Carnegie Mellon University states, “Artificial intelligence is the science and engineering of making computers behave in ways that, until recently, we thought required human intelligence.”. Although there is no universally accepted definition of Artificial Intelligence, Stuart Russell and Peter Norvig, authors of “Artificial Intelligence: A Modern Approach” identify 4 different approaches to define the field:

• Thinking humanly,
• Thinking rationally,
• Acting humanly, and
• Acting rationally.

Typically, Artificial Intelligence is used for prediction, automation, and optimization, which are tasks humans have historically done and are categorized into two classes — narrow and general AI. Narrow AI, or sometimes called “Weak AI” are machines that can perform very specific tasks well, often better than humans. However, such machines are very limited in their capabilities, only operating within a very limited context. On the other side of the spectrum, there is General AI or “Strong AI”, which can follow tasks considered to be extremely human-like, and carry out complicated tasks. These machines can problem-solve and apply intelligence to anything without human intervention and are more close to those we see in movies like Star Trek and Westworld.

Examples of Artificial Intelligence

It is quite difficult to find any examples of Artificial Intelligence that does not include Machine Learning. However, here are some simple implementations of Artificial Intelligence!

The very first working AI programs were written in 1951 by Christopher Strachey and Dietrich Prinz, who made a checkers-playing program and chess-playing program respectively. Strachey wrote the program to be run on the Ferranti Mark I computer and was written in CPL, later revived in Python by Peter Norvig. By 1952, the program could play a complete game of checkers. Prinz’s chess-playing program solved simple problems of the mate-in-two variety. It found a solution by examining all possible moves; several thousand moves had to have been examined to solve a problem and was much slower than a human player.

Another example of Artificial Intelligence without machine learning is chatbots. There are human-defined rules which allow the chatbot to answer questions. The intelligence is received by a large amount of manual data inputted and processed.

Natural Language Processing is also another example, and the rules of syntax and semantics of the language are inputted into a model to interpret and produce a sentence or phrase in a certain language. However, do note that most current-day Natural Language Processing models use Machine Learning and Deep Learning.

What is Machine Learning?

Machine learning is a subset of Artificial Intelligence and is simply a technique to implement the concept of Artificial Intelligence. Machine Learning can be defined as a method to empower computers with the ability to learn like humans. In its essence, an algorithm is given data to learn from using statistical techniques, and then makes predictions. The accuracy of these predictions is dependent on the quality of data, and the algorithm itself. Instead of hard-coding algorithms with a set of instructions that create predictions, the machine is trained with data using a specific algorithm, giving rise to the ability to learn how to perform a single task accurately. The machine will not have been programmed to specifically do this task, which eliminates the need for a large amount of written code. However, so far, the current algorithms are only able to power Narrow AI solutions.

There are two main methods of Machine Learning — Supervised Learning and Unsupervised Learning. The main distinction between these two methods is that Supervised Learning uses labelled data to train the machine, while Unsupervised Learning uses unlabelled data and extracts features using this data. Training with labelled data means that each piece of data comes with the answer the algorithm should output. Training is much easier with Supervised Learning, as the results of the algorithm can be compared to the labelled results of the data. However, training with unlabelled data means that the algorithm has to label, sort, and classify without any guidance of what to do with the data. These unsupervised learning algorithms are more about identifying relationships and patterns in data.

Examples of Machine Learning

An extremely useful application of Machine Learning is in Google Maps and other road-direction apps like Waze. Applications find the optimal route to allow the best route to be recommended. Through machine learning algorithms, traffic is identified, and the model finds a route that will avoid such congestion. It also has learnt how to calculate the exact time and distance based on traffic conditions.

Another application is the Recommendation Algorithms, like those in Netflix and Amazon. Machine Learning is used to create a model that will be able to take the data of your online activities and learn from your behaviour and interests to offer content similar. Continuous training of the Machine Learning model is used to update your preferences. Data is constantly collected at the front end and stored as big data to be analyzed.

One of the most useful Machine Learning applications is in removing spam from your inbox! A spam-detector algorithm works by analyzing the content of the message using a Supervised Naive-Bayes algorithm. This model is always being improved, when an email in the inbox is flagged as spam by someone, it is added to the training data.

What is Deep Learning?

Deep Learning is a subset of Machine Learning and is a technique that realizes Machine learning through the use of “Neural Networks” to mimic the human brain. Neural Networks were inspired by the human brain and makes use of artificial neurones. Neurones in the human brain are connected to each other through synapses and are used to transmit information! This technique shows a lot of promise and can solve problems previous algorithms couldn’t. However, unlike a human brain where the neurones are quite disorganized and are extremely interconnected, artificial neurones have clear, discrete layers and connections.

Deep Learning algorithms work by having each layer carry out a specific task, passing the data from one layer to the next until the final layer is reached, producing the output. The output is determined by the total weights produced by the layers. Each neurone in the network contributes to the weight. Based on the weighting, a “probability vector”, which indicates how confident the algorithm is of the output being correct.

Examples of Deep Learning

One example of Deep Learning in the real world is Computer Vision. Neural networks can power object detection, as well as image classification, restoration, and segmentation. Currently, they can even be used to recognize handwriting and distinguish the different characters.

The more sophisticated chatbots use Deep Learning. Nvidia has now developed a Deep Learning system that allows robots to learn from human’s actions. An example of a bot is a cleaning robot, which processes actions and utilizes Deep Learning to make decisions on the best way to execute certain tasks.

Deep Learning is also used in computer-aided diagnosis, through the use of image detection, recognition, and segmentation. Organs and lesions are identified from CT or MRI scans, producing vital information about the shapes and sizes of such organs / lesions.

I hope you managed to get a better understanding of the differences between Artificial Intelligence, Machine Learning, and Deep Learning! Feel free to message me through Twitter (@literallymonnie) or Instagram (@itsliterallymonique) if you have any questions or feedback!

This program needed to:

• Get the all participants’ name and email and store it
• Assign every participant a Secret Santa, ensuring everyone has a name that is not their own
• Tell everyone their allocations via email

I decided to have two different data entry methods:

• Via text (.txt) file: The user sets up a text file with a specific format of name, email. Every new line has a new participant and the program will process the text file and store all the participants in lists.
• Manual entry: The user manually types in the name and email of each participant, and will be prompted by the program (‘Enter participant 1’s name: ‘, ‘Enter participant 1’s email: ‘, etc.).

Here are the important variables explained:

• sender_address – the email address for the SMTP login (explained later)
• sender_pass – the password for the SMTP login (explained later)
• names – a list which holds the name of all the participants
• emails – a list which holds the email of all the participants
• recipient – a list which holds the name of the person whom the participant with the same index in the names list is the Secret Santa of.
  • This is complicated! So I shall explain with an example. Say the names list is [‘Shawn Mendes’, ‘Lady Gaga’, ‘Celine Dion’, ‘Taylor Swift’], and the recipient list is [‘Lady Gaga’, ‘Taylor Swift’, ‘Shawn Mendes’, ‘Celine Dion’].
  • This means that Shawn Mendes, in index 0, would be the Secret Santa of Lady Gaga (who is in index 0 of recipient), Lady Gaga (index 1) would be the Secret Santa of Taylor Swift (index 2), and so on.
  • Just remember, lists always start with index 0!
• budget – holds the budget value in dollars
• count – holds the total number of participants, important for getting participants details
• option – which data entry method the user chooses to use
• filename – the name of the .txt file (if user chooses the data entry via text file option)
• And if the user chooses the manual entry option:
  • name – temporarily holds the name of the participant to add to the names list
  • email – temporarily holds the email of the participant to add to the emails list
• possible_santa – a duplicate list of the names list, helps when assigning names
• recip – the index of who will be the recipient of the Secret Santa gift.

For all data entry, I used while loops, with the statement (x == 0). Whenever I validated the user input, I changed x to 1 which allowed the program to exit the while loop and move on to the next lines of code. Within the while loops I either added if, elif, else or try and except statements to validate the input. However, for some inputs, like the name, email and .txt file format, I assume that the user gives accurate information. I check that the email ends with ‘.com’, but there is no way to ensure the email is the correct one.

Then, I proceeded to work on the actual program – the allocation of Secret Santas! This was one of the hardest parts, as there were quite a few cases I had to account for – not to mention the all debugging. I went through each name using a for loop to allocate who they would be the Secret Santa of. To decide this, I used the ‘randint’ function from the built-in random library to choose a random number to represent the index

After this was done, I had to research how to email the Secret Santas their recipients. I found out that I would need to use SMTP – Python has a built in library for email sending, smtplib. I also used email.mime.multipart and email.mime.text – more Python libraries. All the details are in the code, and I used this website: https://www.freecodecamp.org/news/send-emails-using-code-4fcea9df63f/

The Code

I have attached a PDF of the program (including comments) which you can copy and paste it into a Python program!

There are many water dispensers currently in the market, here are some examples (DISCLAIMER: I DO NOT OWN THESE PICTURES, LINKS TO THE ACTUAL PICTURES WILL BE IN MY BIBLIOGRAPHY DOWN BELOW) :

Some used technology and were automated, others weren’t. I noticed that all these products brought unique solutions to the problem, and also seemed very effective! I noticed a few key features which made these products so great, and made it into a list:

• The casing was transparent (or had a section which was transparent) so the user can easily see water levels
• Water is either circulated or fresh from a water source, and isn’t stagnant
• Has a ‘bowl’ area for pets to easily drink from
• Container holding water is big, ensuring water lasts long
• Connected to a constant water source (for the outdoor water fountains)

Now that I had a list of key features to add to my product, I needed to look for what else I could do to make my product even better. After all, what’s the point in re-creating what’s already been made? I could just buy it and save me all this effort! Here were the key issues I could come up with:

• There is no alert for the user when the container is empty
• Water is constantly running – even when there is no pet nearby – which wastes energy
• Some (especially the fountains connected to a water source) needed to be outside, however, the average person might not have a backyard for their pet
• With the outdoor fountains, there was an issue of wastage since there is nothing to catch the fallen water
• The freshness of the water was another concern, since the water is likely going to stay in the container for a few days and can cause bacteria to grow

This then led me to start designing the product. I decided that the main features I needed to include were:

1. A fountain section for the water to be pumped out of, along with a container to hold the water. There also should be a drain to let excess water back in the container as to not waste.
2. A sensor to detect when there is a ‘pet’, this will then cause the fountain to pump out water for the dog to drink. This solves the ‘water constantly running’ problem I had. For this I had to choose between an infrared sensor – this measures the distance from an object – and a PIR – this detects motion. I ended up choosing a PIR, since the infrared sensor can be inaccurate and faulty at times, especially if the pet is coming at the fountain from an angle. With a PIR, and motion nearby will be detected, making it less prone to errors.
3. An alert when the water container is empty, and also a scale to tell the user how much water is left in the container.

Here is a sketch of my design:

Afterwards, I ordered the supplies I needed and got to making a prototype! I’ve added the materials, as well as my code, and a video of its functions. There are comments to help explain the functions and purpose of everything!

Materials:

• 3 x Float Switches
• 1 x LCD (Liquid Crystal Display) Screen
• 1 x PIR (Passive infrared sensor)
• 1 x Water Pump
• 1 x UV light
• 1 x Buzzer

How it works:

DISCLAIMER: IF YOU ATTEMPT MAKE THIS, MAKE SURE TO USE GLUE SAFE FOR YOUR PUPPER (OR PET)!!! Since this was just a prototype, I used hot glue, which is definitely not safe for consumption. Hopefully soon I can work on one which my dogs can actually drink from!

Overall, I am quite happy how it turned out! Next time I would most likely want to make it safe for my dogs to drink from and make the container smaller, since my dogs wouldn’t be able to drink from such a high container.

The CODE:

#include <LiquidCrystal_I2C.h>

#include <Wire.h>

LiquidCrystal_I2C lcd (0x3F, 16, 2);

int float1 = 2, float2 = 3, float3 = 4;
int waterlevels[3];
int waterlvl = 0;
int pirPin = 9;
int pumpPin = 8;
int buzz = 11;
int UVpin = 7;
unsigned long lastUV = 0;
bool UVon = false;
unsigned long start = 0;

float setInt = 4;
float interval = 4;
unsigned long lastDrink = 0;
unsigned long currentTime = 0;
bool waterTake = false;

void setup() {
// put your setup code here, to run once:

lcd.init();
lcd.backlight();

Serial.begin(9600);

for (int i = float1; i < float3 + 1; i++) {
pinMode(i, INPUT_PULLUP);
}

pinMode(pirPin, INPUT);

pinMode(pumpPin, OUTPUT);

pinMode(buzz, OUTPUT);

pinMode(UVpin, OUTPUT);

lcd.setCursor(0, 0);

lcd.print(“Water: “);

// Uncomment to be able to change the interval

// Serial.println(“Change water drinking interval(between 1 – 9 hours): “);
//
// while (Serial.available() == 0) {
// }
//
// if (Serial.available() > 0) { // is a character available?
//
// char rx_byte = Serial.read();
//
// Serial.println(rx_byte);
// // check if a number was received
// if ((rx_byte > ‘0’) && (rx_byte <= ‘9’)) {
// setInt = int(rx_byte) – 48;
// Serial.println(setInt);
// interval = setInt;
// }
// }
}

// function which gets the water level using the float switch readings
void WaterLevel() {

int count = 0;

for (int i = float1; i < float3 + 1; i++) {
waterlevels[count] = digitalRead(i);
count++;
}

lcd.setCursor(7, 0);

if (waterlevels[0] == 0 && waterlevels[1] == 0 && waterlevels[2] == 0) {
lcd.print(“100%”);

}
if (waterlevels[0] == 1 && waterlevels[1] == 0 && waterlevels[2] == 0) {
lcd.print(“60% “);

}
if (waterlevels[0] == 1 && waterlevels[1] == 1 && waterlevels[2] == 0) {
lcd.print(“30% “);
}
if (waterlevels[0] == 1 && waterlevels[1] == 1 && waterlevels[2] == 1) {
lcd.print(“0% “);

}
}

// turns on water pump
void pump() {
digitalWrite(pumpPin, HIGH);
lastDrink = millis();
interval = setInt;
}

void loop() {

WaterLevel();

// gets the seconds passed
currentTime = millis();

// if the set interval time has passed, then the buzzer will turn on
if ((currentTime – lastDrink) >= (interval * 1000 * 60 * 60) && waterTake == false) {
tone(buzz, 700);
waterTake = true;
}

// reads PIR
int motion = digitalRead(pirPin);

// if PIR senses motion, pump function will be called, and waterTake reset
if (motion == 1) {
pump();
noTone(buzz);
waterTake = false;
}
// if PIR doesn’t sense motion, nothing will happen
else {
digitalWrite(pumpPin, LOW);
if (waterTake == true) {
lastDrink = millis();
interval = 0.01;
waterTake = false;
}
}

// if it has been longer than the set interval time, UV light will turn on
if ((currentTime – lastUV) >= (0.005 * 1000 * 60 * 60) && UVon == false) {
digitalWrite(UVpin, HIGH);
UVon = true;
currentTime = millis();
start = millis();

}

// once it has been the set time, UV light is turned off
if ((currentTime – start) >= (5 * 60000) && UVon == true) {
digitalWrite(UVpin, LOW);
UVon = false;
lastUV = millis();
}

}

Bibliography:

Credits to these websites!!!

• Existing products:
  • https://sg.carousell.com/p/automatic-pet-cat-dog-water-feeder-step-on-drinking-water-fountain-with-hose-135659800/
  • https://www.qoo10.sg/item/OLD-TJIKKO-DOG-WATER-DISPENSER-PET-WATER-DISPENSER-STATION-1/615733519
  • https://www.aliexpress.com/i/4000141517043.html
  • https://odditymall.com/outdoor-dog-water-drinking-fountain
  • https://www.amazon.com/Automatic-Dispenser-Adjustable-Activated-Replaceable/dp/B07ZVHMRPS
  • https://www.aliexpress.com/item/4000781793209.html

Materials:

• 1 Ultrasonic sensor
• 2 Infrared sensors
• 3 Wheels
• 2 Motors
• Breadboard
• Arduino UNO
• Wires
• Battery pack

The CODE:

Ultrasonic Code

int trigPin = 2;
int echoPin = 3;
long duration, distance;

void setup() {
// put your setup code here, to run once:
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
motor(0, 0, 1000);
}

void motor(int speedLeft, int speedRight, int duration) {
int var = 0;
int i = 1500 + (speedRight * 6);
int k = 1500 – (speedLeft * 6);

while (var < duration) {
digitalWrite(13, HIGH);
delayMicroseconds(i);
digitalWrite(13, LOW);
delay(20);
digitalWrite(12, HIGH);
delayMicroseconds(k);
digitalWrite(12, LOW);
delay(20);
var += 40;
}
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);

distance = duration * 0.034/2;

if (distance <= 20) {
motor(-100, -100, 1000);
motor(100, 0, 1000);
} else {
motor(100, 100, 40);
}
}

Infrared Code

int LM = 13;
int RM = 12;
int LIR = 7;
int RIR = 6;

void setup() {
// put your setup code here, to run once:
pinMode(LM, OUTPUT); //left motor
pinMode(RM, OUTPUT);
pinMode(LIR, INPUT); //left
pinMode(RIR, INPUT);
}

void motor(int speedLeft, int speedRight, int duration) {
int var = 0;
int i = 1500 + (speedLeft * 6);
int k = 1500 – (speedRight * 6);

while (var < duration) {
digitalWrite(LM, HIGH);
delayMicroseconds(i);
digitalWrite(LM, LOW);
delay(20);
digitalWrite(RM, HIGH);
delayMicroseconds(k);
digitalWrite(RM, LOW);
delay(20);
var += 40;
}
}

void linetrace() {
int Left = digitalRead(LIR);
int Right = digitalRead(RIR);
if (Left == 0 && Right == 0) {
//forward
motor(50, 50, 50);
} else if (Left == 0 && Right == 1) {
//right
motor(50, -20, 50);
} else if (Left == 1 && Right == 0) {
//left
motor(-20, 50, 50);
} else {
motor(0, 0, 50);
}
}

void loop() {
// put your main code here, to run repeatedly:
linetrace();
}

How it Works:

Materials:

• 4 buttons
• LCD screen
• Breadboard
• Arduino UNO
• Wires

The CODE:

#include <LiquidCrystal_I2C.h>

#include <Wire.h>

#define B1 7

#define B2 6

#define B3 5

#define B4 4

LiquidCrystal_I2C lcd (0x27, 16, 2);

int M1, M2, M3, M4, T, ST, ED;
bool check;
int H1, H2, H3, H4;
int SC;

void setup() {
// put your setup code here, to run once:
pinMode(B1, INPUT_PULLUP);
pinMode(B2, INPUT_PULLUP);
pinMode(B3, INPUT_PULLUP);
pinMode(B4, INPUT_PULLUP);
Serial.begin(9600);
lcd.init();
lcd.backlight();
}

void loop() {
// put your main code here, to run repeatedly:
lcd.setCursor(0,0);
lcd.print(” “);
T = 0;
H1 = 0;
H2 = 0;
H3 = 0;
H4 = 0;
M1 = random(0, 2);
M2 = random(0, 2);
M3 = random(0, 2);
M4 = random(0, 2);
if(M1 == 0) {
lcd.setCursor(0,0);
lcd.print(“1”);
}
if(M2 == 0) {
lcd.setCursor(5,0);
lcd.print(“2”);
}
if(M3 == 0) {
lcd.setCursor(10,0);
lcd.print(“3”);
}
if(M4 == 0) {
lcd.setCursor(15,0);
lcd.print(“4”);
}
ST = millis();
lcd.setCursor(0,1);
lcd.print(“SCORE: “);
lcd.print(SC);
while (T < 1000) {
if(digitalRead(B1) == 0 && digitalRead(B2) == 0 && digitalRead(B3) == 0 && digitalRead(B4) == 0) {
check = false;
} else {
check = true;
}
if (digitalRead(B1) == 0 && M1 == 0 && check == true && H1 == 0) {
SC += 100;
H1 = 1;
}
if (digitalRead(B2) == 0 && M2 == 0 && check == true && H2 == 0) {
SC += 100;
H2 = 1;
}
if (digitalRead(B3) == 0 && M3 == 0 && check == true && H3 == 0) {
SC += 100;
H3 = 1;
}
if (digitalRead(B4) == 0 && M4 == 0 && check == true && H4 == 0) {
SC += 100;
H4 = 1;
}
ED = millis();
T = ED – ST;
Serial.println(T);
}
}

How It Works:

Materials:

• Servo motor
• LCD screen
• Breadboard
• Arduino Uno
• 2 Buttons
• Wires

The CODE:

// initialise speed and distance
double S, DIST;
// initialise start time and end time
int ST, ED;
// initialise fuel
double fuel = 2000.00;

LiquidCrystal_I2C lcd (0x27, 16, 2);
Servo alligator;

void setup() {
// put your setup code here, to run once:
lcd.init();
lcd.backlight();
// accelerator
pinMode(7, INPUT_PULLUP);
// decelerator
pinMode(6, INPUT_PULLUP);
Serial.begin(9600);
alligator.attach(5);
}

void loop() {
// put your main code here, to run repeatedly:
ST = millis();
if (digitalRead(7) == 0 && S <= 180) { S += 1; } else if (S > 0) {
S -= 0.2;
}
if (digitalRead(6) == 0 && S >= 2) {
S -= 2;
}
Serial.println(S);
alligator.write(S);
ED = millis();
Dist += S * (ED-ST);
fuel -= (S * (ED-ST)) / 1000;
lcd.setCursor(0,0);
lcd.print(“Distance: “);
lcd.print(Dist);
lcd.setCursor(0,1);
lcd.print(“Fuel: “);
lcd.print(fuel);
delay(100);
lcd.clear();

}

How It Works: