test_my_knneighbours_(3_brand).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas\n",
    "from math import sqrt\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "pd.set_option('display.max_rows', 30)\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "#caricamento dei risultati della sentiment analysis per i tag (tabella USERS-TAGS VALUES)\n",
    "user_tags_values = pd.read_csv('final_results/users_tags_values.csv')\n",
    "user_list = np.unique(user_tags_values['User'].to_list())   \n",
    "\n",
    "#SELEZIONE DEGLI UTENTI DA ANALIZZARE CON IL KNN (SCEGLIERE UNO DEI TRE)\n",
    "#gold_standard = pd.read_excel('final_results/true_gold_standard.xlsx')       #SOLO UTENTI FOLLOWERS DELLE PAGINE UFFICIALI\n",
    "gold_standard = pd.read_excel('final_results/sentiment_gold_standard.xlsx')    #SOLO UTENTI ETICHETTATI CON LA SENTIMENT ANALYSIS\n",
    "#gold_standard = pd.read_excel('final_results/strong_gold_standard.xlsx')      #UTENTI INTERSEZIONE TRA FOLLOWERS E ETICHETTATI CON LA SENTIMENT ANALYSIS\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DATAFRAME CON SOLO I BRAND: MICROSOFT - BARILLA - ADIDAS\n",
    "#sono inclusi i soli tag di questi tre brand\n",
    "\n",
    "remove_tag = ['baby','car','chocolate', 'coffee','household appliances','licorice', 'scent']\n",
    "brand = ['microsoft','barilla','adidas']\n",
    "\n",
    "for t in remove_tag:\n",
    "    user_tags_values = user_tags_values.drop(t,axis=1)\n",
    "\n",
    "user_tags_values\n",
    "\n",
    "tag = ['clothing','computer','fashion','home','italian','office','pasta','sporty','technology']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#Raggruppamento dei due dataframe in dizionari per\n",
    "#facilitare la ricerca nella creazione delle classi\n",
    "dict_1 = dict(tuple(gold_standard.groupby('Brand')))  #raggruppa gli utenti del gold standard per Brand\n",
    "dict_2 = dict(tuple(user_tags_values.groupby('User')))     #raggruppa gli utenti di USERS-TAGS table per VETTORI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "#METODI PER LA CREAZIONE DELLE CLASSI\n",
    "\n",
    "\n",
    "#Restituisce il vettore di un utente\n",
    "def get_user_vector(user):\n",
    "    user_values = dict_2.get(user)                     #riga dei valori di sentiment\n",
    "    vector = []\n",
    "    for t in tag:                     #per ogni tag\n",
    "        vector.append(user_values[t].values[0])   #copia il valore letto\n",
    "    return np.array(vector)\n",
    "\n",
    "\n",
    "#Restituisce la lista di utenti di una classe\n",
    "def get_class_users(brand):\n",
    "    brand_users_df = dict_1.get(brand)                 \n",
    "    brand_users_list = np.unique(brand_users_df['User'].to_list())\n",
    "    return brand_users_list\n",
    "\n",
    "\n",
    "#Restituisce una lista di tuple-> (brand,User,[VETTORE] )\n",
    "def get_class_followers_vectors(brand):\n",
    "    vectors_list = []\n",
    "    brand_users_list = get_class_users(brand)\n",
    "    for user in brand_users_list:\n",
    "        tern = (brand, user, get_user_vector(user)) #terna di valori ( brand,User,[VETTORE] )\n",
    "        vectors_list.append(tern)\n",
    "    return vectors_list\n",
    "    \n",
    "    \n",
    "#riempimento degli utenti delle classi:  \n",
    "all_classes = []\n",
    "for b in brand:    #per tutti i label\n",
    "    all_classes.extend(get_class_followers_vectors(b))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "#METODI PER IL K-N NEIGHBOURS\n",
    "\n",
    "#Calcola e restituisce la distanza euclidea tra 2 vettori\n",
    "def euclidean_distance(row1, row2):\n",
    "    distance = 0.0\n",
    "    for i in range(len(row1) - 1):\n",
    "        distance += (row1[i] - row2[i])**2\n",
    "    return sqrt(distance)\n",
    "\n",
    "\n",
    "#Ordina le tuple di valori (Rank, Vettore) in modo crescente rispetto Rank\n",
    "def sort_rank_list(tuple):\n",
    "   return(sorted(tuple, key = lambda n: float(n[0]), reverse = False))\n",
    "\n",
    "\n",
    "#Verifica se piu di K elementi hanno distanza uguale (restituisce True se si verifica)\n",
    "def check_if_greater_than_k(score_and_label,k):\n",
    "    treshold = score_and_label[0][0]\n",
    "    boolean = True\n",
    "    for a in range(k+1):\n",
    "        if score_and_label[a][0]>treshold:\n",
    "            boolean= False\n",
    "            break\n",
    "    return boolean\n",
    "\n",
    "#Raccoglie tutti i primi label presenti in Rx DI PARI UGUAGLIANZA\n",
    "def get_greater_k_labels(score_and_label):\n",
    "    v=[]\n",
    "    count = 0\n",
    "    treshold = score_and_label[0][0]\n",
    "    while(score_and_label[count][0]==treshold):\n",
    "        v.append(score_and_label[count][1])\n",
    "        count+=1\n",
    "    return v\n",
    "\n",
    "#Restituisce la lista dei primi elementi in Rx DI PARI UGUAGLIANZA\n",
    "def get_greater_k_rank_elements(score_and_label):\n",
    "  new=[]\n",
    "  count = 0\n",
    "  treshold = score_and_label[0][0]\n",
    "  while(score_and_label[count][0]==treshold):\n",
    "    new.append(score_and_label.pop(0))\n",
    "  return new\n",
    "\n",
    "#Calcola la distanza euclidea tra TUTTI gli elementi di C_test e C_training.\n",
    "#Restituisce: [ Ux[1] , list[tuple:(distance,Uy[0])]   ]      \n",
    "def get_rank_list(C_test, C_training):\n",
    "    rank_list = []\n",
    "    for Ux in C_test:                                       #LEGENDA: Ux[0]='brand' #Ux[1]='user' #Ux[2]=[VETTORE]\n",
    "        Ux_rank = []\n",
    "        for Uy in C_training:                               #LEGENDA: Uy[0]='brand' #Uy[1]='user' #Uy[2]=[VETTORE]\n",
    "            distance = euclidean_distance(Ux[2], Uy[2])\n",
    "            Uy_data = (distance,Uy[0],Uy[1])                #salva la tupla (distanza, brand (etichetta) di Uy)\n",
    "            Ux_rank.append(Uy_data)                         #aggiunge la tupla alla lista di ranking di Ux\n",
    "        tuple = (Ux[1], sort_rank_list(Ux_rank))            #salva la tupla (Username di Ux, lista di ranking di Ux)\n",
    "        rank_list.append(tuple)\n",
    "    return rank_list\n",
    "\n",
    "\n",
    "#Controlla l'etichetta maggiormente presente e la restituisce\n",
    "#In caso di parità di occorrenze restituisce una stringa vuota\n",
    "def most_frequent_label(v):\n",
    "    label_prediction = \"\"\n",
    "    max_value = 0\n",
    "    for label in np.unique(v):\n",
    "        occurrence = v.count(label)\n",
    "        if occurrence > max_value:\n",
    "            max_value = occurrence\n",
    "            label_prediction = label\n",
    "        elif occurrence == max_value:\n",
    "            label_prediction = \"\"\n",
    "        else:\n",
    "            continue\n",
    "    return label_prediction\n",
    "\n",
    "\n",
    "#Predizione della label\n",
    "#Restituisce una lista di utenti con l'etichetta predetta\n",
    "def get_k_predictions(rank_list, k):\n",
    "    knn_result = []\n",
    "    for result in rank_list:\n",
    "        Ux = result[0]\n",
    "        score_and_label = result[1]\n",
    "        v = []\n",
    "        #se piu dei primi K elementi hanno pari distanza:\n",
    "        if check_if_greater_than_k(score_and_label,k):\n",
    "            v = get_greater_k_labels(score_and_label)\n",
    "\n",
    "        #altrimenti prendi solo i primi K:\n",
    "        else:\n",
    "            for i in range(k):\n",
    "                v.append(score_and_label[i][1])\n",
    "\n",
    "        label_predict = (Ux, most_frequent_label(v))\n",
    "        if label_predict[1] != \"\":\n",
    "            knn_result.append(label_predict)\n",
    "\n",
    "    return knn_result\n",
    "   \n",
    "        \n",
    "#Esegue tutti i metodi sopra definiti\n",
    "def execute_knneighbour(C_train, C_test, k):\n",
    "    rank_list = get_rank_list(C_test,C_train)\n",
    "    knn = get_k_predictions(rank_list,k)\n",
    "    print(\"[K = \",k,\"]\")\n",
    "    print(\"total users in classes: \",len(all_classes))\n",
    "    print(\"train users: \",len(C_train))\n",
    "    print(\"test users: \",len(C_test))\n",
    "    print(\"rank size: \",len(rank_list))\n",
    "    print(\"k-NN predictions: \",len(knn))\n",
    "    print('\\n')\n",
    "    return rank_list, knn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101\n",
      "21\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "#DIVISIONE DEI DATI IN TRAINING E TEST\n",
    "C_train, C_test  = train_test_split(all_classes,test_size=0.2)\n",
    "\n",
    "print(len(all_classes))\n",
    "print(len(C_test))\n",
    "print(len(C_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[K =  1 ]\n",
      "total users in classes:  101\n",
      "train users:  80\n",
      "test users:  21\n",
      "rank size:  21\n",
      "k-NN predictions:  18\n",
      "\n",
      "\n",
      "[K =  3 ]\n",
      "total users in classes:  101\n",
      "train users:  80\n",
      "test users:  21\n",
      "rank size:  21\n",
      "k-NN predictions:  20\n",
      "\n",
      "\n",
      "[K =  5 ]\n",
      "total users in classes:  101\n",
      "train users:  80\n",
      "test users:  21\n",
      "rank size:  21\n",
      "k-NN predictions:  20\n",
      "\n",
      "\n",
      "[K =  7 ]\n",
      "total users in classes:  101\n",
      "train users:  80\n",
      "test users:  21\n",
      "rank size:  21\n",
      "k-NN predictions:  20\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#ESECUZIONE DEL KNN\n",
    "rank_list_1, knn_1 = execute_knneighbour(C_train,C_test,1)\n",
    "predicted_1 = pd.DataFrame(knn_1, columns=['User','predicted-label (K=1)']).sort_values(by=['User'])\n",
    "\n",
    "rank_list_3, knn_3 = execute_knneighbour(C_train,C_test,3)\n",
    "predicted_3 = pd.DataFrame(knn_3, columns=['User','predicted-label (K=3)']).sort_values(by=['User'])\n",
    "\n",
    "rank_list_5, knn_5 = execute_knneighbour(C_train,C_test,5)\n",
    "predicted_5 = pd.DataFrame(knn_5, columns=['User','predicted-label (K=5)']).sort_values(by=['User'])\n",
    "\n",
    "rank_list_7, knn_7 = execute_knneighbour(C_train,C_test,7)\n",
    "predicted_7 = pd.DataFrame(knn_7, columns=['User','predicted-label (K=7)']).sort_values(by=['User'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>User</th>\n",
       "      <th>Brand</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>007maybe</td>\n",
       "      <td>alfaromeo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>21Phylk</td>\n",
       "      <td>armani</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>21Phylk</td>\n",
       "      <td>adidas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ABO_mondo</td>\n",
       "      <td>alfaromeo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ABO_mondo</td>\n",
       "      <td>armani</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>326</th>\n",
       "      <td>thesweetpaisana</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>327</th>\n",
       "      <td>tuscanysusie</td>\n",
       "      <td>alfaromeo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>328</th>\n",
       "      <td>tuscanysusie</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>329</th>\n",
       "      <td>weetish</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>330</th>\n",
       "      <td>weetish</td>\n",
       "      <td>amarelli</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>331 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                User      Brand\n",
       "0           007maybe  alfaromeo\n",
       "1            21Phylk     armani\n",
       "2            21Phylk     adidas\n",
       "3          ABO_mondo  alfaromeo\n",
       "4          ABO_mondo     armani\n",
       "..               ...        ...\n",
       "326  thesweetpaisana    ferrero\n",
       "327     tuscanysusie  alfaromeo\n",
       "328     tuscanysusie    barilla\n",
       "329          weetish    ferrero\n",
       "330          weetish   amarelli\n",
       "\n",
       "[331 rows x 2 columns]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gold_standard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>User</th>\n",
       "      <th>Brand</th>\n",
       "      <th>predicted-label (K=7)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ABO_mondo</td>\n",
       "      <td>alfaromeo</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ABO_mondo</td>\n",
       "      <td>armani</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ABO_mondo</td>\n",
       "      <td>barilla</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Davey_Mitchell</td>\n",
       "      <td>adidas</td>\n",
       "      <td>adidas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Dawnr1979</td>\n",
       "      <td>lavazza</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>61</th>\n",
       "      <td>thesweetpaisana</td>\n",
       "      <td>alfaromeo</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62</th>\n",
       "      <td>thesweetpaisana</td>\n",
       "      <td>barilla</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>thesweetpaisana</td>\n",
       "      <td>ferrero</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64</th>\n",
       "      <td>tuscanysusie</td>\n",
       "      <td>alfaromeo</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>65</th>\n",
       "      <td>tuscanysusie</td>\n",
       "      <td>barilla</td>\n",
       "      <td>barilla</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>66 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               User      Brand predicted-label (K=7)\n",
       "0         ABO_mondo  alfaromeo               barilla\n",
       "1         ABO_mondo     armani               barilla\n",
       "2         ABO_mondo    barilla               barilla\n",
       "3    Davey_Mitchell     adidas                adidas\n",
       "4         Dawnr1979    lavazza               barilla\n",
       "..              ...        ...                   ...\n",
       "61  thesweetpaisana  alfaromeo               barilla\n",
       "62  thesweetpaisana    barilla               barilla\n",
       "63  thesweetpaisana    ferrero               barilla\n",
       "64     tuscanysusie  alfaromeo               barilla\n",
       "65     tuscanysusie    barilla               barilla\n",
       "\n",
       "[66 rows x 3 columns]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gold_standard.merge(predicted_7,on='User')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.8"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "510bf11c66312c57553c778e95194a8e30cff11d9b6d05cf8b0c105636ab8e90"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}