DEV Community: Adolph Odhiambo

From Pythagorean Theorem to K-Means: How Grade School Math Powers Machine Learning

Adolph Odhiambo — Tue, 21 Jan 2025 07:37:21 +0000

A Fourth-Grade Discovery That Shaped My Career

Back in 2010, I was a curious fourth-grader staring at the colorful posters on my math classroom walls. Among them was one that etched itself into my memory: the Pythagorean Theorem. Memorizing the iconic triples like (3-4-5) and (5-12-13) felt like solving magical puzzles. I didn’t know it then, but that simple formula $a^2 + b^2 = c^2$ would one day power some of the most critical algorithms I use in my career.

Fast forward 15 years, and I’m a data scientist clustering customers based on their transaction patterns and account growth. My go-to algorithm? K-Means clustering, a machine learning technique that owes its elegance and efficiency to none other than the Pythagorean theorem.

The Pythagorean Theorem’s Hidden Superpower

The Pythagorean theorem states:

\sqrt{a^2 + b^2}

where ( c ) is the hypotenuse of a right triangle, and ( a ), ( b ) are the other two sides.

But here’s the twist: this formula is the secret sauce behind measuring distances in machine learning.

By simply reinterpreting the sides of the triangle, we can measure distances in higher-dimensional spaces a technique that underpins many algorithms.

The Secret Superpower: Euclidean Distance

Let’s start with the Euclidean distance—the straight-line distance between two points. Imagine two points on a 2D plane, $x_1, y_1)$ and $x_2, y_2)$ . The distance between them is:

\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}

This formula is essentially the Pythagorean theorem in disguise! Instead of triangle sides, the differences in $x$ - and $y$ -coordinates form the “legs,” while the hypotenuse becomes the distance between points.Instead of triangle sides, we’re measuring the “straight-line” distance between points.

Why Distance Matters in Machine Learning ?

In machine learning, distance = similarity. The closer two data points are in a feature space, the more alike they are.

For example, consider two customers:

Customer A: 25 years old, earning $50K. Represented as:

\vec{\mathbf{a}} = \begin{bmatrix} 25 & 50 \end{bmatrix}

Customer B: 40 years old, earning $80K. Represented as:

\vec{\mathbf{b}} = \begin{bmatrix} 40 & 80 \end{bmatrix}

To measure their similarity, calculate the Euclidean distance:

\sqrt{(40 - 25)^2 + (80 - 50)^2} = \sqrt{225 + 900} = 33.54

The smaller the distance, the more similar the customers. This simple concept becomes the backbone of clustering algorithms like K-Means.

Scaling to Higher Dimensions (and Real-World Problems)

What if we add more features, like number of purchases or average transaction amount? The Euclidean distance formula adapts effortlessly:

\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2 + (z_2 - z_1)^2 + \dots}

Even in 100-dimensional space, the principle remains the same simplified as:

\sqrt{\sum_{i=1}^n (x_{i2} - x_{i1})^2}

K-Means Clustering: Geometry in Action

K-Means is one of the most popular clustering algorithms in machine learning. Here’s how it works:

Initialization: Start by guessing initial cluster centers (centroids).
Assignment: Assign each data point to the nearest centroid, using Euclidean distance.
Update: Recalculate the centroids as the average of all points assigned to them.
Repeat: Continue until the centroids stabilize.

Euclidean distance is the heart of this process, ensuring that clusters group together similar points.

Full Circle: A Fourth-Grade Formula in Action

In my customer segmentation project, every customer’s transaction history became a vector in multi-dimensional space. By calculating Euclidean distances, I grouped customers with similar behavior patterns into clusters. This allowed my team to design targeted marketing strategies and predict account growth effectively.

Looking back, it’s incredible to see how a formula I first encountered in elementary school has grown with me, becoming a tool I use every day.

Final Thoughts

Math isn’t just a subject , it’s a lens to understand the world. The Pythagorean theorem, once a tool to solve triangles, now powers machine learning models that drive real-world decisions. Whether it’s triangles on a chalkboard or billion-dollar ML models, the fundamentals remain timeless. Next time you see a right triangle, remember: you’re staring at the foundation of modern AI.

Data Driven Dreams: Building My Data Science Career

Adolph Odhiambo — Mon, 05 Aug 2024 11:58:26 +0000

I wake up every day dreaming of crunching numbers, decoding patterns, and deriving insights that shape the future—right after hitting the snooze button five times and contemplating my life choices. Welcome to the exhilarating, unpredictable, and occasionally maddening world of data science! Here, I will guide you through the labyrinthine journey of building a career in one of today's most sought-after fields, where data scientists are the new rock stars (minus the groupies, of course).

A Fork in the Road: Choosing My Path

After graduating from university, I found myself standing at a crossroads, much like a protagonist in a choose-your-own-adventure book. Should I pursue a master's degree, further entrenching myself in the world of academia, or should I leap into the world of practical skills and possibly insane work hours? The two contenders: data science or software engineering.

Software engineering seemed like the easier choice. After all, I'd been blogging about JavaScript and Node.js for ages, and I could code "Hello World" in my sleep. Never in a thousand lifetimes did I imagine I'd be diving into data science—a field filled with statistical wizardry, machine learning magic, and the occasional existential crisis when your model doesn't work.

Yet, here I am, after a rather depressing job hunt that involved more rejections than I'd like to admit, I found myself with a data science internship. It was a leap of faith, a challenge that I decided to tackle head-on, and now it's become my daily routine. Just picture it: me, sitting in an interview, knowing zilch about data science beyond the introductory courses from college. The only thing I had was the faint memory of my machine learning unit from computer science, which felt about as relevant as a philosophy degree at a tech convention.

The Unexpected Interview Success

I prepared for my interview at one of Kenya's leading financial institutions with the fervor of a detective on a juicy case. And thank the digital gods for GLASSDOOR, which was my saving grace. It felt like having the answers to a test before actually taking it—apart from those pesky technical data science questions. Still, I navigated the interview with the grace of a stumbling giraffe, and somehow, it worked!

Upon landing the internship, I quickly discovered something that would haunt me: impostor syndrome. Surrounded by geniuses, masters of the art, and big names in the Kenyan data industry, I felt like a toddler in a room full of seasoned marathon runners. All I wanted was to become like them—or better—so I had to devise a learning path that would transform me from a data dud to a data dynamo.

Crafting My Learning Path

Creating my learning path was akin to planning a cross-country road trip with only a half-charged GPS and a bag of snacks. I researched online for the best ways to learn data science, acknowledging that my Python programming background would be a helpful, albeit humble, beginning.

I divided my learning path into four critical areas:

Mathematics
Programming
Libraries
Data Science

Here are the resources I've used on this enlightening (and sometimes frustrating) journey.

1. Mathematics: The Language of Data Science

Learning the theoretical background for data science or machine learning can be a daunting experience, as it involves multiple fields of mathematics and a long list of online resources. But fear not! I have broken down these topics into bite-sized pieces that are as digestible as a slice of pizza (or so I tell myself).

Linear Algebra

For linear algebra, Khan Academy came in handy. It's like having a personal math tutor who doesn't judge your lack of algebraic prowess. It will really build your mathematical confidence because you can start from the level you understand, whether it's high school algebra or the more advanced stuff you only pretend to understand.

Calculus

Let's face it, calculus is a bit like cilantro—some people love it, and some people can't stand it. But if you're in data science, you need to acquire a taste for it. Luckily, Khan Academy offers a course that makes it as palatable as possible:

Khan Academy Calculus

Probability and Statistics

Statistics are to data science what salt is to cooking; you can't do without them. And no, making things up and calling it "intuitive" doesn't count.

Khan Academy Probability and Statistics

2. Programming: The Backbone of Data Science

For programming, I turned to Colt Steele, whose teaching style is as engaging as a Netflix series you binge-watch on a lazy Sunday. His course helped me grasp Python concepts with ease and confidence.

Modern Python 3 Bootcamp by Colt Steele on Udemy

3. Libraries: Tools of the Trade

Once you've wrapped your head around the mathematics and programming, it's time to roll up your sleeves and get down to business with data science libraries. These are the Swiss Army knives of data science, and they're indispensable for anyone serious about the field.

I found a fantastic course by Zero to Mastery that offers a hands-on approach to learning these essential tools:

Machine Learning Course on Udemy

4. Data Science: The Grand Finale

This is where it all comes together. After sweating through math problems, debugging Python code, and making friends with libraries, you're ready to take on data science projects like a boss.

So, there you have it! My carefully curated data science learning path, shared with the world for the common good. Whether you're a fellow beginner or a seasoned pro looking for some new resources, I hope this helps you expand your machine learning knowledge and overcome the fear of discovering what's happening behind the scenes of your sklearn, Keras, and pandas import statements.

Your contributions and feedback are more than welcome! Feel free to review one of the listed resources or add new, remarkable ones in the comments. Let's learn, laugh, and conquer the data science world together—one import statement at a time!

Unlocking the Power of JSON Web Tokens: Demystifying Authorization and Authentication in Node.js

Adolph Odhiambo — Mon, 05 Aug 2024 10:57:52 +0000

In the vast digital landscape of today's interconnected applications, ensuring secure access and protecting user data are of paramount importance. As developers, we need reliable tools to handle authorization and authentication effectively. Enter JSON Web Tokens (JWTs), a compact and self-contained way to securely transmit information between parties as a JSON object. In the realm of Node.js, JWTs have emerged as a popular choice for implementing authorization and authentication mechanisms. In this blog post, we will dive into the world of JWTs, exploring their inner workings and uncovering how they can bolster the security of your Node.js applications. So fasten your seatbelts and get ready to embark on a journey where we unravel the secrets behind JWT-based authorization and authentication in Node.js.

What is jwt ??

At its core, a JWT is a string comprised of three distinct parts: the header, the payload, and the signature. The header contains information about the type of token and the algorithm used to sign it. The payload carries the claims or assertions about the user, such as their identity and any additional metadata. Finally, the signature ensures the integrity and authenticity of the token, preventing tampering and unauthorized modifications.

One of the significant advantages of JWTs is their self-contained nature, meaning all the necessary information is embedded within the token itself. This characteristic eliminates the need for server-side storage or database lookups, reducing the overall complexity and improving scalability. Additionally, the compact size of JWTs makes them ideal for transmitting across networks and storing within cookies or local storage.

When it comes to authentication, JWTs offer a reliable way to verify the identity of a user. Once a user provides their credentials, such as a username and password, the server can generate a JWT and send it back to the client. This token can then be included in subsequent requests, allowing the server to validate the user's identity without needing to store session data or perform database queries.

Authorization, on the other hand, deals with determining what actions a user is allowed to perform within an application. JWTs can carry additional claims in the payload, such as user roles or permissions, which can be utilized by the server to grant or deny access to certain resources or functionalities. By decoding the JWT and examining its payload, the server can make informed decisions about what the user is authorized to do.

NUFF said let's get our hands dirt !!!!

For this tutorial I am going to use Node js and following the MVC pattern a popular software architectural pattern.

Prerequisites

Installed Nodejs
Installed MongoDb
Code Editor

Here is my tree structure

1.Initializing the npm, run the following in the terminal

npm init -y

Install the required dependencies:

npm install express axios mongoose bcryptjs cookie-parser cors dotenv hbs jsonwebtoken

In the root folder create a folder with the name src inside the src folder create another folder called db we will use the db folder to store the database configurations . I will be using mongoDb

Create a file inside db and name it mongoose.js which looks like this

const mongoose = require("mongoose");
mongoose.set('strictQuery', false);

function connection() {
    mongoose.connect("mongodb://127.0.0.1:27017/authSec");
}

module.exports = { connection };

The code above begins by importing the mongoose library, which is a popular Object-Document Mapping (ODM) library for MongoDB in Node.js. This library simplifies the interaction with MongoDB by providing a higher-level API and data modeling capabilities.

The line mongoose.set('strictQuery', false); sets the strictQuery option to false. This option allows more flexibility when querying the database, as it disables the strict mode for queries. In strict mode, Mongoose throws an error if you try to query with undefined fields. Setting it to false allows querying with undefined fields without throwing an error.

The connection function is defined, which is exported as a module. It handles establishing a connection to the MongoDB database. The mongoose.connect method is used to connect to the database specified by the MongoDB connection string mongodb://127.0.0.1:27017/authSec. Modify the connection string as per your MongoDB setup.

Finally, the connection function is exported using module.exports, allowing other parts of the application to import and utilize this function to establish a connection with the MongoDB database.

To use this code, you would typically import the connection function from this module and call it whenever you need to establish a connection with your MongoDB database.

After initializing our database let's move to the server .Inside the src folder create two files server.js and app.js.
We will have the following code inside the server.js.

const http = require("http");

const app = require("./app");

const PORT = process.env.PORT || 3000;

const server = http.createServer(app);
const { connection } = require("./db/mongoose");

server.listen(PORT, async() => {
    // console.log(`server has started on ${PORT}`)

    await connection();
    console.log(`server is listening on port ${PORT}`
    );
});

The code begins by importing the http module, which is a built-in Node.js module that provides functionality for creating HTTP servers.
The app module is imported using require("./app"). This refers to a separate file that defines an Express application, which handles the routing and middleware logic for the server. We will create this file later
The PORT constant is defined, which specifies the port number on which the server will listen. It is set to the value of the process.env.PORT environment variable, which allows the server to use the port specified by the hosting environment. If the environment variable is not set, it defaults to port 3000.
The http.createServer(app) method is used to create an HTTP server instance, passing the app module as the request handler. This associates the Express application with the server, allowing it to handle incoming HTTP requests.
The connection function is imported from the "./db/mongoose" module. This likely refers to a separate file that establishes a connection to a MongoDB database using Mongoose.

Creating Weather App using Weather API and Node Js : Part Two

Adolph Odhiambo — Wed, 13 Jul 2022 22:34:48 +0000

In part one 👉👉 (Part One) we made our API get the longitudes of the location we want. In this part we are really going to get the weather data of the location using another API.

We are going to use Weather Stack.The first step to using the API is to authenticate with your weatherstack account's unique API access key, which can be found in your account dashboard after registration. To authenticate with the API, simply use the base URL below and pass your API access key to the API's access_key parameter.

http://api.weatherstack.com/current
    ? access_key = YOUR_ACCESS_KEY
    & query = {coordinates}

Weather Stack is easy to integrate and there is an option of passing the place name you want to get the weather here is an example

http://api.weatherstack.com/current
    ? access_key = YOUR_ACCESS_KEY
    & query = New York

But today we are going to use the geoCoding where we will pass the coordinates returned from the geoCode function we created in part One.In part one the function returns an object so to access the latitude will be cordinates.latitude and longitude we use cordinates.latitude.

geoCode("Nairobi").then(async function(cordinates){
   response = await axios.get(`http://api.weatherstack.com/current?access_key=**your Accesskey&query=${cordinates.latitude},${cordinates.longitude}&units=m`)
   const description=response.data.current.weather_descriptions[0];
   const temperature = response.data.current.temperature;
   const timeTaken = response.data.current.observation_time;


})

This code will get us the weather data but we are going to only use the description ,temperature and time the data was recorded.

In the next part we will be structuring our files and start working with express

Creating Weather App using Weather API and Node Js : Part One

Adolph Odhiambo — Sat, 09 Jul 2022 19:20:50 +0000

We are going to create a webapp using Nodejs ,express and an API, Here is the link to what we are going to build .You only need basic understanding of routes ,async function and promises .The front end may be trash but the focus here is node Js and express 😂. So let's get our hands dirty.

So the first thing you do on the website is inserting the location, I know there are other easier APIs to convert location to API easily but here we are going to use two API's just for practice .The first API we are going to use is mapbox ,head over to https://account.mapbox.com/auth/signup/ and create an account. After creating your account head over to https://account.mapbox.com/ here you will have to copy your "default public token" 👇👇👇👇

I
So head over to your favorite code editor , i am going to use vsCode.
In mapbox we are going to pass the address so that it returns the longitude and latitude

We create a file called app.js 1.In the file we create an async function with the name geoCode

async function geoCode(){


}

From the map box documentation we have to make a request to the API ,the api we are using here is the geocoding api https://docs.mapbox.com/api/search/geocoding/ .

We are making a request to this api

https://api.mapbox.com/geocoding/v5/mapbox.places/**the address you want to get the longitudes**.json?access_token=**Your default public access token**

In the example below I am going to use New York as my address,but sorry because i will hide my access token use the one you copied from mapbox
https://api.mapbox.com/geocoding/v5/mapbox.places/New York.json?access_token=place your access token here

To test if our request works let us post the link above to a new web browser app i am going to use Chrome.

If your request worked you are going to see something similar to the above.

The data returned is a JSON so let us use the JSON viewer chrome extension to format the response.

The data is now readable and you can see the response is a result of all places with the name "New York" but we want the New York which is the capital of USA so we can set the limit to 1 read more about it here https://docs.mapbox.com/api/search/geocoding/#geocoding-response-object.
To add the limit we &limit=1 at the end of the URL

So if we set the limit our code will look like this https://api.mapbox.com/geocoding/v5/mapbox.places/New York.json?access_token=place your access token here&limit=1

We now have one result and that is nice ,now let us go back to our code editor and create a constant const url which will be equal to the url we request data with.The code will look something like this

async function geoCode(){
 const url = "https://api.mapbox.com/geocoding/v5/mapbox.places/newyork.json?access_token=place your access token here&limit=1";

}

Before we continue i'm assuming you have already installed node in your computer without errors.

Let us now open the VS code terminal and install node packages
so in my terminal and in the root folder i am going to run the command npm init -y .

This will create a new folder called package.json .
We are going to install axios which we will be using to fetch data from the API. To install AXIOS we use npm install axios

To use axios we need to require it const axios = require("axios".

This is how our code looks like now, we will also console.log the response

const axios = require("axios")

async function geoCode(){

 const url = "https://api.mapbox.com/geocoding/v5/mapbox.places/newyork.json?access_token=place your access token here&limit=1";
response = await axios.get(url);
console.log(response.data)
}

geocode()   //calling the function

when we run our app.js file we are able to see the results on the terminal.Remember we were only using mapbox to get the coordinates which are stored in response.data.features[0].center. So we let's implement that on our code

const axios = require("axios")

async function geoCode(){

 const url = "https://api.mapbox.com/geocoding/v5/mapbox.places/newyork.json?access_token=place your access token here&limit=1";
response = await axios.get(url);
console.log(response.data.features[0].center)
}

geocode()   //calling the function

So the center array contains the longitude and latitude, with the longitude having an index of 0 and the latitode have an index of 1.

In our code we are going to console.log an object containing an object.
const cordinates= { longitude: response.data.features[0].center[1], latitude: response.data.features[0].center[0] }
then we return cordinates because we will use the cordinates later.

Here is our code now

const axios = require("axios")

async function geoCode(){

 const url = "https://api.mapbox.com/geocoding/v5/mapbox.places/newyork.json?access_token=place your access token here&limit=1";
response = await axios.get(url);
const cordinates= {
   longitude: response.data.features[0].center[1],
   latitude: response.data.features[0].center[0]
}

return cordinates;
}
}

geocode()   //calling the function

We need to load the address dynamically so let us create a constant const address = Nairobi .(Nairobi is the capital city of Kenya). So we concatenated the address in the url , our url variable will be

const address = "Nairobi"
const url `https://api.mapbox.com/geocoding/v5/mapbox.places/${address}.json?access_token=place your access token here&limit=1`;

We are now done for our part One let us continue making our weather app in part two.Here is our our final code

const axios = require("axios")

async function geoCode(){

const address = "Nairobi" 
 const url = "https://api.mapbox.com/geocoding/v5/mapbox.places/${address}.json?access_token=place your access token here&limit=1";
response = await axios.get(url);
const cordinates= {
   longitude: response.data.features[0].center[1],
   latitude: response.data.features[0].center[0]
}

return cordinates;
}
}

geocode()   //calling the function