DEV Community: Abednego Emonena

Implementing Linear Regression from scratch using python

Abednego Emonena — Tue, 05 Sep 2023 11:09:16 +0000

Linear Regression is an essential machine learning algorithm used in various applications today. It works by finding the relationship between a variable or target and one or more data points also known as features by fitting linear equations on the data points. As a machine learning engineer or an aspiring machine learning engineer, you will most possibly find yourself using this algorithm on a day-to-day basis to solve some machine learning problems. In this article, I will be walking you through a step-by-step process on how to implement this same algorithm yourself from scratch using Python. We will also be exploring the linear algorithm intuition so you can understand the mathematical equations behind this powerful algorithm.

lets dive in ...

What is linear Regression?

Linear regression is an algorithm that aims to find the best fit linear relationship between an independent variables(features) and a dependent variable(target). It is denoted by this formula:

y = wx + b

where:

w = parameters (weights)

b = Bias (parameters)

X = features

the goal is to find the parameters w and b that will best fit the data.

How does linear regression works?

Linear regression works by multiplying the weights and the features plus the bias and constantly updating the parameters till the cost J(X) is minimized

Cost Function

Since the goal in linear regression is to find the best line that fits the data, the cost function is the metric used to measure how well the model is performing. This is done by calculating the difference between the predicted value and the actual value.

In linear regression, the popular cost function used is "Mean Squared Error Cost Function"

where h(x) is the predicted value ^y gotten using the linear function y = wx + b across all training examples

y = the actual value

m = the number of training examples

and by constantly optimizing the value of weights and bias, we can minimize the cost function and therefore increase the model accuracy.

Gradient Descent

One very fascinating question is that, "how do we optimize the parameters?". Well, this is done by iterating n number of times, and for each iteration, we take the derivative of the cost J(X), subtract it from the learning rate and updating the parameter with it

I know it sounds confusing,

theta(j) is the parameter weights

alpha = the learning rate, it can be a constant value.

Linear Regression in Python code

import numpy as np

class LinearRegression:
    def __init__ (self, learning_rate=0.01, iter=1000):
        self.lr = learning_rate
        self.iter = iter
        self.weights = None
        self.bias = 0

    def fit(self, X, y):
        n_sample, n_feature = X.shape
        self.weights = np.zeros(n_feature)
        y_pred = self.predict(X)

        for _ in range(self.iter):
            self.weights = self.weights - self.lr * np.dot(
                                           X.T, y_pred - y)
            self.bias = self.bias - self.lr * np.sum(y_pred - y)

    def predict(self, X):
        y_pred = np.dot(X, self.weights) + self.bias
        return y_pred

import numpy as np: This line imports the NumPy library and aliases it as np. NumPy is used for numerical computations, and it's a fundamental library for data manipulation in Python.

class LinearRegression:: This defines a Python class named LinearRegression, which is used to encapsulate the linear regression model and its methods.
def __init__ (self, learning_rate=0.01, iter=1000):: This is the constructor method for the LinearRegression class. It initializes the class attributes:
def fit(self, X, y): This method is used to train the linear regression model. It takes two parameters:

Inside this method:

It calculates the number of samples (n_sample) and the number of features (n_feature) in the input data.
Initializes the weights attribute as an array of zeros with a length equal to the number of features.
Predicts the target variable (y_pred) using the predict method (which is expected to be defined elsewhere in the class).
It performs gradient descent to update the weights and bias iteratively based on the prediction error (the difference between y_pred and y) and the learning rate.

def predict(self, X):: This method is used to make predictions using the trained linear regression model. It takes the input features X as a parameter and returns the predicted values y_pred. Inside this method:

Linear regression is absolutely an essential and interesting algorithm to use as a machine learning engineer.

With this model, you can now solve any supervise learning problem, Also, note that this implementation of linear regression is quite simple and might need some optimization method to help it predict more accurate value.

Thanks for reading

Machine Learning explained for complete Newbie

Abednego Emonena — Mon, 04 Sep 2023 11:12:32 +0000

Introduction

Machine learning is a buzzword that has fascinated a lot of people and has the potential to greatly change how we interact with technology, from virtual assistants, self-driving cars, and large language models like Chatgpt and Bard, to Image generation like Stability AI and Mid Journey. In this blog post, I will explain to you the concept of machine learning in the smallest possible way so that even a newbie can grasp it.

What is Machine Learning?

Machine Learning is a subset of Artificial intelligence that is focused on teaching computers to learn without being explicitly programmed to do so.

Machine Learning involves training computers to learn from data to make predictions or make decisions. For example, you can train a computer on a bunch of e-commerce data and it will learn how to predict which product has the potential to make a hit.

Types of Machine Learning

Machine Learning is a wide field that can be divided into different types..

Supervised learning:

Supervised learning is a type of machine learning that involves training a computer with data that includes its label, For example, you can train a computer on the height, weight as well as gender of a person along with their age, and have it learn and predict the age of another person given the weight, height and gender. In summary, in supervised learning the computer is trained on data containing the features as well as its corresponding output or target.

Unsupervised Learning:

In unsupervised Learning, the machine or computer is given only a set of data without the corresponding output so it learns to understand the data and group similar data together based on what it has learned. This type of machine learning algorithm is mostly used for customer segmentation, anomaly detection, recommendation systems, image and audio processing, natural language processing(NLP) etc.

Reinforcement Learning:

"Reinforcement Learning" is one of the major categories of machine learning and artificial intelligence that focuses on training intelligent agents to make sequences of decisions in an environment to maximize a cumulative reward signal. It is often used in scenarios where an agent interacts with an environment, learns from these interactions, and adapts its behavior to achieve specific goals or tasks. Here's an explanation of the key concepts and components of reinforcement learning:

Agent : The learner or decision-maker that interacts with the environment. The agent makes a sequence of decisions to achieve a goal.
Environment : The external system or world with which the agent interacts. The environment provides feedback to the agent based on its actions.
State (s): A representation of the current situation or configuration of the environment. The state is crucial for decision-making as it encodes all relevant information.
Action (a): The choices or decisions made by the agent in response to the current state. Actions are selected from a set of possible options.
Policy (): A strategy or function that defines the mapping from states to actions. It guides the agent's decision-making process.
Reward (r): A numerical signal provided by the environment after each action. The reward indicates the immediate benefit or cost associated with the chosen action. The agent's objective is typically to maximize the cumulative reward over time.
Trajectory or Episode : A sequence of states, actions, and rewards that occur during the interaction between the agent and the environment. A trajectory represents one complete interaction cycle.

Reinforcement learning is mostly used in various domains, including robotics, games, self-driving cars, recommendation engines etc. It is a powerful paradigm for enabling machines to learn and make decisions in complex, dynamic environments through trial and error.

Popular Algorithm in Machine Learning

Linear Regression: Linear Regression is a popular machine-learning algorithm that aims to find the relationship between a variable (target) and one or more features. It learns to achieve this by fitting a linear equation to the data. This type of algorithm falls under the supervised learning category and it is mostly used for data where their target is a continuous value, such as predicting the price of a house or predicting the salary of a person based on the number of experience etc.

Logistic Regression: Logistic regression is mostly used to learn data where their output or target is binary 0 or 1. This is mostly used to solve classification problems and then has only 2 possible outputs. This algorithm is supervised learning and it's used in cases such as predicting if an email is spam or not, checking if the rain will fall or not or predicting if the stock market will go green or red etc.

K-Means Algorithm: The k-means algorithm falls under the unsupervised learning category.
It is also a clustering method designed to partition a dataset into 'k' distinct, non-overlapping groups or clusters. These clusters are formed based on the similarity of data points, where each cluster represents data points that are more similar to each other than to those in other clusters.

Machine learning is such an interesting field for people who are excited about AI, curious about data, and eager to explore the limitless possibilities of training intelligent systems. Whether you aspire to teach machines to recognize patterns in vast datasets, create robots that can navigate complex environments, or develop algorithms that mimic human decision-making, the world of machine learning offers an incredible journey of discovery and innovation. As technology continues to advance, the opportunities to shape the future through machine learning are boundless, making it an exhilarating path for those with a passion for pushing the boundaries of what's possible.

Thank yu for reading.

Understanding Latency vs Throughput - system design

Abednego Emonena — Sat, 27 May 2023 12:02:13 +0000

Understanding the difference between latency and throughput in a system design will help you design better system that is both scalable and high in performance. It is also an important metric to measure the performance of a system.

In this article, you will understand the difference between this two and how it can affect your system positively and negatively.

But what exactly is Latency?

What is latency?

Latency refers to how long or how much time it takes a system to handle a request, this is often measured in milliseconds or microseconds.

An increase in latency or high latency will mean that your system takes longer time to process a request.

Let use a web server as an example.

Assuming it takes your web server 0.05 milliseconds to process a single request and probably due to network congestion, inefficient algorithm or load on resources, it now takes your server 2millisec to process a request, this is said to be high latency.

High latency slows down your system performance.

What is throughput?

Throughput refers to the number of requests a system can handle at the same time. It is usually measured in requests per second, transactions per second, or even bits per seconds.

There are different factor's that can affect throughput:

Limited CPU
Memory capacity etc

An increase in throughput should always be considered when designing a system that is scalable. It is also widely considered when designing systems such as network, database or storage systems

Here are 4 ways to increase throughput in your system and increase scalability.

Load Balancing
Caching mechanisms
Optimized algorithm or data structure
Increase hardware capacity etc

Load Balancing

This is when you use reverse proxy to distribute incoming requests to different servers such that each server is able to process requests without exceeding it's capacity.

Let's say we have 1 million request coming in through the load Balancer and you have 4 web servers, this requests will not be sent to a single server but rather distributed using an algorithm equally to this 4 servers. This approach can help increase throughput in your system at the cost of latency.

Caching mechanisms

Caching is also an important factor when increasing throughput, and this is by storing frequently used data in a cache. This is to avoid fetching data too frequently from the primary database beyond the server capacity.

Caching can significantly reduce the need for repetitive computations or data retrieval, improving overall system throughput.

Optimized algorithm or data structure

You need to always look for opportunities to improve your algorithm and data structure. Using an optimized algorithm can affect your system greatly positively.

Increase hardware capacity

If your system is limited by your hardware resources, you should consider upgrading or increasing it. This could include increasing CPU cores, memory capacity, disk I/O speed, or network bandwidth to handle higher workloads.

In summary, There is great benefit when you consider latency and throughput when designing a system but there is a tradeoff, increasing your throughput often results in high latency so you should consider which to sacrifice and best for your system.

A step by step guide to building Blog ApI with Django Rest Framework Part 1

Abednego Emonena — Thu, 16 Mar 2023 20:41:14 +0000

In this post, I will cover how you can build a blog API in DRF (Django Rest Framework). This is a step-by-step guide that will help you get started in building your (probably) first API project.

I will assume you already have python installed on your computer and that you know at least basic python, if not you can check out other tutorials on how to do that.

so lets get started:

First open your VSCode Editor or your ubuntu terminal but for this project i will be using my ubuntu terminal but the process remains almost the same with your vscode

create a project project and change into it

mkdir BlogApi
cd BlogApi

Next is to setup a virtual environment so as to isolate your project from other projects.

And you can do that using this command

python -m venv <virtual evironment name>

you can replace with any name of your choice but for this tutorial, we will be using "env" as our vuitual environment name

python -m venv env

Activate your virtual environment

source .env/Scripts/activate
or
./env/Scripts/activate

you will notice your terminal changed to something like this

(env) PS C:\Users\HP\BlogAPI

depending on what you are using.

Now lets move to the next step, which is installing Django.

In your current working directory,

type this command to install django

pip install django

wait for fews seconds and voila...Django finally installed

if you have come this far without experiencing any error, congratulation and if you did, that's also awesome

take a deep breath, recheck where you messed up, google your errors as you try to fix them. Bux and Developers are the most closest partners .

Now let's proceed..

currently this is how your directory should look like

BlogApi/
 env/
     Scripts/
     include/
     lib/
     pyvenv.cfg

now lets create our django project.. in the same directory, type

django-admin startproject blogapi .

and our django app

python manage.py startapp blog

by now your directory should be like this

BlogApi/
 env/
    bin/
    include/
    lib/
    pyvenv.cfg
 manage.py
 blogapi/
    __init__.py
    settings.py
    urls.py
    wsgi.py
 blog/
     __init__.py
     admin.py
     apps.py
     models.py
     tests.py
     views.py

if all is as it is, then lets proceed

When this is done, you will have to add your app to your main project. Here is how to do that

Open the settings.py file located in your project folder BlogApi/blogapi/settings.py using your code editor.
Find the INSTALLED_APPS list in the file, which should already have some default apps installed like django.contrib.admin, django.contrib.auth, etc.
Add the name of your app 'blog' at the end of the list, like this:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',
]

Now let's define our Blog model in the models.py file:

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=100)

    def __str__ (self):
        return self.name
class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    category = models.ForeignKey(Category, on_delete=PROTECT)

    def __str__ (self):
        return self.title

This creates a Post model with four fields: title, content, created_at, and updated_at. The created_at field will be automatically set to the current date and time when a new post is created, and the updated_at field will be automatically updated to the current date and time whenever a post is updated.

after creating your models, you have to run the this command to make the neccesary migrations

python manage.py makemigrations
python manage.py migrate

Next, let's create a serializer for our Post model. But before we do that, we first need to install django rest framework

pip install djangorestframework

then add it in to your list of installed app in your settings.py file

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',
    'djangorestframework',
]

Now when that is done, create a serializer.py file in your app directory.

In the serializers.py file in the blog app, add the following code:

from rest_framework import serializers
from .models import Post, Category

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ('id', 'name')

class PostSerializer(serializers.ModelSerializer):
    Category = CategorySerializer()
    class Meta:
        model = Post
        fields = ('id', 'title', 'content', 'created_at', 'updated_at', 'category')

This creates a PostSerializer that will serialize our Post model into JSON format. The serializer includes all the fields in the Post model same thing also applies to the category but if you noticed we added a category field to the PostSerializer this is so that we can include the category the post belongs to when we call the API.

Now we need to create views that will handle the HTTP requests for our API. In the views.py file in the blog app, add the following code:

from rest_framework import generics
from .models import Post
from .serializers import PostSerializer

class PostList(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

class PostDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

The first class PostList will handle the get and post request which means that you can retrieve all posts and create a new post in the database. While the second class PostDetail will handle the get, put, patch and delete of a specific post .

Here's a brief overview of what these methods mean:

GET: Used to retrieve a resource or a list of resources from a server. It is a safe method that should not modify any resources on the server.
PUT: Used to update a resource on the server. It replaces the entire resource with the new data provided in the request.
PATCH: Used to update a resource on the server. It is similar to PUT, but only updates the fields that are provided in the request, leaving the rest of the fields unchanged.
DELETE: Used to delete a resource from the server.

now that you understand what each of these methods means, lets proceed to the next step which is configuring our urls.

If you check your directory Blog, you will notice that urls.py file isn't present by default, so we are going to create one..

when created,In the urls.py file in the blog app, add the following code:

from django.urls import path
from blog.views import PostList, PostDetail

urlpatterns = [
    path('posts/', PostList.as_view(), name='post-list'),
    path('posts/<int:pk>/', PostDetail.as_view(), name='post-detail'),
]

This creates two URLs: /posts/ for the PostList view, and /posts/<int:pk>/ for the PostDetail view

Also the urls.py in the blogapi project directory, you need to map your app urls to your project urls.

In the urls.py file, import the include function from the django.urls module

from django.urls import path, include

Then define a URL pattern that includes the URL patterns of your app. You can do this by adding the following line of code to the urlpatterns list:

urlpatterns = [
    path('admin/', admin.site.urls)),
    path('blog/', include('blog.urls')),
   # other URL patterns go here
]

Hooray!!!

If you made it this far, it means you have finally created your own BlogApi project, you can now start the development server and access your API by running

python manage.py runserver

and access your api using

 http://localhost:8000/posts/
or
 http://localhost:8000/posts/<postid>

So thats it, congratulation !!!, In my next post, i will share with you how to add Filtering, Searching and Ordering feature to your API project.

GPT-4 has finally arrived: Here is what you need to know

Abednego Emonena — Thu, 16 Mar 2023 07:57:12 +0000

If you are as excited as I am, then you probably have been expecting the arrival of GPT-4 as well. It was less than 1 year ago when OpenAI opened access to the most advanced chatbot called chatgpt, The AI with about 175,000,000 parameters is capable of generating human-like text with almost 100% accuracy, able to write codes, writes documents, communicating and answering questions faster and better than a google search.

This has put a lot of people in fear that their job will be replaced by AI very soon. OpenAI also announced that they were working on another version of AI known as GPT-4 and it would have over 100,000,000,000(100 billion) parameters. This would mean that it would have more than 10 times the current capacity of GPT-3.

Less than 48hours ago, OpenAi finally launched GPT-4 and this post will give you 5 awesome abilities of GPT-4:

Generate Codes: unlike GPT-3, GPT-4 can generate more larger and accurate codes and can handle 25K input words. You can just simply tell it "Generate a python code for todo app" and it will. Not only that, but it can also be your best debug partner.
Create websites from mockup: This is one amazing ability that makes GPT-4 so awesome.
Build working video games: The ability for it to create an entire game from scratch in any language makes it so super scary. You can tell it to write you a game of pong or even a snake game or to beat it all, tell it to write you a 3d video game.
Generate meaning from images: If you ever come across an image or photo in which you arent sure whats going on in it, give it to GPT-4 and it will explain and tell you what the image is all about.
Prepare and ace exams: With GPT-4, you can prepare and even ace you exams with ease

Web stack Monitoring Made Easy: Why you need to set up web stack monitoring

Abednego Emonena — Wed, 15 Mar 2023 20:30:45 +0000

What is web stack monitoring?

When most people hear the word "monitoring", they know this to be when you are being watched or you are watching over something.

But in software engineering, web stack monitoring is simply when you pay constant attention or monitoring to a different component of your web stack such as web server, application server, database, and other services..

And the type of monitoring can range from collecting data from various performance metrics such as CPU usage, memory usage, network traffic, and disk space utilization, to monitoring the availability and response time of web services, applications, and databases. Depending on the needs and requirements of the organization, monitoring can be performed at various levels, including server-level, application-level, and user-level.

Why do we need to monitor?

Webstack monitoring is an important aspect of maintaining the health and performance of your system, application, or network. Always remember your application isn't perfect and there are times when you will experience failure may be due to high traffic or something else.

Here are 3 reasons why you should consider setting up web monitoring:

Preventing Security Breaches: Not only will you be able to detect some security issues, and you will also be able to detect flaws, potential security threats, and vulnerabilities before hackers have the chance to take advantage of them.
Performance Optimization: Monitoring can help identify bottlenecks, slow response times, and other performance issues that can impact user experience. By analyzing metrics such as response time, throughput, and resource utilization, you can optimize system performance and improve the user experience. For example, if a web page is taking too long to load, monitoring can help identify the cause of the issue and allow you to take corrective action to improve load times.
Improve Decision-Making: Monitoring provides you with valuable data and insights that can help you make informed decisions about resource allocation, capacity planning, and infrastructure investments. By tracking KPIs and analyzing trends, you can identify patterns and make data-driven decisions.

so when next you are thinking of building your next project or you already have an existing one, then you should always consider adding a monitoring tool such as datadog, this way, when your application is about to fail be it from the server, load balancer, database, etc you will be able to detect it early then fix it.

In my next post, I will be sharing with you how to set up a web monitoring tool like (datadog) into your web stack.

What happens when you type google.com in your browser and press Enter?

Abednego Emonena — Tue, 07 Feb 2023 08:27:06 +0000

This post will give you an overview of what happens whenever you try to access a web page through a web browser...

Whenever you entered a URL such as www.google.com into your web browser, the browser sends a request to DNS in order to translate the beautiful and easily remembered URL (google.com) into the IP Address (e.g 127.243.753.12) of the server in which the web page is stored. When the IP is identified, a TCP/IP (Transmission Control Protocol/Internet Protocol) is established. This ensures that data is transmitted successfully and efficiently between your device and the server it is trying to access.

The moment a TCP/IP connection is made, the next is the FIREWALL (which checks for incoming and outgoing network traffic based on certain set of rules) which will check if the request is allowed through to the server.

Once the request is cleared by the FIREWALL , your request will be sent to the LOAD BALANCER which will distribute network traffic among other servers (2 or more) so that a single server will not be overloaded with traffic which might cause a server break down or SPOF (single point of failure).

After passing through the LOAD BALANCER , the request will be sent to the web server which will handle your request and server the necessary css, html and javascript needed to make up the website.

The web server then sends the request to the application server, which is responsible for executing any server-side code and querying the database to retrieve any necessary information.

When that is done, the application server sends the request to the database, which retrieves the requested data and sends it back to the application server. The application server then formats the data and sends it back to the web server, which returns it to the user's browser to be displayed as the Google website.

It's also important to note that, the request is using HTTPS (HTTP Secure), a security protocol that encrypts the transmitted data, adding an extra layer of security to the process. The SSL (Secure Sockets Layer) certificate which is used to encrypt the traffic is also verified by the browser.

5 Most Used Linux Commands For Beginners

Abednego Emonena — Sun, 13 Nov 2022 09:49:47 +0000

After a few months of learning to code in the command line, I have come to understand and get to love using Linux to write most of my programs.

As a beginner who is starting to use Linux, you might find it challenging to use the command line especially if you have gotten so use to working on GUI.

In this post, I will share with you 10 most used Linux Command and it's uses.

1.
pwd: Since you are working in the command line, it might sometimes be difficult for you to know which directory you are working on, that's why pwd meaning print working directory will print out the current directory you are working on.
Usage:

pwd

2.
cd: Also known as change directory will help you navigate your way into directory directory
for example: to change into another directory in the same directory you type

cd <directory_name>

3.
ls: Known as less will will all the files and directory in the current working directory

ls

4.
sudo apt-get install: I use this command most of the time to install essential tools or programs into my Linux machine

sudo apt-get install <program_name>

5.
ps: This command is used to print the PID or Process Id of all currently running processes within your Linux machine.

ps

This are my most used Linux Command,which tend to come in whenever I work in the Linux CLI
Thanks for reading.