[PYTHON] [Qiita API] [Statistik • Maschinelles Lernen] Ich habe versucht, die bisher veröffentlichten Artikel zusammenzufassen und zu analysieren.

Es ist ungefähr ein halbes Jahr her, seit ich angefangen habe, in Qiita zu posten, hauptsächlich für Artikel zu Statistik, maschinellem Lernen und Datenanalyse. Werfen wir einen Blick zurück auf die vorherigen Artikel mit der Qiita-API. (Im Folgenden berechnet aus den Daten vom 10. August 2015)

Wir werden uns zuerst die Daten ansehen, dann den Python-Code, der diese Inhalte generiert hat, und wie die Qiita-API von Python verwendet wird.

1. Zeigen Sie die Daten an

Nach Lager Anzahl der veröffentlichten Artikel

Sie sind unter den ersten fünf und machen 73% aus. Beliebte Artikel sind voreingenommen ... Ich persönlich mag "Die Bedeutung der Aufteilung von Brüchen, die von Pizza verstanden werden" unten, aber es ist überhaupt nicht auf Lager. : heat_smile:

Kategorisiert nach Kategorie

Ich schreibe Artikel in den Kategorien "Maschinelles Lernen", "Statistik", "Mathematik", "Datenanalyse" und "Andere".

Nach Tag

Schauen wir uns jedes Tag an. Da ich im Grunde Python verwende, ist Python die höchste Anzahl von Artikeln. In Bezug auf das Lager / Artikel-Verhältnis sind "Deep Learning", "Deep Learning" und "Chainer" überwältigend hoch. Sie können die Aufregung des tiefen Lernens in diesen Tagen sehen.

Die Aktienrate von "Mathematik" und "maschinellem Lernen" scheint relativ hoch zu sein.

In der Grafik sieht es so aus.

Stock Benutzer

Ich stellte mir vor, dass dieselbe Person viel auf Lager haben würde, aber auf den ersten Blick scheint es, dass es ziemlich viele Leute gibt. Die folgende Tabelle zeigt die Stammgäste, die gut bestückt sind. Danke: entspannt:

Es ist eine Grafik der 150 besten Benutzer mit einer großen Anzahl von Aktien. Die Anzahl der eindeutigen Benutzer betrug 1771.

Es ist ein Histogramm der Anzahl der Aktien. Es ist näher an 1 bis 5 Aktien als ich mir vorgestellt habe. Niedrige Wiederholungsrate ...: müde: In Zukunft werde ich mein Bestes geben, um Artikel zu schreiben, die wiederholt werden!

2. Erklärung des Python-Codes

Holen Sie sich Daten von der Qiita API

Das Zugriffstoken ist Qiita [Einstellungen] → [Anwendungen] → [Neues Token ausstellen] Es kann ausgestellt werden bei. Bitte setzen Sie das erworbene Token im folgenden ''.

%matplotlib inline
import requests
import json, sys
from collections import defaultdict
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('ggplot')

key = '<Zugriffstoken>'
auth_str = 'Bearer %s'%(key)
headers = {'Authorization': auth_str}
cnt = 0
data_list = []
users = defaultdict(int)

Definieren Sie eine Funktion get_stockers, um den Aktienbenutzer und die Anzahl der Aktien zu ermitteln.

# -------------------Holen Sie sich die Anzahl der Bestände für jeden Artikel-----------------------#
def get_stockers(_id):
    global headers
    url = 'https://qiita.com/api/v2/items/{}/stockers'.format(_id)
    cnt = 0
    _sum = 0
    while True:
        cnt += 1
        payload = {'page': cnt, 'per_page': 20}
        res = requests.get(url, params=payload, headers=headers)
        data = res.json()
        for d in data:
            users[d['id']] += 1
        num = len(data)
        if num == 0:
            break
        _sum += num
        
    return _sum

Verwenden Sie die folgende Schleife, um die von Ihnen veröffentlichten Artikel abzurufen, die damit verbundenen Aktienbenutzerinformationen abzurufen und in der Liste zu belassen.

# -------------------Artikelinformationserfassung-----------------------#
url = 'https://qiita.com/api/v2/authenticated_user/items'

while True:
    cnt += 1
    sys.stdout.write("{}, ".format(cnt))
    payload = {'page': cnt, 'per_page': 20}
    res = requests.get(url, params=payload, headers=headers)
    data = res.json()
    if len(data) == 0:
        break
    data_list.extend(data)

res = []

Extrahieren Sie die erforderlichen Informationen aus den erfassten Daten und organisieren Sie sie. Auch private Artikel (begrenzte gemeinsame Beiträge) sind ausgeschlossen.

# -------------------Datenformung-----------------------#
for i, d in enumerate(data_list):
    sys.stdout.write("{}, ".format(i))

    #Ausgeschlossen sind private Artikel
    if d['private'] == True:
        continue
        
    article_info = {}
    for k in ['id', 'title', 'private', 'created_at', 'tags', 'url']:
        article_info[k] = d[k]
    
    article_info['stock'] = get_stockers(d['id'])
    res.append(article_info)

Im Folgenden werden der Artikelsatz, die Anzahl der Bestände und das Verhältnis in einer Form ausgegeben, die so wie sie ist als Abschriftstabelle eingefügt werden kann.

sum_of_stocks = np.sum([r['stock'] for r in res]).astype(np.float32)

cum = 0
print "|Bestandsmenge|Prozentsatz(%)|Akkumulation(%)|Titel|"
print "|:----------:|:----------:|:----------:|:----------|"
for i in np.argsort([r['stock'] for r in res])[::-1]:
    r = res[i]
    ratio = r['stock']/sum_of_stocks*100
    cum += ratio
    print "|{0}|{1:.1f}|{2:.1f}|[{3}]({4})|".format(r['stock'],ratio,cum,r['title'].encode('utf-8'),r['url'])

Aggregieren Sie um Tags.

#Tag-Aggregation
tag_cnt = defaultdict(int)
for r in res:
    for t in r['tags']:
        tag_cnt[t['name']] += 1

#Anzahl der Bestände pro Tag
tag_stock_cnt = defaultdict(int)
for t in tag_cnt.keys():
    for r in res:
        for _t in r['tags']:
            if t == _t['name']:
                tag_stock_cnt[t] += r['stock']
tag_stock_dict = {}
for t, cnt in tag_stock_cnt.items():
    tag_stock_dict[t] = cnt

#Verarbeitet, damit es in einem DataFrame platziert werden kann
tag_list = []
ind_list = []
for k, t in tag_cnt.items():
    ind_list.append(k)
    tag_list.append((t , tag_stock_dict[k]))

#Datenrahmengenerierung
tag_list = np.array(tag_list)
df = pd.DataFrame(tag_list, index=ind_list, columns=['cnt', 'stocks'])

n = float(len(tag_cnt))
df['cnt_ratio'] = df['cnt']/n
df['stock_ratio'] = df['stocks']/sum_of_stocks

#Anzeige der Bestandsmenge und des Bestandsverhältnisses nach Tag
df_tag = df.sort(columns='cnt', ascending=False)

print "|Etikett|Anzahl der Artikel|Bestandsmenge|Lager/Artikelverhältnis|"
print "|:----------:|:----------:|:----------:|:----------:|"
for d in df_tag.iterrows():
    print "|[{0}](http://qiita.com/tags/{0})|{1}|{2}|{3:.1f}|".format(d[0].encode('utf-8'),int(d[1][0]),int(d[1][1]),d[1][1]/d[1][0])



#Grafikanzeige
df[['cnt_ratio','stock_ratio']].sort(columns='cnt_ratio', ascending=False).plot(kind="bar", figsize=(17, 8), alpha=0.7, 
                                title="The ratio of article and stocks for each tag.")

Als nächstes wird die Funktion aggregiert und dem Benutzer angezeigt.

#Benutzeraggregation
id_list = []
cnt_list = []
for _id, cnt in users.items():
    id_list.append((_id, cnt))

df = pd.DataFrame(id_list, columns=["id","cnt"])

#Top 20 Personen anzeigen
print "|Rangfolge|Bestandsmenge|"
print "|:----------:|:----------:|"
for i, d in enumerate(df.sort(columns="cnt", ascending=False)['cnt'][:20]):
    print "| {} | {} |".format(i+1, d)


#Balkendiagramm der Benutzerbestellung mit dem höchsten Lagerbestand
df.sort(columns="cnt", ascending=False)[:150].plot(kind="bar", figsize=(17, 8), alpha=0.6, xticks=[], 
                                                   title="The number of stocks from 1 user.", width=1, color="blue")


#Histogramm der Bestandszählung
df['cnt'].plot(kind="hist", figsize=(13, 10), alpha=0.7, color="Green", bins=25, xlim=(1,26),
              title="Histgram of stocked users.")