Assignment 1: End-to-End Sentiment Analysis Pipeline

Objective

You will implement a sentiment analysis pipeline on a well-known public dataset. The process
includes:

1. Downloading the dataset (already annotated with sentiment).

2. Storing the data in a database.
3. Cleaning and exploring the data.
4. Training and evaluating a classification model.
5. Serving the trained model via a Flask API (with an endpoint that predicts sentiment for
new text).

Dataset: IMDB Movie Reviews

 Why IMDB?
o It’s a standard sentiment analysis dataset, with ~25k labeled movie reviews.
Labels are typically positive or negative.
o Easily available via:
 Kaggle: IMDB Dataset of 50K Movie Reviews
 Hugging Face Datasets: huggingface datasets
load_dataset("imdb")

Important: If you prefer another labeled sentiment dataset (e.g., Yelp Reviews Polarity), that’s
fine, but the IMDB dataset is the baseline recommendation.

Steps & Requirements

1. Data Collection

1. Obtain the data

o Download from Kaggle (CSV file) OR load via Hugging Face Datasets.
o Confirm you have ~25k rows of labeled reviews (train + test sets).
2. Database Setup
o Choose any relational database (e.g., MySQL, PostgreSQL, or SQLite).
o Create a table (e.g., imdb_reviews) with columns:
 id (primary key)
 review_text (text)
 sentiment (text or integer, e.g., “positive” / “negative”)
o Insert all data into this table.
Note: If you use SQLite, you won’t need a separate DB server. This is often the simplest option.

2. Data Cleaning & Exploration

1. Data Cleaning
o Ensure there are no obvious errors or duplicates.
o For text cleanup, you can consider:
 Lowercasing
 Removing HTML tags (some IMDB reviews contain <br /> etc.)
 Removing punctuation (optional)
o Keep the cleaned version stored in memory or in a new column, whichever you
prefer.
2. Exploratory Data Analysis (EDA)
o Show basic stats:
 Number of reviews per sentiment (distribution)
 Average review length for positive vs. negative
o (Optional) Some simple plots or word clouds can be included for illustration.

3. Model Training

1. Model Type
o Baseline: A simple approach like Logistic Regression or Naive Bayes on TF-
IDF vectors.
o (Optional) Try a transformer-based model like DistilBERT or BERT if you’re
comfortable with Hugging Face Transformers.
2. Train/Validation Split
o If the dataset is already split into train/test, use that.
o You can create an additional validation split from the training set (e.g., 80%/20%
within the training set).
3. Training
o Fit the model on the training data.
o Monitor basic metrics (accuracy, F1, etc.) on the validation set.
4. Evaluation
o Evaluate on the test set.
o Report metrics (accuracy, precision, recall, F1-score).

Tip: Keep the model as simple or advanced as you like, but logistic regression on TF-IDF is
typically enough for a baseline.

4. Model Serving with Flask

1. Flask API
o Create a simple Flask app (app.py or main.py).
o Include an endpoint, e.g., POST /predict:
 Input: JSON with a field review_text (the new text to classify).
 Output: JSON with a field sentiment_prediction (e.g., "positive" /
"negative").
2. Model Loading
o Ensure your trained model (e.g., a pickle file or Hugging Face model weights) is
loaded once when the app starts.
o The Flask endpoint should do the following:

1. Receive text input.

2. Apply the same preprocessing steps used during training.
3. Run the text through the trained model.
4. Return the predicted sentiment.
3. Testing Locally
o Show how to send a test request (using curl, Postman, or Python’s requests) to
verify the endpoint works.

5. (Optional) Deployment

 Cloud: Deploy to any free-tier service (Heroku, Render, Railway, etc.) or a small EC2
instance on AWS.
 Provide instructions or documentation if you do this step.

Deliverables

1. Code Repository
o A well-structured repository (GitHub, GitLab, etc.) containing:
 Data ingestion/DB setup script or notebook (e.g., data_setup.py).
 Model training script or notebook (e.g., train_model.py).
 Flask app (e.g., app.py).
 Requirements file (requirements.txt) listing all Python dependencies.
2. Database Schema
o Simple instructions or a .sql file that shows table creation if using
MySQL/PostgreSQL.
o If using SQLite, mention your database file name (e.g., imdb_reviews.db) and
how it’s created.
3. README
o Project Setup: Steps to install dependencies (e.g., pip install -r
requirements.txt) and set up the database.
o Data Acquisition: How you downloaded or loaded the dataset.
o Run Instructions:
 How to run the training script.
 How to start the Flask server.
 How to test the endpoint with example commands or requests.
o Model Info: A summary of the chosen model approach and key results (e.g., final
accuracy on test set).
 4. (Optional) Additional Assets
o If you generate plots or a short EDA report, include them in the repo (e.g., a
.ipynb or .pdf).

Time Expectation & Scope

 This assignment should be 2-3 days of work at a normal pace.

 Keep the solution focused on these steps—no need to explore other major NLP tasks.

Evaluation Criteria

1. Completeness: Did you store data in a DB, train a sentiment model, and serve it via
Flask?
2. Correctness: Does the Flask endpoint work? Does the model predict sentiment
accurately on test data?
3. Code Quality & Organization: Is the code clean, documented, and logically separated
into files/modules?
4. Documentation: Is there a clear README with setup and usage instructions?

Assignment 2: RAG (Retrieval-Augmented Generation) Chatbot

Overview

You will implement a simple Retrieval-Augmented Generation (RAG) chatbot that uses a vector database
for semantic search and stores chat history in a local MySQL database. The chatbot will be served via a
Flask API.

Task Breakdown

1. Data Preparation

o Corpus: Pick or create a small text corpus (e.g., a set of documentation pages, articles,
or Wikipedia paragraphs on a particular topic). You can:

 Provide your own text files.

 Scrape a small set of web pages (ensure the data is not too large—just enough
to test retrieval).

o Chunk & Preprocess:

 Split larger documents into smaller chunks (e.g., ~200-300 words each).

 Clean and normalize text (remove extra whitespaces, etc.).

2. Embedding & Vector Store

o Vector Database: You can choose any free and local-friendly vector DB (e.g., Faiss,
Chroma, or Milvus).

o Embeddings:

 Use any sentence embedding model (e.g., sentence-transformers from Hugging

Face).

 Embed each chunk of text and store the resulting vectors in the vector DB.

o Retrieval:

 Implement a function to query the vector DB given a user query (in embeddings
space).

 Return the top-k most relevant chunks.

3. Generation (Answer Construction)

o RAG Approach:

 Take the user’s query.

 Retrieve relevant chunks from the vector DB.

 Use the retrieved chunks as context to generate an answer.

 Model: you can any LLM

o Implementation Details:

 You can run a local model (small transformer, or even a rule-based approach) if
you do not want to rely on large model inference.

 For each query, your pipeline should be:

1. Convert query to embedding.

2. Retrieve top-k relevant chunks.

3. Concatenate these chunks.

4. Pass them (with the query) into your small generation or extraction
function to form the final answer.

4. Flask API

o Endpoints:

 POST /chat: Accepts a JSON payload with the user’s query. Returns:

 Generated answer.
  Possibly the top retrieved chunks for debugging (optional).

 GET /history: Returns the chat history from the MySQL DB.

o Chat History:

 For each user query and system answer, store them as separate rows in MySQL
with fields such as:

 id (auto-increment)

 timestamp

 role (user or system)

 content (the text of the user query or system answer)

 You can store them after each response is generated.

5. Database

o MySQL:

 Set up a local MySQL database.

 Create a table(s) to hold chat messages.

 Optionally, you can also store user IDs if you want to support multiple users (not
mandatory).

6. Testing

o Unit Tests:

 Test embedding and retrieval with a few sample queries.

 Test the Flask endpoints (/chat, /history) to ensure the entire pipeline works.

Deliverables

1. Code Repository:

o All source code for the chatbot pipeline, including the vector DB setup, embedding code,
retrieval code, and Flask API.

o A requirements.txt or Pipfile.

2. Database Schema:

o The SQL schema or migrations for MySQL (tables for storing chat history).

3. Demo / Documentation:

o A short README describing:

 How to install and run the system locally.

  How to set up MySQL and create the required tables.

 How to test the /chat and /history endpoints.

 Any environment variables needed (e.g., DB credentials).

4. (Optional) Extra Credit:

o Dockerize the application to ensure consistent environment setup.

o Provide instructions for a minimal cloud deployment if you want.

General Submission Instructions

1. Repo Structure:

o Assignment1

 data_ingestion.py (or notebook)

 model_training.py (or notebook)

 app.py (Flask API)

 requirements.txt

 etc.

o Assignment2

 data_preprocessing.py

 embed_store.py

 rag_chatbot.py (or app.py for Flask)

 requirements.txt

 etc.

o README.md

2. Instructions: Provide clear instructions on how someone else can clone your repository, install
dependencies, set up the database, and run each assignment’s solution.

3. Time Expectation:

o Each assignment is designed to be completed in about 1-3 days of focused work

(depending on your familiarity with the tools).

Evaluation Criteria
 Correctness & Completeness: Does the code run end-to-end without major issues? Are all parts
of the assignment addressed?

 Project Structure & Code Quality: Is the repository organized logically? Is the code readable,
well-documented, and maintainable?

 Solution Design: Are the chosen methods (data cleaning, feature engineering, model selection,
retrieval, etc.) appropriate and justified?

 Documentation: Is there a clear README explaining how to install, run, and test the solution?

 Bonus/Extras: (Optional) Dockerization, cloud deployment, or additional tests will be considered

a plus.