SpriteDeveloperSpriteDeveloper
Reti neurali · Python

Filtro anti-hater per social network

Versione integrata nel sito senza iframe. Il notebook ricostruito resta disponibile come file .ipynb.

Scarica .ipynb← Archivio
Codice
import pandas as pd
import matplotlib.pyplot as plt
import gdown
import seaborn as sns
import pickle
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
import re
from keras.utils import pad_sequences
import nltk
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
import numpy as np
from imblearn.over_sampling import SMOTE
from sklearn.model_selection import train_test_split

from sklearn.neighbors import NearestNeighbors
import random
from collections import Counter
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Embedding, Bidirectional, LSTM, Dense
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
from sklearn.metrics import accuracy_score, f1_score, precision_score, confusion_matrix, classification_report
from sklearn.metrics import roc_auc_score, roc_curve, auc
from sklearn.metrics import hamming_loss
from sklearn.metrics import precision_recall_curve

from tensorflow.keras.models import load_model, Model
from tensorflow.keras.layers import Dense, Dropout, Input
import tensorflow as tf

import seaborn as sns
import time
from sklearn.metrics import multilabel_confusion_matrix
from tensorflow.keras.backend import clear_session
from colorama import Fore, Style, init
Codice
import warnings
warnings.filterwarnings("ignore")
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='3'
import tensorflow as tf
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
Codice
from colorama import Fore, Back, Style

def print_colored(text, color="white", bg_color=None, end="\n"):
    # Dizionario dei colori del testo
    color_dict = {
        'red': Fore.RED,
        'blue': Fore.BLUE,
        'white': '\033[97m',  # Bianco puro (ANSI)
        'black': Fore.BLACK
    }

    # Dizionario dei colori dello sfondo
    bg_color_dict = {
        'black': Back.BLACK,
        'blue': Back.BLUE,
        'white': Back.WHITE
    }

    color_code = color_dict.get(color.lower(), '\033[97m') 
    bg_color_code = bg_color_dict.get(bg_color.lower(), '') if bg_color else ''
    
    print(f"{color_code}{bg_color_code}{text}{Style.RESET_ALL}", end=end)
Codice
BASE_URL="/home/gap/Scrivania/Filtro_anti_hater/"
Codice
df_hater = pd.read_csv(BASE_URL + "Filter_Toxic_Comments_dataset.csv")
Codice
print_colored("Numero di righe:", "blue") 
print(df_hater.shape[0])
print_colored("Numero di colonne:", "blue") 
print(df_hater.shape[1])
Codice
df_hater.count()
Codice
df_hater.info()
Codice
total_values = df_hater.size
print(total_values)

non_missing_values = df_hater.count().sum()
print(non_missing_values)

missing_values = total_values - non_missing_values
print_colored("\nValori mancanti", "blue")
print(missing_values)
Codice
print_colored("Valori mancanti per colonna:\n", "blue")
print(df_hater.isna())
Codice
df_hater.head()
Codice
df_hater.describe()
Codice
categories = df_hater.columns[1:-2].tolist()

print_colored(f"I commenti appartengono alle seguenti categorie:\n", "blue")
print(categories)
Codice
class_distribution = df_hater[categories].sum().to_frame(name='count')

print_colored("Distribuzione dei commenti per categoria:\n", "blue")
print(class_distribution)
Codice
class_distribution.plot(kind='bar', figsize=(10, 6))
plt.ylabel("Numero di Commenti", fontsize=16)
plt.xlabel("Categorie", fontsize=16)
plt.xticks(fontsize=12, color='#b81414')
plt.title("Distribuzione dei commenti", fontsize=18)
plt.yticks(fontsize=12, color='#b81414')
plt.grid(axis='y', linestyle='--', alpha=0.5, color="#1f77b4")
plt.show()
Codice
class_proportion = (class_distribution / df_hater.shape[0])*10

print_colored("Distribuzione dei commenti in percentuale:\n", "blue")
print(class_proportion)
Codice
class_distribution.plot(kind='bar', figsize=(10, 6))
plt.title("Percentuale di distribuzione dei commenti", fontsize=18)
plt.xlabel("Categorie", fontsize=16)
plt.ylabel("Percentuale", fontsize=16)
plt.xticks(fontsize=12, color='#b81414')
plt.yticks(fontsize=12, color='#b81414')
plt.grid(axis='y', linestyle='--', alpha=0.5, color="#1f77b4")
plt.show()
Codice
# Calcolo il numero di etichette attive per ogni commento
df_hater['label_count'] = df_hater[categories].sum(axis=1)

# Distribuzione del numero di etichette attive
multi_label_distribution = df_hater['label_count'].value_counts().sort_index()

plt.figure(figsize=(10, 6))
multi_label_distribution.plot(kind='bar', )
plt.title("Commenti per numero di categorie attive", fontsize=18)
plt.xlabel("Categorie", fontsize=16)
plt.ylabel("Numero di Commenti", fontsize=16)
plt.xticks(fontsize=12, color='#b81414')
plt.yticks(fontsize=12, color='#b81414')
plt.grid(axis='y', linestyle='--', alpha=0.5, color="#1f77b4")
plt.show()

print_colored("Numero di commenti non classificati, quindi non tossici:", "blue")
print(multi_label_distribution.at[0])

print_colored("Numero di commenti con una categoria attiva:", "blue")
print(multi_label_distribution.at[1])

print_colored("Numero di commenti con due categorie attive:", "blue")
print(multi_label_distribution.at[2])

print_colored("Numero di commenti con tre categorie attive:", "blue")
print(multi_label_distribution.at[3])

print_colored("Numero di commenti con quattro categorie attive:", "blue")
print(multi_label_distribution.at[4])

print_colored("Numero di commenti con cinque categorie attive:", "blue")
print(multi_label_distribution.at[5])

print_colored("Numero di commenti con sei categorie attive:", "blue")
print(multi_label_distribution.at[6])
Codice
nltk.download('stopwords')
nltk.download('wordnet')
nltk.download('omw-1.4')

# Inizializzo stopwords e lemmatizer
stop_words = set(stopwords.words('english'))  # Stopword per la lingua inglese
                                              # Rimuove parole comuni italiane per ridurre il rumore nei dati
lemmatizer = WordNetLemmatizer() # Riduce le parole alla loro forma base per 
                                 # diminuire la dimensionalità del vocabolario.

def clean_text(text):
    # Rimuovo caratteri speciali e punteggiatura
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    # Converto tutte le lettere in minuscolo
    text = text.lower()

    tokens = text.split()
    tokens = [lemmatizer.lemmatize(word) for word in tokens if word not in stop_words]
    # Ricostruisco il testo pulito
    return ' '.join(tokens)

def preprocess_data(df_hater, categories):
    # Pulizia del testo
    df_hater['comment_text'] = df_hater['comment_text'].apply(clean_text)
    
    # Tokenizzazione
    tokenizer = Tokenizer()  # Non limitiamo il vocabolario
    tokenizer.fit_on_texts(df_hater['comment_text'])  # Adatta il tokenizer ai testi
    sequences = tokenizer.texts_to_sequences(df_hater['comment_text'])  # Trasforma i testi in sequenze numeriche
    
    # Labels
    labels = df_hater[categories].values
    
    return sequences, labels, tokenizer

# Preprocessing
sequences, labels, tokenizer = preprocess_data(df_hater, categories)
Codice
# Salvo il tokenizer
with open('tokenizer.pickle', 'wb') as handle:
    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
Codice
# Verifica del vocabolario
word_index = tokenizer.word_index  # Dizionario parola -> indice
vocab_size = len(word_index)

print_colored("Dimensione del vocabolario:", "blue")
print(vocab_size)
Codice
# Lunghezza delle sequenze (senza padding)
sequence_lengths = [len(seq) for seq in tokenizer.texts_to_sequences(df_hater['comment_text'])]

# Statistiche sulla lunghezza
min_length = min(sequence_lengths)
max_length = max(sequence_lengths)
avg_length = sum(sequence_lengths) / len(sequence_lengths)


print_colored("Lunghezza minima:", "blue")
print(min_length)
print_colored("Lunghezza massima:", "blue")
print(max_length)
print_colored("Lunghezza media delle sequenze:", "blue")
print(f"{avg_length:.2f}")
Codice
plt.figure(figsize=(10, 6))
plt.hist(sequence_lengths, bins=10, edgecolor='black')
plt.title("Distribuzione della Lunghezza delle Sequenze", fontsize=18)
plt.xlabel("Lunghezza delle Sequenze", fontsize=16, color='black')
plt.ylabel("Frequenza", fontsize=16, color='black')
plt.xticks(fontsize=12, color='#b81414')
plt.yticks(fontsize=12, color='#b81414')
plt.grid(axis='y', linestyle='--', alpha=0.5, color="#1f77b4")
plt.show()
Codice
# Tokenizzazione dei commenti (eseguita una sola volta)
tokenized_sequences = tokenizer.texts_to_sequences(df_hater['comment_text'])  # Tokenizzazione dei commenti
sequence_lengths = [len(seq) for seq in tokenized_sequences]  # Calcola le lunghezze delle sequenze

# Intervalli di lunghezza
outlier_thresholds = [
    (0, 20),
    (21, 50),
    (51, 100),
    (101, 200),
    (201, 300),
    (301, 400),
    (401, 600),
    (601, 1250)
]

# Commenti per ciascun intervallo
counts = []
for low, high in outlier_thresholds:
    count = sum(1 for length in sequence_lengths if low <= length <= high)
    counts.append((low, high, count))

for low, high, count in counts:
    print_colored(f"Numero di commenti con lunghezza compresa tra {low} e {high} token:", "blue")
    print(count)
Codice
interval_labels = [f"{low}-{high}" for low, high, _ in counts]  # Etichette degli intervalli
frequencies = [count for _, _, count in counts]

plt.figure(figsize=(10, 6))
plt.bar(interval_labels, frequencies, color="#1f77b4", edgecolor='black')
plt.title("Distribuzione dei Token", fontsize=18)
plt.xlabel("Lunghezza delle Sequenze (Token)", fontsize=16, color='black')
plt.ylabel("Numero di Commenti", fontsize=16, color='black')
plt.xticks(fontsize=12, color='#b81414', rotation=45)
plt.yticks(fontsize=12, color='#b81414')
plt.grid(axis='y', linestyle='--', alpha=0.5, color="#1f77b4")
plt.show()
Codice
# Applico il padding
max_len = 400  # Lunghezza massima scelta
padded_sequences = pad_sequences(tokenized_sequences, maxlen=max_len, padding='post', truncating='post')

print(padded_sequences[:5])
Codice
for category in categories:
    counts = df_hater[category].value_counts()
    print_colored(f"Distribuzione per {category}:", "blue")
    print(counts)
    print()
Codice
# 0 e 1 per ogni feature
feature_counts = {feature: df_hater[feature].value_counts() for feature in categories}

features = list(feature_counts.keys())
counts_0 = [feature_counts[feature].get(0, 0) for feature in features]
counts_1 = [feature_counts[feature].get(1, 0) for feature in features]

# Intervallo per le barre
x = np.arange(len(features))
width = 0.4

plt.figure(figsize=(12, 6))
plt.bar(x - width/2, counts_0, width=width, label='Classe 0', color='#1f77b4')
plt.bar(x + width/2, counts_1, width=width, label='Classe 1', color='orange', alpha=0.7)

plt.title("Distribuzione di 0 e 1 per ogni feature", fontsize=18)
plt.xlabel("Categorie", fontsize=16, color="black")
plt.ylabel("Numero di commenti", fontsize=16, color="black")
plt.xticks(x, features, fontsize=14, rotation=45, ha='right', color="#b81414")
plt.yticks(fontsize=14, color="#b81414")
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12)
plt.grid(axis='y', linestyle='--', alpha=0.5, color="#1f77b4")

plt.show()
Codice
# Estraggo i valori dalle colonne
labels_df = df_hater[categories].values

# Creo una etichetta che rappresenta il numero totale di classi positive per ogni campione
# Questo è necessario per stratificare i dati preservando la distribuzione multi-classe
stratify_labels_df = labels_df.sum(axis=1)

# Verifico che il numero di campioni nei dati corrisponda al numero di etichette
assert len(padded_sequences) == len(labels_df), 

X_train_mlsmote, X_temp_mlsmote, y_train_mlsmote, y_temp_mlsmote = train_test_split(
    padded_sequences, labels_df, test_size=0.3, random_state=42, stratify=stratify_labels_df
)

stratify_temp_labels_df = y_temp_mlsmote.sum(axis=1)

X_val_mlsmote, X_test_mlsmote, y_val_mlsmote, y_test_mlsmote = train_test_split(
    X_temp_mlsmote, y_temp_mlsmote, test_size=0.5, random_state=42, stratify=stratify_temp_labels_df
)

print_colored(f"Dimensione Training Set:", "blue")
print(len(X_train_mlsmote))
print_colored(f"Dimensione Validation Set:", "blue")
print(len(X_val_mlsmote))
print_colored(f"Dimensione Test Set:", "blue")
print(len(X_test_mlsmote))
Codice
if not isinstance(X_train_mlsmote, pd.DataFrame):
    X_train_mlsmote = pd.DataFrame(X_train_mlsmote, columns=[f'feature_{i}' for i in range(X_train_mlsmote.shape[1])])
if not isinstance(y_train_mlsmote, pd.DataFrame):
    y_train_mlsmote = pd.DataFrame(y_train_mlsmote, columns=categories)

balanced_datasets = {}

for category in categories:
    print_colored(f"Bilanciando la classe:", "blue")
    print_colored(category, "red")
    
    smote = SMOTE(random_state=42)
    
    # Applico SMOTE per la specifica colonna
    X_resampled, y_resampled = smote.fit_resample(X_train_mlsmote, y_train_mlsmote[category])
    
    # Salvo il risultato per la colonna bilanciata
    balanced_datasets[category] = {
        "X_resampled": X_resampled,
        "y_resampled": y_resampled
    }
   

    print(f"Distribuzione bilanciata per {category}: {Counter(y_resampled)}")
    print()

# Ogni chiave contiene "X_resampled" e "y_resampled".
print_colored("Bilanciamento completato per tutte le classi.", "blue")
Codice
# Converto dict_keys in una lista per l'accesso tramite indice
categories_list = list(categories)  # Se categories è dict_keys

# Combino i dati riequilibrati per il training
X_train_balanced = balanced_datasets[categories_list[0]]["X_resampled"]
y_train_balanced = pd.concat(
    [pd.DataFrame(balanced_datasets[cat]["y_resampled"], columns=[cat]) for cat in categories_list],
    axis=1
)

print_colored(f"Dimensione X_train_balanced:", "blue")
print(X_train_balanced.shape)
print_colored(f"Dimensione y_train_balanced:", "blue")
print(y_train_balanced.shape)
Codice
for category in categories:
    print_colored(category, "blue")
    print(f"Dimensioni X_resampled: {balanced_datasets[category]['X_resampled'].shape}")
    print(f"Dimensioni y_resampled: {balanced_datasets[category]['y_resampled'].shape}")
    print()
Codice
min_samples = min(len(balanced_datasets[cat]["X_resampled"]) for cat in categories)
print_colored(f"Numero minimo di campioni:", "blue")
print(min_samples)
Codice
# Riduco ogni dataset bilanciato alla dimensione minima
X_train_balanced = balanced_datasets[categories_list[0]]["X_resampled"][:min_samples]

# Combino le etichette per tutte le categorie
y_train_balanced = pd.concat(
    [
        pd.DataFrame(balanced_datasets[cat]["y_resampled"][:min_samples], columns=[cat])
        for cat in categories
    ],
    axis=1
)

print(f"Dimensione X_train_balanced: {X_train_balanced.shape}")
print(f"Dimensione y_train_balanced: {y_train_balanced.shape}")
Codice
categories = balanced_datasets.keys()
counts_per_category = {
    category: Counter(balanced_datasets[category]["y_resampled"])
    for category in categories
}

counts_0 = [counts_per_category[cat][0] for cat in categories]
counts_1 = [counts_per_category[cat][1] for cat in categories]

x = np.arange(len(categories))
width = 0.4

plt.figure(figsize=(12, 6))
plt.bar(x - width / 2, counts_0, width, label="Classe 0", alpha=0.7)
plt.bar(x + width / 2, counts_1, width, label="Classe 1", alpha=0.7)

plt.xlabel("Categorie", fontsize=16, color='black')
plt.ylabel("Conteggio", fontsize=16, color='black')
plt.title("Bilanciamento delle classi dopo SMOTE", fontsize=18)
plt.xticks(x, categories, rotation=45, ha='right', color='#b81414')
plt.yticks(fontsize=12, color='#b81414')
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12)
plt.grid(axis="y", linestyle="--", alpha=0.5, color="#1f77b4")

plt.tight_layout()
plt.show()
Codice
vocab_size_padding = len(tokenizer.word_index) + 1  # Aggiungi 1 per il token di padding
print_colored(f"Vocab size padding:", "blue")
print(vocab_size_padding)
Codice
clear_session()
Codice
model = Sequential()

# Ho dovuto aggiungere i valori in modo esplicito per non farmi restituire 'unbuilt'
model.add(Input(shape=(400,), name='input_layer'))

model.add(Embedding(
    input_dim=212563,  # vocab_size_padding
    output_dim=128,
    name='embedding_layer'
))

model.add(Bidirectional(a
    LSTM(64, activation='tanh'),
    name='bidirectional_lstm'
))

model.add(Dense(6, activation='sigmoid', name='output_layer'))  # num_labels = 6

# Compilazione
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

model.summary()
Codice
early_stopping = EarlyStopping(
    monitor='val_loss',        # metrica da monitorare
    patience=2,                # numero di epoche da aspettare prima di fermarsi
    restore_best_weights=True, # ripristina i migliori pesi
    mode='min',                # minimizzare la loss
    min_delta=0.001,           # cambiamento minimo da considerare come miglioramento
)
Codice
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,
    patience=1,              # riduce il learning rate dopo 1 epoca senza miglioramenti
    min_lr=1e-6,
    verbose=1
)
Codice
model_checkpoint_path = "anti_hater_model_stratify_400_128_6__1.keras"

# Callback per salvare il miglior modello basato sulla metrica monitorata
model_checkpoint = ModelCheckpoint(
    filepath=model_checkpoint_path,   # Percorso per salvare il modello
    monitor='val_loss',               # Metrica da monitorare
    save_best_only=True,              # Salva solo il modello migliore
    save_weights_only=False,          # Salva l'intero modello (inclusa l'architettura)
    mode='min',                       # minimizzare la val_loss
    verbose=1                        
)
Codice
history = model.fit(
    X_train_balanced,
    y_train_balanced,
    validation_data=(X_val_mlsmote, y_val_mlsmote),# Usa i dati di validazione originali l set di validazione serve per monitorare il 
                                                     # progresso del modello durante il training
    epochs=5,
    batch_size=32,
    callbacks=[early_stopping, reduce_lr, model_checkpoint], 
    verbose=1
)

print(f"Il miglior modello è stato salvato in: {model_checkpoint_path}")
Codice
print("\nValutazione sul Test Set:")
y_test_pred = model.predict(X_test_mlsmote)  # Predizioni sul test set
y_test_pred_binary = (y_test_pred > 0.5).astype(int)  # Converto probabilità in etichette binarie

test_metrics_df = pd.DataFrame()
test_metrics_df['Category'] = categories

test_accuracies = []
test_f1_scores = []
test_precisions = []

for i in range(len(categories)):
    test_acc = accuracy_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_f1 = f1_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_prec = precision_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    
    test_accuracies.append(test_acc)
    test_f1_scores.append(test_f1)
    test_precisions.append(test_prec)

test_metrics_df['Accuracy'] = test_accuracies
test_metrics_df['F1-Score'] = test_f1_scores
test_metrics_df['Precision'] = test_precisions

print("\nMetriche del Test Set:")
print(test_metrics_df)

print("\nInferenza su alcuni esempi del Test Set:")

num_examples = 15
for idx in range(num_examples):
    comment = X_test_mlsmote[idx]
    true_labels = y_test_mlsmote[idx]
    predicted_probs = y_test_pred[idx]
    predicted_labels = y_test_pred_binary[idx]
    
    print(f"Commento #{idx + 1}:")
    print(f" - Predetto: {predicted_labels} (probabilità: {predicted_probs.round(2)})")
    print(f" - Vero: {true_labels}")
    print("-" * 50)
Codice
# Calcolo la Hamming Loss tra le etichette vere (ytest) e le etichette predette (ypred)
# la somma degli errori tra ytest e il ypred diviso il numero totale di etichette
global_hamming_loss = hamming_loss(y_test_mlsmote, y_test_pred_binary)

# Inverto la Hamming Loss per ottenere la Global Accuracy
global_accuracy_1 = 1 - global_hamming_loss

print_colored(f"Precisione Globale (Global Accuracy):", "blue")
print(f"{global_accuracy_1:.4f}")
Codice
conf_matrices = multilabel_confusion_matrix(y_test_mlsmote, y_test_pred_binary)

# Controllo dimensioni
if conf_matrices.shape[0] != len(categories):
    print("Errore: Il numero di confusion matrix non corrisponde al numero di categorie.")
else:
    for i, category in enumerate(categories):
        plt.figure(figsize=(6, 4))
        
        conf_matrix = conf_matrices[i]
        
        labels = np.array([['TN', 'FP'], ['FN', 'TP']])
        annotated_matrix = np.empty_like(conf_matrix, dtype=object)
        for row in range(conf_matrix.shape[0]):
            for col in range(conf_matrix.shape[1]):
                annotated_matrix[row, col] = f"{labels[row, col]}: {conf_matrix[row, col]}"
        
        sns.heatmap(conf_matrix, annot=annotated_matrix, fmt='', cmap='Blues', cbar=False)
        plt.title(f"Confusion Matrix per {category}")
        plt.xlabel("Predizioni")
        plt.ylabel("Valori Reali")
        plt.show()
        
        print(f"Confusion Matrix per {category}:")
        print(conf_matrix)
Codice
for i, category in enumerate(categories):
    fpr, tpr, _ = roc_curve(y_test_mlsmote[:, i], y_test_pred[:, i])
    roc_auc = auc(fpr, tpr)
    
    plt.figure(figsize=(6, 4))
    plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.2f}')
    plt.plot([0, 1], [0, 1], 'k--', label='Random Guessing')
    plt.title(f"ROC Curve per {category}")
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.legend(loc='lower right')
    plt.grid(alpha=0.3)
    plt.show()
Codice
for i, category in enumerate(categories):
    precision, recall, thresholds = precision_recall_curve(y_test_mlsmote[:, i], y_test_pred[:, i])
    
    print(f"\nPrecision-Recall per {category} (valori campionati):")
    print(f"{'Threshold':<10}{'Precision':<12}{'Recall':<12}")
    print("-" * 34)
    
    sampled_indices = np.linspace(0, len(thresholds) - 1, 10, dtype=int)  # Campiona 10 valori
    for idx in sampled_indices:
        print(f"{thresholds[idx]:<10.2f}{precision[idx]:<12.2f}{recall[idx]:<12.2f}")
    
    plt.figure(figsize=(6, 4))
    plt.plot(recall, precision, label='Precision-Recall Curve')
    plt.title(f"Precision-Recall Curve per {category}")
    plt.xlabel('Recall')
    plt.ylabel('Precision')
    plt.legend(loc='upper right')
    plt.grid(alpha=0.3)
    plt.show()
Codice
def load_model_safely(path):
    try:
        model = load_model(path)
        return model
    except Exception as e:
        print(f"Errore nel caricamento del modello: {e}")
        return None

model_checkpoint_path = "/home/gap/Scrivania/Filtro_anti_hater/anti_hater_model_stratify_400_128_6__1.keras"

first_model = load_model_safely(model_checkpoint_path)

if first_model is None:
    print("Impossibile caricare il modello. Controllare il file del modello.")
else:

    # Preservo i pesi già addestrati per evitare che vengano riaddestrati
    for layer in first_model.layers:
        layer.trainable = False  # Congelo tutti i layer esistenti
    
    print("Sommario del Modello:")
    first_model.summary()

    # Estraggo la forma dell'input, rimuovendo la dimensione del batch
    if isinstance(first_model.input_shape, tuple):
        input_shape = first_model.input_shape[1:]  # Rimuove la dimensione del batch
    else:
        input_shape = first_model.input_shape[0][1:]  # input multipli
    
    # Creo un nuovo strato di input con la forma estratta
    inputs = Input(shape=input_shape)
    
    # Clono i layer del modello originale (escludendo l'ultimo layer di output)
    x = inputs
    for layer in first_model.layers[:-1]:
        x = layer(x)
    
    # Nuovi layer
    x = Dense(64, activation='relu', name='new_dense_1')(x)
    
    # Layer di Dropout per ridurre l'overfitting
    x = Dropout(0.5, name='new_dropout')(x)
    
    x = Dense(32, activation='relu', name='new_dense_2')(x)
    
    # Layer di output con 6 neuroni e attivazione sigmoid per classificazione multi-label
    output_layer = Dense(6, activation='sigmoid', name='new_output_layer')(x)
    
    second_model = Model(inputs=inputs, outputs=output_layer)
    
    second_model.compile(
        optimizer='adam',
        loss='binary_crossentropy',  # Funzione di perdita per problemi multi-label
        metrics=['accuracy']  # Metrica per valutare le prestazioni
    )
    
    second_model.summary()
Codice
early_stopping = EarlyStopping(
    monitor='val_loss',        # metrica da monitorare
    patience=3,                # numero di epoche da aspettare prima di fermarsi
    restore_best_weights=True, # ripristina i migliori pesi
    mode='min',                # minimizzare la loss
    min_delta=0.001,           # cambiamento minimo da considerare come miglioramento
    verbose=1               
)
Codice
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,
    patience=1,           
    min_lr=1e-6,
    verbose=1
)
Codice
model_checkpoint_path = "/home/gap/Scrivania/Filtro_anti_hater/anti_hater_model_stratify_400_128_64_32_dropout0.5_6__2.keras"

# Callback per salvare il miglior modello basato sulla metrica monitorata
model_checkpoint = ModelCheckpoint(
    filepath=model_checkpoint_path,   # Percorso per salvare il modello
    monitor='val_loss',               # Metrica da monitorare
    save_best_only=True,              # Salvo solo il modello migliore
    save_weights_only=False,          # Salvo l'intero modello (inclusa l'architettura)
    mode='min',                       # minimizzare la val_loss
    verbose=1                        
)
Codice
history = second_model.fit(
    X_train_balanced,
    y_train_balanced,
    validation_data=(X_val_mlsmote, y_val_mlsmote), # dati di validazione originali
    epochs=5,
    batch_size=32,
    callbacks=[early_stopping, reduce_lr, model_checkpoint], 
    verbose=1
)

# Messaggio finale
print(f"Il miglior modello è stato salvato in: {model_checkpoint_path}")
Codice
print("\nValutazione sul Test Set:")
y_test_pred = second_model.predict(X_test_mlsmote) 
y_test_pred_binary = (y_test_pred > 0.5).astype(int)

test_metrics_df_2 = pd.DataFrame()
test_metrics_df_2['Category'] = categories

test_accuracies = []
test_f1_scores = []
test_precisions = []

for i in range(len(categories)):
    test_acc = accuracy_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_f1 = f1_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_prec = precision_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    
    test_accuracies.append(test_acc)
    test_f1_scores.append(test_f1)
    test_precisions.append(test_prec)

test_metrics_df_2['Accuracy'] = test_accuracies
test_metrics_df_2['F1-Score'] = test_f1_scores
test_metrics_df_2['Precision'] = test_precisions

print("\nMetriche del Test Set:")
print(test_metrics_df_2)


print("\nInferenza su alcuni esempi del Test Set:")

num_examples = 15
for idx in range(num_examples):
    comment = X_test_mlsmote[idx]
    true_labels = y_test_mlsmote[idx]
    predicted_probs = y_test_pred[idx]
    predicted_labels = y_test_pred_binary[idx]
    
    print(f"Commento #{idx + 1}:")
    print(f" - Predetto: {predicted_labels} (probabilità: {predicted_probs.round(2)})")
    print(f" - Vero: {true_labels}")
    print("-" * 50)
Codice
global_hamming_loss = hamming_loss(y_test_mlsmote, y_test_pred_binary)

global_accuracy_2 = 1 - global_hamming_loss

print_colored(f"Precisione Globale (Global Accuracy):", "blue")
print(f"{global_accuracy_2:.4f}")
Codice
conf_matrices = multilabel_confusion_matrix(y_test_mlsmote, y_test_pred_binary)

if conf_matrices.shape[0] != len(categories):
    print("Errore: Il numero di confusion matrix non corrisponde al numero di categorie.")
else:
    for i, category in enumerate(categories):
        plt.figure(figsize=(6, 4))
        
        conf_matrix = conf_matrices[i]
        
        labels = np.array([['TN', 'FP'], ['FN', 'TP']])
        annotated_matrix = np.empty_like(conf_matrix, dtype=object)
        for row in range(conf_matrix.shape[0]):
            for col in range(conf_matrix.shape[1]):
                annotated_matrix[row, col] = f"{labels[row, col]}: {conf_matrix[row, col]}"
        
        sns.heatmap(conf_matrix, annot=annotated_matrix, fmt='', cmap='Blues', cbar=False)
        plt.title(f"Confusion Matrix per {category}")
        plt.xlabel("Predizioni")
        plt.ylabel("Valori Reali")
        plt.show()
        
        print(f"Confusion Matrix per {category}:")
        print(conf_matrix)
Codice
from sklearn.metrics import roc_auc_score, roc_curve, auc

# Calcolo AUC per ogni categoria
for i, category in enumerate(categories):
    fpr, tpr, _ = roc_curve(y_test_mlsmote[:, i], y_test_pred[:, i])
    roc_auc = auc(fpr, tpr)
    
    plt.figure(figsize=(6, 4))
    plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.2f}')
    plt.plot([0, 1], [0, 1], 'k--', label='Random Guessing')
    plt.title(f"ROC Curve per {category}")
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.legend(loc='lower right')
    plt.grid(alpha=0.3)
    plt.show()
Codice
for i, category in enumerate(categories):
    precision, recall, thresholds = precision_recall_curve(y_test_mlsmote[:, i], y_test_pred[:, i])
    
    print(f"\nPrecision-Recall per {category} (valori campionati):")
    print(f"{'Threshold':<10}{'Precision':<12}{'Recall':<12}")
    print("-" * 34)
    
    # Indici campionati per valori distribuiti
    sampled_indices = np.linspace(0, len(thresholds) - 1, 10, dtype=int)  # Campiona 10 valori
    for idx in sampled_indices:
        print(f"{thresholds[idx]:<10.2f}{precision[idx]:<12.2f}{recall[idx]:<12.2f}")
    
    plt.figure(figsize=(6, 4))
    plt.plot(recall, precision, label='Precision-Recall Curve')
    plt.title(f"Precision-Recall Curve per {category}")
    plt.xlabel('Recall')
    plt.ylabel('Precision')
    plt.legend(loc='upper right')
    plt.grid(alpha=0.3)
    plt.show()
Codice
def load_model_safely(path):
    try:
        model = load_model(path)
        return model
    except Exception as e:
        print(f"Errore nel caricamento del modello: {e}")
        return None

model_checkpoint_path = "/home/gap/Scrivania/Filtro_anti_hater/anti_hater_model_stratify_400_128_6__1.keras"

first_model = load_model_safely(model_checkpoint_path)

if first_model is None:
    print("Impossibile caricare il modello. Controllare il file del modello.")
else:

    # Preservo i pesi già addestrati per evitare che vengano riaddestrati
    for layer in first_model.layers:
        layer.trainable = False  # Congelo tutti i layer esistenti
    
    print("Sommario del Modello:")
    first_model.summary()

    # Estraggo la forma dell'input, rimuovendo la dimensione del batch
    if isinstance(first_model.input_shape, tuple):
        input_shape = first_model.input_shape[1:]  # Rimuovo la dimensione del batch
    else:
        input_shape = first_model.input_shape[0][1:]  # input multipli
    
    # Creo un nuovo strato di input con la forma estratta
    inputs = Input(shape=input_shape)
    
    # Clono i layer del modello originale (escludendo l'ultimo layer di output)
    x = inputs
    for layer in first_model.layers[:-1]:
        x = layer(x)
    
    # ReLU aggiunge non-linearità al modello accelerando la convergenza
    x = Dense(256, activation='relu', name='new_dense_1')(x)
    
    # Layer di Dropout per ridurre l'overfitting
    x = Dropout(0.5, name='new_dropout')(x)

    x = Dense(128, activation='relu', name='new_dense_2')(x)

    x = Dropout(0.5, name='new_dropout_1')(x)

    x = Dense(64, activation='relu', name='new_dense_3')(x)
    
    x = Dropout(0.5, name='new_dropout_2')(x)
    
    x = Dense(32, activation='relu', name='new_dense_4')(x)
    
    # Layer di output con 6 neuroni e attivazione sigmoid per classificazione multi-label
    output_layer = Dense(6, activation='sigmoid', name='new_output_layer')(x)
    
    thirth_model = Model(inputs=inputs, outputs=output_layer)
    

    thirth_model.compile(
        optimizer='adam',  
        loss='binary_crossentropy',  # Funzione di perdita per problemi multi-label
        metrics=['accuracy']  
    )

    thirth_model.summary()
Codice
early_stopping = EarlyStopping(
    monitor='val_loss',       # metrica da monitorare
    patience=3,               # numero di epoche da aspettare prima di fermarsi
    restore_best_weights=True, # ripristina i migliori pesi
    mode='min',              # minimizzare la loss
    min_delta=0.001,         # cambiamento minimo da considerare come miglioramento
    verbose=1              
)
Codice
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,
    patience=2,             
    min_lr=1e-6,
    verbose=1
)
Codice
model_checkpoint_path = "anti_hater_model_stratify_400_256_128_64_32_dropout0.5_6__3.keras"

model_checkpoint = ModelCheckpoint(
    filepath=model_checkpoint_path,   # Percorso per salvare il modello
    monitor='val_loss',               # Metrica da monitorare
    save_best_only=True,              # Salvo solo il modello migliore
    save_weights_only=False,          # Salvo l'intero modello (inclusa l'architettura)
    mode='min',                       # minimizzare la val_loss
    verbose=1                        
)
Codice
history = thirth_model.fit(
    X_train_balanced,
    y_train_balanced,
    validation_data=(X_val_mlsmote, y_val_mlsmote),
    epochs=10,
    batch_size=32,
    callbacks=[early_stopping, reduce_lr, model_checkpoint], 
    verbose=1
)

print_colored(f"Il miglior modello è stato salvato in:", "blue")
print(model_checkpoint_path)
Codice
print("\nValutazione sul Test Set:")
y_test_pred = thirth_model.predict(X_test_mlsmote)  
y_test_pred_binary = (y_test_pred > 0.5).astype(int)  

test_metrics_df_3 = pd.DataFrame()
test_metrics_df_3['Category'] = categories

test_accuracies = []
test_f1_scores = []
test_precisions = []

for i in range(len(categories)):
    test_acc = accuracy_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_f1 = f1_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_prec = precision_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    
    test_accuracies.append(test_acc)
    test_f1_scores.append(test_f1)
    test_precisions.append(test_prec)

test_metrics_df_3['Accuracy'] = test_accuracies
test_metrics_df_3['F1-Score'] = test_f1_scores
test_metrics_df_3['Precision'] = test_precisions

print("\nMetriche del Test Set:")
print(test_metrics_df_3)


print("\nInferenza su alcuni esempi del Test Set:")

num_examples = 15
for idx in range(num_examples):
    comment = X_test_mlsmote[idx]
    true_labels = y_test_mlsmote[idx]
    predicted_probs = y_test_pred[idx]
    predicted_labels = y_test_pred_binary[idx]
    
    print(f"Commento #{idx + 1}:")
    print(f" - Predetto: {predicted_labels} (probabilità: {predicted_probs.round(2)})")
    print(f" - Vero: {true_labels}")
    print("-" * 50)
Codice
global_hamming_loss = hamming_loss(y_test_mlsmote, y_test_pred_binary)

global_accuracy_3 = 1 - global_hamming_loss

print_colored(f"Precisione Globale (Global Accuracy):", "blue")
print(f"{global_accuracy_3:.4f}")
Codice
for i, category in enumerate(categories):
    print_colored(f"Categoria {category}\n".ljust(16), "blue", end="")
    
    # Primo Modello
    print_colored(f"   Primo     Modello:".ljust(10), "red", end="")
    accuracy = test_metrics_df['Accuracy'][i]
    f1_score = test_metrics_df['F1-Score'][i]
    precision = test_metrics_df['Precision'][i]
    print_colored(f"   Accuracy: {accuracy:<10.4f} ", bg_color="blue" if accuracy == max(accuracy, test_metrics_df_2['Accuracy'][i], test_metrics_df_3['Accuracy'][i]) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score:<10.4f} ", bg_color="blue" if f1_score == max(f1_score, test_metrics_df_2['F1-Score'][i], test_metrics_df_3['F1-Score'][i]) else "", color="black", end="")
    print_colored(f"   Precision: {precision:<10.4f}", bg_color="blue" if precision == max(precision, test_metrics_df_2['Precision'][i], test_metrics_df_3['Precision'][i]) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_1:<10.4f}", "black")

    # Secondo Modello
    print_colored(f"   Secondo   Modello:".ljust(10), "red", end="")
    accuracy_2 = test_metrics_df_2['Accuracy'][i]
    f1_score_2 = test_metrics_df_2['F1-Score'][i]
    precision_2 = test_metrics_df_2['Precision'][i]
    print_colored(f"   Accuracy: {accuracy_2:<10.4f} ", bg_color="blue" if accuracy_2 == max(accuracy, accuracy_2, test_metrics_df_3['Accuracy'][i]) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score_2:<10.4f} ", bg_color="blue" if f1_score_2 == max(f1_score, f1_score_2, test_metrics_df_3['F1-Score'][i]) else "", color="black", end="")
    print_colored(f"   Precision: {precision_2:<10.4f}", bg_color="blue" if precision_2 == max(precision, precision_2, test_metrics_df_3['Precision'][i]) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_1:<10.4f}", "black")

    # Terzo Modello
    print_colored(f"   Terzo     Modello:".ljust(10), "red", end="")
    accuracy_3 = test_metrics_df_3['Accuracy'][i]
    f1_score_3 = test_metrics_df_3['F1-Score'][i]
    precision_3 = test_metrics_df_3['Precision'][i]
    print_colored(f"   Accuracy: {accuracy_3:<10.4f} ", bg_color="blue" if accuracy_3 == max(accuracy, accuracy_2, accuracy_3) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score_3:<10.4f} ", bg_color="blue" if f1_score_3 == max(f1_score, f1_score_2, f1_score_3) else "", color="black", end="")
    print_colored(f"   Precision: {precision_3:<10.4f}", bg_color="blue" if precision_3 == max(precision, precision_2, precision_3) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_3:<10.4f}\n", "black")
Codice
# Indici per le categorie
x = range(len(categories))

# Larghezza delle barre
width = 0.3

plt.figure(figsize=(12, 6))
plt.bar(x, test_metrics_df['F1-Score'], width=width, label='Primo Modello', align='center', alpha=0.7)
plt.bar([i + width for i in x], test_metrics_df_2['F1-Score'], width=width, label='Secondo Modello', align='center', alpha=0.7)
plt.bar([i + 2 * width for i in x], test_metrics_df_3['F1-Score'], width=width, label='Terzo Modello', align='center', alpha=0.7)

plt.xticks([i + width for i in x], categories, fontsize=14, rotation=45, ha='right', color="#b81414")
plt.yticks(fontsize=14, color="#b81414")
plt.xlabel("Categorie", fontsize=16, color="black")
plt.ylabel('F1-Score', fontsize=16, color="black")
plt.title('Confronto F1-Score tra Modelli', fontsize=18)
plt.legend()

plt.tight_layout()
plt.show()
Codice
# Indici per le categorie
x = range(len(categories))

# Larghezza delle barre
width = 0.3

plt.figure(figsize=(12, 6))
plt.bar(x, test_metrics_df['Accuracy'], width=width, label='Primo Modello', align='center', alpha=0.7)
plt.bar([i + width for i in x], test_metrics_df_2['Accuracy'], width=width, label='Secondo Modello', align='center', alpha=0.7)
plt.bar([i + 2 * width for i in x], test_metrics_df_3['Accuracy'], width=width, label='Terzo Modello', align='center', alpha=0.7)

plt.title('Confronto Accuracy tra Modelli', fontsize=18)
plt.xticks([i + width for i in x], categories, fontsize=14, rotation=45, ha='right', color="#b81414")
plt.yticks(fontsize=14, color="#b81414")
plt.xlabel("Categorie", fontsize=16, color="black")
plt.ylabel('Accuracy', fontsize=16, color="black")
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12)

plt.tight_layout()
plt.show()
Codice
# Indici per le categorie
x = range(len(categories))

# Larghezza delle barre
width = 0.3

plt.figure(figsize=(12, 6))
plt.bar(x, test_metrics_df['Precision'], width=width, label='Primo Modello', align='center', alpha=0.7)
plt.bar([i + width for i in x], test_metrics_df_2['Precision'], width=width, label='Secondo Modello', align='center', alpha=0.7)
plt.bar([i + 2 * width for i in x], test_metrics_df_3['Precision'], width=width, label='Terzo Modello', align='center', alpha=0.7)

plt.title('Confronto Precision tra Modelli', fontsize=18)
plt.xticks([i + width for i in x], categories, fontsize=14, rotation=45, ha='right', color="#b81414")
plt.yticks(fontsize=14, color="#b81414")
plt.xlabel("Categorie", fontsize=16, color="black")
plt.ylabel('Precision', fontsize=16, color="black")

plt.legend()

plt.tight_layout()
plt.show()
Codice
# Indici per le categorie
x = range(len(categories))

# Larghezza delle barre
width = 0.3

plt.figure(figsize=(12, 6))
plt.bar(x, global_accuracy_1, width=width, label='Primo Modello', align='center', alpha=0.7)
plt.bar([i + width for i in x], global_accuracy_2, width=width, label='Secondo Modello', align='center', alpha=0.7)
plt.bar([i + 2 * width for i in x], global_accuracy_3, width=width, label='Terzo Modello', align='center', alpha=0.7)

plt.title('Confronto Global accuracy tra Modelli', fontsize=18)
plt.xticks([i + width for i in x], categories, fontsize=14, rotation=45, ha='right', color="#b81414")
plt.yticks(fontsize=14, color="#b81414")
plt.xlabel("Categorie", fontsize=16, color="black")
plt.ylabel('Global Accuracy', fontsize=16, color="black")

plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12)

plt.tight_layout()
plt.show()
Codice
load_model_path = '/home/gap/Scrivania/Filtro_anti_hater/anti_hater_model_stratify_400_128_6__1.keras' 
model_reload_1 = load_model(load_model_path)
Codice
def focal_loss(alpha=0.25, gamma=2.0):
    def loss(y_true, y_pred):
        y_true = tf.cast(y_true, tf.float32)
        y_pred = tf.clip_by_value(y_pred, 1e-8, 1 - 1e-8)
        ce_loss = -y_true * tf.math.log(y_pred)
        focal = alpha * tf.pow(1 - y_pred, gamma) * ce_loss
        return tf.reduce_mean(tf.reduce_sum(focal, axis=-1))
    return loss
Codice
model_reload_1.compile(
    optimizer='adam',
    loss=focal_loss(alpha=0.25, gamma=2.0),
    metrics=['accuracy']
)
Codice
model_reload_1.summary()
Codice
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,
    patience=2,             
    min_lr=1e-6,
    verbose=1
)
Codice
early_stopping = EarlyStopping(
    monitor='val_loss',       # metrica da monitorare
    patience=3,               # numero di epoche da aspettare prima di fermarsi
    restore_best_weights=True, # ripristina i migliori pesi
    mode='min',              # minimizzare la loss
    min_delta=0.001,         # cambiamento minimo da considerare come miglioramento
)
Codice
model_checkpoint_path = "anti_hater_model_reload__1.keras"

model_checkpoint = ModelCheckpoint(
    filepath=model_checkpoint_path,   # Percorso per salvare il modello
    monitor='val_loss',               # Metrica da monitorare
    save_best_only=True,              # Salvo solo il modello migliore
    save_weights_only=False,          # Salvo l'intero modello (inclusa l'architettura)
    mode='min',                       # minimizzare la val_loss
)
Codice
history = model.fit(
    X_train_balanced,
    y_train_balanced,
    validation_data=(X_val_mlsmote, y_val_mlsmote), # Usa i dati di validazione originali
    epochs=10,
    batch_size=32,
    callbacks=[early_stopping, reduce_lr, model_checkpoint], 
    verbose=1
)

print(f"Il modello è stato salvato in: {model_checkpoint_path}")
Codice
print("\nValutazione sul Test Set:")
y_test_pred = model_reload_1.predict(X_test_mlsmote)  # Predizioni sul test set
y_test_pred_binary = (y_test_pred > 0.5).astype(int)  # Converto probabilità in etichette binarie

test_metrics_df_reload_1 = pd.DataFrame()
test_metrics_df_reload_1['Category'] = categories

test_accuracies = []
test_f1_scores = []
test_precisions = []

for i in range(len(categories)):
    test_acc = accuracy_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_f1 = f1_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    test_prec = precision_score(y_test_mlsmote[:, i], y_test_pred_binary[:, i])
    
    test_accuracies.append(test_acc)
    test_f1_scores.append(test_f1)
    test_precisions.append(test_prec)

test_metrics_df_reload_1['Accuracy'] = test_accuracies
test_metrics_df_reload_1['F1-Score'] = test_f1_scores
test_metrics_df_reload_1['Precision'] = test_precisions

print("\nMetriche del Test Set:")
print(test_metrics_df_reload_1)


print("\nInferenza su alcuni esempi del Test Set:")

num_examples = 15
for idx in range(num_examples):
    comment = X_test_mlsmote[idx]
    true_labels = y_test_mlsmote[idx]
    predicted_probs = y_test_pred[idx]
    predicted_labels = y_test_pred_binary[idx]
    
    print(f"Commento #{idx + 1}:")
    print(f" - Predetto: {predicted_labels} (probabilità: {predicted_probs.round(2)})")
    print(f" - Vero: {true_labels}")
    print("-" * 50)
Codice
global_hamming_loss = hamming_loss(y_test_mlsmote, y_test_pred_binary)

global_accuracy_reload_1 = 1 - global_hamming_loss

print_colored(f"Precisione Globale (Global Accuracy):", "blue")
print(f"{global_accuracy_reload_1:.4f}")
Codice
conf_matrices = multilabel_confusion_matrix(y_test_mlsmote, y_test_pred_binary)

if conf_matrices.shape[0] != len(categories):
    print("Errore: Il numero di confusion matrix non corrisponde al numero di categorie.")
else:
    for i, category in enumerate(categories):
        plt.figure(figsize=(6, 4))
        
        conf_matrix = conf_matrices[i]
        
        labels = np.array([['TN', 'FP'], ['FN', 'TP']])
        annotated_matrix = np.empty_like(conf_matrix, dtype=object)
        for row in range(conf_matrix.shape[0]):
            for col in range(conf_matrix.shape[1]):
                annotated_matrix[row, col] = f"{labels[row, col]}: {conf_matrix[row, col]}"
        
        sns.heatmap(conf_matrix, annot=annotated_matrix, fmt='', cmap='Blues', cbar=False)
        plt.title(f"Confusion Matrix per {category}")
        plt.xlabel("Predizioni")
        plt.ylabel("Valori Reali")
        plt.show()
        
        print(f"Confusion Matrix per {category}:")
        print(conf_matrix)
Codice
for i, category in enumerate(categories):
    fpr, tpr, _ = roc_curve(y_test_mlsmote[:, i], y_test_pred[:, i])
    roc_auc = auc(fpr, tpr)
    
    plt.figure(figsize=(6, 4))
    plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.2f}')
    plt.plot([0, 1], [0, 1], 'k--', label='Random Guessing')
    plt.title(f"ROC Curve per {category}")
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.legend(loc='lower right')
    plt.grid(alpha=0.3)
    plt.show()
Codice
for i, category in enumerate(categories):
    precision, recall, thresholds = precision_recall_curve(y_test_mlsmote[:, i], y_test_pred[:, i])
    
    print(f"\nPrecision-Recall per {category} (valori campionati):")
    print(f"{'Threshold':<10}{'Precision':<12}{'Recall':<12}")
    print("-" * 34)
    
    sampled_indices = np.linspace(0, len(thresholds) - 1, 10, dtype=int)  # Campiona 10 valori
    for idx in sampled_indices:
        print(f"{thresholds[idx]:<10.2f}{precision[idx]:<12.2f}{recall[idx]:<12.2f}")
    
    plt.figure(figsize=(6, 4))
    plt.plot(recall, precision, label='Precision-Recall Curve')
    plt.title(f"Precision-Recall Curve per {category}")
    plt.xlabel('Recall')
    plt.ylabel('Precision')
    plt.legend(loc='upper right')
    plt.grid(alpha=0.3)
    plt.show()
Codice
for i, category in enumerate(categories):
    print_colored(f"Categoria {category}\n".ljust(16), "blue", end="")
    
    # Primo Modello
    print_colored(f"   Primo     Modello:".ljust(10), "red", end="")
    accuracy = test_metrics_df['Accuracy'][i]
    f1_score = test_metrics_df['F1-Score'][i]
    precision = test_metrics_df['Precision'][i]
    print_colored(f"   Accuracy: {f1_score:<10.4f} ", bg_color="blue" if accuracy == max(accuracy, test_metrics_df_2['Accuracy'][i], test_metrics_df_3['Accuracy'][i], test_metrics_df_reload_1['Accuracy'][i]) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score:<10.4f} ", bg_color="blue" if f1_score == max(f1_score, test_metrics_df_2['F1-Score'][i], test_metrics_df_3['F1-Score'][i], test_metrics_df_reload_1['F1-Score'][i]) else "", color="black", end="")
    print_colored(f"   Precision: {precision:<10.4f}", bg_color="blue" if precision == max(precision, test_metrics_df_2['Precision'][i], test_metrics_df_3['Precision'][i], test_metrics_df_reload_1['Precision'][i]) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_1:<10.4f}", "black")

    # Secondo Modello
    print_colored(f"   Secondo   Modello:".ljust(10), "red", end="")
    accuracy_2 = test_metrics_df_2['Accuracy'][i]
    f1_score_2 = test_metrics_df_2['F1-Score'][i]
    precision_2 = test_metrics_df_2['Precision'][i]
    print_colored(f"   Accuracy: {accuracy_2:<10.4f} ", bg_color="blue" if accuracy_2 == max(accuracy, accuracy_2, test_metrics_df_3['Accuracy'][i], test_metrics_df_reload_1['Accuracy'][i]) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score_2:<10.4f} ", bg_color="blue" if f1_score_2 == max(f1_score, f1_score_2, test_metrics_df_3['F1-Score'][i], test_metrics_df_reload_1['F1-Score'][i]) else "", color="black", end="")
    print_colored(f"   Precision: {precision_2:<10.4f}", bg_color="blue" if precision_2 == max(precision, precision_2, test_metrics_df_3['Precision'][i], test_metrics_df_reload_1['Precision'][i]) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_1:<10.4f}", "black")

    # Terzo Modello
    print_colored(f"   Terzo     Modello:".ljust(10), "red", end="")
    accuracy_3 = test_metrics_df_3['Accuracy'][i]
    f1_score_3 = test_metrics_df_3['F1-Score'][i]
    precision_3 = test_metrics_df_3['Precision'][i]
    print_colored(f"   Accuracy: {accuracy_3:<10.4f} ", bg_color="blue" if accuracy_3 == max(accuracy, accuracy_2, accuracy_3, test_metrics_df_reload_1['Accuracy'][i]) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score_3:<10.4f} ", bg_color="blue" if f1_score_3 == max(f1_score, f1_score_2, f1_score_3, test_metrics_df_reload_1['F1-Score'][i]) else "", color="black", end="")
    print_colored(f"   Precision: {precision_3:<10.4f}", bg_color="blue" if precision_3 == max(precision, precision_2, precision_3, test_metrics_df_reload_1['Precision'][i]) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_3:<10.4f}", "black")

    # Quarto Modello
    print_colored(f"   Quarto    Modello:".ljust(10), "red", end="")
    accuracy_reload_1 = test_metrics_df_reload_1['Accuracy'][i]
    f1_score_reload_1 = test_metrics_df_reload_1['F1-Score'][i]
    precision_reload_1 = test_metrics_df_reload_1['Precision'][i]
    print_colored(f"   Accuracy: {accuracy_reload_1:<10.4f} ", bg_color="blue" if accuracy_reload_1 == max(accuracy, accuracy_2, accuracy_3, test_metrics_df_reload_1['Accuracy'][i]) else "", color="black", end="")
    print_colored(f"   F1-Score: {f1_score_reload_1:<10.4f} ", bg_color="blue" if f1_score_reload_1 == max(f1_score, f1_score_2, f1_score_3, f1_score_reload_1) else "", color="black", end="")
    print_colored(f"   Precision: {precision_reload_1:<10.4f}", bg_color="blue" if precision_reload_1 == max(precision, precision_2, precision_3, precision_reload_1) else "", color="black", end="")
    print_colored(f"   Global Accuracy: {global_accuracy_reload_1:<10.4f}\n", "black")
Codice
for i, category in enumerate(categories):
    print_colored(f"Categoria {category}\n".ljust(16), "blue", end="")
    
    # Primo Modello
    print_colored(f"   Primo     Modello:".ljust(10), "red", end="")
    accuracy = test_metrics_df['Accuracy'][i]
    f1_score = test_metrics_df['F1-Score'][i]
    precision = test_metrics_df['Precision'][i]
    
    print_colored(
        f"   Accuracy: {accuracy:<10.4f} ",
        bg_color="blue" if accuracy == max(accuracy, test_metrics_df_2['Accuracy'][i], test_metrics_df_3['Accuracy'][i], test_metrics_df_reload_1['Accuracy'][i]) else "",
        color="white" if accuracy == max(accuracy, test_metrics_df_2['Accuracy'][i], test_metrics_df_3['Accuracy'][i], test_metrics_df_reload_1['Accuracy'][i]) else "black",
        end=""
    )
    print_colored(
        f"   F1-Score: {f1_score:<10.4f} ",
        bg_color="blue" if f1_score == max(f1_score, test_metrics_df_2['F1-Score'][i], test_metrics_df_3['F1-Score'][i], test_metrics_df_reload_1['F1-Score'][i]) else "",
        color="white" if f1_score == max(f1_score, test_metrics_df_2['F1-Score'][i], test_metrics_df_3['F1-Score'][i], test_metrics_df_reload_1['F1-Score'][i]) else "black",
        end=""
    )
    print_colored(
        f"   Precision: {precision:<10.4f}",
        bg_color="blue" if precision == max(precision, test_metrics_df_2['Precision'][i], test_metrics_df_3['Precision'][i], test_metrics_df_reload_1['Precision'][i]) else "",
        color="white" if precision == max(precision, test_metrics_df_2['Precision'][i], test_metrics_df_3['Precision'][i], test_metrics_df_reload_1['Precision'][i]) else "black",
        end=""
    )
    print_colored(f"   Global Accuracy: {global_accuracy_1:<10.4f}", "black")

   
    
    
   
    
    # Secondo Modello
    print_colored(f"   Secondo   Modello:".ljust(10), "red", end="")
    accuracy_2 = test_metrics_df_2['Accuracy'][i]
    f1_score_2 = test_metrics_df_2['F1-Score'][i]
    precision_2 = test_metrics_df_2['Precision'][i]
    
    print_colored(
        f"   Accuracy: {accuracy_2:<10.4f} ",
        bg_color="blue" if accuracy_2 == max(accuracy, accuracy_2, test_metrics_df_3['Accuracy'][i], test_metrics_df_reload_1['Accuracy'][i]) else "",
        color="white" if accuracy_2 == max(accuracy, accuracy_2, test_metrics_df_3['Accuracy'][i], test_metrics_df_reload_1['Accuracy'][i]) else "black",
        end=""
    )
    print_colored(
        f"   F1-Score: {f1_score_2:<10.4f} ",
        bg_color="blue" if f1_score_2 == max(f1_score, f1_score_2, test_metrics_df_3['F1-Score'][i], test_metrics_df_reload_1['F1-Score'][i]) else "",
        color="white" if f1_score_2 == max(f1_score, f1_score_2, test_metrics_df_3['F1-Score'][i], test_metrics_df_reload_1['F1-Score'][i]) else "black",
        end=""
    )
    print_colored(
        f"   Precision: {precision_2:<10.4f}",
        bg_color="blue" if precision_2 == max(precision, precision_2, test_metrics_df_3['Precision'][i], test_metrics_df_reload_1['Precision'][i]) else "",
        color="white" if precision_2 == max(precision, precision_2, test_metrics_df_3['Precision'][i], test_metrics_df_reload_1['Precision'][i]) else "black",
        end=""
    )
    print_colored(f"   Global Accuracy: {global_accuracy_1:<10.4f}", "black")

   
    
    
    
    
    # Terzo Modello
    print_colored(f"   Terzo     Modello:".ljust(10), "red", end="")
    accuracy_3 = test_metrics_df_3['Accuracy'][i]
    f1_score_3 = test_metrics_df_3['F1-Score'][i]
    precision_3 = test_metrics_df_3['Precision'][i]
   
    print_colored(
        f"   Accuracy: {accuracy_3:<10.4f} ",
        bg_color="blue" if accuracy_3 == max(accuracy, accuracy_2, accuracy_3, test_metrics_df_reload_1['Accuracy'][i]) else "",
        color="white" if accuracy_3 == max(accuracy, accuracy_2, accuracy_3, test_metrics_df_reload_1['Accuracy'][i]) else "black",
        end=""
    )
    print_colored(
        f"   F1-Score: {f1_score_3:<10.4f} ",
        bg_color="blue" if f1_score_3 == max(f1_score, f1_score_2, f1_score_3, test_metrics_df_reload_1['F1-Score'][i]) else "",
        color="white" if f1_score_3 == max(f1_score, f1_score_2, f1_score_3, test_metrics_df_reload_1['F1-Score'][i]) else "black",
        end=""
    )
    print_colored(
        f"   Precision: {precision_3:<10.4f}",
        bg_color="blue" if precision_3 == max(precision, precision_2, precision_3, test_metrics_df_reload_1['Precision'][i]) else "",
        color="white" if precision_3 == max(precision, precision_2, precision_3, test_metrics_df_reload_1['Precision'][i]) else "black",
        end=""
    )
    print_colored(f"   Global Accuracy: {global_accuracy_3:<10.4f}", "black")

   
    
    
    
    
    # Quarto Modello
    print_colored(f"   Quarto    Modello:".ljust(10), "red", end="")
    accuracy_reload_1 = test_metrics_df_reload_1['Accuracy'][i]
    f1_score_reload_1 = test_metrics_df_reload_1['F1-Score'][i]
    precision_reload_1 = test_metrics_df_reload_1['Precision'][i]
    
    print_colored(
        f"   Accuracy: {accuracy_reload_1:<10.4f} ",
        bg_color="blue" if accuracy_reload_1 == max(accuracy, accuracy_2, accuracy_3, test_metrics_df_reload_1['Accuracy'][i]) else "",
        color="white" if accuracy_reload_1 == max(accuracy, accuracy_2, accuracy_3, test_metrics_df_reload_1['Accuracy'][i]) else "black",
        end=""
    )
    print_colored(
        f"   F1-Score: {f1_score_reload_1:<10.4f} ",
        bg_color="blue" if f1_score_reload_1 == max(f1_score, f1_score_2, f1_score_3, f1_score_reload_1) else "",
        color="white" if f1_score_reload_1 == max(f1_score, f1_score_2, f1_score_3, f1_score_reload_1) else "black",
        end=""
    )
    print_colored(
        f"   Precision: {precision_reload_1:<10.4f}",
        bg_color="blue" if precision_reload_1 == max(precision, precision_2, precision_3, precision_reload_1) else "",
        color="white" if precision_reload_1 == max(precision, precision_2, precision_3, precision_reload_1) else "black",
        end=""
    )
    print_colored(f"   Global Accuracy: {global_accuracy_reload_1:<10.4f}\n", "black")
Codice
# Carico il modello salvato
model = tf.keras.models.load_model('anti_hater_model_stratify_400_128_6__1.keras')
Codice
# Carico il tokenizer
with open('tokenizer.pickle', 'rb') as handle:
    tokenizer = pickle.load(handle)
Codice
def analyze_comment(comment, max_length=400):
    # Pre-processo il commento
    tokenized_sequence = tokenizer.texts_to_sequences([comment]) 
    padded_sequence = pad_sequences(tokenized_sequence, maxlen=max_length, padding='post') 

    prediction = model.predict(padded_sequence)

    results = {category: prob for category, prob in zip(categories, prediction[0])}

    return results
Codice
# Esempio di utilizzo
comment = "You are a stupid person!"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "Your content on Instagram sucks, if I catch you on the street I will insult you"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "You are beautiful"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = """Well done, if you combine your passion for images with knowledge of programming and data science, 
you could develop highly sought-after skills. "
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = """Let's look at an example that shows how quantum computers can succeed where classical computers fail:
A classical computer might be great for difficult tasks like sorting a large database of molecules. 
But it struggles to solve more complex problems, such as simulating the behavior of those molecules.Today, 
if scientists want to know how a molecule behaves, they must synthesize it and experiment with it in the real world. 
If they want to know how a small change affects its behavior, they usually have to synthesize the new version and 
repeat the experiment. This is a costly and time-consuming process that impedes progress in fields as diverse as 
medicine and semiconductor design."""
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "You're ridiculous"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "Son of a bitch"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "You ugly nigger bastard"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "I'm busy with work and I can't travel, but thanks to your travels I feel like I'm there, you make me dream."
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = """I organized this trip following the advice in your article, thanks for the wonderful places you made me 
discover.!!!!!!!!"""
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = """With that look you are obscene, you should work in a red light TV instead of making travel videos, 
shame on you.!!!!!!!!"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "Don't write nonsense, go to work and get a serious job!"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "Don't write nonsense, go to work and get a serious job bitch"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "You are a great person and you bring really interesting and wonderful content. Thanks for what you do"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "Next time I meet you on the street I will stab you"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "Next time I meet you on the street I'll kill you"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
# Esempio di utilizzo
comment = "I want to offer you a coffee"
Codice
results = analyze_comment(comment)
Codice
print_colored("Analisi del commento:", "blue")
for category, prob in results.items():
    print(f"{category}: {prob:.4f}")
Codice
fig, ax = plt.subplots(figsize=(12, 12))

# Colori pastello
colors = {
    "yellow": "#f8f32b",  
    "purple": "#899ad5",   
    "blu": "#00aaff"    
}

# Posizioni dei cerchi
nodes = {
    'x1': (1, 5),
    'x2': (1, 3),
    'xn': (1, 1),
    'Neurone 1': (4, 5),
    'Neurone 2': (4, 3),
    'Neurone 3': (4, 1),
    'Neurone 4': (7, 5),
    'Neurone 5': (7, 3),
    'Neurone 6': (7, 1),
    'y': (10, 3)
}

# Nodi
for label, (x, y) in nodes.items():
    if "Neurone" in label:  # Colorare i neuroni da 1 a 6 in rosso pastello
        color = colors["purple"]
    elif label == 'y':  # Colorare il nodo di output in verde pastello
        color = colors["blu"]
    else:  # Colorare gli input in giallo pastello
        color = colors["yellow"]
    circle = plt.Circle((x, y), 0.5, color=color, zorder=2)
    ax.add_patch(circle)
    ax.text(x, y, label, fontsize=10, ha='center', va='center', zorder=3)

# Tre pallini sotto il nodo x2
dots_x2 = [(1, 2.2), (1, 1.95), (1, 1.7)]  # Posizioni dei pallini
for x, y in dots_x2:
    circle = plt.Circle((x, y), 0.05, color='black', zorder=2) 
    ax.add_patch(circle)

connections = [
    ('x1', 'Neurone 1'), ('x1', 'Neurone 2'), ('x1', 'Neurone 3'),
    ('x2', 'Neurone 1'), ('x2', 'Neurone 2'), ('x2', 'Neurone 3'),
    ('xn', 'Neurone 1'), ('xn', 'Neurone 2'), ('xn', 'Neurone 3'),
    ('Neurone 1', 'Neurone 4'), ('Neurone 1', 'Neurone 5'), ('Neurone 1', 'Neurone 6'),
    ('Neurone 2', 'Neurone 4'), ('Neurone 2', 'Neurone 5'), ('Neurone 2', 'Neurone 6'),
    ('Neurone 3', 'Neurone 4'), ('Neurone 3', 'Neurone 5'), ('Neurone 3', 'Neurone 6'),
    ('Neurone 4', 'y'), ('Neurone 5', 'y'), ('Neurone 6', 'y')
]
weights = {
    ('x1', 'Neurone 1'): 'w1', ('x1', 'Neurone 2'): 'w2', ('x1', 'Neurone 3'): 'w3',
    ('x2', 'Neurone 1'): 'w4', ('x2', 'Neurone 2'): 'w5', ('x2', 'Neurone 3'): 'w6',
    ('xn', 'Neurone 1'): 'w7', ('xn', 'Neurone 2'): 'w8', ('xn', 'Neurone 3'): 'w9',
    ('Neurone 1', 'Neurone 4'): 'w10', ('Neurone 1', 'Neurone 5'): 'w11', ('Neurone 1', 'Neurone 6'): 'w12',
    ('Neurone 2', 'Neurone 4'): 'w13', ('Neurone 2', 'Neurone 5'): 'w14', ('Neurone 2', 'Neurone 6'): 'w15',
    ('Neurone 3', 'Neurone 4'): 'w16', ('Neurone 3', 'Neurone 5'): 'w17', ('Neurone 3', 'Neurone 6'): 'w18',
    ('Neurone 4', 'y'): 'w19', ('Neurone 5', 'y'): 'w20', ('Neurone 6', 'y'): 'w21'
}

for start, end in connections:
    x_start, y_start = nodes[start]
    x_end, y_end = nodes[end]
    
    # Freccia
    ax.annotate(
        '', xy=(x_end, y_end), xytext=(x_start, y_start),
        arrowprops=dict(arrowstyle="->", color='black', lw=1.5), zorder=1
    )
    
    # Angolo di inclinazione della linea
    dx = x_end - x_start
    dy = y_end - y_start
    angle = np.degrees(np.arctan2(dy, dx))
    
    # Weights
    if (start, end) in weights:
        label_x = x_start + dx * 0.68 
        label_y = y_start + dy * 0.70
        ax.text(label_x, label_y, weights[(start, end)], fontsize=14, color='black', 
                rotation=angle+1, rotation_mode='anchor') 

ax.set_xlim(0, 11)
ax.set_ylim(0, 6)
ax.set_aspect('equal')
ax.axis('off')

plt.show()