first commit

nb.ipynb

@@ -0,0 +1,380 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3a03d7b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "device(type='cpu')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from transformers import AutoModelForSequenceClassification\n",
+    "from transformers import TFAutoModelForSequenceClassification\n",
+    "from transformers import AutoTokenizer, RobertaForSequenceClassification\n",
+    "import numpy as np\n",
+    "from scipy.special import softmax\n",
+    "import csv\n",
+    "import urllib.request\n",
+    "import torch.utils.data as data_utils\n",
+    "import torch\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "device\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e50cfece",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocess(text):\n",
+    "    new_text = []\n",
+    "    for t in text.split(\" \"):\n",
+    "        t = '@user' if t.startswith('@') and len(t) > 1 else t\n",
+    "        t = 'http' if t.startswith('http') else t\n",
+    "        new_text.append(t)\n",
+    "    return \" \".join(new_text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0b451180",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['negative', 'neutral', 'positive']"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "task='sentiment'\n",
+    "MODEL = f\"cardiffnlp/twitter-roberta-base-{task}\"\n",
+    "# download label mapping\n",
+    "mapping_link = f\"https://raw.githubusercontent.com/cardiffnlp/tweeteval/main/datasets/{task}/mapping.txt\"\n",
+    "with urllib.request.urlopen(mapping_link) as f:\n",
+    "    html = f.read().decode('utf-8').split(\"\\n\")\n",
+    "    csvreader = csv.reader(html, delimiter='\\t')\n",
+    "labels = [row[1] for row in csvreader if len(row) > 1]\n",
+    "labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "ede5d09e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at FacebookAI/roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "MODEL = \"FacebookAI/roberta-base\"\n",
+    "model = RobertaForSequenceClassification.from_pretrained(\n",
+    "    MODEL, num_labels=3, problem_type=\"multi_label_classification\")\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "id": "c4bafe30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_text_file = \"train_text.txt\"\n",
+    "with open(train_text_file, \"r\") as f:\n",
+    "    texts = f.readlines()\n",
+    "\n",
+    "train_label_file = \"train_labels.txt\"\n",
+    "with open(train_label_file, \"r\") as f:\n",
+    "    labels = f.readlines()\n",
+    "\n",
+    "len(texts), len(labels)\n",
+    "\n",
+    "texts, labels = texts[:100], labels[:100]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87030ba1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(2, 100)"
+      ]
+     },
+     "execution_count": 93,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "encoded_inputs = tokenizer([ preprocess(t.strip()) for t in texts], return_tensors='pt',   padding=True,\n",
+    "    truncation=True)\n",
+    "labels = [int(labels[i].strip()) for i in range(len(labels))]\n",
+    "labels = torch.tensor(labels, dtype=torch.int)\n",
+    "len(encoded_inputs), len(labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "id": "e9548356",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = data_utils.TensorDataset(encoded_inputs[\"input_ids\"], encoded_inputs[\"attention_mask\"], labels)\n",
+    "test_dataloader = data_utils.DataLoader(dataset, batch_size=10, shuffle=True)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f40f7fd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08435697",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "model = AutoModelForSequenceClassification.from_pretrained(MODEL)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL)\n",
+    "text = \"Good night 😊\"\n",
+    "text = preprocess(text)\n",
+    "encoded_input = tokenizer(text, return_tensors='pt')\n",
+    "output = model(**encoded_input)\n",
+    "scores = output[0][0].detach().numpy()\n",
+    "scores = softmax(scores)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "cf6dfc8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1) positive 0.8466\n",
+      "2) neutral 0.1458\n",
+      "3) negative 0.0076\n"
+     ]
+    }
+   ],
+   "source": [
+    "ranking = np.argsort(scores)\n",
+    "ranking = ranking[::-1]\n",
+    "for i in range(scores.shape[0]):\n",
+    "    l = labels[ranking[i]]\n",
+    "    s = scores[ranking[i]]\n",
+    "    print(f\"{i+1}) {l} {np.round(float(s), 4)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f25d8f1",
+   "metadata": {},
+   "source": [
+    "### Tentativo di training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0a6382f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import evaluate\n",
+    "\n",
+    "from transformers import AutoTokenizer\n",
+    "from transformers import AutoModelForSequenceClassification\n",
+    "from transformers import TrainingArguments, Trainer\n",
+    "from datasets import load_dataset, concatenate_datasets\n",
+    "\n",
+    "def tokenize_function(examples):\n",
+    "    return tokenizer(examples[\"text\"], padding=\"max_length\", truncation=True)\n",
+    "\n",
+    "def compute_metrics(eval_pred):\n",
+    "    logits, labels = eval_pred\n",
+    "    predictions = np.argmax(logits, axis=-1)\n",
+    "    return metric.compute(predictions=predictions, references=labels, average='macro')\n",
+    "\n",
+    "\n",
+    "dataset = load_dataset('tweet_eval', 'sentiment')\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "dafaf26d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Map: 100%|██████████| 45615/45615 [00:10<00:00, 4346.61 examples/s]\n",
+      "Map: 100%|██████████| 12284/12284 [00:03<00:00, 3758.76 examples/s]\n",
+      "Map: 100%|██████████| 2000/2000 [00:00<00:00, 4820.04 examples/s]\n",
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at cardiffnlp/twitter-roberta-base-sep2022 and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+      "/workspaces/MLOPS_Project/Env/lib/python3.12/site-packages/torch/utils/data/dataloader.py:668: UserWarning: 'pin_memory' argument is set as true but no accelerator is found, then device pinned memory won't be used.\n",
+      "  warnings.warn(warn_msg)\n"
+     ]
+    },
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
+      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
+      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
+      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
+     ]
+    }
+   ],
+   "source": [
+    "MODEL_NAME = 'cardiffnlp/twitter-roberta-base-sep2022'  # change to desired model from the hub\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)\n",
+    "tokenized_datasets = dataset.map(tokenize_function, batched=True)\n",
+    "\n",
+    "# augment train set with test set, for downstream apps only - DO NOT EVALUATE ON TEST\n",
+    "# tokenized_datasets['train+test'] = concatenate_datasets([tokenized_datasets['train'],\n",
+    "#                                                          tokenized_datasets['test']])\n",
+    "\n",
+    "model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, num_labels=3)\n",
+    "\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"test_trainer\",\n",
+    "    learning_rate=1e-5,\n",
+    "    per_device_train_batch_size=16,   # modern name\n",
+    "    per_device_eval_batch_size=16,    # modern name\n",
+    "    num_train_epochs=10,\n",
+    "    weight_decay=0.01,\n",
+    "    warmup_ratio=0.1,\n",
+    "\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    logging_strategy=\"epoch\",\n",
+    "    save_strategy=\"epoch\",\n",
+    "\n",
+    "    load_best_model_at_end=True,\n",
+    "    metric_for_best_model=\"recall\",\n",
+    "    greater_is_better=True,\n",
+    "    report_to=\"none\",\n",
+    ")\n",
+    "\n",
+    "metric = evaluate.load('recall')  # default metric for sentiment dataset is recall (macro)\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=tokenized_datasets['train'],\n",
+    "    eval_dataset=tokenized_datasets['validation'],\n",
+    "    compute_metrics=compute_metrics,\n",
+    ")\n",
+    "\n",
+    "trainer.train()\n",
+    "\n",
+    "trainer.create_model_card()\n",
+    "trainer.save_model('saved_model')\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "183032a5",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'torch' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mtorch\u001b[49m.cuda.is_available()\n",
+      "\u001b[31mNameError\u001b[39m: name 'torch' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "torch.cuda.is_available()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1246f9c6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Env",
+   "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.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -0,0 +1,103 @@
+accelerate==1.11.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.2
+aiosignal==1.4.0
+anyio==4.11.0
+asttokens==3.0.0
+attrs==25.4.0
+certifi==2025.10.5
+charset-normalizer==3.4.4
+comm==0.2.3
+contourpy==1.3.3
+cycler==0.12.1
+datasets==4.4.1
+debugpy==1.8.17
+decorator==5.2.1
+dill==0.4.0
+evaluate==0.4.6
+executing==2.2.1
+filelock==3.20.0
+fonttools==4.60.1
+frozenlist==1.8.0
+fsspec==2025.10.0
+gluonnlp==0.8.3
+graphviz==0.8.4
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.36.0
+idna==3.11
+ipykernel==7.1.0
+ipython==9.7.0
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+Jinja2==3.1.6
+jupyter_client==8.6.3
+jupyter_core==5.9.1
+kiwisolver==1.4.9
+MarkupSafe==3.0.3
+matplotlib==3.10.7
+matplotlib-inline==0.2.1
+mpmath==1.3.0
+multidict==6.7.0
+multiprocess==0.70.18
+mxnet==1.6.0
+nest-asyncio==1.6.0
+networkx==3.5
+numpy==1.26.4
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.27.5
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.3.20
+nvidia-nvtx-cu12==12.8.90
+packaging==25.0
+pandas==2.3.3
+parso==0.8.5
+pexpect==4.9.0
+pillow==12.0.0
+platformdirs==4.5.0
+prompt_toolkit==3.0.52
+propcache==0.4.1
+psutil==7.1.3
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyarrow==22.0.0
+Pygments==2.19.2
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.3
+pyzmq==27.1.0
+regex==2025.11.3
+requests==2.32.5
+safetensors==0.6.2
+scipy==1.16.3
+setuptools==80.9.0
+six==1.17.0
+sniffio==1.3.1
+stack-data==0.6.3
+sympy==1.14.0
+tokenizers==0.22.1
+torch==2.9.0
+tornado==6.5.2
+tqdm==4.67.1
+traitlets==5.14.3
+transformers==4.57.1
+triton==3.5.0
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+wcwidth==0.2.14
+xxhash==3.6.0
+yarl==1.22.0