update content with the text model from Thomas repository https://huggingface.co/spaces/tombou/frugal-ai-challenge

.gitignore

@@ -5,7 +5,6 @@ venv/
 __pycache__/
 .env
 .ipynb_checkpoints
-*ipynb
 .vscode/
 
 eval-queue/
@@ -15,3 +14,9 @@ eval-results-bk/
 logs/
 
 emissions.csv
+
+# PyCharm
+.idea/*
+
+# sandbox folder: contains draft files
+sandbox/

README.md

@@ -1,28 +1,41 @@
 ---
-title: Submission Template
-emoji: 🔥
-colorFrom: yellow
+title: Frugal AI Challenge Submission
+emoji: 🌍
+colorFrom: blue
 colorTo: green
 sdk: docker
 pinned: false
 ---
 
 
-# Random Baseline Model for Climate Disinformation Classification
+# Models for Climate Disinformation Classification
 
-## Model Description
+## Evaluate locally
 
-This is a random baseline model for the Frugal AI Challenge 2024, specifically for the text classification task of identifying climate disinformation. The model serves as a performance floor, randomly assigning labels to text inputs without any learning.
+To evaluate the model locally, you can use the following command:
 
-### Intended Use
+```bash
+python main.py --config config_evaluation_{model_name}.json
+```
+
+where `{model_name}` is either `distilBERT` or `embeddingML`.
+
+
+## Models Description
+
+### DistilBERT Model
+
+The model uses the `distilbert-base-uncased` model from the Hugging Face Transformers library, fine-tuned on the 
+training dataset (see below).
+
+### Embedding + ML Model
 
-- **Primary intended uses**: Baseline comparison for climate disinformation classification models
-- **Primary intended users**: Researchers and developers participating in the Frugal AI Challenge
-- **Out-of-scope use cases**: Not intended for production use or real-world classification tasks
+The model uses a simple embedding layer followed by a classic ML model. Currently, the embedding layer is a simple
+TF-IDF vectorizer, and the ML model is a logistic regression.
 
 ## Training Data
 
-The model uses the QuotaClimat/frugalaichallenge-text-train dataset:
+The model uses the [`QuotaClimat/frugalaichallenge-text-train`](https://huggingface.co/datasets/QuotaClimat/frugalaichallenge-text-train) dataset:
 - Size: ~6000 examples
 - Split: 80% train, 20% test
 - 8 categories of climate disinformation claims

config_evaluation_distilBERT.json

@@ -0,0 +1,5 @@
+{
+  "mode": "evaluate",
+  "model_type": "distilbert-pretrained",
+  "model_name": "2025-01-27_17-00-47_DistilBERT_Model_fined-tuned_from_distilbert-base-uncased"
+}

config_evaluation_embeddingML.json

@@ -0,0 +1,4 @@
+{
+  "mode": "evaluate",
+  "model_type": "embeddingML"
+}

config_training.json

@@ -0,0 +1,8 @@
+{
+  "mode": "train",
+  "model_type": "distilbert",
+  "model_name": "distilbert-base-uncased",
+  "batch_size": 16,
+  "num_epochs": 5,
+  "initial_learning_rate": 2e-5
+}

config_training_embedding_test.json

@@ -0,0 +1,4 @@
+{
+  "mode": "train",
+  "model_type": "embeddingML"
+}

config_training_test.json

@@ -0,0 +1,8 @@
+{
+  "mode": "train",
+  "model_type": "distilbert",
+  "model_name": "distilbert-base-uncased",
+  "batch_size": 1,
+  "num_epochs": 1,
+  "initial_learning_rate": 2e-5
+}

main.py

@@ -0,0 +1,70 @@
+import json
+import argparse
+import asyncio
+
+from tasks.data.data_loaders import TextDataLoader
+from tasks.models.text_classifiers import ModelFactory
+from tasks.text import evaluate_text
+from tasks.utils.evaluation import TextEvaluationRequest
+
+def load_config(config_path):
+    with open(config_path, 'r') as config_file:
+        config = json.load(config_file)
+    return config
+
+async def train_model(config):
+    # loading data
+    text_request = TextEvaluationRequest()
+    is_light_dataset = False
+    data_loader = TextDataLoader(text_request, light=is_light_dataset)
+
+    # define model
+    model = ModelFactory.create_model(config)
+
+    # train model
+    train_dataset = data_loader.get_train_dataset()
+    if model.model is None:
+        model.train(train_dataset)
+        model.save()
+    print("Model training completed and saved.")
+
+async def evaluate_model(config):
+    # loading data
+    text_request = TextEvaluationRequest()
+    data_loader = TextDataLoader(text_request)
+
+    # define model
+    model = ModelFactory.create_model(config)
+
+    # Call the evaluate_text function
+    results = await evaluate_text(request=text_request, model=model)
+
+    # Print the results
+    print(json.dumps(results, indent=2))
+    print(f"Achieved accuracy: {results['accuracy']}")
+    print(f"Energy consumed: {results['energy_consumed_wh']} Wh")
+
+async def main():
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(description="Train or evaluate the model.")
+    parser.add_argument("--config", type=str, default="config.json", help="Path to the configuration file")
+    args = parser.parse_args()
+
+    # Load configuration
+    config_path = args.config
+    config = load_config(config_path)
+
+    try:
+        mode = config["mode"]
+    except ValueError:
+        raise ValueError(f"Missing mode in configuration file: {config_path}")
+
+    if mode == "train":
+        await train_model(config)
+    elif mode == "evaluate":
+        await evaluate_model(config)
+    else:
+        raise ValueError(f"Invalid mode in file '{config_path}': '{mode}'")
+
+if __name__ == "__main__":
+    asyncio.run(main())

notebooks/template-audio.ipynb

@@ -0,0 +1,1351 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Text task notebook template\n",
+    "## Loading the necessary libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[codecarbon WARNING @ 19:48:07] Multiple instances of codecarbon are allowed to run at the same time.\n",
+      "[codecarbon INFO @ 19:48:07] [setup] RAM Tracking...\n",
+      "[codecarbon INFO @ 19:48:07] [setup] CPU Tracking...\n",
+      "[codecarbon WARNING @ 19:48:09] We saw that you have a 13th Gen Intel(R) Core(TM) i7-1365U but we don't know it. Please contact us.\n",
+      "[codecarbon WARNING @ 19:48:09] No CPU tracking mode found. Falling back on CPU constant mode. \n",
+      " Windows OS detected: Please install Intel Power Gadget to measure CPU\n",
+      "\n",
+      "[codecarbon WARNING @ 19:48:11] We saw that you have a 13th Gen Intel(R) Core(TM) i7-1365U but we don't know it. Please contact us.\n",
+      "[codecarbon INFO @ 19:48:11] CPU Model on constant consumption mode: 13th Gen Intel(R) Core(TM) i7-1365U\n",
+      "[codecarbon WARNING @ 19:48:11] No CPU tracking mode found. Falling back on CPU constant mode.\n",
+      "[codecarbon INFO @ 19:48:11] [setup] GPU Tracking...\n",
+      "[codecarbon INFO @ 19:48:11] No GPU found.\n",
+      "[codecarbon INFO @ 19:48:11] >>> Tracker's metadata:\n",
+      "[codecarbon INFO @ 19:48:11]   Platform system: Windows-11-10.0.22631-SP0\n",
+      "[codecarbon INFO @ 19:48:11]   Python version: 3.12.7\n",
+      "[codecarbon INFO @ 19:48:11]   CodeCarbon version: 3.0.0_rc0\n",
+      "[codecarbon INFO @ 19:48:11]   Available RAM : 31.347 GB\n",
+      "[codecarbon INFO @ 19:48:11]   CPU count: 12\n",
+      "[codecarbon INFO @ 19:48:11]   CPU model: 13th Gen Intel(R) Core(TM) i7-1365U\n",
+      "[codecarbon INFO @ 19:48:11]   GPU count: None\n",
+      "[codecarbon INFO @ 19:48:11]   GPU model: None\n",
+      "[codecarbon INFO @ 19:48:11] Saving emissions data to file c:\\git\\submission-template\\notebooks\\emissions.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "from fastapi import APIRouter\n",
+    "from datetime import datetime\n",
+    "from datasets import load_dataset\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "import random\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('../tasks')\n",
+    "\n",
+    "from utils.evaluation import AudioEvaluationRequest\n",
+    "from utils.emissions import tracker, clean_emissions_data, get_space_info\n",
+    "\n",
+    "\n",
+    "# Define the label mapping\n",
+    "LABEL_MAPPING = {\n",
+    "    \"chainsaw\": 0,\n",
+    "    \"environment\": 1\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the datasets and splitting them"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "668da7bf85434e098b95c3ec447d78fe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md:   0%|          | 0.00/5.18k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\theo.alvesdacosta\\AppData\\Local\\anaconda3\\Lib\\site-packages\\huggingface_hub\\file_download.py:139: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\\Users\\theo.alvesdacosta\\.cache\\huggingface\\hub\\datasets--QuotaClimat--frugalaichallenge-text-train. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.\n",
+      "To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development\n",
+      "  warnings.warn(message)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b68d43359eb429395da8be7d4b15556",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train.parquet:   0%|          | 0.00/1.21M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "140a304773914e9db8f698eabeb40298",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/6091 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6d04e8ab1906400e8e0029949dc523a5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/6091 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "request = AudioEvaluationRequest()\n",
+    "\n",
+    "# Load and prepare the dataset\n",
+    "dataset = load_dataset(request.dataset_name)\n",
+    "\n",
+    "# Split dataset\n",
+    "train_test = dataset[\"train\"].train_test_split(test_size=request.test_size, seed=request.test_seed)\n",
+    "test_dataset = train_test[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Baseline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Start tracking emissions\n",
+    "tracker.start()\n",
+    "tracker.start_task(\"inference\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 6,\n",
+       " 3,\n",
+       " 6,\n",
+       " 6,\n",
+       " 5,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 3,\n",
+       " 6,\n",
+       " 4,\n",
+       " 2,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 2,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 4,\n",
+       " 4,\n",
+       " 1,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 1,\n",
+       " 2,\n",
+       " 2,\n",
+       " 2,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " 2,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 2,\n",
+       " 0,\n",
+       " 1,\n",
+       " 6,\n",
+       " 3,\n",
+       " 2,\n",
+       " 5,\n",
+       " 5,\n",
+       " 2,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 7,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 1,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 2,\n",
+       " 5,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 2,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 0,\n",
+       " 3,\n",
+       " 1,\n",
+       " 4,\n",
+       " 6,\n",
+       " 0,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 2,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 3,\n",
+       " 4,\n",
+       " 4,\n",
+       " 2,\n",
+       " 2,\n",
+       " 3,\n",
+       " 3,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 5,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 0,\n",
+       " 4,\n",
+       " 0,\n",
+       " 1,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 3,\n",
+       " 3,\n",
+       " 0,\n",
+       " 1,\n",
+       " 2,\n",
+       " 4,\n",
+       " 4,\n",
+       " 3,\n",
+       " 1,\n",
+       " 2,\n",
+       " 4,\n",
+       " 3,\n",
+       " 0,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 3,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 4,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 3,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 0,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 3,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 0,\n",
+       " 4,\n",
+       " 1,\n",
+       " 2,\n",
+       " 6,\n",
+       " 3,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 0,\n",
+       " 7,\n",
+       " 4,\n",
+       " 6,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 4,\n",
+       " 6,\n",
+       " 6,\n",
+       " 4,\n",
+       " 0,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 1,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 2,\n",
+       " 4,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 0,\n",
+       " 7,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 5,\n",
+       " 5,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 3,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 5,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 1,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 5,\n",
+       " 6,\n",
+       " 3,\n",
+       " 2,\n",
+       " 3,\n",
+       " 0,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 6,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 2,\n",
+       " 7,\n",
+       " 5,\n",
+       " 7,\n",
+       " 6,\n",
+       " 3,\n",
+       " 5,\n",
+       " 6,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 1,\n",
+       " 2,\n",
+       " 1,\n",
+       " 5,\n",
+       " 3,\n",
+       " 0,\n",
+       " 3,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 4,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 2,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 3,\n",
+       " 2,\n",
+       " 6,\n",
+       " 4,\n",
+       " 4,\n",
+       " 1,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 2,\n",
+       " 7,\n",
+       " 1,\n",
+       " 3,\n",
+       " 5,\n",
+       " 2,\n",
+       " 6,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 0,\n",
+       " 5,\n",
+       " 1,\n",
+       " 6,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 1,\n",
+       " 5,\n",
+       " 1,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 2,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 5,\n",
+       " 4,\n",
+       " 2,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 5,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 1,\n",
+       " 2,\n",
+       " 3,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 4,\n",
+       " 7,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 5,\n",
+       " 3,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 5,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 2,\n",
+       " 7,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 0,\n",
+       " 2,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 6,\n",
+       " 3,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 7,\n",
+       " 7,\n",
+       " 4,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 3,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 0,\n",
+       " 1,\n",
+       " 3,\n",
+       " 7,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 5,\n",
+       " 3,\n",
+       " 3,\n",
+       " 4,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 7,\n",
+       " 5,\n",
+       " 0,\n",
+       " 0,\n",
+       " 5,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 6,\n",
+       " 6,\n",
+       " 0,\n",
+       " 4,\n",
+       " 7,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 5,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 3,\n",
+       " 3,\n",
+       " 7,\n",
+       " 3,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 4,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 2,\n",
+       " 0,\n",
+       " 6,\n",
+       " 0,\n",
+       " 6,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 7,\n",
+       " 7,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 4,\n",
+       " 7,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " 0,\n",
+       " 6,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 0,\n",
+       " 5,\n",
+       " 0,\n",
+       " 5,\n",
+       " 7,\n",
+       " 2,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 4,\n",
+       " 0,\n",
+       " 7,\n",
+       " 1,\n",
+       " 4,\n",
+       " 5,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 2,\n",
+       " 0,\n",
+       " 2,\n",
+       " 5,\n",
+       " 5,\n",
+       " 6,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 2,\n",
+       " 3,\n",
+       " 2,\n",
+       " 5,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 5,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 1,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 0,\n",
+       " 7,\n",
+       " 6,\n",
+       " 2,\n",
+       " 4,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 3,\n",
+       " 0,\n",
+       " 7,\n",
+       " 3,\n",
+       " 1,\n",
+       " 2,\n",
+       " 1,\n",
+       " 6,\n",
+       " 4,\n",
+       " 7,\n",
+       " 1,\n",
+       " 7,\n",
+       " 1,\n",
+       " 5,\n",
+       " 1,\n",
+       " 6,\n",
+       " 3,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 6,\n",
+       " 2,\n",
+       " 4,\n",
+       " 4,\n",
+       " 6,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 6,\n",
+       " 1,\n",
+       " 2,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 5,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 2,\n",
+       " 1,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 7,\n",
+       " 5,\n",
+       " 2,\n",
+       " 5,\n",
+       " 4,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 1,\n",
+       " 3,\n",
+       " 3,\n",
+       " 6,\n",
+       " 4,\n",
+       " 6,\n",
+       " 4,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 2,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 4,\n",
+       " 2,\n",
+       " 2,\n",
+       " 3,\n",
+       " 0,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 6,\n",
+       " 5,\n",
+       " 3,\n",
+       " 2,\n",
+       " 3,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 1,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 2,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 4,\n",
+       " 7,\n",
+       " 0,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 3,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 4,\n",
+       " 7,\n",
+       " 5,\n",
+       " 0,\n",
+       " 4,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 6,\n",
+       " 4,\n",
+       " 0,\n",
+       " 5,\n",
+       " 4,\n",
+       " 6,\n",
+       " 6,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 3,\n",
+       " 2,\n",
+       " 2,\n",
+       " 1,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 5,\n",
+       " 5,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 5,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 0,\n",
+       " 5,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 0,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 2,\n",
+       " 4,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 7,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 0,\n",
+       " 3,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 5,\n",
+       " 3,\n",
+       " 1,\n",
+       " 2,\n",
+       " 5,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 7,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 3,\n",
+       " 1,\n",
+       " 5,\n",
+       " 4,\n",
+       " 2,\n",
+       " 4,\n",
+       " 6,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " ...]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "#--------------------------------------------------------------------------------------------\n",
+    "# YOUR MODEL INFERENCE CODE HERE\n",
+    "# Update the code below to replace the random baseline by your model inference within the inference pass where the energy consumption and emissions are tracked.\n",
+    "#--------------------------------------------------------------------------------------------   \n",
+    "\n",
+    "# Make random predictions (placeholder for actual model inference)\n",
+    "true_labels = test_dataset[\"label\"]\n",
+    "predictions = [random.randint(0, 1) for _ in range(len(true_labels))]\n",
+    "\n",
+    "predictions\n",
+    "\n",
+    "#--------------------------------------------------------------------------------------------\n",
+    "# YOUR MODEL INFERENCE STOPS HERE\n",
+    "#--------------------------------------------------------------------------------------------   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[codecarbon WARNING @ 19:53:32] Background scheduler didn't run for a long period (47s), results might be inaccurate\n",
+      "[codecarbon INFO @ 19:53:32] Energy consumed for RAM : 0.000156 kWh. RAM Power : 11.755242347717285 W\n",
+      "[codecarbon INFO @ 19:53:32] Delta energy consumed for CPU with constant : 0.000564 kWh, power : 42.5 W\n",
+      "[codecarbon INFO @ 19:53:32] Energy consumed for All CPU : 0.000564 kWh\n",
+      "[codecarbon INFO @ 19:53:32] 0.000720 kWh of electricity used since the beginning.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "EmissionsData(timestamp='2025-01-21T19:53:32', project_name='codecarbon', run_id='908f2e7e-4bb2-4991-a0f6-56bf8d7eda21', experiment_id='5b0fa12a-3dd7-45bb-9766-cc326314d9f1', duration=47.736408500000834, emissions=4.032368007471064e-05, emissions_rate=8.444466886328872e-07, cpu_power=42.5, gpu_power=0.0, ram_power=11.755242347717285, cpu_energy=0.0005636615353475565, gpu_energy=0, ram_energy=0.00015590305493261682, energy_consumed=0.0007195645902801733, country_name='France', country_iso_code='FRA', region='île-de-france', cloud_provider='', cloud_region='', os='Windows-11-10.0.22631-SP0', python_version='3.12.7', codecarbon_version='3.0.0_rc0', cpu_count=12, cpu_model='13th Gen Intel(R) Core(TM) i7-1365U', gpu_count=None, gpu_model=None, longitude=2.3494, latitude=48.8558, ram_total_size=31.347312927246094, tracking_mode='machine', on_cloud='N', pue=1.0)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Stop tracking emissions\n",
+    "emissions_data = tracker.stop_task()\n",
+    "emissions_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.10090237899917966"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate accuracy\n",
+    "accuracy = accuracy_score(true_labels, predictions)\n",
+    "accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'submission_timestamp': '2025-01-21T19:53:46.639165',\n",
+       " 'accuracy': 0.10090237899917966,\n",
+       " 'energy_consumed_wh': 0.7195645902801733,\n",
+       " 'emissions_gco2eq': 0.040323680074710634,\n",
+       " 'emissions_data': {'run_id': '908f2e7e-4bb2-4991-a0f6-56bf8d7eda21',\n",
+       "  'duration': 47.736408500000834,\n",
+       "  'emissions': 4.032368007471064e-05,\n",
+       "  'emissions_rate': 8.444466886328872e-07,\n",
+       "  'cpu_power': 42.5,\n",
+       "  'gpu_power': 0.0,\n",
+       "  'ram_power': 11.755242347717285,\n",
+       "  'cpu_energy': 0.0005636615353475565,\n",
+       "  'gpu_energy': 0,\n",
+       "  'ram_energy': 0.00015590305493261682,\n",
+       "  'energy_consumed': 0.0007195645902801733,\n",
+       "  'country_name': 'France',\n",
+       "  'country_iso_code': 'FRA',\n",
+       "  'region': 'île-de-france',\n",
+       "  'cloud_provider': '',\n",
+       "  'cloud_region': '',\n",
+       "  'os': 'Windows-11-10.0.22631-SP0',\n",
+       "  'python_version': '3.12.7',\n",
+       "  'codecarbon_version': '3.0.0_rc0',\n",
+       "  'cpu_count': 12,\n",
+       "  'cpu_model': '13th Gen Intel(R) Core(TM) i7-1365U',\n",
+       "  'gpu_count': None,\n",
+       "  'gpu_model': None,\n",
+       "  'ram_total_size': 31.347312927246094,\n",
+       "  'tracking_mode': 'machine',\n",
+       "  'on_cloud': 'N',\n",
+       "  'pue': 1.0},\n",
+       " 'dataset_config': {'dataset_name': 'QuotaClimat/frugalaichallenge-text-train',\n",
+       "  'test_size': 0.2,\n",
+       "  'test_seed': 42}}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Prepare results dictionary\n",
+    "results = {\n",
+    "    \"submission_timestamp\": datetime.now().isoformat(),\n",
+    "    \"accuracy\": float(accuracy),\n",
+    "    \"energy_consumed_wh\": emissions_data.energy_consumed * 1000,\n",
+    "    \"emissions_gco2eq\": emissions_data.emissions * 1000,\n",
+    "    \"emissions_data\": clean_emissions_data(emissions_data),\n",
+    "    \"dataset_config\": {\n",
+    "        \"dataset_name\": request.dataset_name,\n",
+    "        \"test_size\": request.test_size,\n",
+    "        \"test_seed\": request.test_seed\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "results"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/template-image.ipynb

@@ -0,0 +1,416 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Image task notebook template\n",
+    "## Loading the necessary libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastapi import APIRouter\n",
+    "from datetime import datetime\n",
+    "from datasets import load_dataset\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
+    "\n",
+    "import random\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('../')\n",
+    "\n",
+    "from tasks.utils.evaluation import ImageEvaluationRequest\n",
+    "from tasks.utils.emissions import tracker, clean_emissions_data, get_space_info\n",
+    "from tasks.image import parse_boxes,compute_iou,compute_max_iou"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the datasets and splitting them"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4f62b23ca587477d9f37430e687bf951",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md:   0%|          | 0.00/7.72k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\theo.alvesdacosta\\AppData\\Local\\anaconda3\\Lib\\site-packages\\huggingface_hub\\file_download.py:139: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\\Users\\theo.alvesdacosta\\.cache\\huggingface\\hub\\datasets--pyronear--pyro-sdis. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.\n",
+      "To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development\n",
+      "  warnings.warn(message)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "70735dd748e343119b5a7cd966dcd0f0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00000-of-00007.parquet:   0%|          | 0.00/433M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "903c3227c24649f1a0424e039d74d303",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00001-of-00007.parquet:   0%|          | 0.00/434M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8795b7696f124715b9d52287d5cd4ee0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00002-of-00007.parquet:   0%|          | 0.00/432M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4b6c1240bf024d61bf913584d13834f5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00003-of-00007.parquet:   0%|          | 0.00/428M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cd5f8172a31f4fd79d489db96ede9c21",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00004-of-00007.parquet:   0%|          | 0.00/431M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "416af82dba3a4ab7ad13190703c90757",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00005-of-00007.parquet:   0%|          | 0.00/429M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6819ad85508641a1a64bea34303446ac",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00006-of-00007.parquet:   0%|          | 0.00/431M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "90a7f85c802b4330b502c8bbd3cca7f9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "val-00000-of-00001.parquet:   0%|          | 0.00/407M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b93f2f19aafb43e2b8db0fd7bb3ebd34",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/29537 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c14c0f2cde184c959970dfccaa26b2d2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating val split:   0%|          | 0/4099 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "request = ImageEvaluationRequest()\n",
+    "\n",
+    "# Load and prepare the dataset\n",
+    "dataset = load_dataset(request.dataset_name)\n",
+    "\n",
+    "# Split dataset\n",
+    "train_test = dataset[\"train\"].train_test_split(test_size=request.test_size, seed=request.test_seed)\n",
+    "test_dataset = train_test[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Baseline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Start tracking emissions\n",
+    "tracker.start()\n",
+    "tracker.start_task(\"inference\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "#--------------------------------------------------------------------------------------------\n",
+    "# YOUR MODEL INFERENCE CODE HERE\n",
+    "# Update the code below to replace the random baseline by your model inference within the inference pass where the energy consumption and emissions are tracked.\n",
+    "#--------------------------------------------------------------------------------------------   \n",
+    "\n",
+    "# Make random predictions (placeholder for actual model inference)\n",
+    "\n",
+    "predictions = []\n",
+    "true_labels = []\n",
+    "pred_boxes = []\n",
+    "true_boxes_list = []  # List of lists, each inner list contains boxes for one image\n",
+    "\n",
+    "for example in test_dataset:\n",
+    "    # Parse true annotation (YOLO format: class_id x_center y_center width height)\n",
+    "    annotation = example.get(\"annotations\", \"\").strip()\n",
+    "    has_smoke = len(annotation) > 0\n",
+    "    true_labels.append(int(has_smoke))\n",
+    "    \n",
+    "    # Make random classification prediction\n",
+    "    pred_has_smoke = random.random() > 0.5\n",
+    "    predictions.append(int(pred_has_smoke))\n",
+    "    \n",
+    "    # If there's a true box, parse it and make random box prediction\n",
+    "    if has_smoke:\n",
+    "        # Parse all true boxes from the annotation\n",
+    "        image_true_boxes = parse_boxes(annotation)\n",
+    "        true_boxes_list.append(image_true_boxes)\n",
+    "        \n",
+    "        # For baseline, make one random box prediction per image\n",
+    "        # In a real model, you might want to predict multiple boxes\n",
+    "        random_box = [\n",
+    "            random.random(),  # x_center\n",
+    "            random.random(),  # y_center\n",
+    "            random.random() * 0.5,  # width (max 0.5)\n",
+    "            random.random() * 0.5   # height (max 0.5)\n",
+    "        ]\n",
+    "        pred_boxes.append(random_box)\n",
+    "\n",
+    "\n",
+    "#--------------------------------------------------------------------------------------------\n",
+    "# YOUR MODEL INFERENCE STOPS HERE\n",
+    "#--------------------------------------------------------------------------------------------   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Stop tracking emissions\n",
+    "emissions_data = tracker.stop_task()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# Calculate classification metrics\n",
+    "classification_accuracy = accuracy_score(true_labels, predictions)\n",
+    "classification_precision = precision_score(true_labels, predictions)\n",
+    "classification_recall = recall_score(true_labels, predictions)\n",
+    "\n",
+    "# Calculate mean IoU for object detection (only for images with smoke)\n",
+    "# For each image, we compute the max IoU between the predicted box and all true boxes\n",
+    "ious = []\n",
+    "for true_boxes, pred_box in zip(true_boxes_list, pred_boxes):\n",
+    "    max_iou = compute_max_iou(true_boxes, pred_box)\n",
+    "    ious.append(max_iou)\n",
+    "\n",
+    "mean_iou = float(np.mean(ious)) if ious else 0.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'submission_timestamp': '2025-01-22T15:57:37.288173',\n",
+       " 'classification_accuracy': 0.5001692620176033,\n",
+       " 'classification_precision': 0.8397129186602871,\n",
+       " 'classification_recall': 0.4972677595628415,\n",
+       " 'mean_iou': 0.002819781629108398,\n",
+       " 'energy_consumed_wh': 0.779355299496116,\n",
+       " 'emissions_gco2eq': 0.043674291628462855,\n",
+       " 'emissions_data': {'run_id': '4e750cd5-60f0-444c-baee-b5f7b31f784b',\n",
+       "  'duration': 51.72819679998793,\n",
+       "  'emissions': 4.3674291628462856e-05,\n",
+       "  'emissions_rate': 8.445163379568943e-07,\n",
+       "  'cpu_power': 42.5,\n",
+       "  'gpu_power': 0.0,\n",
+       "  'ram_power': 11.755242347717285,\n",
+       "  'cpu_energy': 0.0006104993474311617,\n",
+       "  'gpu_energy': 0,\n",
+       "  'ram_energy': 0.00016885595206495442,\n",
+       "  'energy_consumed': 0.0007793552994961161,\n",
+       "  'country_name': 'France',\n",
+       "  'country_iso_code': 'FRA',\n",
+       "  'region': 'île-de-france',\n",
+       "  'cloud_provider': '',\n",
+       "  'cloud_region': '',\n",
+       "  'os': 'Windows-11-10.0.22631-SP0',\n",
+       "  'python_version': '3.12.7',\n",
+       "  'codecarbon_version': '3.0.0_rc0',\n",
+       "  'cpu_count': 12,\n",
+       "  'cpu_model': '13th Gen Intel(R) Core(TM) i7-1365U',\n",
+       "  'gpu_count': None,\n",
+       "  'gpu_model': None,\n",
+       "  'ram_total_size': 31.347312927246094,\n",
+       "  'tracking_mode': 'machine',\n",
+       "  'on_cloud': 'N',\n",
+       "  'pue': 1.0},\n",
+       " 'dataset_config': {'dataset_name': 'pyronear/pyro-sdis',\n",
+       "  'test_size': 0.2,\n",
+       "  'test_seed': 42}}"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "# Prepare results dictionary\n",
+    "results = {\n",
+    "    \"submission_timestamp\": datetime.now().isoformat(),\n",
+    "    \"classification_accuracy\": float(classification_accuracy),\n",
+    "    \"classification_precision\": float(classification_precision),\n",
+    "    \"classification_recall\": float(classification_recall),\n",
+    "    \"mean_iou\": mean_iou,\n",
+    "    \"energy_consumed_wh\": emissions_data.energy_consumed * 1000,\n",
+    "    \"emissions_gco2eq\": emissions_data.emissions * 1000,\n",
+    "    \"emissions_data\": clean_emissions_data(emissions_data),\n",
+    "    \"dataset_config\": {\n",
+    "        \"dataset_name\": request.dataset_name,\n",
+    "        \"test_size\": request.test_size,\n",
+    "        \"test_seed\": request.test_seed\n",
+    "    }\n",
+    "}\n",
+    "results"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/template-text.ipynb

@@ -0,0 +1,1642 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Text task notebook template\n",
+    "## Loading the necessary libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[codecarbon WARNING @ 19:48:07] Multiple instances of codecarbon are allowed to run at the same time.\n",
+      "[codecarbon INFO @ 19:48:07] [setup] RAM Tracking...\n",
+      "[codecarbon INFO @ 19:48:07] [setup] CPU Tracking...\n",
+      "[codecarbon WARNING @ 19:48:09] We saw that you have a 13th Gen Intel(R) Core(TM) i7-1365U but we don't know it. Please contact us.\n",
+      "[codecarbon WARNING @ 19:48:09] No CPU tracking mode found. Falling back on CPU constant mode. \n",
+      " Windows OS detected: Please install Intel Power Gadget to measure CPU\n",
+      "\n",
+      "[codecarbon WARNING @ 19:48:11] We saw that you have a 13th Gen Intel(R) Core(TM) i7-1365U but we don't know it. Please contact us.\n",
+      "[codecarbon INFO @ 19:48:11] CPU Model on constant consumption mode: 13th Gen Intel(R) Core(TM) i7-1365U\n",
+      "[codecarbon WARNING @ 19:48:11] No CPU tracking mode found. Falling back on CPU constant mode.\n",
+      "[codecarbon INFO @ 19:48:11] [setup] GPU Tracking...\n",
+      "[codecarbon INFO @ 19:48:11] No GPU found.\n",
+      "[codecarbon INFO @ 19:48:11] >>> Tracker's metadata:\n",
+      "[codecarbon INFO @ 19:48:11]   Platform system: Windows-11-10.0.22631-SP0\n",
+      "[codecarbon INFO @ 19:48:11]   Python version: 3.12.7\n",
+      "[codecarbon INFO @ 19:48:11]   CodeCarbon version: 3.0.0_rc0\n",
+      "[codecarbon INFO @ 19:48:11]   Available RAM : 31.347 GB\n",
+      "[codecarbon INFO @ 19:48:11]   CPU count: 12\n",
+      "[codecarbon INFO @ 19:48:11]   CPU model: 13th Gen Intel(R) Core(TM) i7-1365U\n",
+      "[codecarbon INFO @ 19:48:11]   GPU count: None\n",
+      "[codecarbon INFO @ 19:48:11]   GPU model: None\n",
+      "[codecarbon INFO @ 19:48:11] Saving emissions data to file c:\\git\\submission-template\\notebooks\\emissions.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "from fastapi import APIRouter\n",
+    "from datetime import datetime\n",
+    "from datasets import load_dataset\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "import random\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('../tasks')\n",
+    "\n",
+    "from utils.evaluation import TextEvaluationRequest\n",
+    "from utils.emissions import tracker, clean_emissions_data, get_space_info\n",
+    "\n",
+    "\n",
+    "# Define the label mapping\n",
+    "LABEL_MAPPING = {\n",
+    "    \"0_not_relevant\": 0,\n",
+    "    \"1_not_happening\": 1,\n",
+    "    \"2_not_human\": 2,\n",
+    "    \"3_not_bad\": 3,\n",
+    "    \"4_solutions_harmful_unnecessary\": 4,\n",
+    "    \"5_science_unreliable\": 5,\n",
+    "    \"6_proponents_biased\": 6,\n",
+    "    \"7_fossil_fuels_needed\": 7\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the datasets and splitting them"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "668da7bf85434e098b95c3ec447d78fe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md:   0%|          | 0.00/5.18k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\theo.alvesdacosta\\AppData\\Local\\anaconda3\\Lib\\site-packages\\huggingface_hub\\file_download.py:139: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\\Users\\theo.alvesdacosta\\.cache\\huggingface\\hub\\datasets--QuotaClimat--frugalaichallenge-text-train. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.\n",
+      "To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development\n",
+      "  warnings.warn(message)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b68d43359eb429395da8be7d4b15556",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train.parquet:   0%|          | 0.00/1.21M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "140a304773914e9db8f698eabeb40298",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/6091 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6d04e8ab1906400e8e0029949dc523a5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/6091 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "request = TextEvaluationRequest()\n",
+    "\n",
+    "# Load and prepare the dataset\n",
+    "dataset = load_dataset(request.dataset_name)\n",
+    "\n",
+    "# Convert string labels to integers\n",
+    "dataset = dataset.map(lambda x: {\"label\": LABEL_MAPPING[x[\"label\"]]})\n",
+    "\n",
+    "# Split dataset\n",
+    "train_test = dataset[\"train\"].train_test_split(test_size=request.test_size, seed=request.test_seed)\n",
+    "test_dataset = train_test[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Baseline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Start tracking emissions\n",
+    "tracker.start()\n",
+    "tracker.start_task(\"inference\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 6,\n",
+       " 3,\n",
+       " 6,\n",
+       " 6,\n",
+       " 5,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 3,\n",
+       " 6,\n",
+       " 4,\n",
+       " 2,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 2,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 4,\n",
+       " 4,\n",
+       " 1,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 1,\n",
+       " 2,\n",
+       " 2,\n",
+       " 2,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " 2,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 2,\n",
+       " 0,\n",
+       " 1,\n",
+       " 6,\n",
+       " 3,\n",
+       " 2,\n",
+       " 5,\n",
+       " 5,\n",
+       " 2,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 7,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 1,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 2,\n",
+       " 5,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 2,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 0,\n",
+       " 3,\n",
+       " 1,\n",
+       " 4,\n",
+       " 6,\n",
+       " 0,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 2,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 3,\n",
+       " 4,\n",
+       " 4,\n",
+       " 2,\n",
+       " 2,\n",
+       " 3,\n",
+       " 3,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 5,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 0,\n",
+       " 4,\n",
+       " 0,\n",
+       " 1,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 3,\n",
+       " 3,\n",
+       " 0,\n",
+       " 1,\n",
+       " 2,\n",
+       " 4,\n",
+       " 4,\n",
+       " 3,\n",
+       " 1,\n",
+       " 2,\n",
+       " 4,\n",
+       " 3,\n",
+       " 0,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 3,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 4,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 3,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 0,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 3,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 0,\n",
+       " 4,\n",
+       " 1,\n",
+       " 2,\n",
+       " 6,\n",
+       " 3,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 0,\n",
+       " 7,\n",
+       " 4,\n",
+       " 6,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 4,\n",
+       " 6,\n",
+       " 6,\n",
+       " 4,\n",
+       " 0,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 1,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 2,\n",
+       " 4,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 0,\n",
+       " 7,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 5,\n",
+       " 5,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 3,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 5,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 1,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 5,\n",
+       " 6,\n",
+       " 3,\n",
+       " 2,\n",
+       " 3,\n",
+       " 0,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 6,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 2,\n",
+       " 7,\n",
+       " 5,\n",
+       " 7,\n",
+       " 6,\n",
+       " 3,\n",
+       " 5,\n",
+       " 6,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 1,\n",
+       " 2,\n",
+       " 1,\n",
+       " 5,\n",
+       " 3,\n",
+       " 0,\n",
+       " 3,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 4,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 2,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 3,\n",
+       " 2,\n",
+       " 6,\n",
+       " 4,\n",
+       " 4,\n",
+       " 1,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 2,\n",
+       " 7,\n",
+       " 1,\n",
+       " 3,\n",
+       " 5,\n",
+       " 2,\n",
+       " 6,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 0,\n",
+       " 5,\n",
+       " 1,\n",
+       " 6,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 1,\n",
+       " 5,\n",
+       " 1,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 2,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 5,\n",
+       " 4,\n",
+       " 2,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 5,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 1,\n",
+       " 2,\n",
+       " 3,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 5,\n",
+       " 5,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 4,\n",
+       " 7,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 0,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 5,\n",
+       " 3,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 5,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 2,\n",
+       " 7,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 0,\n",
+       " 2,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 6,\n",
+       " 3,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 7,\n",
+       " 7,\n",
+       " 4,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 3,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 0,\n",
+       " 1,\n",
+       " 3,\n",
+       " 7,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 5,\n",
+       " 3,\n",
+       " 3,\n",
+       " 4,\n",
+       " 0,\n",
+       " 1,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 7,\n",
+       " 5,\n",
+       " 0,\n",
+       " 0,\n",
+       " 5,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 6,\n",
+       " 6,\n",
+       " 0,\n",
+       " 4,\n",
+       " 7,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 5,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 0,\n",
+       " 0,\n",
+       " 3,\n",
+       " 3,\n",
+       " 7,\n",
+       " 3,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 6,\n",
+       " 7,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 4,\n",
+       " 5,\n",
+       " 4,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 2,\n",
+       " 0,\n",
+       " 6,\n",
+       " 0,\n",
+       " 6,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 7,\n",
+       " 7,\n",
+       " 5,\n",
+       " 5,\n",
+       " 1,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 5,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 4,\n",
+       " 7,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " 0,\n",
+       " 6,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 0,\n",
+       " 5,\n",
+       " 0,\n",
+       " 5,\n",
+       " 7,\n",
+       " 2,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 4,\n",
+       " 0,\n",
+       " 7,\n",
+       " 1,\n",
+       " 4,\n",
+       " 5,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 2,\n",
+       " 0,\n",
+       " 2,\n",
+       " 5,\n",
+       " 5,\n",
+       " 6,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 2,\n",
+       " 3,\n",
+       " 2,\n",
+       " 5,\n",
+       " 0,\n",
+       " 7,\n",
+       " 2,\n",
+       " 3,\n",
+       " 7,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 5,\n",
+       " 7,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 3,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 0,\n",
+       " 3,\n",
+       " 4,\n",
+       " 3,\n",
+       " 5,\n",
+       " 2,\n",
+       " 4,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 1,\n",
+       " 3,\n",
+       " 1,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 3,\n",
+       " 0,\n",
+       " 7,\n",
+       " 6,\n",
+       " 2,\n",
+       " 4,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 1,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 4,\n",
+       " 3,\n",
+       " 0,\n",
+       " 7,\n",
+       " 3,\n",
+       " 1,\n",
+       " 2,\n",
+       " 1,\n",
+       " 6,\n",
+       " 4,\n",
+       " 7,\n",
+       " 1,\n",
+       " 7,\n",
+       " 1,\n",
+       " 5,\n",
+       " 1,\n",
+       " 6,\n",
+       " 3,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 5,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 6,\n",
+       " 2,\n",
+       " 4,\n",
+       " 4,\n",
+       " 6,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 4,\n",
+       " 7,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 6,\n",
+       " 1,\n",
+       " 2,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 5,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 2,\n",
+       " 1,\n",
+       " 6,\n",
+       " 5,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 7,\n",
+       " 5,\n",
+       " 2,\n",
+       " 5,\n",
+       " 4,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 1,\n",
+       " 3,\n",
+       " 3,\n",
+       " 6,\n",
+       " 4,\n",
+       " 6,\n",
+       " 4,\n",
+       " 6,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 2,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 4,\n",
+       " 3,\n",
+       " 3,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 1,\n",
+       " 1,\n",
+       " 7,\n",
+       " 7,\n",
+       " 6,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 4,\n",
+       " 2,\n",
+       " 2,\n",
+       " 3,\n",
+       " 0,\n",
+       " 1,\n",
+       " 4,\n",
+       " 0,\n",
+       " 4,\n",
+       " 6,\n",
+       " 5,\n",
+       " 3,\n",
+       " 2,\n",
+       " 3,\n",
+       " 2,\n",
+       " 3,\n",
+       " 6,\n",
+       " 2,\n",
+       " 1,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 4,\n",
+       " 5,\n",
+       " 6,\n",
+       " 7,\n",
+       " 7,\n",
+       " 2,\n",
+       " 0,\n",
+       " 5,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 6,\n",
+       " 6,\n",
+       " 5,\n",
+       " 4,\n",
+       " 4,\n",
+       " 7,\n",
+       " 0,\n",
+       " 5,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 3,\n",
+       " 1,\n",
+       " 7,\n",
+       " 0,\n",
+       " 1,\n",
+       " 4,\n",
+       " 7,\n",
+       " 5,\n",
+       " 0,\n",
+       " 4,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 6,\n",
+       " 4,\n",
+       " 0,\n",
+       " 5,\n",
+       " 4,\n",
+       " 6,\n",
+       " 6,\n",
+       " 7,\n",
+       " 2,\n",
+       " 6,\n",
+       " 2,\n",
+       " 6,\n",
+       " 0,\n",
+       " 3,\n",
+       " 2,\n",
+       " 2,\n",
+       " 1,\n",
+       " 5,\n",
+       " 4,\n",
+       " 7,\n",
+       " 6,\n",
+       " 6,\n",
+       " 2,\n",
+       " 5,\n",
+       " 5,\n",
+       " 5,\n",
+       " 0,\n",
+       " 3,\n",
+       " 5,\n",
+       " 4,\n",
+       " 5,\n",
+       " 7,\n",
+       " 5,\n",
+       " 0,\n",
+       " 5,\n",
+       " 0,\n",
+       " 0,\n",
+       " 2,\n",
+       " 0,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 2,\n",
+       " 4,\n",
+       " 3,\n",
+       " 4,\n",
+       " 1,\n",
+       " 7,\n",
+       " 2,\n",
+       " 1,\n",
+       " 0,\n",
+       " 3,\n",
+       " 0,\n",
+       " 3,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 5,\n",
+       " 3,\n",
+       " 1,\n",
+       " 2,\n",
+       " 5,\n",
+       " 6,\n",
+       " 7,\n",
+       " 6,\n",
+       " 7,\n",
+       " 0,\n",
+       " 2,\n",
+       " 6,\n",
+       " 3,\n",
+       " 1,\n",
+       " 5,\n",
+       " 4,\n",
+       " 2,\n",
+       " 4,\n",
+       " 6,\n",
+       " 5,\n",
+       " 2,\n",
+       " 7,\n",
+       " ...]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "#--------------------------------------------------------------------------------------------\n",
+    "# YOUR MODEL INFERENCE CODE HERE\n",
+    "# Update the code below to replace the random baseline by your model inference within the inference pass where the energy consumption and emissions are tracked.\n",
+    "#--------------------------------------------------------------------------------------------   \n",
+    "\n",
+    "# Make random predictions (placeholder for actual model inference)\n",
+    "true_labels = test_dataset[\"label\"]\n",
+    "predictions = [random.randint(0, 7) for _ in range(len(true_labels))]\n",
+    "\n",
+    "predictions\n",
+    "\n",
+    "#--------------------------------------------------------------------------------------------\n",
+    "# YOUR MODEL INFERENCE STOPS HERE\n",
+    "#--------------------------------------------------------------------------------------------   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[codecarbon WARNING @ 19:53:32] Background scheduler didn't run for a long period (47s), results might be inaccurate\n",
+      "[codecarbon INFO @ 19:53:32] Energy consumed for RAM : 0.000156 kWh. RAM Power : 11.755242347717285 W\n",
+      "[codecarbon INFO @ 19:53:32] Delta energy consumed for CPU with constant : 0.000564 kWh, power : 42.5 W\n",
+      "[codecarbon INFO @ 19:53:32] Energy consumed for All CPU : 0.000564 kWh\n",
+      "[codecarbon INFO @ 19:53:32] 0.000720 kWh of electricity used since the beginning.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "EmissionsData(timestamp='2025-01-21T19:53:32', project_name='codecarbon', run_id='908f2e7e-4bb2-4991-a0f6-56bf8d7eda21', experiment_id='5b0fa12a-3dd7-45bb-9766-cc326314d9f1', duration=47.736408500000834, emissions=4.032368007471064e-05, emissions_rate=8.444466886328872e-07, cpu_power=42.5, gpu_power=0.0, ram_power=11.755242347717285, cpu_energy=0.0005636615353475565, gpu_energy=0, ram_energy=0.00015590305493261682, energy_consumed=0.0007195645902801733, country_name='France', country_iso_code='FRA', region='île-de-france', cloud_provider='', cloud_region='', os='Windows-11-10.0.22631-SP0', python_version='3.12.7', codecarbon_version='3.0.0_rc0', cpu_count=12, cpu_model='13th Gen Intel(R) Core(TM) i7-1365U', gpu_count=None, gpu_model=None, longitude=2.3494, latitude=48.8558, ram_total_size=31.347312927246094, tracking_mode='machine', on_cloud='N', pue=1.0)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Stop tracking emissions\n",
+    "emissions_data = tracker.stop_task()\n",
+    "emissions_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.10090237899917966"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate accuracy\n",
+    "accuracy = accuracy_score(true_labels, predictions)\n",
+    "accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'submission_timestamp': '2025-01-21T19:53:46.639165',\n",
+       " 'accuracy': 0.10090237899917966,\n",
+       " 'energy_consumed_wh': 0.7195645902801733,\n",
+       " 'emissions_gco2eq': 0.040323680074710634,\n",
+       " 'emissions_data': {'run_id': '908f2e7e-4bb2-4991-a0f6-56bf8d7eda21',\n",
+       "  'duration': 47.736408500000834,\n",
+       "  'emissions': 4.032368007471064e-05,\n",
+       "  'emissions_rate': 8.444466886328872e-07,\n",
+       "  'cpu_power': 42.5,\n",
+       "  'gpu_power': 0.0,\n",
+       "  'ram_power': 11.755242347717285,\n",
+       "  'cpu_energy': 0.0005636615353475565,\n",
+       "  'gpu_energy': 0,\n",
+       "  'ram_energy': 0.00015590305493261682,\n",
+       "  'energy_consumed': 0.0007195645902801733,\n",
+       "  'country_name': 'France',\n",
+       "  'country_iso_code': 'FRA',\n",
+       "  'region': 'île-de-france',\n",
+       "  'cloud_provider': '',\n",
+       "  'cloud_region': '',\n",
+       "  'os': 'Windows-11-10.0.22631-SP0',\n",
+       "  'python_version': '3.12.7',\n",
+       "  'codecarbon_version': '3.0.0_rc0',\n",
+       "  'cpu_count': 12,\n",
+       "  'cpu_model': '13th Gen Intel(R) Core(TM) i7-1365U',\n",
+       "  'gpu_count': None,\n",
+       "  'gpu_model': None,\n",
+       "  'ram_total_size': 31.347312927246094,\n",
+       "  'tracking_mode': 'machine',\n",
+       "  'on_cloud': 'N',\n",
+       "  'pue': 1.0},\n",
+       " 'dataset_config': {'dataset_name': 'QuotaClimat/frugalaichallenge-text-train',\n",
+       "  'test_size': 0.2,\n",
+       "  'test_seed': 42}}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Prepare results dictionary\n",
+    "results = {\n",
+    "    \"submission_timestamp\": datetime.now().isoformat(),\n",
+    "    \"accuracy\": float(accuracy),\n",
+    "    \"energy_consumed_wh\": emissions_data.energy_consumed * 1000,\n",
+    "    \"emissions_gco2eq\": emissions_data.emissions * 1000,\n",
+    "    \"emissions_data\": clean_emissions_data(emissions_data),\n",
+    "    \"dataset_config\": {\n",
+    "        \"dataset_name\": request.dataset_name,\n",
+    "        \"test_size\": request.test_size,\n",
+    "        \"test_seed\": request.test_seed\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Development of the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "90f50ab19698484489f36976745efad3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/1.15k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\theo.alvesdacosta\\AppData\\Local\\anaconda3\\Lib\\site-packages\\huggingface_hub\\file_download.py:139: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\\Users\\theo.alvesdacosta\\.cache\\huggingface\\hub\\models--facebook--bart-large-mnli. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.\n",
+      "To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development\n",
+      "  warnings.warn(message)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6e3974d8ff284603821f7beca9bd353d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors:   0%|          | 0.00/1.63G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bc29cb379c644b00b1bdf61d5426d99d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/26.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "635503cf819747c9a83f22aa4f2f11db",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "vocab.json:   0%|          | 0.00/899k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3a5f53e451e8483ca7c33f42245abd13",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "merges.txt:   0%|          | 0.00/456k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "84f922d1b68a4a0faa5e920d004efca0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/1.36M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Device set to use cpu\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import pipeline\n",
+    "classifier = pipeline(\"zero-shot-classification\",\n",
+    "                      model=\"facebook/bart-large-mnli\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sequence_to_classify = \"one day I will see the world\"\n",
+    "\n",
+    "candidate_labels = [\n",
+    "    \"Not related to climate change disinformation\",\n",
+    "    \"Climate change is not real and not happening\",\n",
+    "    \"Climate change is not human-induced\",\n",
+    "    \"Climate change impacts are not that bad\",\n",
+    "    \"Climate change solutions are harmful and unnecessary\",\n",
+    "    \"Climate change science is unreliable\",\n",
+    "    \"Climate change proponents are biased\",\n",
+    "    \"Fossil fuels are needed to address climate change\"\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'sequence': 'one day I will see the world',\n",
+       " 'labels': ['Fossil fuels are needed to address climate change',\n",
+       "  'Climate change science is unreliable',\n",
+       "  'Not related to climate change disinformation',\n",
+       "  'Climate change proponents are biased',\n",
+       "  'Climate change impacts are not that bad',\n",
+       "  'Climate change solutions are harmful and unnecessary',\n",
+       "  'Climate change is not human-induced',\n",
+       "  'Climate change is not real and not happening'],\n",
+       " 'scores': [0.16242119669914246,\n",
+       "  0.15683825314044952,\n",
+       "  0.1564282774925232,\n",
+       "  0.14603719115257263,\n",
+       "  0.12794046103954315,\n",
+       "  0.10180754214525223,\n",
+       "  0.0936085507273674,\n",
+       "  0.0549185685813427]}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "classifier(sequence_to_classify, candidate_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[codecarbon WARNING @ 11:00:07] Already started tracking\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5d66a13f76a4411d95b62d4a73012495",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "0it [00:00, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[codecarbon WARNING @ 11:05:57] Background scheduler didn't run for a long period (349s), results might be inaccurate\n",
+      "[codecarbon INFO @ 11:05:57] Energy consumed for RAM : 0.018069 kWh. RAM Power : 11.755242347717285 W\n",
+      "[codecarbon INFO @ 11:05:57] Delta energy consumed for CPU with constant : 0.004122 kWh, power : 42.5 W\n",
+      "[codecarbon INFO @ 11:05:57] Energy consumed for All CPU : 0.065327 kWh\n",
+      "[codecarbon INFO @ 11:05:57] 0.083395 kWh of electricity used since the beginning.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "EmissionsData(timestamp='2025-01-22T11:05:57', project_name='codecarbon', run_id='908f2e7e-4bb2-4991-a0f6-56bf8d7eda21', experiment_id='5b0fa12a-3dd7-45bb-9766-cc326314d9f1', duration=349.19709450000664, emissions=0.0002949120266226386, emissions_rate=8.445461750018632e-07, cpu_power=42.5, gpu_power=0.0, ram_power=11.755242347717285, cpu_energy=0.004122396676597424, gpu_energy=0, ram_energy=0.0011402244733631148, energy_consumed=0.005262621149960539, country_name='France', country_iso_code='FRA', region='île-de-france', cloud_provider='', cloud_region='', os='Windows-11-10.0.22631-SP0', python_version='3.12.7', codecarbon_version='3.0.0_rc0', cpu_count=12, cpu_model='13th Gen Intel(R) Core(TM) i7-1365U', gpu_count=None, gpu_model=None, longitude=2.3494, latitude=48.8558, ram_total_size=31.347312927246094, tracking_mode='machine', on_cloud='N', pue=1.0)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Start tracking emissions\n",
+    "tracker.start()\n",
+    "tracker.start_task(\"inference\")\n",
+    "\n",
+    "from tqdm.auto import tqdm\n",
+    "predictions = []\n",
+    "\n",
+    "\n",
+    "\n",
+    "# Option 1: Simple loop approach\n",
+    "\n",
+    "for i, text in tqdm(enumerate(test_dataset[\"quote\"])):\n",
+    "\n",
+    "    result = classifier(text, candidate_labels)\n",
+    "\n",
+    "    # Get index of highest scoring label\n",
+    "\n",
+    "    pred_label = candidate_labels.index(result[\"labels\"][0])\n",
+    "\n",
+    "    predictions.append(pred_label)\n",
+    "    if i == 100:\n",
+    "        break\n",
+    "\n",
+    "\n",
+    "# Stop tracking emissions\n",
+    "emissions_data = tracker.stop_task()\n",
+    "emissions_data\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.4"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate accuracy\n",
+    "accuracy = accuracy_score(true_labels[:100], predictions[:100])\n",
+    "accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -7,4 +7,8 @@ pydantic>=1.10.0
 python-dotenv>=1.0.0
 gradio>=4.0.0
 requests>=2.31.0
-librosa==0.10.2.post1
+librosa==0.10.2.post1
+tf-keras
+tensorflow[and-cuda]>=2.0
+evaluate
+transformers

tasks/audio.py

@@ -6,7 +6,7 @@ import random
 import os
 
 from .utils.evaluation import AudioEvaluationRequest
-from .utils.emissions import tracker, clean_emissions_data, get_space_info
+from .utils.emissions import get_tracker, clean_emissions_data, get_space_info
 
 from dotenv import load_dotenv
 load_dotenv()
@@ -45,6 +45,7 @@ async def evaluate_audio(request: AudioEvaluationRequest):
     test_dataset = train_test["test"]
     
     # Start tracking emissions
+    tracker = get_tracker()
     tracker.start()
     tracker.start_task("inference")
     
@@ -85,4 +86,4 @@ async def evaluate_audio(request: AudioEvaluationRequest):
         }
     }
     
-    return results 
+    return results 

tasks/data/data_loaders.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+
+from datasets import load_dataset, DatasetDict
+
+from tasks.utils.evaluation import TextEvaluationRequest
+
+
+class DataLoader(ABC):
+    @abstractmethod
+    def get_train_dataset(self):
+        pass
+
+    @abstractmethod
+    def get_test_dataset(self):
+        pass
+
+class TextDataLoader(DataLoader):
+    def __init__(self, request: TextEvaluationRequest = TextEvaluationRequest(), light: bool = False):
+        self.label_mapping = {
+            "0_not_relevant": 0,
+            "1_not_happening": 1,
+            "2_not_human": 2,
+            "3_not_bad": 3,
+            "4_solutions_harmful_unnecessary": 4,
+            "5_science_unreliable": 5,
+            "6_proponents_biased": 6,
+            "7_fossil_fuels_needed": 7
+        }
+        # Load the dataset, and convert string labels to integers
+        dataset = load_dataset(request.dataset_name)
+        dataset = dataset.map(lambda x: {"label": self.label_mapping[x["label"]]})
+        self.dataset = dataset["train"].train_test_split(test_size=request.test_size, seed=request.test_seed)
+
+        # Create a smaller version of the dataset for quick testing
+        if light:
+            self.dataset = DatasetDict({
+                "train": self.dataset["train"].shuffle(seed=42).select(range(10)),
+                "test": self.dataset["test"].shuffle(seed=42).select(range(2))
+            })
+
+    def get_train_dataset(self):
+        return self.dataset["train"]
+
+    def get_test_dataset(self):
+        return self.dataset["test"]
+
+    def get_label_to_id_mapping(self):
+        return self.label_mapping
+
+    def get_id_to_label_mapping(self):
+        return {v: k for k, v in self.label_mapping.items()}

tasks/image.py

@@ -2,12 +2,12 @@ from fastapi import APIRouter
 from datetime import datetime
 from datasets import load_dataset
 import numpy as np
-from sklearn.metrics import accuracy_score
+from sklearn.metrics import accuracy_score, precision_score, recall_score
 import random
 import os
 
 from .utils.evaluation import ImageEvaluationRequest
-from .utils.emissions import tracker, clean_emissions_data, get_space_info
+from .utils.emissions import get_tracker, clean_emissions_data, get_space_info
 
 from dotenv import load_dotenv
 load_dotenv()
@@ -92,6 +92,7 @@ async def evaluate_image(request: ImageEvaluationRequest):
     test_dataset = train_test["test"]
     
     # Start tracking emissions
+    tracker = get_tracker()
     tracker.start()
     tracker.start_task("inference")
     
@@ -138,8 +139,10 @@ async def evaluate_image(request: ImageEvaluationRequest):
     # Stop tracking emissions
     emissions_data = tracker.stop_task()
     
-    # Calculate classification accuracy
+    # Calculate classification metrics
     classification_accuracy = accuracy_score(true_labels, predictions)
+    classification_precision = precision_score(true_labels, predictions)
+    classification_recall = recall_score(true_labels, predictions)
     
     # Calculate mean IoU for object detection (only for images with smoke)
     # For each image, we compute the max IoU between the predicted box and all true boxes
@@ -157,6 +160,8 @@ async def evaluate_image(request: ImageEvaluationRequest):
         "submission_timestamp": datetime.now().isoformat(),
         "model_description": DESCRIPTION,
         "classification_accuracy": float(classification_accuracy),
+        "classification_precision": float(classification_precision),
+        "classification_recall": float(classification_recall),
         "mean_iou": mean_iou,
         "energy_consumed_wh": emissions_data.energy_consumed * 1000,
         "emissions_gco2eq": emissions_data.emissions * 1000,
@@ -169,4 +174,4 @@ async def evaluate_image(request: ImageEvaluationRequest):
         }
     }
     
-    return results 
+    return results 

tasks/models/pretrained_models/2025-01-27_17-00-47_DistilBERT_Model_fined-tuned_from_distilbert-base-uncased/config.json

@@ -0,0 +1,43 @@
+{
+  "_name_or_path": "distilbert-base-uncased",
+  "activation": "gelu",
+  "architectures": [
+    "DistilBertForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "dim": 768,
+  "dropout": 0.1,
+  "hidden_dim": 3072,
+  "id2label": {
+    "0": "0_not_relevant",
+    "1": "1_not_happening",
+    "2": "2_not_human",
+    "3": "3_not_bad",
+    "4": "4_solutions_harmful_unnecessary",
+    "5": "5_science_unreliable",
+    "6": "6_proponents_biased",
+    "7": "7_fossil_fuels_needed"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "0_not_relevant": 0,
+    "1_not_happening": 1,
+    "2_not_human": 2,
+    "3_not_bad": 3,
+    "4_solutions_harmful_unnecessary": 4,
+    "5_science_unreliable": 5,
+    "6_proponents_biased": 6,
+    "7_fossil_fuels_needed": 7
+  },
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "pad_token_id": 0,
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "tie_weights_": true,
+  "transformers_version": "4.48.1",
+  "vocab_size": 30522
+}

tasks/models/pretrained_models/2025-01-27_17-00-47_DistilBERT_Model_fined-tuned_from_distilbert-base-uncased/config_training.json

@@ -0,0 +1,8 @@
+{
+    "model_type": "distilbert",
+    "model_name": "distilbert-base-uncased",
+    "batch_size": 32,
+    "num_epochs": 10,
+    "initial_learning_rate": 2e-05,
+    "description": "DistilBERT Model (fined-tuned from distilbert-base-uncased)"
+}

tasks/models/pretrained_models/2025-01-27_17-00-47_DistilBERT_Model_fined-tuned_from_distilbert-base-uncased/tf_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:591192ddd9bcff8168d045251b3962050cfec081700cd516e24d37f348866125
+size 267970240

tasks/models/text_classifiers.py

@@ -0,0 +1,390 @@
+import json
+import random
+from abc import ABC, abstractmethod
+from datetime import datetime
+from pathlib import Path
+
+import joblib
+import numpy as np
+import tensorflow as tf
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from transformers import AutoTokenizer, DataCollatorWithPadding, create_optimizer, TFAutoModelForSequenceClassification, \
+    KerasMetricCallback
+import evaluate
+
+from tasks.data.data_loaders import TextDataLoader
+
+class PredictionModel(ABC):
+    def __init__(self, data_loader: TextDataLoader = TextDataLoader()):
+        self.description = ""
+        self.model = None
+
+    @abstractmethod
+    def predict(self, quote: str) -> int:
+        """
+        Predict the label for a given quote.
+
+        Parameters:
+        -----------
+        quote: str
+            The quote to classify.
+
+        Returns:
+        --------
+        int
+            The predicted label (0-7).
+        """
+        pass
+
+    @abstractmethod
+    def train(self, dataset) -> None:
+        """
+        Train the model on a given dataset.
+
+        Parameters:
+        -----------
+        dataset:
+            The dataset to train on.
+
+        Returns:
+        --------
+        None
+        """
+        pass
+
+    @abstractmethod
+    def save_to_directory(self, directory: Path) -> None:
+        pass
+
+    def save(self) -> None:
+        save_directory = Path(__file__).parent / "pretrained_models"
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        sanitized_description = (((self.description.
+                                            replace(" ", "_")).
+                                            replace("(", "")).
+                                            replace(")", ""))
+        save_filename = f"{timestamp}_{sanitized_description}"
+        self.save_to_directory(save_directory / save_filename)
+
+
+class BaselineModel(PredictionModel):
+    def __init__(self, data_loader: TextDataLoader = TextDataLoader()):
+        super().__init__()
+        self.description = "Random Baseline (with Strategy Pattern, from another module)"
+
+    def predict(self, quote: str) -> int:
+        return random.randint(0, 7)
+
+    def train(self, dataset):
+        pass
+
+    def save_to_directory(self, directory: Path) -> None:
+        pass
+
+class DistilBERTModel(PredictionModel):
+    def __init__(self,
+                 data_loader: TextDataLoader = TextDataLoader(),
+                 batch_size: int = 4,
+                 num_epochs: int = 5,
+                 initial_learning_rate: float = 2e-5,
+                 start_model_name: str = "distilbert-base-uncased"):
+        super().__init__()
+        self.start_model_name = start_model_name
+        self.description = f"DistilBERT Model (fined-tuned from {self.start_model_name})"
+        self.label_to_id_mapping = data_loader.get_label_to_id_mapping()
+        self.id_to_label_mapping = data_loader.get_id_to_label_mapping()
+
+        # tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(self.start_model_name)
+
+        # data collator with dynamic padding
+        self.data_collator = DataCollatorWithPadding(tokenizer=self.tokenizer, return_tensors="tf")
+
+        # load accuracy metric
+        self.accuracy = evaluate.load("accuracy")
+
+        # training parameters
+        self.batch_size = batch_size
+        self.num_epochs = num_epochs
+        self.initial_learning_rate = initial_learning_rate
+
+    def predict(self, quote: str) -> int:
+        if self.model is None:
+            raise ValueError("Model has not been trained yet. Please train the model before making predictions.")
+
+        inputs = self.tokenizer(quote, return_tensors="tf", truncation=True, max_length=128)
+        outputs = self.model(**inputs)
+        logits = outputs.logits
+        probabilities = tf.nn.softmax(logits)
+        predicted_label = self.model.config.id2label[tf.argmax(probabilities, axis=1).numpy()[0]]
+        return self.label_to_id_mapping[predicted_label]
+
+    def train(self, dataset):
+        # Pre-process data
+        tokenized_data = self.pre_process_data(dataset)
+
+        # Training setup
+        batch_size = self.batch_size
+        num_epochs = self.num_epochs
+        batches_per_epoch = len(tokenized_data["train"]) // batch_size
+        total_train_steps = int(batches_per_epoch * num_epochs)
+
+        # Learning rate scheduler
+        initial_learning_rate = self.initial_learning_rate
+        lr_schedule = tf.keras.optimizers.schedules.PolynomialDecay(
+            initial_learning_rate=initial_learning_rate,
+            decay_steps=total_train_steps,
+            end_learning_rate=0.0,
+            power=1.0
+        )
+
+        # Optimizer with learning rate scheduler
+        optimizer, schedule = create_optimizer(init_lr=initial_learning_rate, num_warmup_steps=0,
+                                               num_train_steps=total_train_steps)
+
+        # Load model
+        self.model = TFAutoModelForSequenceClassification.from_pretrained(
+            self.start_model_name,
+            num_labels=8,
+            id2label=self.id_to_label_mapping,
+            label2id=self.label_to_id_mapping
+        )
+
+        # Convert datasets to tf.data.Dataset format
+        tf_train_set = self.model.prepare_tf_dataset(
+            tokenized_data["train"],
+            shuffle=True,
+            batch_size=batch_size,
+            collate_fn=self.data_collator,
+        )
+
+        tf_validation_set = self.model.prepare_tf_dataset(
+            tokenized_data["test"],
+            shuffle=False,
+            batch_size=batch_size,
+            collate_fn=self.data_collator,
+        )
+
+        # Compile model
+        self.model.compile(optimizer=optimizer)
+
+        # Keras metric callback
+        metric_callback = KerasMetricCallback(metric_fn=self.compute_metrics, eval_dataset=tf_validation_set)
+
+        # Train model
+        self.model.fit(tf_train_set, validation_data=tf_validation_set, epochs=num_epochs, callbacks=[metric_callback])
+
+    def pre_process_data(self, dataset):
+        return ((dataset.
+                train_test_split(test_size=0.2, seed=42).
+                remove_columns([col for col in dataset.column_names if col not in ["quote", "label"]])).
+                map(self.tokenize))
+
+    def tokenize(self, example):
+        return self.tokenizer(example["quote"], truncation=True, max_length=128)
+
+    def compute_metrics(self, eval_pred):
+        predictions, labels = eval_pred
+        predictions = np.argmax(predictions, axis=1)
+        return self.accuracy.compute(predictions=predictions, references=labels)
+
+    def save_to_directory(self, directory: Path) -> None:
+        self.model.save_pretrained(str(directory))
+
+class TextEmbedder(ABC):
+    @abstractmethod
+    def encode(self, text: list[str]) -> np.ndarray[float]:
+        """
+        Encode a list of text inputs into a numpy array.
+
+        Parameters:
+        -----------
+        text: list[str]
+            The text inputs to encode.
+
+        Returns:
+        --------
+        np.ndarray
+            The encoded text inputs.
+        """
+        pass
+
+    def fit(self, param):
+        pass
+
+    @abstractmethod
+    def save_to_directory(self, directory: Path) -> None:
+        pass
+
+
+class TfIdfEmbedder(TextEmbedder):
+    """
+    A simple TF-IDF text embedder.
+
+    TF-IDF stands for Term Frequency-Inverse Document Frequency.
+    It can be defined as the calculation of how relevant a word
+    in a series or corpus is to a text. The meaning increases
+    proportionally to the number of times in the text a word
+    appears but is compensated by the word frequency in the corpus
+    (data-set).
+    Source: https://www.geeksforgeeks.org/understanding-tf-idf-term-frequency-inverse-document-frequency/
+
+    The TfidfVectorizer class from scikit-learn is used to encode
+    """
+    def __init__(self):
+        self.vectorizer = TfidfVectorizer()
+        self._is_fitted = False  # Nouveau flag
+
+    def fit(self, text: list[str]):
+        """Fit the embedder to the given text."""
+        self.vectorizer.fit(text)
+        self._is_fitted = True
+
+    def encode(self, text: list[str]) -> np.ndarray[float]:
+        if not self._is_fitted:
+            raise RuntimeError("TfIdfEmbedder should be fitted before encoding text.")
+        return self.vectorizer.transform(text).toarray()
+
+    def save_to_directory(self, directory: Path) -> None:
+        directory.mkdir(parents=True, exist_ok=True)
+        joblib.dump(self.vectorizer, directory / "tfidf_vectorizer.joblib")
+
+class MLModel(ABC):
+    @abstractmethod
+    def fit(self, embedded_quotes: np.ndarray[float], y: list[int]) -> None:
+        """
+        Fit the model to the data.
+
+        Parameters:
+        -----------
+        embedded_quotes: np.ndarray
+            The embedded quotes, given by TextEmbedder.encode().
+
+        y: list[int]
+            The labels (ranging from 0 to 7).
+        """
+        pass
+
+    @abstractmethod
+    def predict(self, embedded_quotes: np.ndarray[float]) -> int:
+        """
+        Predict the labels for the given embedded quotes.
+
+        Parameters:
+        -----------
+        embedded_quotes: np.ndarray
+            The embedded quotes, given by TextEmbedder.encode().
+
+        Returns:
+        --------
+        int
+            The predicted labels (ranging from 0 to 7).
+        """
+        pass
+
+    @abstractmethod
+    def save_to_directory(self, directory: Path) -> None:
+        pass
+
+class MultivariateLogisticRegression(MLModel):
+    def __init__(self):
+        self.model = LogisticRegression()
+
+    def fit(self, embedded_quotes: np.ndarray[float], y: list[int]) -> None:
+        self.model.fit(embedded_quotes, y)
+
+    def predict(self, embedded_quotes: np.ndarray[float]) -> int:
+        return self.model.predict(embedded_quotes)
+
+    def save_to_directory(self, directory: Path) -> None:
+        directory.mkdir(parents=True, exist_ok=True)
+        joblib.dump(self.model, directory / "logistic_regression.joblib")
+
+
+class EmbeddingMLModel(PredictionModel):
+    def __init__(self,
+                 data_loader: TextDataLoader = TextDataLoader(),
+                 embedder: TextEmbedder = TfIdfEmbedder(),
+                 ml_model: MLModel = MultivariateLogisticRegression()):
+        super().__init__()
+        self.embedder = embedder
+        self.ml_model = ml_model
+        self.description = f"EmbeddingMLModel ({embedder.__class__.__name__} + {ml_model.__class__.__name__})"
+
+    def predict(self, quote: str) -> int:
+        embedded_quote = self.embedder.encode([quote])
+        return self.ml_model.predict(embedded_quote)
+
+    def train(self, dataset):
+        self.embedder.fit(dataset["quote"])
+        embedded_quotes = self.embedder.encode(dataset["quote"])
+        labels = dataset["label"]
+        self.ml_model.fit(embedded_quotes, labels)
+
+    def save_to_directory(self, directory: Path) -> None:
+        directory.mkdir(parents=True, exist_ok=True)
+
+        # save embedder and ml_model
+        self.embedder.save_to_directory(directory)
+        self.ml_model.save_to_directory(directory)
+
+        # Metadata pour le reload
+        metadata = {
+            "embedder_type": self.embedder.__class__.__name__,
+            "ml_model_type": self.ml_model.__class__.__name__
+        }
+        with open(directory / "metadata.json", "w") as f:
+            json.dump(metadata, f)
+
+
+class ModelFactory:
+    @staticmethod
+    def create_model(config) -> PredictionModel:
+        """
+        Factory method to create a model based on the model type.
+
+        Parameters:
+        -----------
+        model_type: str
+            The type of model to create. Options: "baseline", "distilbert"
+
+        Returns:
+        --------
+        PredictionModel
+            The model instance.
+
+        Raises:
+        -------
+        ValueError
+            If the model type is not recognized.
+        """
+        model_type = config["model_type"]
+        if model_type == "baseline":
+            return BaselineModel()
+        elif model_type == "distilbert":
+            try:
+                batch_size = config["batch_size"]
+                num_epochs = config["num_epochs"]
+                initial_learning_rate = config["initial_learning_rate"]
+            except KeyError as e:
+                raise ValueError(f"Missing configuration parameter: {e}")
+
+            return DistilBERTModel(batch_size=batch_size,
+                                   num_epochs=num_epochs,
+                                   initial_learning_rate=initial_learning_rate)
+        elif model_type == "distilbert-pretrained":
+            model = DistilBERTModel()
+            model_name = config["model_name"]
+            model_path = Path(__file__).parent / "pretrained_models" / model_name
+            if model_path.exists():
+                model.model = TFAutoModelForSequenceClassification.from_pretrained(model_path)
+                return model
+            else:
+                raise FileNotFoundError(f"Pretrained model not found at {model_path}")
+        elif model_type == "embeddingML":
+            embedding_ml_model = EmbeddingMLModel()
+            embedding_ml_model.train(TextDataLoader().get_train_dataset())
+            return embedding_ml_model
+        else:
+            raise ValueError(f"Unknown model type: {model_type}")

tasks/text.py

@@ -2,73 +2,81 @@ from fastapi import APIRouter
 from datetime import datetime
 from datasets import load_dataset
 from sklearn.metrics import accuracy_score
-import random
 
+from .data.data_loaders import TextDataLoader
+from .models.text_classifiers import BaselineModel
 from .utils.evaluation import TextEvaluationRequest
-from .utils.emissions import tracker, clean_emissions_data, get_space_info
+from .utils.emissions import get_tracker, clean_emissions_data, get_space_info, EmissionsData
+
+# define models
+from .models.text_classifiers import ModelFactory
+embedding_ml_model = ModelFactory.create_model({"model_type": "embeddingML"})
+
+distilbert_model = ModelFactory.create_model({"model_type":
+                                                  "distilbert-pretrained",
+                                              "model_name":
+                                                  "2025-01-27_17-00-47_DistilBERT_Model_fined-tuned_from_distilbert-base-uncased"
+                                              })
 
-router = APIRouter()
 
-DESCRIPTION = "Random Baseline"
+model_to_evaluate = distilbert_model
+
+# define router
+router = APIRouter()
+DESCRIPTION = model_to_evaluate.description
 ROUTE = "/text"
 
 @router.post(ROUTE, tags=["Text Task"], 
              description=DESCRIPTION)
-async def evaluate_text(request: TextEvaluationRequest):
+async def evaluate_text(request: TextEvaluationRequest,
+                        track_emissions: bool = True,
+                        model = distilbert_model,
+                        light_dataset: bool = False) -> dict:
     """
     Evaluate text classification for climate disinformation detection.
     
-    Current Model: Random Baseline
-    - Makes random predictions from the label space (0-7)
-    - Used as a baseline for comparison
-    """
-    # Get space info
-    username, space_url = get_space_info()
+    Parameters:
+    -----------
+    request: TextEvaluationRequest
+        The request object containing the dataset configuration.
 
-    # Define the label mapping
-    LABEL_MAPPING = {
-        "0_not_relevant": 0,
-        "1_not_happening": 1,
-        "2_not_human": 2,
-        "3_not_bad": 3,
-        "4_solutions_harmful_unnecessary": 4,
-        "5_science_unreliable": 5,
-        "6_proponents_biased": 6,
-        "7_fossil_fuels_needed": 7
-    }
+    track_emissions: bool
+        Whether to track emissions or not.
 
-    # Load and prepare the dataset
-    dataset = load_dataset(request.dataset_name)
+    model: TextClassifier
+        The model to use for inference.
 
-    # Convert string labels to integers
-    dataset = dataset.map(lambda x: {"label": LABEL_MAPPING[x["label"]]})
+    light_dataset: bool
+        Whether to use a light dataset or not.
 
-    # Split dataset
-    train_test = dataset["train"].train_test_split(test_size=request.test_size, seed=request.test_seed)
-    test_dataset = train_test["test"]
-    
-    # Start tracking emissions
-    tracker.start()
-    tracker.start_task("inference")
+    Returns:
+    --------
+    dict
+        A dictionary containing the evaluation results.
+    """
+    # Get space info
+    username, space_url = get_space_info()
 
-    #--------------------------------------------------------------------------------------------
-    # YOUR MODEL INFERENCE CODE HERE
-    # Update the code below to replace the random baseline by your model inference within the inference pass where the energy consumption and emissions are tracked.
-    #--------------------------------------------------------------------------------------------   
+    # Load the dataset
+    test_dataset = TextDataLoader(request, light=light_dataset).get_test_dataset()
     
-    # Make random predictions (placeholder for actual model inference)
-    true_labels = test_dataset["label"]
-    predictions = [random.randint(0, 7) for _ in range(len(true_labels))]
+    # Start tracking emissions
+    if track_emissions:
+        tracker = get_tracker()
+        tracker.start()
+        tracker.start_task("inference")
 
-    #--------------------------------------------------------------------------------------------
-    # YOUR MODEL INFERENCE STOPS HERE
-    #--------------------------------------------------------------------------------------------   
+    # model inference
+    predictions = [model.predict(quote) for quote in test_dataset["quote"]]
 
-    
     # Stop tracking emissions
-    emissions_data = tracker.stop_task()
+    if track_emissions:
+        emissions_data = tracker.stop_task()
+    else:
+        emissions_data = EmissionsData(0, 0)
     
     # Calculate accuracy
+    true_labels = test_dataset["label"]
     accuracy = accuracy_score(true_labels, predictions)
     
     # Prepare results dictionary
@@ -89,4 +97,4 @@ async def evaluate_text(request: TextEvaluationRequest):
         }
     }
     
-    return results 
+    return results

tasks/utils/emissions.py

@@ -1,8 +1,8 @@
 from codecarbon import EmissionsTracker
 import os
 
-# Initialize tracker
-tracker = EmissionsTracker(allow_multiple_runs=True)
+def get_tracker() -> EmissionsTracker:
+    return EmissionsTracker(allow_multiple_runs=True)
 
 class EmissionsData:
     def __init__(self, energy_consumed: float, emissions: float):
@@ -25,4 +25,4 @@ def get_space_info():
             return username, space_url
         except Exception as e:
             print(f"Error getting space info: {e}")
-    return "local-user", "local-development" 
+    return "local-user", "local-development" 

test_text_classifiers.py

@@ -0,0 +1,104 @@
+import random
+
+import numpy as np
+import pytest
+
+from main import load_config
+from tasks.data.data_loaders import TextDataLoader
+from tasks.models.text_classifiers import DistilBERTModel, ModelFactory, TextEmbedder, MLModel, EmbeddingMLModel, \
+    TfIdfEmbedder
+from tasks.utils.evaluation import TextEvaluationRequest
+
+@pytest.fixture()
+def data_loader():
+    # define text request
+    text_request = TextEvaluationRequest()
+
+    return TextDataLoader(text_request, light=True)
+
+@pytest.fixture()
+def train_dataset(data_loader):
+    return data_loader.get_train_dataset()
+
+@pytest.fixture()
+def test_dataset(data_loader):
+    return data_loader.get_test_dataset()
+
+
+class TestDistilBERTModel:
+    @pytest.fixture()
+    def distilBERT_model(self):
+        config = load_config("config_training_test.json")
+        return ModelFactory.create_model(config)
+
+    def test_trained_distilBERT(self, train_dataset, distilBERT_model, test_dataset):
+        assert "DistilBERT" in distilBERT_model.description
+
+        # train model
+        distilBERT_model.train(train_dataset)
+
+        # inference
+        predictions = [distilBERT_model.predict(quote) for quote in test_dataset["quote"]]
+        for prediction in predictions:
+            assert prediction in range(8)
+
+    def test_data_preprocessing(self, train_dataset, distilBERT_model):
+        pre_processed_data = distilBERT_model.pre_process_data(train_dataset)
+        assert pre_processed_data is not None
+        assert pre_processed_data["train"].num_rows == 8
+        assert pre_processed_data["test"].num_rows == 2
+
+        for subset in ["train", "test"]:
+            for feature_name in ['quote', 'label', 'input_ids', 'attention_mask']:
+                assert feature_name in pre_processed_data[subset].features.keys()
+
+
+class DummyEmbedder(TextEmbedder):
+    def encode(self, text: str) -> np.ndarray:
+        return np.random.rand(42)
+
+
+class DummyMLModel(MLModel):
+    def fit(self, X, y):
+        pass
+
+    def predict(self, X):
+        return random.choice(range(8))
+
+
+class TestEmbeddingMLModel:
+    @pytest.fixture()
+    def embeddingML(self):
+        config = load_config("config_training_embedding_test.json")
+        config["model"] = "EmbeddingMLModel"
+        return ModelFactory.create_model(config)
+
+    def test_EmbeddingML(self, train_dataset, embeddingML):
+        assert "EmbeddingMLModel" in embeddingML.description
+
+        # train model
+        embeddingML.train(train_dataset)
+
+        # inference
+        assert embeddingML.predict("a quote") in range(8)
+
+    def test_dummy_train_EmbeddingML(self, train_dataset):
+        dummy_model = EmbeddingMLModel(embedder=DummyEmbedder(),
+                                       ml_model=DummyMLModel())
+
+        dummy_model.train(train_dataset)
+        assert dummy_model.predict("dummy") in range(8)
+
+class TestEmbedders:
+    def test_tf_idf(self):
+        embedder = TfIdfEmbedder()
+
+        texts = [
+            "hello world",
+            "world hello",
+            "yet another text",
+            "this is a test",
+            "this one as well"
+        ]
+        encoded_texts = embedder.encode(texts)
+        assert encoded_texts.shape == (5, 11)