my_knneighbours.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "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 brand_lists import *\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": 10,
   "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",
    "\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": 11,
   "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 tag in all_brands_tags:                     #per ogni tag\n",
    "        vector.append(user_values[tag].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 brand in brands_dict.keys():    #per tutti i label\n",
    "    all_classes.extend(get_class_followers_vectors(brand))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "331\n",
      "67\n",
      "264\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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[K =  1 ]\n",
      "total users in classes:  331\n",
      "train users:  264\n",
      "test users:  67\n",
      "rank size:  67\n",
      "k-NN predictions:  25\n",
      "\n",
      "\n",
      "[K =  3 ]\n",
      "total users in classes:  331\n",
      "train users:  264\n",
      "test users:  67\n",
      "rank size:  67\n",
      "k-NN predictions:  23\n",
      "\n",
      "\n",
      "[K =  5 ]\n",
      "total users in classes:  331\n",
      "train users:  264\n",
      "test users:  67\n",
      "rank size:  67\n",
      "k-NN predictions:  31\n",
      "\n",
      "\n",
      "[K =  7 ]\n",
      "total users in classes:  331\n",
      "train users:  264\n",
      "test users:  67\n",
      "rank size:  67\n",
      "k-NN predictions:  37\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": 23,
   "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>21Phylk</td>\n",
       "      <td>armani</td>\n",
       "      <td>armani</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>21Phylk</td>\n",
       "      <td>adidas</td>\n",
       "      <td>armani</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AnteaterButters</td>\n",
       "      <td>lavazza</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AnteaterButters</td>\n",
       "      <td>barilla</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AnteaterButters</td>\n",
       "      <td>ferrero</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>114</th>\n",
       "      <td>smithywannabe</td>\n",
       "      <td>amarelli</td>\n",
       "      <td>armani</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>115</th>\n",
       "      <td>tuscanysusie</td>\n",
       "      <td>alfaromeo</td>\n",
       "      <td>alfaromeo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>116</th>\n",
       "      <td>tuscanysusie</td>\n",
       "      <td>barilla</td>\n",
       "      <td>alfaromeo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117</th>\n",
       "      <td>weetish</td>\n",
       "      <td>ferrero</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>118</th>\n",
       "      <td>weetish</td>\n",
       "      <td>amarelli</td>\n",
       "      <td>ferrero</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>119 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                User      Brand predicted-label (K=7)\n",
       "0            21Phylk     armani                armani\n",
       "1            21Phylk     adidas                armani\n",
       "2    AnteaterButters    lavazza               ferrero\n",
       "3    AnteaterButters    barilla               ferrero\n",
       "4    AnteaterButters    ferrero               ferrero\n",
       "..               ...        ...                   ...\n",
       "114    smithywannabe   amarelli                armani\n",
       "115     tuscanysusie  alfaromeo             alfaromeo\n",
       "116     tuscanysusie    barilla             alfaromeo\n",
       "117          weetish    ferrero               ferrero\n",
       "118          weetish   amarelli               ferrero\n",
       "\n",
       "[119 rows x 3 columns]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = predicted_7.reset_index(drop=True)\n",
    "gold_standard.merge(t, 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
}