Forem: Robin Kiplangat

Decomposition.

Robin Kiplangat — Mon, 20 May 2024 08:55:26 +0000

In the world of data science, web scraping is a common method for gathering data from the internet. However, it can be a complex task, especially for those new to programming.
This is where decomposition comes into play. It's a method that helps you understand the overall structure and logic of a program by presenting it in a simplified, step-by-step manner, making it more accessible to both techies and non-techies alike.

In this post, we'll walk you through an example of how decomposition can be used to scrape data from a website.

What is decomposition.?

Decomposition refers to the process of breaking down a large, complex tasks into smaller, more manageable subtasks. This approach simplifies the problem-solving process, making it easier to understand, design, and implement solutions.

It involves creating a detailed plan, executing each step individually, and constantly reviewing and adjusting the plan as needed.

This method is particularly useful in programming tasks, as it allows for better error handling and debugging.

The Task at Hand

Our goal is to scrape data from pages on a website. We want to extract information such as the title, description, contact information, and images of each page.

Step 1: Planning

The first step is to create a detailed plan. For our task, the plan might look something like this:

Fetch the HTML content of the webpage.
Parse the HTML content to extract the required data.
Save the extracted data in a structured format.
Download the image of the initiative.

Step 2: Fetching the Webpage Content

We'll use the requests library in Python to fetch the HTML content of the webpage. Here's a simple function that does this:

import requests

def fetch_page_content(url):
  response = requests.get(url)
return response.text

Step 3: Parsing the HTML Content

Next, we'll use the BeautifulSoup library to parse the HTML content and extract the required data. We'll create a function called extract_data that takes the HTML content as input and returns a dictionary with the extracted data.

from bs4 import BeautifulSoup

def extract_data(html_content):
  soup = BeautifulSoup(html_content, 'html.parser')
  # Extract the data…
return data

Step 4: Saving the Data

Once we have the data, we can save it in a structured format. For simplicity, we'll just print the data for now.

for url in urls:
  html_content = fetch_page_content(url)
  data = extract_data(html_content)
print(data)

Step 5: Downloading the images

Finally, we'll create a function to download the image of each initiative. We'll use the requests library again to fetch the image, and then save it to a file.

def download_image(url, title):
  response = requests.get(url)
  with open(f'{title}.png', 'wb') as f:
    f.write(response.content)

So Now . .

And that's it! With decomposition, we've broken down a complex task into manageable steps, making it easier to understand and execute. This method is not only useful for web scraping, but for any programming task. So next time you're faced with a complex task, give it a try!

Navigating building AI products: A Step-by-Step Guide

Robin Kiplangat — Wed, 01 Nov 2023 10:00:00 +0000

Introduction

Imagine having to go through a stack of lab reports, each filled with complex medical jargon and lengthy explanations. It’s a daunting task, isn’t it? But what if we could use Artificial Intelligence (AI) to simplify this process?

In this blog post, I’ll guide you on how to create a tool that uses AI to read and summarize lab reports. This tool uses two key components: Langchain and OpenAI.

What are Langchain and OpenAI?

Before we dive into the how-to, let’s understand what Langchain and OpenAI are. Langchain is a library that allows us to combine different AI models to perform complex tasks. Think of Langchain as a master chef who knows how to combine different ingredients (in our case, AI models) to create a delicious dish (a summary in our case 😋)

OpenAI, on the other hand, is an AI research lab that provides powerful AI models. We use one of their models, GPT-3.5-turbo, to process the lab reports and generate a summary.

The Magic Behind the Scenes

Our tool consists of two parts: a backend script that processes the lab reports and a frontend script that provides a user interface. The backend script reads the text from a PDF file, identifies the key points using OpenAI, and then creates a summary using Langchain. The frontend script provides a user-friendly interface where you can upload your lab report, and displays the key points and the summary of the report.

Building the AI Tool: A Step-by-Step Guide

Now that we’ve set the stage, let’s get our hands dirty and start building this tool.

A. Backend Script

Install the necessary libraries: First, we need to install some libraries. If you’ve ever baked a cake, think of this step as gathering your ingredients. You can install the libraries using pip, which is a package manager for Python.

git clone https://github.com/robinkiplangat/LabScanner.git
cd LabScanner
pip install -r requirements.txt

Get your OpenAI API key: To use OpenAI, you need an API key. You can get this key from the OpenAI website after creating an account.

Run the backend script: Once you have your ingredients ready, it’s time to start baking! You can run the backend script using Python.

python3 scripts/reports_frontend.py

B. Frontend Script

Install Streamlit : The frontend script is a Streamlit application. Streamlit is a library that allows you to create web applications using Python. You can install it using pip.

Run the frontend script : Once you have installed Streamlit, you can run the frontend script. This will open a new tab in your web browser with the application.

streamlit run scripts/reports_frontend.py

To use the application, upload a lab report, enter your OpenAI API key, and click Submit. Check out the demo below.

Set Up a Self Hosted Outline VPN with Amazon LightSail in 5 steps.

Robin Kiplangat — Thu, 24 Aug 2023 07:22:43 +0000

Outline, a free and open-source VPN service developed by Google, is renowned for its user-friendly design. It can be conveniently established on diverse platforms, and this blog will specifically guide you through the process of setting up a self-hosted Outline VPN using Amazon LightSail.

Prerequisites

Before diving into the procedure, ensure you have the basics:

An active Amazon LightSail account.
A computer equipped with a web browser.

Step 1: Set Up the Outline Manager

Kick-start your setup by downloading and installing the Outline Manager desktop application. This is your control centre for establishing and managing your server.

Post-setup, click on the Add Server option to begin the process of creating your server , Then select the option for configuring the application on an AWS Linux server.

Step 2: Incorporate Outline on Your Amazon LightSail Instance

Once the instance is created, the next step would be integrating the Outline server with your instance.
For this:

Head over to the Amazon Lightsail instances screen.
Select the instance you wish to host Outline on and switch to the Networking tab.
In the Firewall section, click Add Rule and ;
Assign All Protocols a value of All TCP+UDP.
Save the changes.

Step 3: Establish Connection to Your Instance

Choose your preferred method to connect to your instance; it could either be through your browser or an SSH client that aligns with your requirements.

Next, connect to your server and execute the following command that can be traced back to the setup instructions offered in the manager:



sudo bash -c "$(wget -qO- https://raw.githubusercontent.com/Jigsaw-Code/outline-server/master/src/server_manager/install_scripts/install_server.sh)"

Follow the subsequent instructions to successfully install Outline on your instance.

Step 4: Configuring the Outline Server

With Outline now a part of your instance, it's time to configure it as per your requirements. To accomplish this, paste the installation output from your SSH session onto the manager and click Done to finalize the configurations.

Step 5: Adding and Connecting Keys

With the server now configured, the next move involves adding keys and establishing a connection to the server.

Open the Outline application on your computer and provide the name and address of your server for this process. After successfully connecting to your server, utilize unhindered access to the internet through it.

Conclusion

This guide offers a comprehensive panorama of the process to set up a self-hosted Outline VPN with Amazon LightSail. Remember, this is a basic outline, and for more detailed understanding and troubleshooting, always refer to the Outline documentation