first commit

.gitignore

@@ -0,0 +1 @@
+.env

README.md

@@ -1,13 +1,128 @@
----
-title: Sentiment Analysis
-emoji: 📈
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Sentiment-Analysis
+
+A lightweight sentiment analysis project that demonstrates data preprocessing, model training, evaluation, and inference for text sentiment classification. This repository contains code, datasets examples, and utility scripts to build and experiment with machine-learning and deep-learning approaches to classify text (e.g., positive, negative, neutral).
+
+## Table of contents
+- [Project Overview](#project-overview)
+- [Features](#features)
+- [Repository structure](#repository-structure)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Dataset](#dataset)
+- [Usage](#usage)
+  - [Training a model](#training-a-model)
+  - [Evaluating a model](#evaluating-a-model)
+  - [Running inference](#running-inference)
+- [Modeling notes](#modeling-notes)
+- [Best practices & tips](#best-practices--tips)
+- [Contributing](#contributing)
+- [License](#license)
+- [Contact](#contact)
+
+## Project Overview
+This project aims to provide a clear, reproducible example of building a sentiment analysis pipeline:
+- load and clean text data,
+- convert text into features (tokenization, embeddings, TF-IDF),
+- train classification models (baseline and neural),
+- evaluate performance with standard metrics,
+- run inference on new texts.
+
+It is suitable for learning, experimentation, classroom demos, and small production prototyping.
+
+## Features
+- Data preprocessing utilities (cleaning, tokenization, train/test split).
+- Feature extraction options (TF-IDF, pre-trained embeddings).
+- Example classifiers: logistic regression, SVM, simple neural network (PyTorch/Keras/TensorFlow depending on supplied code).
+- Training and evaluation scripts with metrics: accuracy, precision, recall, F1, confusion matrix.
+- Inference script to classify individual sentences or batch inputs.
+
+## Repository structure
+(Adjust paths if your code differs)
+- data/ — example datasets, `.csv` samples (do NOT store large proprietary datasets here).
+- src/
+  - data_processing.py — cleaning and preprocessing utilities.
+  - features.py — TF-IDF and embedding feature builders.
+  - models.py — model definitions and wrappers.
+  - train.py — training entrypoint.
+  - evaluate.py — evaluation scripts and metrics.
+  - predict.py — inference script for new text.
+- notebooks/ — exploratory notebooks and experiments.
+- requirements.txt — Python dependencies.
+- README.md — this file.
+
+## Requirements
+- Python 3.8+
+- Typical libraries: numpy, pandas, scikit-learn, nltk, transformers (optional), torch or tensorflow (optional)
+- See `requirements.txt` for an exact list.
+
+Install with:
+pip install -r requirements.txt
+
+## Installation
+1. Clone the repo:
+   git clone https://github.com/missaouimedamine/Sentiment-Analysis.git
+2. Create and activate a virtual environment (recommended):
+   python -m venv venv
+   source venv/bin/activate  # macOS / Linux
+   venv\Scripts\activate     # Windows
+3. Install dependencies:
+   pip install -r requirements.txt
+
+## Dataset
+Provide your dataset in data/ as a CSV with at least two columns:
+- text — the text to classify
+- label — the sentiment label (e.g., "positive", "negative", "neutral" or 1/0)
+
+If you plan to use external datasets (e.g., IMDb, SST, Twitter Sentiment), add instructions or scripts to download them into `data/`.
+
+## Usage
+
+### Training a model
+Example (replace flags with code's CLI options if present):
+python src/train.py --data data/train.csv --model-dir models/ --epochs 10 --batch-size 32 --feature tfidf
+
+This will:
+- load and preprocess the data,
+- extract features,
+- train the selected model,
+- save the trained model and preprocessing artifacts to `models/`.
+
+### Evaluating a model
+python src/evaluate.py --data data/test.csv --model models/latest_model.pkl --output results/eval.json
+
+Generates metrics (accuracy, precision, recall, F1) and a confusion matrix saved in the output path.
+
+### Running inference
+Single sentence:
+python src/predict.py --model models/latest_model.pkl --text "I love this product!"
+
+Batch mode (CSV input):
+python src/predict.py --model models/latest_model.pkl --input data/new_texts.csv --output predictions.csv
+
+## Modeling notes
+- Baselines: TF-IDF + Logistic Regression or SVM often give strong baselines for sentiment tasks.
+- For higher performance, use pre-trained transformer encoders (BERT variants) and fine-tune.
+- Pay attention to class imbalance; consider stratified splitting, class weights, or resampling.
+- Monitor overfitting with validation curves and apply regularization / dropout as needed.
+
+## Best practices & tips
+- Clean and normalize text (lowercasing, removing extra whitespace, handling emojis if relevant).
+- Preserve tokens like negations ("not", "never") because they strongly affect sentiment.
+- Use consistent label encoding and save label->index mappings with the model.
+- Version models and preprocessing steps so results are reproducible.
+
+## Contributing
+Contributions are welcome. Typical ways to help:
+- Open issues for bugs or feature requests.
+- Provide pull requests with bug fixes, added models, or improved preprocessing.
+- Add example notebooks showing experiments and model comparisons.
+Before submitting PRs, run linters / tests if available.
+
+## License
+Specify your license here (e.g., MIT). If absent, add a LICENSE file to the repository.
+
+## Contact
+Maintainer: missaouimedamine
+Project: https://github.com/missaouimedamine/Sentiment-Analysis
+
+

app.py

@@ -0,0 +1,103 @@
+import gradio as gr
+from data_clean import clean_text
+from data_process import query_hf_sentiment, extract_themes, create_openai_client
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+API_KEY = os.getenv("API_KEY")
+HF_MODEL_URL = "https://api-inference.huggingface.co/models/tabularisai/multilingual-sentiment-analysis"
+
+
+def analyze_post_gradio(post):
+    """
+    Gradio version of the analyze_post function
+    """
+    try:
+        # Clean the text
+        cleaned_post = clean_text(post)
+        
+        # Get sentiment analysis
+        sentiment_result = query_hf_sentiment(cleaned_post, API_KEY, HF_MODEL_URL)
+        sentiment = sentiment_result['raw_output'][0]
+        
+        # Extract themes
+        themes = extract_themes(cleaned_post, create_openai_client(API_KEY))
+        
+        # Prepare data for storage and display
+        data = {
+            "post": post,
+            "cleaned_post": cleaned_post,
+            "sentiment": {
+                "label": sentiment['label'],
+                "score": sentiment['score']
+            },
+            "theme": themes
+        }
+        
+        # Store in MongoDB
+        #insert_post(data)
+        
+        # Format output for display
+        output = f"""
+        **Original Post:** {post}
+        
+        **Cleaned Post:** {cleaned_post}
+        
+        **Sentiment Analysis:**
+        - Label: {sentiment['label']}
+        - Score: {sentiment['score']:.4f}
+        
+        **Extracted Themes:** {themes}
+        
+        **Status:** ✅ Post analyzed and stored successfully in MongoDB
+        """
+        
+        return output
+        
+    except Exception as e:
+        return f"❌ Error analyzing post: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Post Analyzer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📊 Post Analysis Tool")
+    gr.Markdown("Enter a post to analyze its sentiment and extract themes")
+    
+    with gr.Row():
+        with gr.Column():
+            post_input = gr.Textbox(
+                label="Enter your post",
+                placeholder="Type your post here...",
+                lines=4,
+                max_lines=10
+            )
+            analyze_btn = gr.Button("Analyze Post", variant="primary")
+        
+        with gr.Column():
+            output = gr.Markdown(label="Analysis Results")
+    
+    # Set up the interaction
+    analyze_btn.click(
+        fn=analyze_post_gradio,
+        inputs=post_input,
+        outputs=output
+    )
+    
+    # Add examples
+    gr.Examples(
+        examples=[
+            "I absolutely love this product! It's amazing and works perfectly.",
+            "I'm really disappointed with the service. It was slow and unhelpful.",
+            "The weather today is nice, but I'm concerned about climate change."
+        ],
+        inputs=post_input
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

data_clean.py

@@ -0,0 +1,29 @@
+
+import re
+import emoji
+import unicodedata
+
+def clean_text(text):
+    # 1. Supprimer les URLs
+    text = re.sub(r"http\S+|www\S+|https\S+", "", text)
+
+    # 2. Supprimer les mentions @
+    text = re.sub(r"@\w+", "", text)
+
+    # 3. Supprimer les hashtags (garder le mot ou tout enlever ? ici on garde le mot)
+    text = re.sub(r"#(\w+)", r"\1", text)
+
+    # 4. Supprimer les emojis
+    text = emoji.replace_emoji(text, replace="")
+
+    # 5. Supprimer les caractères spéciaux (sauf lettres, chiffres et ponctuation de base)
+    text = re.sub(r"[^a-zA-ZÀ-ÿ0-9\s.,!?;:()\"'-]", " ", text)
+
+    # 6. Normaliser en minuscules
+    text = text.lower()
+
+    # 7. Supprimer les espaces multiples
+    text = re.sub(r"\s+", " ", text).strip()
+
+    return text
+

data_process.py

@@ -0,0 +1,40 @@
+import requests
+from openai import OpenAI
+
+# === Hugging Face Sentiment Analysis ===
+
+def create_hf_headers(api_key):
+    """Create headers for Hugging Face API requests."""
+    return {"Authorization": f"Bearer {api_key}"}
+
+def query_hf_sentiment(post, api_key, model_url):
+    """Query Hugging Face sentiment analysis API for a list of posts."""
+    headers = create_hf_headers(api_key)
+    response = requests.post(model_url, headers=headers, json={"inputs": post})
+    return {
+        "text": post,
+        "raw_output": response.json()[0]
+    }
+
+
+# === OpenAI / Hugging Face GPT-based Theme Extraction ===
+
+def create_openai_client(api_key, base_url="https://router.huggingface.co/v1"):
+    """Create an OpenAI client for Hugging Face router."""
+    return OpenAI(api_key=api_key, base_url=base_url)
+
+def extract_themes(post, client, prompt=None):
+    """Extract main themes from posts using GPT model."""
+    if prompt is None:
+        prompt = ("Donne uniquement les thèmes principaux en un ou deux mots pour le texte suivant, "
+                  "sans explication. (par exemple, contenus liés à la solitude, "
+                  "au soutien psychologique, aux symptômes, etc.).")
+    
+    completion = client.chat.completions.create(
+        model="openai/gpt-oss-20b:fireworks-ai",
+        messages=[{"role": "user", "content": f"{prompt}\n\nTexte : {post}"}],
+    )
+    return completion.choices[0].message.content
+
+
+# === Example Usage ===

requirements.txt

@@ -0,0 +1,9 @@
+emoji==2.6.0
+regex==2023.10.11
+requests==2.31.0
+openai==0.27.8
+fastapi==0.95.2
+pydantic==1.10.12
+uvicorn==0.22.0
+python-dotenv==1.0.0
+pymongo==4.4.0