DEV Community: Amira Bekhta

How I stay immersed with Data science every day?🔎

Amira Bekhta — Mon, 18 Aug 2025 17:07:41 +0000

After posting a twitter thread in which I shared my best online resources to keep myself immersed with the beautiful world of data science, I decided to make it a more detailed article in which I will explain each online resource and how I use it!

1- Data science blogs:

The world of data science is constantly evolving, with new tools, frameworks, and methodologies emerging at a rapid pace. Because of this dynamic nature, it’s essential for anyone in the field to continuously learn and stay up to date with the latest trends.

1.1 - Data camp blogs:

Staying informed not only keeps your skills relevant but also gives you a competitive edge when tackling real-world problems or applying for new opportunities. For that reason, I make it a habit to read DataCamp articles every week. These articles introduce recent technologies, showcase practical use cases, and delve into important topics that every data scientist should be familiar with – including common interview questions and tips. By keeping up with this kind of content regularly, I ensure that my knowledge stays fresh and aligned with industry expectations.

1.2 - Towards data science:

Another valuable resource I regularly rely on is the Towards Data Science website – a global online publication that brings together thought leaders and practitioners from all over the world. It features in-depth articles and practical tutorials covering a wide range of topics across artificial intelligence, machine learning, and data science. What I like about it is that it doesn’t just cover the theory, but also includes real-world use cases, best practices, and new perspectives from people actively working in the field. By going through these posts on a regular basis, I’m able to expose myself to different ideas and approaches, deepen my understanding of complex concepts, and stay informed on the latest industry developments.

2- Kaggle discussion:

I also believe that actively discussing data science–related topics is extremely valuable. Engaging in conversation allows you not only to reinforce what you already know, but also to expose yourself to alternative viewpoints and new problem-solving strategies. In many cases, explaining a concept to others is one of the best ways to truly master it. That’s why I regularly take part in Kaggle discussions — a collaborative space where data science professionals and enthusiasts share ideas, ask questions, and help one another. The platform offers a unique opportunity to learn from real use cases and contribute your own knowledge, fostering a sense of community and continuous improvement.

3- Exercism.org:

Another important activity that helps me grow, learn, practice, and even give back to the programming community is using Exercism. It’s an amazing platform that offers hands-on practice in a wide range of programming languages — in my case, Python. What makes it especially valuable is that it doesn’t just provide exercises; it also allows you to contribute to open-source projects and support the development of new learning resources. This way, you’re not only improving your own skills through practical challenges and mentor feedback, but also actively contributing to the broader tech community. It’s a great way to turn learning into something collaborative and meaningful.

Got questions/feedback? write everything in the comments?🚀

How I found myself in machine learning - My story 🤖

Amira Bekhta — Mon, 04 Aug 2025 19:41:47 +0000

September 2023, this is the month where I officially started my computer science major. In that period, AI, machine learning, and many similar terms were trendy, and everybody was talking about them, and 90% of the replies I received when I told people that I am going to study computer sciecne was "So you will build ChatGPT, huh?", and as a typical stubborn person, I always rolled my eyes at this question, and think inside my head "Never, everybody talks about AI, I don't want it!"

My first heartbreak

And I started my studies, very excited to start in a world full of semicolons and semantic errors, my freshman year wasn't this much though, I was just following the university courses, thinking that I will decide my future with computer science on the go, and that what I learn in university is already enough.

I remember that the very first course I took in college was a Python course, something simple that teaches things such as print statement, functions, loops, conditionals, and so on, but by the end of that course, I said to myself "Now that I know all this Python, I should build a project", so I went to my bestfriend aka chatgpt and asked it to suggest a project that I can start with, well, every project it named was just something I don't know how to build, so I was like "Screw chatgpt" and I googled this "How to build Youtube using Python?" but Google disappointed me too, and I thought to myself "Uh, so I can't build something with print statement and an if-else clause?!!"

Depressed, I kept following the courses, and didn't even dare to try and read anything about computer science. And then, sophomore year started, and I was just lost there, I didn't feel like I am capable of anything, and I decided I want to build a website, so I started with frontend webdev, and I loved it, my first webpage was basically a stack of sentences, some in H1, some in H2, and so on, and I was very confident that this is my career path and what fate chose for me.

Not my thing

By time, there was something not so interesting about frontend webdev, well, it's so "visual", and I somehow discovered that this is not what I want, so I asked my besty aka chatgpt again, and it told me to try backend.

As someone that knows Python, Django was the first thing I tried, and all I can say about Django is that it tortured me, so I blamed Django and said that it is the problem, and then I moved to PHP, and with many hours with BroCode's PHP tutorial, I realized I am the problem. (BroCode if you read this your PHP tutorial is super amazing, and your tutorials always saved my life <3)

More months of depression, feeling hopeless in life, and then I went very desperatrly to chatgpt, just looking for any CS related thing that I might enjoy, anything at all, chatgpt suggested Machine learning, and I said "NOOOOOO NOT THIS!".

The video that changed my life

I colsed chatgpt, and scrolled youtube a bit, and then, one youtube video catched my attention, this video:

Python for Data Analytics by Luke Barousse (the least I can say about this man is that he is a legend), when I saw it, I was wondering what data analytics really is, and I clicked on the video (thankfully I did), finding that it teaches from the very basics of Python, to a full Portfolio project for data analytics and it felt like all the secrets of the universe were revealed to me then.

"Wow, where were I all this time, I am loving this!" I thought to myself, all of the data, the visualizations, the fact that we can answer questions using data, I was in heaven!

After finishing the course, and reinforcing my knowledge with some Kaggle courses (With free certificates ofc!), I was finally able to make to build what I actually enjoyed, data analytics projects that felt more like having fun than coding to me, especially the Netflix userbase analytics project, one that I more than enjoyed.

ML again?

And with this happiness, and after sharing it with chatgpt, I realized something, "Oh oh, this can take me to ML?!"

That was shocking, it really was, I've always ran away from ML and somehow I found myself approaching it, "Do I proceed?" I asked myself, and at that point, I was very excited, and more than ready, I started simply and slowly, I was afraid of this field, thinking it is only for "Gifted" people (I was actually born gifted, but I was never confident about my capabilities in computer science lol), so I decided to go for intro to machine learning course by Kaggle.

And slowly, I was intorduced to scikit-learn, this is why I followed this legendary course:

And with that, my portfolio started populating, my knowledge started growing, and I didn't go to ML, it came to me, by itself...

My future plans

Right now, I can't say that I am the best AI/ML engineer in the world, but I can't say I am the worst, I am simply someone that succeeded in her journey, and that was finally able to know what she really wants, and what she wants to focus on, and I am planning to work on Microsoft AI & ML engineering professional certificate in Coursera, and I believe it will be more than helpful to make me grasp more concepts and gain more knowledge!

Enjoyed the article? Have feedback/question? Drop everything in the comments! 🫶

Level Up Your Portfolio: Weekend AI Projects You Need to Build! 🚀

Amira Bekhta — Mon, 28 Jul 2025 15:12:11 +0000

Ever felt that your portfolio could use a little extra sparkle, especially when it comes to AI? and don’t worry! You definitely won’t need a P.h.D or months of free time to make it shine, you just need the right mindset, and hey! We're talking about some seriously cool AI projects you can build this weekend, yup, just a couple of days, and you'll have some awesome new additions to show off, ready to dive in and make your portfolio sparkle?

Why Are Weekend Projects Powerful?

You might think you need months to build something impressive, but the truth is that even a small, well-executed idea can make your portfolio stand out, weekend projects are like low-risk experiments, they give you fast wins, let you test new tools or models, and most importantly, they show initiative.
For students, job seekers, and freelancers, these quick builds can act as creative proof of what you’re capable of, far beyond what a CV alone could say.

Whether you want to experiment with generative AI, NLP, computer vision, or practical tools people might actually use, the key is to pick one idea and go all in, here are four exciting and totally doable project ideas to get you started this weekend, no long tutorials, no over-complicated math, just fun and functional AI.

1- Build a Chatbot With Personality

As you definitely know, chatbots are everywhere, but a chatbot with a distinct personality? That’s where you can get creative, imagine a texting-style AI that cheers you up like your best friend, or responds to questions as if it were a historical figure or fictional character, you don’t need to build the next ChatGPT! Just a focused, fun experience that people can interact with.

This project is perfect for showcasing prompt engineering and language model usage, you can do it by using tools like Hugging Face Transformers and a simple interface builder like Gradio, you can set up a working demo in hours, want to go further? Deploy it with Flask or Streamlit so anyone can test it online! Even a handful of responses with some flair can make this feel alive.

To guide you, Hugging Face has a great chatbot tutorial, and Gradio’s quickstart helps you launch the interface fast, record a demo video or take screenshots of your bot’s funniest answers, people love seeing personality in AI :)

2- Caption Generator

If you’re into computer vision, an image caption generator is a brilliant weekend project, the idea is simple: upload an image, and your app writes a caption that describes it. This is like making a baby version of what Instagram or accessibility tools might use, you don’t even need to train a model from scratch, pre-trained models like BLIP on Hugging Face make this easier than ever.

Using a tool like Streamlit, you can create a smooth interface where users upload images and receive captions instantly, add a little CSS polish or emoji flair, and it becomes a delightful little portfolio piece.

Also, this is one of those projects that’s extremely visual, perfect for sharing on social media, in your resume, or as part of an online portfolio.

3. Create an AI-Powered Resume Screener

Why not build a simple tool that analyzes a resume and provides feedback? Flagging vague phrases, pointing out strong skills, and even suggesting clearer language using NLP techniques?

You can use Python with spaCy or the OpenAI API to extract named entities, detect common buzzwords, or rewrite weak phrases, then, with a tool like Streamlit or Gradio, you can create a basic web app where users upload a PDF or paste their text to receive feedback.

What makes this project portfolio-worthy is how practical and helpful it is, imagine recruiters, career coaches, or students using a tool you made.

Not sure where to start? spaCy’s beginner guide is excellent for you!

Make It Shine: Showing Off Your Work

Once you’ve built your project, don’t just let it sit in a folder! Document it, explain why you built it, what you learned, what challenges you faced, and how someone else could try it too.

Turn your code into a GitHub repo with a clean README, share your app using free hosting like Hugging Face Spaces, Streamlit Cloud, or even Replit.

For extra visibility, post a short write-up or demo clip on LinkedIn, Dev.to, or Reddit, write as if you're teaching others, you’ll stand out as someone who not only builds things, but also explains them clearly.

Final Words: Just Start

You don’t need to build the next big startup or train your own LLM to stand out, a single thoughtful, well-presented weekend project can open doors, impress recruiters, and build your confidence, and now, you’ve got 3 ideas, tools to try, and resources to follow.

So this weekend, why not put your curiosity to work and build something that lives beyond your screen?

Enjoyed the article?
🌟 Star us on Github now!

Got questions/feedback? Tell us in the comments! 🖊️

🔎 What is OCR? and How Can You Use It Without Any ML Experience?!

Amira Bekhta — Mon, 21 Jul 2025 10:51:09 +0000

Ever wished your computer could understand the words on a picture or a scanned paper? Well, get ready to be amazed, because that magic is totally real and it's all thanks to something super cool called Optical Character Recognition or simply OCR!

Let us think about it, OCR has transformed text extraction from images, eliminating manual retyping, it enables computers to "read" and convert static visual information into editable, searchable text, revolutionizing tasks from digitizing archives to processing invoices, making our lives easier and more efficient!

1- What is OCR?

Okay, so you already know OCR is super cool, right? But have you ever stopped to think about the magic behind it? Imagine you've got a stack of old printed documents, maybe some old school notes, typing all that text out by hand would be, well, a total drag, that's where OCR swoops in like a superhero!

At its core, OCR is all about teaching computers to "read" text from images, just like we do, think of it like this: when you look at a letter "A" on a page, your brain instantly recognizes it, but for a computer, it's just a bunch of pixels, a jumble of dots, OCR acts as the translator, taking that visual information and turning it into something editable and searchable real, live text!

So, how does this all happen? briefly, it starts with an image, that’s all you need! And the OCR software then goes to work, first prepping the image, it might straighten it out, enhance the contrast, and even remove any pesky smudges, next, it looks for distinct regions of text, separating them from the background, this is where the real "reading" begins! The software analyzes each character, breaking it down into features like lines, curves, and angles. It compares these features to a vast library of known characters, and once it makes a match, it converts that image of a character into its digital equivalent.

2- Why is OCR Useful?

Beyond just entering data, OCR makes everything searchable. Instead of flipping through pages, you can instantly find any word or phrase in a digitized document, just like on a website. This is incredibly useful for finding specific info fast.

OCR also boosts accessibility. It can turn printed text into spoken words for people with visual impairments and makes document translation much easier, helping to bridge language gaps.

OCR works its magic in many areas:
Healthcare: Quickly digitizes patient records for better care.
Finance: Speeds up processing checks and loan applications.
Education: Students can turn textbook pages into editable notes.
Legal: Organizes vast amounts of legal documents for easy searching.
Retail: Helps self-checkouts quickly scan items.
Archiving: Preserves historical documents and makes them accessible.
Here is an example from Docuglean.com:

See? It’s magical!

3- How Can You Use OCR Without Any ML Experience?

Yes, you can!
You really can use OCR without any knowledge in machine learning! Amazing isn’t it? Here are some examples that you can use:

Tesseract Open-Source OCR:

Tesseract OCR is a powerful, free, open-source engine for converting images to text, developers use Python wrappers like pytesseract to integrate it, it's easy to use with basic coding, requiring no ML expertise, install Tesseract, then use simple functions to extract text from images, making digitization accessible, you can check it now here.

It is very easy to install using just one line of code:

tesseract imagename outputbase [-l lang] [--oem ocrenginemode] [--psm pagesegmode] [configfiles...]

Docling:

Docling simplifies document processing, parsing diverse formats — including advanced PDF understanding — and providing seamless integrations with the gen AI ecosystem, you can check it here

Docling is easy to use and you can get started with it with only a few lines of code:

from docling.document_converter import DocumentConverter
source = "https://arxiv.org/pdf/2408.09869"  # document per local path or URL
converter = DocumentConverter()
result = converter.convert(source)
print(result.document.export_to_markdown())  # output: "## Docling Technical Report[...]"

Docuglean AI SDK:
Docuglean is a unified SDK for intelligent document processing using State of the Art AI models. Docuglean provides multilingual and multimodal capabilities with plug-and-play APIs for document OCR, structured data extraction, annotation, classification, summarization, and translation. It also comes with inbuilt tools and supports different types of documents out of the box, check it out here, and learn how to use it here.

Docuglean AI makes it easy for you to use OCR with no ML experience, here is an example code snippet:

import { ocr } from 'docuglean';
const result = await ocr({
  filePath: './document.pdf',
  provider: 'mistral',
  model: 'mistral-ocr-latest'
  apiKey: 'your-api-key'
});

Enjoyed the article? star us now! 🌟

🌟 Star our github

Got question/feedback/request? Drop them in the comments! 🖊️

Pytorch quickstart ☄️: Some of my Pytorch notes

Amira Bekhta — Sat, 19 Jul 2025 16:55:37 +0000

Hello everyone! Today I wanted to share with you all some of my Pytorch notes if you need a quickstart, enjoy!
PyTorch is an open-source Python-based deep learning library that has been the most widely used deep learning library for research since 2019 by a wide margin.

It is popular because it's user-friendly and efficient, yet still flexible enough for advanced users to customize and optimize models, it has a good balance between ease of use and powerful features.
It is a tensor library extending NumPy with GPU acceleration, an automatic differentiation engine (Autograd) for simplified gradient computation and model optimization, and a comprehensive deep learning library offering modular building blocks for designing and training a wide range of deep learning models for both researchers and developers.

To install PyTorch (Automatically detects default CPU/GPU):

pip install torch

Specific version for the tutorial:
pip install torch==2.4.1

Explicit CUDA/GPU version: on https://pytorch.org, select your OS and desired CUDA version, and then modify the generated command to include your torch version

Verify installation:
import torch print(torch.__version__)

NVIDIA GPU recognition:
import torch print(torch.cuda.is_available())

Apple Silicon GPU recognition:
import torch print(torch.backends.mps.is_available())
Tensors are a mathematical concept that extends scalars, vectors, and matrices to higher dimensions, with their "rank" indicating the number of dimensions (for example, a scalar is rank 0, a vector is rank 1, a matrix is rank 2) in computing, tensors act as multi-dimensional data containers, efficiently managed by libraries like PyTorch where tensors are similar to NumPy arrays but offer key advantages for deep learning, including an automatic differentiation engine for gradient computation and GPU support to accelerate neural network training, all while maintaining a familiar NumPy-like API.

We can create objects of PyTorch’s Tensor class using the torch.tensor function as follows:

import torch

# create a 0D tensor (scalar) from a Python integer
tensor0d = torch.tensor(1)

# create a 1D tensor (vector) from a Python list
tensor1d = torch.tensor([1, 2, 3])

# create a 2D tensor from a nested Python list
tensor2d = torch.tensor([[1, 2], [3, 4]])

# create a 3D tensor from a nested Python list
tensor3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

To check the data type of a tensor in Pytorch we use:

tensor1d = torch.tensor([1, 2, 3])
print(tensor1d.dtype)

And it should print something like:

torch.int64

In a Pytorch Tensor, we can use the .shape:

print(tensor2d.shape)

It would print something like:

torch.Size([2, 3])

Which means that the tensor has 2 rows and 3 columns. To reshape the tensor into a 3 by 2 tensor, we can use the .reshape method or more commonly .view() method:

tensor2d.reshape(3, 2) tensor2d.view(3, 2)

Next, we can use .T to transpose a tensor, which means flipping it across its diagonal:

tensor2d.T

Lastly, the common way to multiply two matrices in PyTorch is the .matmul method:

tensor2d.matmul(tensor2d.T)

However, we can also adopt the @ operator, which accomplishes the same thing more compactly:

tensor2d @ tensor2d.T

PyTorch's autograd engine automatically computes gradients using computational graphs.
A computational graph is:
A directed graph that visualizes mathematical expressions.
In deep learning, it maps out the steps a neural network takes to produce an output.
Crucial for backpropagation, the main training method for neural networks, as it allows us to calculate necessary gradients.
PyTorch builds internal computation graphs if requires_grad=True on a tensor.
These graphs enable gradient calculation, crucial for backpropagation (neural network training).
Backpropagation uses the chain rule to calculate how much each parameter contributes to the loss.
PyTorch's Autograd engine automatically handles this via:
grad() (manual, for specific tensors)
.backward() (automatic, computes gradients for all parameters).

PyTorch makes it easy to define custom neural networks by subclassing torch.nn.Module.
We use init to define layers.
and forward() to define how data flows through the network.
Example:

class NeuralNetwork(torch.nn.Module):
    def __init__(self, num_inputs, num_outputs):
        super().__init__()
        self.layers = torch.nn.Sequential(
            torch.nn.Linear(num_inputs, 30),
            torch.nn.ReLU(),
            torch.nn.Linear(30, 20),
            torch.nn.ReLU(),
            torch.nn.Linear(20, num_outputs),
        )

    def forward(self, x):
        return self.layers(x)

And to output the model:

model = NeuralNetwork(50, 3)
print(model)

Model parameters:

# Count trainable parameters
num_params = sum(p.numel() for p in model.parameters() if p.requires_grad)

# Access weights
print(model.layers[0].weight.shape)  # torch.Size([30, 50])

Set random seed to ensure reproducible weights:
torch.manual_seed(123)

Forward pass:
X = torch.rand((1, 50)) out = model(X)
Use torch.no_grad() to skip tracking gradients:

with torch.no_grad(): out = model(X)

Apply softmax to get class probabilities:

probs = torch.softmax(out, dim=1)

Custom dataset class:

from torch.utils.data import Dataset

class ToyDataset(Dataset):
    def __init__(self, X, y):
        self.X, self.y = X, y

    def __getitem__(self, i):
        return self.X[i], self.y[i]

    def __len__(self):
        return len(self.y)

Create DataLoaders:

from torch.utils.data import DataLoader

train_ds = ToyDataset(X_train, y_train)
train_loader = DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=0)

Iterate through batches:

for x, y in train_loader: print(x, y)

num_workers=0: Data loads in main process (slower but safer).

0: Faster for large datasets, but may cause issues in small datasets or Jupyter.

Training the neural network:

model = NeuralNetwork(2, 2)
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)

for epoch in range(3):
    model.train()
    for features, labels in train_loader:
        loss = F.cross_entropy(model(features), labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

cross_entropy = softmax + loss
zero_grad() prevents gradient buildup
train() sets model to training mode
After 3 epochs, loss ≈ 0 (model fits training data)

Making predictions:

model.eval()
with torch.no_grad():
    outputs = model(X_train)
    predictions = torch.argmax(outputs, dim=1)

eval() = evaluation mode
no_grad() saves memory
argmax gives predicted class
Use softmax for probabilities
Accuracy:

(predictions == y_train).sum()

Reusable accuracy function:

def compute_accuracy(model, loader):
    model.eval()
    correct = 0
    for X, y in loader:
        with torch.no_grad():
            preds = model(X).argmax(dim=1)
        correct += (preds == y).sum()
    return correct.item() / len(loader.dataset)

Saving and loading:


torch.save(model.state_dict(), "model.pth")

model = NeuralNetwork(2, 2)
model.load_state_dict(torch.load("model.pth", weights_only=True))

Distributed Training with PyTorch's DistributedDataParallel (DDP):

Distributed training:
Speeds up training by splitting work across GPUs/machines.

Essential for large models and repeated training runs.

How DDP works:
Each GPU gets a copy of the model.

Data is split between GPUs (via DistributedSampler).

Gradients are synchronized across GPUs after each backward pass.
Conclusion:
PyTorch is a flexible and powerful deep learning framework built around three key components: tensors, autograd, and neural network tools. It supports GPU acceleration, making it efficient for training large models. With tools like Dataset, DataLoader, and DistributedDataParallel, PyTorch simplifies everything from loading data to scaling training across multiple GPUs. Whether you're starting on a CPU or scaling to clusters, PyTorch makes it straightforward to build and train deep learning models efficiently.

Drop any question/feedback/request in comments! 🖊️

Build a Receipt Reader with Docuglean AI in Under 10 Minutes! 📜

Amira Bekhta — Mon, 14 Jul 2025 14:55:56 +0000

Did you know that you can build an AI receipt reader in under 10 minutes? In this tutorial, we will explore how to extract structured data from a PDF receipt using the Docuglean SDK. I will guide you step-by-step through the setup process, it's easy and only requires a little knowledge!

🌟 Visit and star Docuglean SDK

1- Prerequisites:

In order to be able to use the Docuglean AI SDK you need a little bit of JavaScript knowledge, you can review some JavaScript here , other than that you’ll need Node.js and NPM installed in your machine, to check if you have them already, in Windows, click the Windows key + R on your keyboard, and type cmd, then type the commands:
node -v
and:
npm -v

If you are able to see the versions of node and npm, good! You’re ready!, instead, you can simply go here and install the node.js windows installer (msi), after the setup is complete, check the versions again in cmd, and you will see that you are ready!

2- Installing the Docuglean SDK

To start, you will have to create a directory (a folder) that will contain your receipt reader project, you can do this by pressing Windows + R on your keyboard and typing cmd, use the command mkdir followed by the project name, for example:

mkdir my-receipt-extractor

Now navigate to that directory using the command:

cd my-receipt extractor

Once you’re there, simply run:

npm i docuglean

And hooray! Now your directory has all the features that Docuglean AI provides!
Another thing you’ll need is an API key, currently, the available API keys are from these providers:
OpenAI: gpt-4.1-mini, gpt-4.1, gpt-4o-mini, gpt-4o, o1-mini, o1, o3, o4-mini
Mistral: mistral-ocr-latest
Once you get your API key from one of the providers, don’t share it, this is your very own API key, save it in a safe place!
Want to use an API key from another provider? More API keys are coming soon! check the Docuglean repository to know more, and star it to stay up to date!

🌟 Visit and star Docuglean SDK

3- Creating a Zod Schema for Receipts

The Zod schema is your blueprint for the data you want to extract from a receipt, it tells Docuglean AI the exact structure and types of information to look for, which ensures you get consistent, predictable data back every time.

What it is: A defined structure (like a template) for the data Docuglean should extract.
Why it's important:

- Predictable Output: Guarantees data comes back in the format you expect.
- Type Safety: Ensures fields are the correct type (date as a string, total as a number…)
- Guides the AI: Helps the AI understand what specific pieces of information to pull out.

Here is an example Zod Schema for a Receipt:

import { z } from 'zod';
// Define the structure for a single item on the receipt
const ReceiptItemSchema = z.object({
name: z.string().describe('The name of the item purchased.'),
price: z.number().describe('The price of this specific item.')
});
// Define the overall structure for the entire receipt
const ReceiptSchema = z.object({
date: z.string().describe('The date of the receipt in YYYY-MM-DD format.'),
total: z.number().describe('The grand total amount shown on the receipt.'),
currency: z.string().optional().describe('The currency symbol or code (e.g., "$", "EUR").'), // Optional field
vendorName: z.string().optional().describe('The name of the store or business.'),
items: z.array(ReceiptItemSchema).describe('A list of all individual items purchased, with their names and prices.')
});

4- Writing the Extraction Script

This script is the core of your application, it brings together your receipt, your API key, and the Zod schema to tell Docuglean AI what to do, it calls Docuglean's extract function to process your receipt and return structured data

Here is a simple Extraction Script Example:

import { extract } from 'docuglean';
import { z } from 'zod';
import * as dotenv from 'dotenv'; // Tool to load API keys securely
dotenv.config(); // Loads variables from a .env file
// Define your Zod Schema (from Part 3)
const ReceiptItemSchema = z.object({
name: z.string().describe('The name of the item purchased.'),
price: z.number().describe('The price of this specific item.')
});
const ReceiptSchema = z.object({
date: z.string().describe('The date of the receipt in YYYY-MM-DD format.'),
total: z.number().describe('The grand total amount shown on the receipt.'),
currency: z.string().optional().describe('The currency symbol or code (e.g., "$", "EUR").'),
vendorName: z.string().optional().describe('The name of the store or business.'),
items: z.array(ReceiptItemSchema).describe('A list of all individual items purchased, with their names and prices.')
});
async function runReceiptExtraction() {
const apiKey = process.env.OPENAI_API_KEY; // Ensure you set this in a .env file!
const receiptFilePath = './receipt_example.pdf'; // Ensure this file exists!
if (!apiKey) {
console.error("Error: API key not found. Please set OPENAI_API_KEY in your .env file.");
return;
}
try {
console.log("Starting receipt data extraction...");
const extractedData = await extract({
filePath: receiptFilePath,
apiKey: apiKey,
provider: 'openai', // Or 'mistral'
responseFormat: ReceiptSchema, // Our blueprint for the output
prompt: 'Extract the date, total, currency, vendor name, and a list of items with their names and prices from this receipt.'
});
console.log("Extraction successful!");
// Print the result in a nicely formatted way
console.log(JSON.stringify(extractedData, null, 2));
} catch (error) {
console.error("An error occurred during extraction:", error);
}
}
runReceiptExtraction(); // Run the function

5- Understanding the Output

Once your script runs successfully, Docuglean will return a JavaScript object containing all the extracted information, perfectly matching your Zod schema, you will get a JavaScript object that is guaranteed to have the structure you defined in your ReceiptSchema.
Example Output (based on our schema):

{
"date": "2024-07-09",
"total": 55.75,
"currency": "USD",
"vendorName": "SuperMart",
"items": [
{
"name": "Organic Bananas",
"price": 3.49
},
{
"name": "Milk (1 Gallon)",
"price": 4.99
},

{
"name": "Avocado (Each)",
"price": 2.50
}
]
}

6- Let’s wrap up!

In this article, we have learned the essentials of using Docuglean for receipt extraction, this is a powerful skill that automates tedious data entry and unlocks new possibilities for document processing!
What's Coming Soon to Docuglean:
summarize(): Get quick summaries (TLDRs) of long documents.
translate(): Built-in support for processing multilingual documents.
classify(): Automatically detect the type of document (receipt, invoice, ID, etc.).
search(query): Search across your documents using powerful AI.
More AI Models: Integrations with other providers like Meta's Llama, Together AI, and OpenRouter for more choice and flexibility.
Keep an eye on Docuglean's updates by and star the GitHub repository to get notified when these exciting new features become available!

🌟 Visit and star Docuglean SDK

⭐ Want More?
Check out the full Docuglean repository on GitHub and star the project to support future updates!

🌟 Visit and star Docuglean SDK

Have questions/requests? Drop them the comments! 🖊️

How I built a Github star tracker in one afternoon? 🌟

Amira Bekhta — Fri, 11 Jul 2025 17:35:35 +0000

Hello everyone, today I decided to share with you all how I was able to make a frontend application that tracks our github repository's star count in only one afternoon!

Check the app here: https://amira-bekhta.github.io/Github_star_tracker/

Find the repository and star it to see the magic here!

Check my Github here: https://github.com/Amira-Bekhta

Check the tracking app's Github repository here: https://github.com/Amira-Bekhta/Github_star_tracker

1- The HTML code first:

Before starting with anything, I decided to have all the HTML code I needed, here is the code I had at first:

    <h1>How are the stars going?</h1>
    <progress id="progress" max="1000" value="3"></progress>
    <h3>Stars so far</h3>
    <footer>Made with 🩷 by Amira</footer>

And then I thought to myself, wouldn't it be better to have a good Github icon that leads to the repository and makes the app more visually appealing? To do so, I had to add this to the head of my HTML document:

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">

And for the HTML body, I simply added this:

<a href="https://github.com/docuglean-ai/docuglean" target="_blank"><i class="fa fa-github" style="font-size:12em"></i></a>

2- Styling:
When I use CSS, the first thing I go for is making sure everything is aligned in the center, this makes me feel like all the items are well-organized (Do you do this too? Tell me in the comments!), this is the code I use in almost every CSS code I do:

body{
            display: flex;
            justify-content: center;
            align-items: center;
            flex-direction: column;
            text-align: center;
            min-height: 100vh;
}

Other than that, I wanted to style the HTML progress bar, this part was a bit tricky, click here to find the app's repo and find out how I did it 👀

3- Github API:

Before I started building the app, I was worried that tracking the star count would be the hardest part, but hey, it's actually super easy, and you can do it too! Here is how I did it:

<script>
        async function updateStars() {
            try {
                const response = await fetch('https://api.github.com/repos/docuglean-ai/docuglean');
                const data = await response.json();
                const stars = data.stargazers_count;
                document.getElementById('progress').value = stars;
                document.querySelector('h3').textContent = `${stars} stars so far!`;
            } catch (error) {
                console.error('Failed to fetch star count:', error);
                document.querySelector('h3').textContent = 'Unable to load stars 😢';
            }
        }
        setInterval(updateStars, 60000); 

        updateStars();
</script>

Thanks for reading! 💕

Check the app here: https://amira-bekhta.github.io/Github_star_tracker/

Find the repository and star it to see the magic here!

Check my Github here: https://github.com/Amira-Bekhta

Check the tracking app's Github repository here: https://github.com/Amira-Bekhta/Github_star_tracker

**Got questions/feedback? Drop them in the comments! 🖊️

Don't forget to support us by starring our Github here: https://github.com/docuglean-ai/docuglean 🌟**

What Is Machine Learning? A Beginner’s Guide 🤖

Amira Bekhta — Mon, 07 Jul 2025 18:36:22 +0000

Machine learning, a term we hear everywhere these days, has become one of the most transformative technologies of our time. Chances are you have at least once wondered what machine learning is and how it works.
In this article, we will enter the world of machine learning and explore its fascinating capabilities, ready to discover some of the coolest things you can do with it?

1- What is Machine Learning?

Machine learning (ML) is a fascinating domain that allows computers to perform tasks typically related to human intelligence, actually, ML is just a branch of artificial intelligence where systems “learn” from data to identify patterns, make predictions, or even generate new content, but are you still trying to figure out why is it called "machine learning"? Well, the process of machine learning ensures that machines do not need to be programmed for every single scenario, they just “learn” from big amounts of data, just like how humans learn, for example, when you open your favorite music app, the system doesn’t need to be programmed every day to recommend you new songs, it just learns from data about you (like your favorite songs, artists…) and then tries to find songs that you will possibly like!

Let’s try to think about it this way: when a child learns to recognize a certain object, say a ball, they aren't given a precise, step-by-step instruction manual on "what makes a ball a ball." Instead, they see many different balls, hear the word "ball" related to them, and with repeated exposure and corrections (e.g., being corrected if they call another thing a ball), they build an internal model of what a ball looks like over time, similarly, machine learning algorithms get equipped with massive datasets ( images of balls, for instance ) along with labels indicating "this is a ball." The algorithms then crunch this data, detecting features and relationships that define a "ball" on its own, and the next time a machine receives a picture of a ball, it will compare it to all the images it saw before, and will decide if this looks more like the ball images it saw before.

This amazing ability for computers to "learn" from data without explicit programming is what makes ML so revolutionary, it means we can build systems that adapt, improve, and discover insights in ways that were previously impossible, whether it's recommending your next favorite song, powering self-driving cars, or helping doctors diagnose diseases, machine learning is rapidly transforming our world by enabling computers to not just follow instructions, but to truly learn and evolve.

2- The process of Machine learning:

The whole process begins, quite fundamentally, with data, which is the foundation upon which the impressive field of machine learning is constructed. You can imagine the process as nurturing machines, these machines are not born with an innate understanding but are instead carefully fed huge amounts of training data. This digital nourishment comes in various forms and is prepared through diverse methodologies to optimize the learning process.

The way that machines learn from data can be split into two types, supervised and unsupervised learning:

Supervised learning: Here, the machine is presented with data that has been thoughtfully labeled, much like a teacher providing examples with correct answers. For example, in computer vision, a machine might be shown thousands of images of dogs, each explicitly tagged "dog." Through this iterative exposure, and often leveraging the power of deep learning architectures that mimic the human brain's neural networks, the machine learns to differentiate patterns and make predictions. This approach is particularly effective for tasks like image classification or speech recognition.
Unsupervised learning: This approach is about unlabeled data, challenging the machine to uncover inherent structures or relationships without prior guidance. Think of it as presenting a child with a number of toys and asking them to sort them into groups based on their own observations, they could sort the toys by color, shape, or material. This method is invaluable for tasks such as customer segmentation or anomaly detection, where the underlying patterns are not immediately apparent.

Once the training phase is complete, the machine's ability to apply its learned knowledge should be tested. This crucial step involves a separate, unseen dataset known as the test set. We will let the machine use what it learned on the test set, and by evaluating its performance, we can accurately judge its proficiency and identify any areas requiring further refinement. This cyclical process of data preparation, training, and testing is fundamental to developing robust and intelligent systems that can truly make sense of the world around us.

3- The role of Machine learning:

With all we have discovered so far, we now know what machine learning is. We also know the process it goes through to ensure a good output. What if I tell you that this simple process is the core to building all the huge AI applications you see everywhere?!

Today, ML is ubiquitous, silently powering everything from personalized recommendations on your favorite streaming services to robust spam filters in your email. It's integral to fraud detection in finance, disease diagnosis in healthcare, and optimizing logistics in transportation, making countless daily interactions smoother and more efficient.

Looking ahead, ML's impact will only grow, extending far beyond the traditional tech industry. Imagine smarter agriculture that predicts optimal planting times, personalized education adapting to individual learning styles, or advanced materials science accelerating discoveries. Its ability to analyze vast datasets and uncover hidden patterns will drive unprecedented innovation, enhancing productivity, improving decision-making, and fundamentally reshaping nearly every facet of our lives, creating a future that is more intelligent, responsive, and connected.

Overall, machine learning, by enabling machines to learn from data like humans do, is revolutionizing our world. This ability, from supervised learning with labeled examples to unsupervised learning uncovering hidden patterns, empowers systems to adapt and improve. As ML continues to evolve, its impact will only grow, driving innovation and reshaping nearly every aspect of our lives for a more intelligent and connected future.

Enjoyed the article? Star us on Github!🌟

🌟 Star us here

Have questions/requests? Drop it them the comments! 🖊️