DEV Community: Mohd Aquib

[Boost]

Mohd Aquib — Sun, 26 Oct 2025 20:13:35 +0000

Mohd Aquib

Jul 5 '24

Building a CRUD API with FastAPI and MongoDB

#python #mongodb #fastapi #beginners

Comments 4

2 min read

Building RAGenius: A Production-Ready RAG System with FastAPI, Azure OpenAI & ChromaDB

Mohd Aquib — Sun, 26 Oct 2025 19:11:21 +0000

🧠 Building RAGenius: A Production-Ready RAG System

Have you ever wanted to chat with your documents using AI? Whether it's PDFs, Excel spreadsheets, or JSON files - imagine having an intelligent assistant that can answer questions based on your entire document collection. That's exactly what I built with RAGenius!

🤔 What is RAG?

Retrieval-Augmented Generation (RAG) is a technique that combines the power of large language models (LLMs) with your own data. Instead of relying solely on the model's training data, RAG:

Retrieves relevant information from your documents
Augments the LLM prompt with this context
Generates accurate, contextual answers

This approach dramatically reduces hallucinations and allows LLMs to answer questions about your specific domain knowledge.

💡 Why I Built RAGenius

While experimenting with various RAG implementations, I noticed most tutorials focused on simple, single-file demos. I wanted something more:

✅ Production-ready with proper error handling

✅ Multi-format support (PDF, Excel, JSON, DOCX, CSV, TXT)

✅ Streaming responses for better UX

✅ REST API for easy integration

✅ Incremental updates without rebuilding the entire index

Thus, RAGenius was born! 🎉

🏗️ Architecture Overview

RAGenius follows a clean, modular architecture:

┌─────────────┐
│  Documents  │ (PDF, Excel, JSON, etc.)
└──────┬──────┘
       │
       ▼
┌─────────────────┐
│  Data Loader    │ (Multi-format processing)
└──────┬──────────┘
       │
       ▼
┌─────────────────┐
│  Chunking       │ (Smart text splitting)
└──────┬──────────┘
       │
       ▼
┌─────────────────┐
│  Azure OpenAI   │ (Generate embeddings)
└──────┬──────────┘
       │
       ▼
┌─────────────────┐
│   ChromaDB      │ (Vector storage)
└──────┬──────────┘
       │
       ▼
┌─────────────────┐
│   RAG Engine    │ (Query + Generate)
└──────┬──────────┘
       │
       ▼
┌─────────────────┐
│   FastAPI       │ (REST API)
└─────────────────┘

🛠️ Tech Stack

FastAPI: Lightning-fast API framework
LangChain: Document processing and LLM orchestration
ChromaDB: Vector database for embeddings
Azure OpenAI: GPT-4 and embedding models
Python 3.10+: Core language
UV: Modern Python package manager

🚀 Key Features Breakdown

1️⃣ Multi-Format Document Processing

One of the coolest features is the ability to handle various file types seamlessly:

from src.data_loader import load_all_documents

# Automatically detects and loads all supported formats
docs = load_all_documents("data")
print(f"Loaded {len(docs)} documents")

The data_loader.py uses a smart mapping system:

LOADER_MAP = {
    ".pdf": PyPDFLoader,
    ".txt": lambda path: TextLoader(path, encoding="utf-8"),
    ".csv": CSVLoader,
    ".docx": Docx2txtLoader,
    ".json": JSONLoader,
    ".xlsx": UnstructuredExcelLoader,
}

2️⃣ Smart Document Chunking

Not all text should be split the same way. RAGenius uses RecursiveCharacterTextSplitter with configurable parameters:

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    separators=["\n\n", "\n", " ", ""]
)

Why overlap? It ensures context isn't lost at chunk boundaries - crucial for maintaining semantic coherence!

3️⃣ Vector Storage with ChromaDB

ChromaDB provides persistent, efficient vector storage:

class ChromaVectorStore:
    def __init__(self, persist_directory="chromadb_store"):
        self.client = chromadb.PersistentClient(path=persist_directory)
        self.collection = self.client.get_or_create_collection(
            name="pdf_documents",
            metadata={"description": "PDF embeddings using Azure OpenAI"}
        )

Key benefit: Your embeddings persist across restarts - no need to re-process documents!

4️⃣ Streaming RAG Responses

Modern UIs demand real-time feedback. RAGenius supports token-by-token streaming:

async def stream_query(self, question: str, top_k: int = 5):
    """Async generator for true token streaming"""
    results = self.vectorstore.query(question, top_k=top_k)
    docs = results.get("documents", [[]])[0]

    if not docs:
        yield "No relevant context found."
        return

    context = "\n\n".join(docs)
    prompt = self._build_prompt(context, question)

    async for chunk in self.llm.astream([HumanMessage(content=prompt)]):
        token = getattr(chunk, "content", str(chunk))
        yield token

5️⃣ RESTful API with FastAPI

Three main endpoints power the system:

📤 Upload Documents

curl -X POST "http://localhost:8000/rag/upload" \
  -F "files=@document.pdf" \
  -F "files=@spreadsheet.xlsx"

🔍 Basic Query

curl -X POST "http://localhost:8000/rag/basic" \
  -H "Content-Type: application/json" \
  -d '{"query": "What is attention mechanism?", "top_k": 5}'

🌊 Streaming Query

curl -X POST "http://localhost:8000/rag/stream" \
  -H "Content-Type: application/json" \
  -d '{"query": "Explain transformers", "top_k": 3}' \
  --no-buffer

🎯 The RAG Pipeline in Action

Here's what happens when you ask a question:

Query Embedding: Your question is converted to a vector using Azure OpenAI
Similarity Search: ChromaDB finds the top-k most relevant document chunks
Context Building: Retrieved chunks are combined into a context window
Prompt Construction: The context and question are formatted into a prompt
LLM Generation: GPT-4 generates an answer based on the provided context
Streaming Response: Tokens are streamed back to the client in real-time

def query(self, question: str, top_k: int = 5):
    # Step 1 & 2: Retrieve relevant context
    results = self.vectorstore.query(question, top_k=top_k)
    docs = results.get("documents", [[]])[0]

    # Step 3: Build context
    context = "\n\n".join(docs)

    # Step 4: Construct prompt
    prompt = f"""
    Use the following context to answer the question.

    Context:
    {context}

    Question: {question}

    Answer:
    """

    # Step 5: Generate response
    response = self.llm.invoke([HumanMessage(content=prompt)])
    return {"answer": response.content}

📊 Performance Optimizations

Chunking Strategy

Chunk Size: 1000 characters - balances context vs. precision
Overlap: 200 characters - maintains semantic continuity
Smart Separators: Prioritizes paragraph breaks over word breaks

Embedding Efficiency

Batch Processing: Multiple chunks embedded in single API calls
Persistent Storage: Embeddings cached in ChromaDB
Incremental Updates: Add new documents without re-embedding existing ones

Query Optimization

Top-K Selection: Default k=5 balances relevance and token usage
Temperature Control: 0.7 provides creative yet grounded responses
Async Operations: Non-blocking streaming for better UX

🐛 Challenges & Solutions

Challenge 1: JSONLoader Complexity

Problem: JSONLoader required jq_schema parameter, complicating multi-format support.

Solution: Implemented dynamic loader selection with custom error handling:

def dynamic_loader(file_path: str):
    ext = Path(file_path).suffix.lower()
    loader_cls = LOADER_MAP.get(ext)
    if not loader_cls:
        raise ValueError(f"❌ Unsupported file type: {file_path}")
    return loader_cls(file_path)

Challenge 2: Streaming with FastAPI

Problem: Server-Sent Events (SSE) format required careful handling.

Solution: Used StreamingResponse with proper headers:

return StreamingResponse(
    stream_response(),
    media_type="text/event-stream",
    headers={
        "Cache-Control": "no-cache",
        "Connection": "keep-alive",
        "X-Accel-Buffering": "no"
    }
)

Challenge 3: File Upload Memory Management

Problem: Large file uploads could cause memory issues.

Solution: Temporary directory with automatic cleanup:

temp_dir = os.path.join(DATA_DIR, f"temp_{uuid.uuid4().hex[:8]}")
try:
    # Process files
    docs = load_all_documents(temp_dir)
    vectorstore.add_documents(docs)
finally:
    if os.path.exists(temp_dir):
        shutil.rmtree(temp_dir)

🎓 Lessons Learned

Modular Design Pays Off: Separating concerns (loading, embedding, storage, querying) made debugging and testing much easier.
Async is Essential: For streaming responses and file processing, async/await dramatically improves performance.
Error Handling Matters: Production systems need comprehensive logging and graceful error recovery.
Chunk Overlap is Critical: Without overlap, important context can be lost at boundaries, leading to incomplete answers.
Persistent Storage Rocks: ChromaDB's persistence means zero downtime for re-indexing after restarts.

🔮 Future Enhancements

Here's what's on the roadmap:

[ ] Multi-LLM Support: OpenAI, Anthropic Claude, Cohere
[ ] Web UI: React-based interface for document management
[ ] Advanced Filtering: Metadata-based search refinement
[ ] Cloud Storage Integration: S3, Azure Blob, Google Cloud Storage
[ ] Conversation Memory: Multi-turn dialogue support
[ ] Fine-tuned Embeddings: Domain-specific embedding models
[ ] Kubernetes Manifests: Production-ready deployment configs

🚀 Getting Started

Want to try RAGenius? It's super easy:

# Clone the repository
git clone https://github.com/AquibPy/RAGenius.git
cd RAGenius

# Install dependencies (using UV)
uv sync

# Set up environment variables
cp .env.example .env
# Add your Azure OpenAI credentials

# Start the server
uvicorn app:app --reload

# Visit http://localhost:8000/docs for API documentation

📝 Example Usage

Python Script

from src.search import RAGEngine

# Initialize
rag = RAGEngine()

# Query
result = rag.query(
    "What is the attention mechanism in transformers?",
    top_k=5
)

print(result["answer"])

CLI

python main.py \
  --query "Explain BERT architecture" \
  --mode streaming

API

import requests

response = requests.post(
    "http://localhost:8000/rag/basic",
    json={"query": "What is machine learning?", "top_k": 3}
)

print(response.json()["answer"])

🎉 Conclusion

Building RAGenius has been an incredible learning experience. It combines cutting-edge AI technologies with practical software engineering to create a tool that's actually useful in production environments.

The beauty of RAG systems is that they make LLMs grounded in reality - answering questions based on YOUR data, not just internet-scale training data. Whether you're building internal knowledge bases, customer support systems, or research tools, RAG is the way forward.

🔗 Links

GitHub: AquibPy/RAGenius
Demo Video: [Coming soon!]

💬 Let's Connect!

I'd love to hear your thoughts and ideas! Feel free to:

⭐ Star the repo if you find it useful
🐛 Report bugs or request features via GitHub Issues
🤝 Contribute through Pull Requests
💬 Connect with me on X or LinkedIn

Have you built any RAG systems? What challenges did you face? Drop a comment below! 👇

Happy coding! 🚀

Traditional RAG vs Agentic RAG: How AI is Learning to Think for Itself

Mohd Aquib — Tue, 21 Oct 2025 07:49:42 +0000

Introduction

You know that moment when an AI gives you the perfect answer backed by real facts? That's RAG working behind the scenes — and it's honestly been a lifesaver for making AI systems actually trustworthy.

But here's the thing: traditional RAG has some real limitations. It's like having a really smart intern who only knows how to fetch documents and summarize them. They can't decide what to grab or where to look. They just do what they're told.

Agentic RAG? That's the upgrade. It's when AI systems actually think about what information they need, where to find it, and how to use it — more like working with a seasoned analyst than an intern.

Let me walk you through how these two approaches differ and why it matters.

What's RAG, Anyway?

Think of RAG as a simple but brilliant idea: instead of asking an AI to make something up from memory (which often goes wrong), give it real information to work with before it answers.

The flow is dead simple:

You ask a question → AI grabs relevant documents → AI uses those docs to answer → You get a factual response

Real example:

You ask: "Tell me about Agentic RAG based on recent research."

Instead of the AI bullshitting, it goes: "Okay, let me grab those research papers... fetches docs ...now I'll answer based on what these actually say."

Much better, right?

Traditional RAG: The First Generation

How It's Built

Traditional RAG is pretty straightforward. You've got:

Your question going in
A database full of documents converted to numerical vectors (so AI can understand them)
An LLM (the language model doing the heavy lifting)
A prompt template that tells the LLM how to behave

The Process

Here's what happens step-by-step:

Your question gets converted into a number-based format the AI understands
The system searches the database for relevant documents
Your original question + those documents get packed into one prompt
The LLM reads it all and gives you an answer

Where It Works Great

Imagine a customer support chatbot for an e-learning platform. Someone asks about a course, the system grabs the course description from the database, and boom — accurate answer. Simple and effective.

The Real Problem with Traditional RAG

Here's where traditional RAG falls short:

The AI doesn't actually think. It's more like a really obedient search tool than an intelligent system. The developer has to make all the smart decisions upfront — which database to check, how to handle edge cases, what to do if the answer isn't found.

You're stuck with one data source. Most traditional RAG systems connect to a single database. Want to combine information from multiple sources? Good luck manually coding that.

Everything's hardcoded and static. The routing (deciding where to look) is fixed. There's no flexibility. Your system can't adapt to different types of questions.

It works fine for simple, repetitive tasks. But for anything complex? You're fighting the system.

Agentic RAG: The Thinking Generation

Agentic RAG changes the game by actually giving AI the ability to reason and make decisions.

What's Different

Instead of one rigid pipeline, you've got:

Multiple databases — maybe one with YouTube transcripts, another with company docs, another with research papers
An actual agent — an AI system that looks at your question and decides what to do
Retrieval tools — the agent's way of accessing each data source
Smart routing — the system automatically figures out where to look, without hardcoding

How It Actually Works

Let's say you ask: "Show me Udemy courses on Agentic AI."

Here's what happens:

The agent reads your question and understands what you're looking for
It decides: "I need to check the Udemy database for this one"
It grabs the relevant courses
It sends back an answer with real data
If something's missing? The agent can check another database or use its reasoning to fill in gaps

It's flexible. The agent adapts to what you're asking instead of forcing your question into a fixed mold.

Side-by-Side Comparison

What We're Talking About	Traditional RAG	Agentic RAG
Who makes the decisions?	You did, when you built it	The AI agent does it on the fly
How many data sources?	Usually just one	As many as you want
Is the routing flexible?	Nope, it's hardcoded	Completely automatic and adaptable
What's the setup?	One database + one LLM	Multiple databases + agents + tools
Best for...	FAQ bots, simple Q&A	Complex questions, multiple sources
Real example	"Summarize this blog for me"	"Compare insights from all our internal docs and external research"

The Real Magic: Smart Routing

Here's what makes Agentic RAG actually special — the routing.

When you ask a question, the system doesn't just blindly search everywhere. The agent looks at what you're asking and thinks: "Where should I actually look for this?"

It's like having someone who knows your entire filing system and can instantly grab exactly what you need instead of checking every drawer.

You can:

Combine results from multiple databases
Decide on-the-fly whether to search or use reasoning
Handle edge cases without hardcoding them
Scale up without rebuilding everything

See It in Action

Imagine your system has two databases: one for LangGraph content and one for LangChain content.

Question 1: "What is LangChain?"
→ Agent thinks: "That's in DB2" → grabs it → answers

Question 2: "What's Machine Learning?"
→ Agent thinks: "That's not in either database... I'll use my own knowledge" → answers

No manual routing, no if-else statements. The agent just figures it out.

Bottom Line

Traditional RAG solved a real problem — making AI factual. It's solid for what it does.

But Agentic RAG is the next level. It's what happens when you combine retrieval, reasoning, and decision-making into one intelligent system. The AI isn't just following orders anymore; it's actually thinking.

For anything more complex than a simple FAQ bot — think enterprise assistants, research tools, or multi-source analysis — Agentic RAG is the way forward.

In one sentence: Agentic RAG = Traditional RAG + real intelligence + the ability to make smart choices

Teaching AI with Human Wisdom: A Deep Dive into RLHF

Mohd Aquib — Mon, 17 Feb 2025 12:04:10 +0000

In the rapidly evolving field of artificial intelligence (AI), ensuring that AI systems align with human values and preferences is paramount. Reinforcement Learning from Human Feedback (RLHF) has emerged as a pivotal technique to achieve this alignment. This guide delves deep into RLHF, elucidating its principles, methodologies, applications, and the challenges it faces.

Understanding RLHF

Reinforcement Learning from Human Feedback (RLHF) is a machine learning paradigm that integrates human evaluative input into the training loop of AI models. By leveraging human feedback, RLHF guides AI behavior, ensuring outputs resonate with human expectations and ethical standards.

Core Components of RLHF

Reinforcement Learning (RL):
- Agent and Environment: In RL, an agent interacts with an environment, making decisions to achieve a specific goal.
- Rewards and Penalties: The agent receives feedback in the form of rewards for desirable actions and penalties for undesirable ones, refining its strategy over time.
Human Feedback:
- Direct Evaluation: Humans assess the agent's actions or outputs, providing feedback that reflects preferences, corrections, or improvements.
- Feedback Mechanisms: This can range from ranking outputs, numerical scoring, to qualitative comments.
Reward Model:
- Learning Human Preferences: A model trained to predict the desirability of an agent's actions based on collected human feedback.
- Guiding the Agent: This model serves as a reference, informing the agent which actions align with human values.

The RLHF Process

The implementation of RLHF involves a systematic approach:

Initial Training:
- Supervised Learning: The AI model is trained on a dataset to perform a task, establishing a foundational capability.
Interaction Phase:
- Agent Deployment: The model begins interacting with real users or simulated environments, generating outputs or actions.
Feedback Collection:
- Human Evaluation: Users or annotators review the agent's outputs, providing feedback through rankings, ratings, or direct edits.
Reward Model Training:
- Supervised Learning: The collected feedback is used to train a reward model that predicts human preferences.
Policy Optimization:
- Reinforcement Learning: The agent's policy is fine-tuned using the reward model, optimizing for actions that align with human feedback.
Iterative Refinement:
- Continuous Loop: Steps 2 through 5 are repeated, progressively enhancing the agent's alignment with human values.

Applications of RLHF

RLHF has been instrumental in advancing various AI applications:

Conversational Agents:
- Enhanced Responsiveness: Models like OpenAI's ChatGPT have utilized RLHF to generate more accurate and contextually appropriate responses.
Content Moderation:
- Aligning Outputs: RLHF helps in training models to produce content that adheres to community guidelines and ethical standards.
Robotics:
- Behavioral Refinement: Robots learn complex tasks by receiving human feedback, improving their adaptability in dynamic environments.
Recommendation Systems:
- Personalized Suggestions: By incorporating user feedback, systems can offer recommendations that better align with individual preferences.

Challenges and Considerations

While RLHF offers significant benefits, it also presents certain challenges:

Quality of Feedback:
- Consistency Issues: Human feedback can be subjective, leading to variability that the model must learn to interpret accurately.
Scalability:
- Resource Intensive: Collecting and integrating human feedback, especially at scale, can be time-consuming and costly.
Bias and Fairness:
- Reflecting Human Biases: If not carefully managed, models can inadvertently learn and amplify biases present in human feedback.
Safety Concerns:
- Overfitting Feedback: There's a risk of models becoming overly tailored to specific feedback, potentially reducing generalizability.

Future Directions

The evolution of RLHF is poised to address its current limitations:

Automated Feedback Mechanisms:
- Reducing Human Burden: Developing systems that can autonomously generate feedback to minimize reliance on human annotators.
Diverse Data Collection:
- Enhancing Representativeness: Ensuring feedback is sourced from a broad demographic to mitigate biases.
Advanced Reward Modeling:
- Capturing Nuance: Improving reward models to better understand and predict complex human preferences.
Ethical Frameworks:
- Guiding Development: Establishing robust guidelines to ensure RLHF applications uphold ethical standards and societal values.

Conclusion

Reinforcement Learning from Human Feedback stands at the forefront of creating AI systems that are not only intelligent but also aligned with human values and expectations. By synergizing human insights with machine learning, RLHF paves the way for AI that is both powerful and principled.

For a visual and in-depth exploration of RLHF, consider watching the following video:

Reinforcement Learning from Human Feedback - YouTube

XGBoost: The Superpower of Gradient Boosting

Mohd Aquib — Fri, 26 Jul 2024 08:57:37 +0000

XGBoost (Extreme Gradient Boosting) is a powerful and widely used machine learning algorithm, particularly known for its performance in structured data. It's essentially a highly optimized implementation of gradient boosting, a technique that combines multiple weak learners (like decision trees) to form a strong predictor.

Let's break down the magic behind XGBoost:

1. Gradient Boosting, in a nutshell:

Imagine building a model by adding tiny, simple trees (decision trees) one by one. Each new tree tries to correct the errors made by the previous ones. This iterative process, where each tree learns from the mistakes of its predecessors, is called Gradient Boosting.

2. XGBoost: Taking it to the next level:

XGBoost takes gradient boosting to the extreme by incorporating several crucial improvements:

Regularization: XGBoost prevents overfitting by adding penalties to the complexity of the model.
Tree Pruning: This technique helps control the size and complexity of individual trees, further preventing overfitting.
Sparse Data Handling: XGBoost is optimized to work efficiently with data containing missing values.
Parallel Computing: XGBoost leverages parallelism to speed up the training process, making it suitable for large datasets.

3. The Math Intuition (Simplified):

XGBoost minimizes a loss function (a measure of error) using a technique called gradient descent. Here's a simplified explanation:

Loss Function: Represents the error between the predicted and actual values.
Gradient: Indicates the direction of steepest descent in the loss function.
Gradient Descent: We move the model parameters in the direction of the negative gradient, iteratively reducing the loss.

4. Getting Started with XGBoost:

Let's see a simple example of using XGBoost with Python:

import xgboost as xgb
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Create an XGBoost model
model = xgb.XGBClassifier()

# Train the model
model.fit(X_train, y_train)

# Make predictions
y_pred = model.predict(X_test)

# Evaluate the model
from sklearn.metrics import accuracy_score
print("Accuracy:", accuracy_score(y_test, y_pred))

Tips for Success:

Fine-Tune Parameters: XGBoost has many parameters that control its behavior. Experiment with different settings to optimize performance for your specific dataset.
Handle Missing Values: XGBoost handles missing values efficiently, but you may need to explore strategies for handling extreme cases.
Regularization: Experiment with L1 and L2 regularization to control the complexity of your model.

In Conclusion:

XGBoost is a robust and versatile machine learning algorithm capable of achieving impressive results in various applications. Its power lies in its gradient boosting framework, combined with sophisticated optimizations for speed and efficiency. By understanding the fundamental principles and experimenting with different settings, you can unleash the power of XGBoost to tackle your own data-driven challenges.

The Battle of Databases: SQL, PostgreSQL, MongoDB, and Redis Explored

Mohd Aquib — Thu, 11 Jul 2024 20:35:45 +0000

As a data enthusiast, you've likely encountered the names SQL, PostgreSQL, MongoDB, and Redis, but what exactly are they and when should you use them? This blog aims to demystify these powerful database technologies, comparing their features, use cases, and offering a headstart to get you started.

SQL: The Foundation

SQL (Structured Query Language) is the king of relational databases. It's the language used to interact with structured data, organized into tables with rows and columns. Imagine a spreadsheet, but on a much larger scale.

Key Features:

Data Integrity: SQL excels at maintaining data consistency through features like primary and foreign keys.
Structured Query Language: SQL uses a powerful query language for data manipulation and retrieval.
Transactions: Ensures data accuracy by treating operations as atomic units, either all succeed or all fail.
Widely adopted: SQL has a vast community, making it easy to find resources and support.

Examples:

SELECT * FROM customers WHERE city = 'New York'; Retrieves all customers from the city New York.
UPDATE products SET price = price * 1.10 WHERE category = 'Electronics'; Increases the price of all electronics products by 10%.

PostgreSQL: The Relational Powerhouse

PostgreSQL, often called Postgres, is a popular open-source object-relational database system that extends the power of SQL.

Why choose PostgreSQL?

Advanced Features: Supports features like inheritance, foreign data wrappers, and triggers.
Data Integrity: Provides ACID (Atomicity, Consistency, Isolation, Durability) properties for transactional integrity.
Extensible: Offers a wide range of extensions for custom functionality.
Mature and Stable: A long-standing database with a strong reputation for reliability.

MongoDB: The NoSQL Dynamo

MongoDB is a NoSQL database, meaning it doesn't follow the rigid structure of SQL. Instead, it uses document-oriented storage, where data is represented as JSON-like documents.

MongoDB Advantages:

Flexibility: Adapts to changing data structures and schema changes.
Scalability: Designed for high availability and horizontal scaling, making it ideal for large datasets.
Ease of use: Uses a simple document-based model for efficient data storage and retrieval.

Examples:

db.users.insertOne({ name: "John Doe", age: 30, city: "New York" }); Inserts a new user document.
db.users.find({ age: { $gt: 25 } }); Retrieves all users older than 25.

Redis: The Speed Demon

Redis is an in-memory data store known for its lightning-fast performance. It acts as a caching layer, storing frequently accessed data in memory for quick retrieval.

Redis Use Cases:

Caching: Improves website performance by storing frequently used data in memory.
Session Management: Stores user session data for faster access.
Real-time Analytics: Handles high-frequency data processing for real-time insights.

Tips for Getting Started

Learn SQL: Even if you're using NoSQL databases, understanding SQL is essential for data manipulation.
Choose the right tool: Consider your specific requirements, like data structure, scalability, and performance needs.
Experiment with different databases: Start with small projects to understand the strengths and weaknesses of each technology.

Conclusion

Choosing the right database can make or break your data-driven project. SQL, PostgreSQL, MongoDB, and Redis offer unique strengths and are well-suited for different use cases. By understanding their differences and experimenting with their capabilities, you can confidently navigate the world of data management.

Go and MongoDB: Building a CRUD API from Scratch

Mohd Aquib — Sun, 07 Jul 2024 20:21:57 +0000

Want to create a dynamic web application with a robust backend? Look no further than Go and MongoDB! This powerful combination allows you to build scalable, efficient APIs that handle data creation, reading, updating, and deletion (CRUD) with ease.

In this beginner-friendly guide, we'll walk through the process of building a simple CRUD API using Go and MongoDB. We'll cover the essential steps, provide code examples, and sprinkle in useful tips along the way.

Getting Started

First things first, let's set up our environment:

Go Installation: Download and install the latest version of Go from https://go.dev/dl/.
MongoDB Setup: If you don't have MongoDB running, you can download and install it from https://www.mongodb.com/try/download/community.
IDE or Text Editor: Choose your preferred coding environment. Some popular options include VS Code, GoLand, or Atom.

Project Structure:

Create a new project directory and organize your files like this:

my-crud-api/
├── main.go
├── models/
│   └── user.go
├── handlers/
│   └── user.go
└── config/
    └── config.go

Defining Our Model

Let's start with defining our data model. For this example, we'll create a simple User struct:

// models/user.go
package models

import (
    "go.mongodb.org/mongo-driver/bson/primitive"
)

type User struct {
    ID     primitive.ObjectID `bson:"_id,omitempty"`
    Name   string             `bson:"name,omitempty"`
    Email  string             `bson:"email,omitempty"`
    Age    int                `bson:"age,omitempty"`
    Active bool               `bson:"active,omitempty"`
}

Explanation:

We use primitive.ObjectID from the mongo-driver package to represent the unique MongoDB document ID.
The bson tags are crucial for mapping our Go struct fields to the corresponding fields in our MongoDB documents.

Connecting to MongoDB

We need to establish a connection to our MongoDB database. Create a config.go file in the config directory:

// config/config.go
package config

import (
    "context"
    "fmt"
    "os"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func ConnectToMongoDB() (*mongo.Client, error) {
    uri := os.Getenv("MONGODB_URI")
    if uri == "" {
        return nil, fmt.Errorf("MONGODB_URI is not set")
    }

    clientOptions := options.Client().ApplyURI(uri)
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Ping(context.Background(), nil)
    if err != nil {
        return nil, err
    }

    return client, nil
}

Explanation:

We use os.Getenv to retrieve the MongoDB connection URI from the environment variable MONGODB_URI. Make sure to set this variable in your environment.
We use the mongo-driver package to connect to the MongoDB database and perform basic operations like pinging the database.

Building Handlers

Now, let's build the API handlers for our CRUD operations. In the handlers directory, create a user.go file:

// handlers/user.go
package handlers

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/your-username/my-crud-api/config"
    "github.com/your-username/my-crud-api/models"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)

// Create a new user
func CreateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.InsertOne(context.Background(), user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Get all users
func GetAllUsers(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    collection := client.Database("your_database_name").Collection("users")
    cursor, err := collection.Find(context.Background(), bson.D{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(context.Background())

    var users []models.User
    for cursor.Next(context.Background()) {
        var user models.User
        if err := cursor.Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        users = append(users, user)
    }

    json.NewEncoder(w).Encode(users)
}

// Get a user by ID
func GetUserByID(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    var user models.User
    if err := collection.FindOne(context.Background(), bson.M{"_id": id}).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    json.NewEncoder(w).Encode(user)
}

// Update a user
func UpdateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    var updatedUser models.User
    if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    filter := bson.M{"_id": id}
    update := bson.M{"$set": updatedUser}
    result, err := collection.UpdateOne(context.Background(), filter, update)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Delete a user
func DeleteUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.DeleteOne(context.Background(), bson.M{"_id": id})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

Explanation:

We implement the CRUD operations: CreateUser, GetAllUsers, GetUserByID, UpdateUser, and DeleteUser.
Each function connects to MongoDB, retrieves the collection, performs the respective operation, and returns a JSON response.
We handle potential errors and return appropriate HTTP status codes.

Setting up the Main Application

Finally, let's tie everything together in our main.go file:

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/your-username/my-crud-api/handlers"
)

func main() {
    http.HandleFunc("/users", handlers.CreateUser)
    http.HandleFunc("/users", handlers.GetAllUsers)
    http.HandleFunc("/users/", handlers.GetUserByID)
    http.HandleFunc("/users/", handlers.UpdateUser)
    http.HandleFunc("/users/", handlers.DeleteUser)

    fmt.Println("Server running on port 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Explanation:

We register the API handlers with the corresponding HTTP endpoints.
We start the server and listen on port 8080.

Running the API

Environment Variable: Set the MONGODB_URI environment variable with your MongoDB connection string.
Build and Run: Build the Go application using go build and then run it using ./my-crud-api.

Testing the API

You can test your API using tools like Postman or curl.

Create: Send a POST request to /users with a JSON payload containing user details.
Read: Send a GET request to /users to retrieve all users or to /users/?id={user_id} to get a specific user.
Update: Send a PUT request to /users/?id={user_id} with a JSON payload containing updated user details.
Delete: Send a DELETE request to /users/?id={user_id} to delete a user.

Tips for Success

Error Handling: Always handle potential errors and return meaningful HTTP status codes.
Security: Implement proper authentication and authorization mechanisms for your API.
Database Design: Design your database schema thoughtfully to optimize performance and scalability.
Documentation: Document your API endpoints, request/response formats, and error codes.

Congratulations! You've successfully built a basic CRUD API using Go and MongoDB. With this foundation, you can expand your API to handle more complex functionalities and build impressive web applications. Keep learning and exploring the endless possibilities of Go and MongoDB!

Building a CRUD API with FastAPI and MongoDB

Mohd Aquib — Fri, 05 Jul 2024 21:30:11 +0000

Welcome, fellow developers! In this blog post, we'll dive into the exciting world of building RESTful APIs with FastAPI, a modern, fast, and easy-to-use framework, and MongoDB, a powerful NoSQL database. We'll create a simple CRUD (Create, Read, Update, Delete) API for managing a collection of books. Let's get started!

1. Setting the Stage:

Install Dependencies: Begin by installing the required libraries:

  pip install fastapi uvicorn pymongo[srv]

Create Project Structure: Organize your project with a clear structure:

  my-book-api/
  ├── main.py
  ├── models.py
  └── schemas.py

2. Defining Our Book Model:

We'll start by defining our book model in models.py. This model represents the structure of our book data:

from pydantic import BaseModel

class Book(BaseModel):
    title: str
    author: str
    description: str
    published_year: int

    class Config:
        schema_extra = {
            "example": {
                "title": "The Hitchhiker's Guide to the Galaxy",
                "author": "Douglas Adams",
                "description": "A humorous science fiction novel.",
                "published_year": 1979
            }
        }

3. Database Connection:

In main.py, we'll establish a connection to our MongoDB database:

from fastapi import FastAPI
from pymongo import MongoClient

app = FastAPI()

client = MongoClient("mongodb+srv://<your_username>:<your_password>@<your_cluster>.mongodb.net/<your_database>?retryWrites=true&w=majority")
db = client["my_book_database"]
collection = db["books"]

4. Creating the CRUD Operations:

Now, let's define our CRUD endpoints within main.py:

4.1. Creating a Book (POST):

@app.post("/books", response_model=Book)
async def create_book(book: Book):
  book_dict = book.dict()
  collection.insert_one(book_dict)
  return book

4.2. Reading Books (GET):

@app.get("/books")
async def get_books():
  books = []
  for book in collection.find():
    books.append(Book(**book))
  return books

4.3. Getting a Specific Book (GET):

@app.get("/books/{book_id}", response_model=Book)
async def get_book(book_id: str):
  book = collection.find_one({"_id": ObjectId(book_id)})
  if book:
    return Book(**book)
  else:
    raise HTTPException(status_code=404, detail="Book not found")

4.4. Updating a Book (PUT):

@app.put("/books/{book_id}", response_model=Book)
async def update_book(book_id: str, book: Book):
  book_dict = book.dict()
  collection.update_one({"_id": ObjectId(book_id)}, {"$set": book_dict})
  return book

4.5. Deleting a Book (DELETE):

@app.delete("/books/{book_id}")
async def delete_book(book_id: str):
  collection.delete_one({"_id": ObjectId(book_id)})
  return {"message": "Book deleted successfully"}

5. Running the API:

Finally, run the API using uvicorn:

uvicorn main:app --reload

6. Testing the API:

You can test your API using tools like Postman or curl. For example, to create a new book:

curl -X POST -H "Content-Type: application/json" -d '{"title": "The Lord of the Rings", "author": "J.R.R. Tolkien", "description": "A classic fantasy novel.", "published_year": 1954}' http://localhost:8000/books

Tips and Tricks:

Use a .env file: Store sensitive information like database credentials in a .env file.
Implement error handling: Handle potential errors with appropriate error messages and status codes.
Document your API: Use tools like Swagger or OpenAPI to create documentation for your API.
Consider using a database driver for more robust connections and operations.

Conclusion:

Creating CRUD operations with FastAPI and MongoDB is a simple yet powerful way to build RESTful APIs. By following these steps, you can quickly get your API up and running. Remember to explore additional features like pagination, filtering, and authentication for a more robust and user-friendly API. Happy coding!

The Transformer Revolution

Mohd Aquib — Sun, 16 Jun 2024 13:04:46 +0000

Unlocking the Power of Transformers: A Beginner's Guide to "Attention is All You Need"

Ever wondered how Google Translate can magically decipher languages, or how your phone can understand your voice commands with amazing accuracy? The answer lies in a powerful tool called Transformers. These deep learning models are revolutionizing the world of natural language processing (NLP), making it possible for machines to understand and generate human language with remarkable proficiency.

Transformers: A Game-Changer in NLP

Before we dive into the heart of "Attention is All You Need," let's understand what Transformers are all about. Imagine a language model as a detective investigating a crime scene – a sentence. Traditional models like RNNs would analyze the scene sequentially, word by word, like a detective following a trail of clues. But Transformers are different. They take a holistic view, considering the entire scene at once, analyzing the relationships between all the words, like a detective piecing together a puzzle.

This ability to understand the context of each word through its relationship with others is what makes Transformers so powerful. They can handle long sequences of text, identify intricate patterns, and even translate languages with impressive accuracy.

"Attention is All You Need": The Breakthrough Model

Now, "Attention is All You Need" isn't just a catchy title; it's the name of a groundbreaking paper that introduced a new architecture for Transformers, completely ditching the traditional recurrent neural networks (RNNs). This architecture, known as the "Transformer model," uses a mechanism called attention to understand the relationships between words in a sentence.

Think of attention as a mechanism that allows the model to "focus" on the most relevant parts of a sentence, while ignoring the less important ones. This selective focus makes the model more efficient and accurate in capturing the meaning of the text.

How it Works: A Simplified Explanation

Imagine you're trying to understand the sentence "The cat sat on the mat." A Transformer with attention will:

Encode each word: Each word is converted into a numerical representation, a vector, that captures its meaning.
Calculate attention scores: The model then calculates the "attention" score between each pair of words. This score indicates how strongly the words are related to each other.
Focus on relevant words: Words with high attention scores are "paid attention to," while those with low scores are ignored.
Generate output: The model uses the attention scores to generate the final output, whether it's a translation, a summary, or a prediction.

Getting Started with Transformers: Practical Tips

Ready to explore the world of Transformers? Here's how you can get started:

Choose your framework: Popular libraries like TensorFlow, PyTorch, and Hugging Face provide pre-trained Transformer models for various tasks.
Pick a task: Start with a simple task like text classification or question answering. There are numerous tutorials and examples available online.
Explore pre-trained models: Hugging Face offers a vast collection of pre-trained models, making it easy to get started without building your own model from scratch.
Experiment with different hyperparameters: Fine-tune the model's parameters to achieve the best performance for your specific task.

The Future of NLP: Transformers Leading the Way

Transformers are a true game-changer in the world of NLP. They are driving innovation in various fields, including:

Machine Translation: Transformers have dramatically improved machine translation, making it more accurate and natural-sounding.
Text Summarization: Transformers can automatically generate concise summaries of long documents, saving time and effort.
Chatbots and Conversational AI: Transformers are making chatbots more intelligent and human-like, enabling more engaging interactions.
Sentiment Analysis: Transformers can analyze the sentiment of text, allowing businesses to understand customer feedback and market trends.

The world of Transformers is vast and exciting, offering endless possibilities. As you learn and explore, you'll discover how these powerful models are transforming our world, one sentence at a time. So, start your journey today, and unlock the power of Transformers!

Python vs. Go: The Backend Battle Royale

Mohd Aquib — Fri, 24 May 2024 13:42:23 +0000

Choosing Between Python and Go for Backend Development

You've decided to dive into the exciting world of backend development, but with so many languages vying for your attention, it can be overwhelming! Two giants stand out: Python and Go. Both offer powerful features, but which one should you choose? Let's break it down!

Python: The Friendly Giant

Python is renowned for its readability, ease of learning, and vast ecosystem. Its syntax is straightforward, and it boasts a rich collection of libraries and frameworks like Django and Flask, making it a breeze to build web applications quickly.

Pros:

Beginner-friendly: Easy to learn and pick up, perfect for new developers.
Extensive libraries: Offers a vast collection of libraries for various tasks, saving you time and effort.
Large community: Strong community support means you'll always find help when you need it.
Versatile: Used in web development, data science, machine learning, and more.

Cons:

Performance: Can be slower than Go for demanding tasks.
Dynamically typed: Requires careful testing to avoid errors.

Go: The Speedy Challenger

Go, developed by Google, is known for its speed, concurrency, and simplicity. It's a compiled language, meaning it's faster than interpreted languages like Python. Go's focus on efficiency and parallelism makes it ideal for building robust, scalable applications.

Pros:

Performance: Excellent performance and scalability, great for handling heavy workloads.
Concurrency: Built-in features for efficient handling of concurrent tasks.
Strong tooling: Well-designed tools and libraries for building and testing applications.
Simple syntax: Clear and concise syntax, making it easy to learn.

Cons:

Limited ecosystem: Smaller community and library collection compared to Python.
Less beginner-friendly: Steeper learning curve for those new to programming.

Choosing Your Weapon

So, which language should you choose? It ultimately depends on your project's needs and your own preferences.

Choose Python if:

You're a beginner and value ease of learning.
Your project requires a rich set of libraries and frameworks.
You need a language for tasks like data science or machine learning.

Choose Go if:

Your project requires high performance and scalability.
You need to handle concurrent tasks efficiently.
You prefer a simple and straightforward syntax.

Getting Started

Ready to jump in? Here are some tips:

Try both! Play around with both languages using online tutorials and resources.
Build a small project: Choose a simple project and implement it in both Python and Go.
Join online communities: Connect with other developers and get advice.
Practice consistently: The more you code, the better you'll become!

No matter which path you choose, both Python and Go offer exciting opportunities in backend development. So grab your keyboard and start building!

Neural Style Transfer Using PyTorch

Mohd Aquib — Mon, 08 Feb 2021 17:18:09 +0000

Neural Style Transfer is an optimization technique used to take two images i.e content image and style reference image and blend them such that the output image looks like the content image but painted in a style of a style reference image.
It is a deep learning technique that generates artistic images. It extracts the structural features from the content image, whereas the style features from the style image.

Define content and style representations

The deep convolution neural networks develop the representations of the images. As we move deeper in the network it will take care of structural features. Reconstruction from the lower layer will reproduce the exact image. In contrast, the higher layer's reconstruction will capture the high-level content and hence we refer to the feature responses from the higher layer as the content representation.

To extract the representation of the style content, we build a feature space on the top of the filter responses in each network layer. It consists of the correlations between the different filter responses over the spatial extent of the feature maps. The filter correlation of different layers captures the texture information of the input image. This creates images that match a given image's style on an increasing scale while discarding information of the global arrangement. This multi-scale representation is called style representation.
This can be easily understood by the diagram given below.

Model

The above architecture of the model proposed in the paper “A Neural Algorithm of Artistic Style”. Here we will use a pre-trained VGG-19 model for content and style reconstruction. By putting structural information from content representation and texture information from style representation together we will generate an artistic image. A strong emphasis on style will result in images that match the artwork's appearance, effectively giving a texturized version of it, but hardly show any of the photograph’s content. When placing a strong emphasis on content, one can identify the photograph, but the painting style is not as well-matched. We perform the gradient descent on the generated image to find another image that matches the original image's feature responses.

Implementation

You can install PyTorch from here.

Importing Libraries

import torch
import torch.nn as nn
import torchvision
import torchvision.models as models
import torchvision.transforms as transforms
import torch.optim as optim
from torchvision.utils import save_image
from PIL import Image
import matplotlib.pyplot as plt

Loading Model

We will use VGG-19 model from torch.models().
VGG-19 is a convolutional neural network that is 19 layers deep. You can load a pre-trained version of the network trained on more than a million images from the ImageNet database. The pretrained network can classify images into 1000 object categories, such as a keyboard, mouse, pencil, and many animals. As a result, the network has learned rich feature representations for a wide range of images. The network has an image input size of 224-by-224.

Architecture

A fixed size of (224 * 224) RGB image was given as input to this network which means that the matrix was of shape (224,224,3).
Used kernels of (3 * 3) size with a stride size of 1 pixel, this enabled them to cover the whole notion of the image.
Spatial padding was used to preserve the spatial resolution of the image.
MaxPooling has performed over 2 * 2 pixel windows with stride 2.
This was followed by a Rectified linear unit(ReLu) to introduce non-linearity to make the model classify better and to improve computational time.
implemented three fully connected layers from which the first two were of size 4096 and after that, a layer with 1000 channels for 1000-way ILSVRC classification and the final layer is a softmax function.

The Layers in VGG-19 model are given below

Now let's load the model

model = models.vgg19(pretrained=True)

device = 'cuda' if torch.cuda.is_available() else 'cpu'

This makes sure if the device has GPU then it will load our model in GPU otherwise in CPU.

Feature Representations

we will define a class that will help us to provide feature representations of intermediate layers(as they are complex feature extractor). In this we will use 'block_conv1_1', 'block_conv2_1','block_conv3_1', 'block_conv4_1', 'block_conv5_1' layers whose index values are 0, 5, 10, 19, 28 respectively and then store these activations of 5 convolutional layers in an array and return the array.

class VGG(nn.Module):
    def __init__(self):
        super(VGG,self).__init__()
        self.req_features = ['0','5','10','19','28']
        self.model = models.vgg19(pretrained=True).features[:29]
    def forward(self,x):
        features = []
        for layer_num,layer in enumerate(self.model):
            x = layer(x)
            if(str(layer_num) in self.req_features):
                features.append(x)
        return features

Image Preprocessing

Preprocessing is required to make an image suitable for the model.
we will perform preprocessing using torch.transform() like image resizing and converting image into Tensor.
we will define the function with an argument as the path of the image which will return a preprocessed image.

def image_loader(path):
    image = Image.open(path)
    loader = transforms.Compose([transforms.Resize((512,512)),
transforms.ToTensor()])
    image = loader(image).unsqueeze(0)
    return image.to(device,torch.float)

unsqueeze() is used to add extra dimension at 0th index for batch size.

Now, use the image_loader function to load the style and the content image from the local disk. We will use the content image clone as the input base image or the generated image. Since the gradient descent will alter the generated image's pixel values, we will pass the parameter true for require_grads_().

original_image = image_loader('/content/mountain.jpg')
style_image = image_loader('/content/style.jpg')
generated_image = original_image.clone().requires_grad_(True)

Loss Functions

Here we will describe two loss functions i.e 1. Content Loss 2. Style Loss.
The content loss function ensures that the activations of higher layers are similar between content and generated image. The style loss function ensures that the correlation of all the layers are similar between style and generated image.

Content Loss Function
The content_image and generated_image are passed into a model and output is extracted using intermediate layers using VGG class that we have defined above. Then we will calculate the Euclidean Distance between the output of the generated_image and content_image.Therefore content loss for layer1 is

def calc_content_loss(gen_feat,orig_feat):
    content_l = torch.mean((gen_feat - orig_feat)**2)
    return content_l

Style Loss Function
To calculate style loss we need to compute Gram Matrix. A gram matrix is a multiplication of a matrix with its transposed matrix.

The gram matrix represents the correlation between each filter in an intermediate representation.

In the above equation, Gˡᵢⱼ is the inner product between the vectorized feature map i and j in layer l.
The following diagram shows how gram matrix is computed in a CNN layer.

The style loss of layer l is the squared error between the gram matrices of the intermediate representation of the generated_image and style image.

Where Eₗ is the style loss for layer l, Nₗ and Mₗ are the numbers of channels and height times width in the feature representation of layer l respectively. Gˡᵢⱼ and Aˡᵢⱼ are the intermediate representation of gram matrices of the generated_image and style image respectively.
Therefore overall style loss is
Here w^l is a weight factor contributing to each layer of total style loss.

def calc_style_loss(gen,style):
    batch_size,channel,height,width = gen.shape
    G = torch.mm(gen.view(channel,height*width),gen.view(channel,height*width).t())
    A = torch.mm(style.view(channel,height*width),style.view(channel,height*width).t())
    style_l = torch.mean((G-A)**2)
    return style_l

Final Loss
The final loss is defined as,
where α and β are user-defined hyperparameters. By controlling α and β we can set how much style and content to be inserted to a generated image.

def calculate_loss(gen_features,orig_features,style_features):
    style_loss=content_loss=0
    for gen,con,style in zip(gen_features,orig_features,style_features):
        content_loss += calc_content_loss(gen,con)
        style_loss += calc_style_loss(gen,style)
    total_loss = alpha*content_loss + beta*style_loss
    return total_loss

Training

before training, we should set our hyperparameters and optimizer.
I have chosen Adam Optimizer but if you want to can try out with LBFGS Optimizer(Limited-memory BFGS (L-BFGS or LM-BFGS) is an optimization algorithm in the family of quasi-Newton methods that approximates the Broyden–Fletcher–Goldfarb–Shanno algorithm (BFGS) using a limited amount of computer memory) using optim.LBFGS.

model = VGG().to(device).eval()
epoch = 6000
lr = 0.004
alpha = 8
beta = 70
optimizer = optim.Adam([generated_image],lr=lr)

Now using for loop we will iterate over the number of epochs. extract feature representations of intermediate layers of content, style, generated image using model. Then calculate the loss function using above define function i.e calculates_loss().Set gradient to zero using optimizer.zero_grad() then backpropagate the loss using total_loss.backward() and update weights(gradient descent) using optimizer.step().

for i in range(epoch):
    gen_features = model(generated_image)
    orig_features = model(original_image)
    style_features = model(style_image)

    total_loss = calculate_loss(gen_features,orig_features,style_features)
    optimizer.zero_grad()
    total_loss.backward()
    optimizer.step()

    if(not(i%100)):
        print(total_loss)
        save_image(generated_image,'gen.png')

Input

The content and style image are as follows:

Output

The output using Neural style Transfer on content and style image is

Conclusion

So in this blog, we learned how Neural Style Transfer works. We loaded the pre-trained VGG-19 model then preprocess the image, then define content and style loss functions, which combined to calculate the total loss function and finally we ran our model and get the artistic image as output.

GitHub Link - Here

References -

AutoNLP for Automating Twitter Sentiment Analysis

Mohd Aquib — Sat, 02 Jan 2021 20:17:24 +0000

What is NLP?

Natural Language Processing or NLP is a field of Artificial Intelligence that gives machines the ability to read, understand, and derive meaning from human languages.

NLP is particularly booming in the healthcare industry. This technology is improving care delivery, disease diagnosis, and bringing costs down while healthcare organizations are going through a growing adoption of electronic health records. The fact that clinical documentation can be improved means that patients can be better understood and benefited through better healthcare. The goal should be to optimize their experience, and several organizations are already working on this.

A number of publications containing the sentence “natural language processing” in PubMed in the period 1978–2018. As of 2018, PubMed comprised more than 29 million citations for biomedical literature

What is Automated Machine Learning?

Automated machine learning changes that, making it easier to build and use machine learning models in the real world by running systematic processes on raw data and selecting models that pull the most relevant information from the data.
Automated Machine Learning(AutoML) is currently one of the explosive subfields within Data Science. It sounds great for those who are not fluent in machine learning and terrifying for current Data Scientists.

What is AutoNLP?

Using the concepts of AutoML, AutoNLP helps in automating the process of exploratory data analysis like stemming, tokenization, lemmatization, etc. It also helps in text processing and picking the best model for the given dataset. AutoNLP was developed under AutoVIML which stands for Automatic Variant Interpretable ML.

Some of the features of AutoNLP are:

Data cleansing: The entire dataset can be sent to the model without performing any process like vectorization. It even fills the missing data and cleans the data automatically.
Uses feature tools library for feature extraction: Feature Tools is another great library that helps in feature engineering and extraction in any easy way.
Model performance and graphs are produced automatically: Just by setting the verbose, the model graph and performance can be shown.
Feature reduction is automatic: With huge datasets, it becomes tough to select the best features and perform EDA. But this is taken care of by AutoNLP.

Let start implementing twitter sentiments analysis using auto NLP.

Without auto NLP we have to clean the data, then vectorized, stemmed, lemmatized, and then choose the best model for data.
But with Auto NLP we can do this thing in few lines of codes.

Installing the AutoNLP

To install this we can use a simple pip command. Since AutoNLP belongs to autoviml we need to install that.

!pip install autoviml

After installation, You can download the dataset from here.

Let's look at our dataset

import pandas as pd
df = pd.read_csv('../input/twitter-sentiment-analysis-analytics-vidya/train_E6oV3lV.csv')
df.head()

Model

Now we will split the data into training and test dataset and use AutoNLP to build our model

from sklearn.model_selection import train_test_split
from autoviml.Auto_NLP import Auto_NLP
train, test = train_test_split(df, test_size=0.2)

This will split the dataset into 80% training and 20% test dataset.
Since this is a Classification problem so we have to tell this in AutoNLP method.

input_feature, target = "tweet", "label"
train_x, test_x, final, predicted= Auto_NLP(input_feature, train, test,target,score_type="balanced_accuracy",top_num_features=200,modeltype="Classification",verbose=2,build_model=True)

If we don't mention top_num_features then it will take its default value i.e 300. Also training with more top_num_features will result in slower training.

After a few couples of minutes, you will see the trained model along with some plots for visualization of data.
This is the most beautiful thing about AutoNLP is that after choosing the best model it performs Hyperparameter Tuning over 30 params using RandomizedSearchCV and automatically generates plots for Exploratory Data Analysis.
You can see the results below:

After completing the training process, Auto NLP also generates Confusion Matrix which tells how good our classifier had performed over the dataset.

The model has selected Multinomial NB as a classifier and has performed the training.
Note: If the top_num_features were not given, a Random Forest Algorithm would be used.

Predictions

You can make predictions as

final.predict(test_x[input_feature])

Conclusion

We saw how AutoNLP cleans, preprocess, vectorized the data, and also it generates plots for visualization, and performs hyperparameter tuning for the best model. Also, it uses Cross-Validation to avoid Overfitting the model.
But we can't say this is the best approach for classification in NLP Because we are living in the era of Transformer which gives state-of-the-art Natural Language Processing. There are many transformers like Google's BERT(Bidirectional Encoder Representations from Transformers), GPT-2, XLM, etc.

Thank You!! I hope this helps you in clearing the concept behind Automating NLP. If you liked this post, then please do give me a few ❤️.

The full code is here.