Pikabu-Datensatz

Es wird empfohlen, den Datensatz der Beiträge von pikabu.ru unter dem Gesichtspunkt der Datenstatistik zu betrachten. Der Datensatz selbst, der aus 450 Teilen besteht, wird von den besten Parsern rund um die Uhr zusammengestellt, mit Parfums verarbeitet, die doppelte Artikel entfernen, und mit zusätzlichen Spalten gefüllt, deren Bedeutung nur den Eingeweihten zur Verfügung steht. Hier ist der Datensatz selbst weniger interessant als der Ansatz zur Analyse solcher Websites. In den nächsten Beiträgen werden wir versuchen, Elemente aus dem maschinellen Lernen zur Analyse anzuwenden.







Sie können mit dem Datensatz sowohl in normalem Excel als auch in Jupyter Notebook arbeiten. Datenfelder sind durch Tabulatoren getrennt. Wir werden uns auf die letzte Option konzentrieren, und alle Befehle werden unter Berücksichtigung der Tatsache gegeben, dass die Arbeit in einem Jupyter-Notizbuch ausgeführt wird.



Wir werden in Fenstern arbeiten. Verwenden Sie daher cmd, um zu dem Ordner mit dem heruntergeladenen Datensatz zu wechseln und jupyter notebook mit dem gleichnamigen Befehl auszuführen .



Als nächstes importieren wir die Module.

import pandas as pd
import numpy as np

Da das Dataset keine Header enthält, legen Sie diese vor dem Laden des Datasets fest:

headers=['story_title','link','story_id','data_rating','data_timestamp','story_comments','data_author_id','data_meta_rating','user_name','user_link','story__community_link']

Hier ist alles klar: Titel des Artikels, Link dazu, Artikel-ID, Bewertung (Anzahl der Pluspunkte), Artikel-Datum, Anzahl der Kommentare, Autoren-ID, Artikel-Meta-Bewertung, Autorenname, Link zum Autor, Link zur Community.



Wir zählen den Datensatz.

df = pd.read_csv('400k-pikabu.csv',parse_dates=['data_timestamp'],
                   warn_bad_lines=True,
                   index_col = False,                   
                   dtype ={'story_title':'object','link':'object','story_id':'float32','data_rating':'float32',
                   'story_comments':'float32','data_author_id':'float32'},
                   delimiter='\t',names=headers)

Hier ist eine leichte Optimierung der Lesewerte, sodass einige Spalten als numerisch angezeigt werden.



Der Datensatz repräsentiert also 468.595 Zeilen, 11 Spalten.

print(df.shape)#468595 ,11 

Erste 5 Datensätze

df.head(5)

Statistische Beschreibung:

df.describe()

Arbeiten mit leeren Werten in einem Datensatz

Trotz der Tatsache, dass die Parser unermüdlich arbeiteten, gibt es kleine Löcher im Datensatz, dh technologische Löcher, die durch Lücken dargestellt werden. Diese Lücken in Pandas haben den Wert NaN. Sehen wir uns die Anzahl der Zeilen mit solchen Hohlräumen an:

len(df.loc[pd.isnull( df['story_title'])])

Wie es auf dem Datensatz aussieht:

df.loc[pd.isnull( df['story_title'])]

1444 Zeilen mit Lücken beeinträchtigen das Gesamtbild nicht, aber lassen Sie uns sie trotzdem loswerden:

data1=df.dropna(axis=0, thresh=5)

Wir überprüfen, ob der Löschvorgang erfolgreich war:

len(data1.loc[pd.isnull(data1['story_id'])]) 

Lassen Sie uns mit dem Datensatz arbeiten

Sehen wir uns die Spaltennamen an

df.columns

Wählen wir die erste Spalte aus

col = df['story_title']
col

Schauen wir uns das Minimum im Datensatz an

data1.min()

Maximal

data1.max()

Das gleiche ist visueller:

data1.loc[:,['user_name', 'data_rating', 'story_comments']].min()

Sammeln wir nun die Werte aus den interessanten Spalten in einem Array:

arr = data1[['story_id', 'data_rating', 'data_timestamp','user_name']].values

Sie können sich eine der Spalten des Arrays ansehen:

arr[:, 1] # 

Schauen wir uns die Anzahl der Artikel mit einer Bewertung von über 10.000 an:

print((arr[:, 1] > 10000.0).sum())

Nur 2672 Artikel haben eine ultrahohe Bewertung von 450.000

Zeichnen wir Diagramme

Importieren wir zunächst das Modul:

import matplotlib.pyplot as plt

Lassen Sie uns herausfinden, ob es einen Zusammenhang zwischen der ID des Autors des Artikels und der Bewertung des Artikels gibt.

plt.scatter(data1['data_author_id'], data1['data_rating'])
plt.xlabel('data_author_id') 
plt.ylabel('data_rating')

Aufgrund der großen Datenmenge ist es schwierig, die Beziehung zu erfassen, und höchstwahrscheinlich fehlt sie.



Gibt es einen Zusammenhang zwischen Artikel-ID und Artikelbewertung?

plt.scatter(data1['story_id'], data1['data_rating'])
plt.xlabel('story_id') 
plt.ylabel('data_rating')

Hier fällt auf, dass Beiträge mit einer höheren Anzahl (spätere Beiträge) eine höhere Bewertung erhalten und häufiger gewählt werden. Wird die Ressource immer beliebter?



Gibt es einen Zusammenhang zwischen dem Datum des Artikels und der Bewertung?

plt.scatter(data1['data_timestamp'], data1['data_rating'])
plt.xlabel('data_timestamp') 
plt.ylabel('data_rating')

Sie können auch die Beziehung zwischen späteren Posts und dem Post-Rank sehen. Bessere Inhalte oder wiederum nur eine Steigerung des Website-Verkehrs?



Gibt es einen Zusammenhang zwischen der Bewertung eines Artikels und der Anzahl der Kommentare dazu?

plt.scatter(data1['story_comments'], data1['data_rating'])
plt.xlabel('story_comments') 
plt.ylabel('data_rating')

Hier besteht eine lineare Beziehung, obwohl sie stark gestreut ist. Es gibt eine bestimmte Logik: Je höher die Bewertung des Beitrags, desto mehr Kommentare.



Werfen wir einen Blick auf die Top-Autoren (Autoren mit den höchsten Gesamtbewertungen):

top_users_df = data1.groupby('user_name')[['data_rating']].sum().sort_values('data_rating', ascending=False).head(10)   
top_users_df

Fügen wir Klarheit hinzu:

top_users_df.style.bar()

Probieren wir andere Visualisierungstools aus. Zum Beispiel Seaborn

#   
 ! pip3 install seaborn
from __future__ import (absolute_import, division,
                        print_function, unicode_literals)
#  
import warnings
warnings.simplefilter('ignore')

#      jupyter'e
%pylab inline
#  svg   
%config InlineBackend.figure_format = 'svg' 

#  
from pylab import rcParams
rcParams['figure.figsize'] = 6,3
import seaborn as sns

Lassen Sie uns Diagramme mit Spalten mit Post-ID, deren Bewertung und Kommentaren erstellen und das Ergebnis in .png speichern:

%config InlineBackend.figure_format = 'png' 
sns_plot = sns.pairplot(data1[['story_id', 'data_rating', 'story_comments']]);
sns_plot.savefig('pairplot.png')

Probieren wir das Plotly-Visualisierungstool aus

from plotly.offline import init_notebook_mode, iplot
import plotly
import plotly.graph_objs as go
init_notebook_mode(connected=True)

Gruppieren wir die Daten nach Datum und Gesamtbewertung der Artikel für dieses Datum:

df2 = data1.groupby('data_timestamp')[['data_rating']].sum()
df2.head()

Mal sehen, wie viele Artikel an einem bestimmten Datum (Monat) veröffentlicht wurden:

released_stories = data1.groupby('data_timestamp')[['story_id']].count()
released_stories.head()

Kleben wir zwei Tabellen:

years_df = df2.join(released_stories)
years_df.head()

Zeichnen wir nun mit plotly:

trace0 = go.Scatter(
    x=years_df.index,
    y=years_df.data_rating,
    name='data_rating'
)
trace1 = go.Scatter(
    x=years_df.index,
    y=years_df.story_id,
    name='story_id'
)
data = [trace0, trace1]
layout = {'title': 'Statistics'}
fig = go.Figure(data=data, layout=layout)
iplot(fig, show_link=False)

Das Schöne an Plotly ist seine Interaktivität. In diesem Fall zeigt die Grafik beim Hover die Gesamtbewertung der Artikel für ein bestimmtes Datum (Monat). Es ist ersichtlich, dass die Bewertung im Jahr 2020 gesunken ist. Dies kann jedoch durch die Tatsache erklärt werden, dass die Anzahl der Artikel aus diesem Intervall von den Parsern nicht ausreichend erfasst wurde, sowie durch die Tatsache, dass die Beiträge noch nicht genügend Pluspunkte erhalten haben.



Am unteren Rand des Diagramms zeigt eine rote Linie auch interaktiv die Anzahl der eindeutigen Artikel für ein bestimmtes Datum.



Speichern wir das Diagramm als HTML-Datei.

plotly.offline.plot(fig, filename='stats_pikabu.html', show_link=False);

Datengruppierungen

Mal sehen, wie viele Autoren im Datensatz sind:

data1.groupby('user_name').size()

Wie viele Artikel pro Autor:

data1['user_name'].value_counts()

Wer schreibt am häufigsten (mehr als 500 Artikel):

for i in data1.groupby('user_name').size():
    if i>500:        
        print (data1.iloc[i,8],i) #8-   user_name

Das ist es also, der die Ressource "verstopft". Es gibt nicht so viele von ihnen:





Mal sehen, wie viele Communities sich insgesamt auf der Ressource befinden:

data1.groupby('story__community_link').size() 

Und welches ist das produktivste:

data1['story__community_link'].value_counts()

* Die Daten über die Community sind nicht ganz korrekt, da die zuerst erwähnte Community während des Parsens gesammelt wurde und die Autoren häufig mehrere Teile angeben.



Lassen Sie uns abschließend sehen, wie Sie die Funktion mit der Ausgabe des Ergebnisses in einer separaten Spalte anwenden .



Dies wird für die weitere Untersuchung des Datensatzes benötigt.



Einfache Funktion zum Zuweisen der Bewertung eines Artikels zu einer Gruppe.



Wenn die Bewertung mehr als <5000 - schlecht,> 5000 - gut ist.

def ratingGroup( row ):
    # ,      NaN
    if not pd.isnull( row['data_rating'] ):
        if row['data_rating'] <= 5000:
            return 'bad'
        if row['data_rating'] >= 20000:
            return 'good'        
    
    #    NaN,   Undef
    return 'Undef'

Wenden wir die Funktion ratioGroup auf den DataFrame an und zeigen das Ergebnis in einer separaten Spalte -ratingGroup an

data1['ratingGroup'] = data1.apply( ratingGroup, axis = 1 )
data1.head(10)

Im Datensatz wird eine neue Spalte mit den folgenden Werten







angezeigt : Download - Datensatz .



Laden Sie einen nicht gereinigten Datensatz herunter, um Duplikate selbst zu bereinigen - einen Datensatz .



* Python bereinigt (entfernt doppelte Zeilen basierend auf der Artikel-ID) für fast eine Stunde! Wenn jemand den Code in C ++ umschreibt, bin ich dankbar!

with open('f-final-clean-.txt','a',encoding='utf8',newline='') as f:
    for line in my_lines:
        try:
            b=line.split("\t")[2]
            if b in a:        
                pass
            else:
                a.append(b)            
                f.write(line)            
        except:
            print(line)

Die Frage wird entfernt, tk. unerwartet) hat ein Wörterbuch in Python gefunden, das zehnmal schneller funktioniert:

a={}
f = open("f-final.txt",'r',encoding='utf8',newline='')
f1 = open("f-final-.txt",'a',encoding='utf8',newline='') 
for line in f.readlines():
    try:            
        b=line.split("\t")[2]
        if b in a:        
            pass
        else:
            a[b]=b
            #print (a[b])
            f1.write(line) 
    except:
        pass
f.close()
f1.close()

Jupyter Notebook - herunterladen .