Update app.py

app.py

@@ -1,133 +1,183 @@
-import gradio as gr
 import pandas as pd
-import numpy as np
-import plotly.express as px
-from itertools import combinations
-from collections import Counter
-
-# Caricamento del dataset
-file_path = 'sa-dataset.csv'  # Assumiamo che il dataset sia nella stessa cartella
-df = pd.read_csv(file_path)
-df['anno_pubblicazione'] = pd.to_numeric(df['anno_pubblicazione'], errors='coerce')
-df['num_parole'] = pd.to_numeric(df['num_parole'], errors='coerce')
-
-# Funzione per calcolare la co-occorrenza delle parole chiave
-def calcola_cooccorrenza_keywords(top_n=30):
-    keywords_list = df['keyword'].dropna().str.split(', ')
-    all_keywords = [kw for sublist in keywords_list for kw in sublist]
-    common_keywords = Counter(all_keywords).most_common(top_n)
-    common_keywords = [kw[0] for kw in common_keywords]
-
-    cooccurrence = Counter()
-    for keywords in keywords_list:
-        filtered_keywords = [kw for kw in keywords if kw in common_keywords]
-        cooccurrence.update(combinations(sorted(filtered_keywords), 2))
-
-    co_matrix = pd.DataFrame(np.zeros((len(common_keywords), len(common_keywords))), 
-                             index=common_keywords, columns=common_keywords)
-    for (kw1, kw2), count in cooccurrence.items():
-        co_matrix.loc[kw1, kw2] = count
-        co_matrix.loc[kw2, kw1] = count
-
-    return px.imshow(co_matrix, x=co_matrix.columns, y=co_matrix.index, 
-                     color_continuous_scale='Blues', labels=dict(color="Co-occorrenza"),
-                     title="Mappa di Co-occorrenza delle Parole Chiave")
-
-# Funzione per calcolare il trend delle keyword
-def calcola_trend_keyword(top_n=10):
-    trend_df = df[['anno_pubblicazione', 'keyword']].dropna()
-    trend_df['keyword'] = trend_df['keyword'].str.split(', ')
-    trend_df = trend_df.explode('keyword')
-    keyword_counts = trend_df['keyword'].value_counts().head(top_n).index
-    trend_df = trend_df[trend_df['keyword'].isin(keyword_counts)]
-    trend_df = trend_df.groupby(['anno_pubblicazione', 'keyword']).size().reset_index(name='count')
-
-    return px.line(trend_df, x='anno_pubblicazione', y='count', color='keyword',
-                   title='Trend Temporale delle Keyword',
-                   labels={'anno_pubblicazione': 'Anno', 'count': 'Frequenza'})
-
-# Funzione per calcolare la produttività degli autori
-def produttivita_autori_mod(top_n=15, min_articoli=5):
-    autori_df = df[['anno_pubblicazione', 'primo_autore']].dropna()
-    total_counts = autori_df['primo_autore'].value_counts()
-    autori_eligible = total_counts[total_counts > min_articoli]
-    top_authors = autori_eligible.head(top_n).index
-    filtered_df = autori_df[autori_df['primo_autore'].isin(top_authors)]
-    produttivita = filtered_df.groupby(['anno_pubblicazione', 'primo_autore']).size().reset_index(name='conteggio')
-
-    return px.line(produttivita, x='anno_pubblicazione', y='conteggio', color='primo_autore',
-                   title="Produttività degli Autori (Top 15 con >5 articoli)",
-                   labels={'anno_pubblicazione': 'Anno', 'conteggio': 'Numero di Articoli'})
-
-# Funzione per calcolare la frequenza dei luoghi citati
-def frequenza_luoghi(top_n=10):
-    luoghi_df = df[['anno_pubblicazione', 'luoghi_citati']].dropna()
-    luoghi_df['luoghi_citati'] = luoghi_df['luoghi_citati'].str.split(', ')
-    luoghi_df = luoghi_df.explode('luoghi_citati')
-    luoghi_counts = luoghi_df['luoghi_citati'].value_counts().head(top_n).index
-    luoghi_df = luoghi_df[luoghi_df['luoghi_citati'].isin(luoghi_counts)]
-    luoghi_df = luoghi_df.groupby(['anno_pubblicazione', 'luoghi_citati']).size().reset_index(name='conteggio')
-
-    return px.line(luoghi_df, x='anno_pubblicazione', y='conteggio', color='luoghi_citati',
-                   title="Frequenza dei Luoghi nel Tempo",
-                   labels={'anno_pubblicazione': 'Anno', 'conteggio': 'Frequenza'})
-
-# Funzioni per grafici aggiuntivi
-def numero_parole_per_articolo():
-    return px.histogram(df, x='num_parole', title='Distribuzione del Numero di Parole per Articolo',
-                        nbins=50, labels={'num_parole': 'Numero di Parole', 'count': 'Numero di Articoli'},
-                        template='plotly')
-
-def distribuzione_per_anno():
-    return px.histogram(df, x='anno_pubblicazione', title='Distribuzione degli Articoli per Anno di Pubblicazione',
-                        nbins=50, labels={'anno_pubblicazione': 'Anno di Pubblicazione', 'count': 'Numero di Articoli'},
-                        template='plotly')
-
-def distribuzione_per_lingua():
-    return px.pie(df, names='lingua', title='Distribuzione degli Articoli per Lingua', template='plotly')
-
-# **NUOVI GRAFICI AGGIUNTI**
-def distribuzione_articoli_per_autore():
-    return px.histogram(df, x='primo_autore', title='Distribuzione del Numero di Articoli per Autore',
-                        nbins=50, labels={'primo_autore': 'Autore', 'count': 'Numero di Articoli'},
-                        template='plotly')
-
-def evoluzione_articoli_per_anno():
-    conteggio_annuale = df['anno_pubblicazione'].value_counts().reset_index()
-    conteggio_annuale.columns = ['anno_pubblicazione', 'conteggio']
-    return px.line(conteggio_annuale, x='anno_pubblicazione', y='conteggio',
-                   title='Evoluzione Temporale del Numero di Articoli Pubblicati',
-                   labels={'anno_pubblicazione': 'Anno', 'conteggio': 'Numero di Articoli'})
-
-def lunghezza_media_articoli_per_anno():
-    lunghezza_media = df.groupby('anno_pubblicazione')['num_parole'].mean().reset_index()
-    return px.line(lunghezza_media, x='anno_pubblicazione', y='num_parole',
-                   title='Lunghezza Media degli Articoli per Anno',
-                   labels={'anno_pubblicazione': 'Anno', 'num_parole': 'Lunghezza Media (Parole)'})
-
-# **Creazione interfaccia Gradio**
-with gr.Blocks() as app:
-    gr.Markdown("## Dashboard per l'Analisi degli Articoli di Storia dell'Arte")
-
-    with gr.Row():
-        cooccorrenza = gr.Plot(label="Co-occorrenza delle Parole Chiave")
-        trend = gr.Plot(label="Trend Temporale delle Keyword")
-
-    with gr.Row():
-        produttivita = gr.Plot(label="Produttività degli Autori")
-        distribuzione_autori = gr.Plot(label="Distribuzione del Numero di Articoli per Autore")
-
-    with gr.Row():
-        evoluzione_articoli = gr.Plot(label="Evoluzione del Numero di Articoli Pubblicati")
-        lunghezza_media = gr.Plot(label="Lunghezza Media degli Articoli per Anno")
-
-    btn = gr.Button("Genera Grafici")
-    btn.click(lambda: (calcola_cooccorrenza_keywords(), calcola_trend_keyword(), produttivita_autori_mod(),
-                        frequenza_luoghi(), numero_parole_per_articolo(), distribuzione_per_anno(),
-                        distribuzione_per_lingua(), distribuzione_articoli_per_autore(), 
-                        evoluzione_articoli_per_anno(), lunghezza_media_articoli_per_anno()),
-              inputs=[], outputs=[cooccorrenza, trend, produttivita, distribuzione_autori, 
-                                  evoluzione_articoli, lunghezza_media])
+import matplotlib.pyplot as plt
+import gradio as gr
+from io import BytesIO
+
+def load_dataset():
+    """
+    Carica il dataset dal file CSV.
+    """
+    df = pd.read_csv("sa-dataset.csv")
+    return df
+
+def genera_grafici():
+    """
+    Elabora il dataset e genera una serie di grafici secondo le specifiche richieste.
+    Viene restituita una lista di immagini in formato bytes.
+    """
+    df = load_dataset()
+
+    # Verifica e conversione dei dati in formato stringa per le colonne testuali
+    df["articolo"] = df["articolo"].astype(str)
+    df["keyword"] = df["keyword"].astype(str)
+    df["luoghi"] = df["luoghi"].astype(str)
+    
+    # Calcolo del numero di parole per articolo
+    df["parole"] = df["articolo"].apply(lambda x: len(x.split()))
+    
+    immagini = []  # Lista per salvare le immagini dei grafici
+
+    # 1. Lunghezza media di articoli per anno
+    df_media = df.groupby("anno")["parole"].mean().sort_index()
+    plt.figure()
+    df_media.plot(kind="bar")
+    plt.title("Lunghezza media di articoli per anno")
+    plt.xlabel("Anno")
+    plt.ylabel("Numero medio di parole")
+    buf = BytesIO()
+    plt.tight_layout()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 2. Trend delle keyword per anno
+    # Suddivide la colonna 'keyword' in una lista di parole chiave
+    df["keyword_list"] = df["keyword"].apply(lambda x: [k.strip() for k in x.split(",") if k.strip() != ""])
+    df_keywords = df.explode("keyword_list")
+    # Calcola la frequenza delle keyword per anno
+    keyword_year = df_keywords.groupby(["anno", "keyword_list"]).size().reset_index(name="count")
+    # Seleziona le 5 keyword più frequenti complessivamente
+    top_keywords = df_keywords["keyword_list"].value_counts().head(5).index.tolist()
+    keyword_year_top = keyword_year[keyword_year["keyword_list"].isin(top_keywords)]
+    pivot = keyword_year_top.pivot(index="anno", columns="keyword_list", values="count").fillna(0).sort_index()
+    plt.figure()
+    for kw in pivot.columns:
+        plt.plot(pivot.index, pivot[kw], marker="o", label=kw)
+    plt.title("Trend delle keyword per anno")
+    plt.xlabel("Anno")
+    plt.ylabel("Frequenza")
+    plt.legend(title="Keyword")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 3. Produttività degli autori (15 autori più prolifici)
+    top15_autori = df["autore"].value_counts().head(15)
+    plt.figure()
+    top15_autori.plot(kind="bar")
+    plt.title("Produttività degli autori (15 autori più prolifici)")
+    plt.xlabel("Autore")
+    plt.ylabel("Numero di articoli")
+    plt.xticks(rotation=45, ha="right")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 4. Numero complessivo di articoli per ciascun autore
+    articoli_per_autore = df["autore"].value_counts().sort_index()
+    plt.figure()
+    articoli_per_autore.plot(kind="bar")
+    plt.title("Numero complessivo di articoli per ciascun autore")
+    plt.xlabel("Autore")
+    plt.ylabel("Numero di articoli")
+    plt.xticks(rotation=90)
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 5. Autori che hanno pubblicato più di 5 articoli
+    autori_oltre5 = df["autore"].value_counts()[df["autore"].value_counts() > 5]
+    plt.figure()
+    autori_oltre5.plot(kind="bar")
+    plt.title("Autori che hanno pubblicato più di 5 articoli")
+    plt.xlabel("Autore")
+    plt.ylabel("Numero di articoli")
+    plt.xticks(rotation=45, ha="right")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 6. Distribuzione per Lingua
+    distribuzione_lingua = df["lingua"].value_counts()
+    plt.figure()
+    distribuzione_lingua.plot(kind="pie", autopct='%1.1f%%', startangle=90)
+    plt.title("Distribuzione per Lingua")
+    plt.ylabel("")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 7. Numero di articoli per ciascun anno
+    articoli_per_anno = df["anno"].value_counts().sort_index()
+    plt.figure()
+    articoli_per_anno.plot(kind="bar")
+    plt.title("Numero di articoli per ciascun anno")
+    plt.xlabel("Anno")
+    plt.ylabel("Numero di articoli")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 8. Frequenza dei luoghi citati
+    df["luoghi_list"] = df["luoghi"].apply(lambda x: [l.strip() for l in x.split(",") if l.strip() != ""])
+    df_luoghi = df.explode("luoghi_list")
+    frequenza_luoghi = df_luoghi["luoghi_list"].value_counts().head(10)
+    plt.figure()
+    frequenza_luoghi.plot(kind="barh")
+    plt.title("Frequenza dei luoghi citati (top 10)")
+    plt.xlabel("Frequenza")
+    plt.ylabel("Luogo")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    # 9. Numero di Parole per Articolo (distribuzione)
+    plt.figure()
+    df["parole"].hist(bins=20)
+    plt.title("Distribuzione del numero di parole per articolo")
+    plt.xlabel("Numero di parole")
+    plt.ylabel("Frequenza")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    immagini.append(buf.getvalue())
+    plt.close()
+
+    return immagini
+
+# Creazione dell'interfaccia Gradio
+demo = gr.Interface(
+    fn=genera_grafici,
+    inputs=[],
+    outputs=gr.outputs.Gallery(label="Grafici dell'analisi del dataset"),
+    title="Visualizzazione Grafici del Dataset",
+    description=("Questo spazio visualizza una serie di grafici derivati dal dataset. "
+                 "Vengono mostrati, tra gli altri, la lunghezza media degli articoli per anno, il trend delle keyword, "
+                 "la produttività degli autori e la distribuzione per lingua.")
+)
 
 if __name__ == "__main__":
-    app.launch()
+    demo.launch()