[API Qiita] [Statistiques • Apprentissage automatique] J'ai essayé de résumer et d'analyser les articles publiés jusqu'à présent.

Cela fait environ six mois que j'ai commencé à publier sur Qiita, principalement pour des articles liés aux statistiques, à l'apprentissage automatique et à l'analyse de données. Revenons aux articles précédents en utilisant l'API Qiita. (Ci-après calculé à partir des données du 10 août 2015)

Nous examinerons d'abord les données, puis le code Python qui a généré ces contenus, et comment utiliser l'API Qiita de Python.

1. Afficher les données

Par nombre d'articles publiés

Vous êtes parmi les cinq premiers, avec 73%. Les articles populaires sont biaisés ... J'aime personnellement «La signification de la division des fractions comprise par pizza» en bas, mais il n'est pas du tout stocké. : sweat_smile:

Catégorisé par catégorie

J'écris des articles dans les catégories «apprentissage automatique», «statistiques», «mathématiques», «analyse de données» et «autres».

Par tag

Regardons chaque balise. Puisque j'utilise essentiellement Python, le nombre d'articles le plus élevé est Python. En regardant le ratio stock / article, «Deep Learning», «Deep Learning» et «Chainer» sont extrêmement élevés. Vous pouvez voir l'excitation de l'apprentissage en profondeur ces jours-ci.

Le taux de stock des «mathématiques» et de «l'apprentissage automatique» semble relativement élevé.

En regardant le graphique, cela ressemble à ceci.

Utilisateur de stock

J'imaginais que la même personne en stockerait beaucoup, mais à première vue, il semble qu'il y ait pas mal de monde. Le tableau ci-dessous montre les habitués qui sont bien approvisionnés. Merci: détendu:

C'est un graphique des 150 premiers utilisateurs avec un grand nombre d'actions. Le nombre d'utilisateurs uniques était de 1771.

C'est un histogramme du nombre de stocks. C'est plus proche de 1 à 5 titres que je ne l'imaginais. Faible taux de répétition ...: fatigué: À l'avenir, je ferai de mon mieux pour écrire des articles qui seront répétés!

2. Explication du code Python

Obtenir des données de l'API Qiita

Le jeton d'accès est Qiita [Paramètres] → [Applications] → [Émettre un nouveau jeton] Il peut être émis à. Veuillez définir le jeton acquis dans le '<jeton d'accès>' suivant.

%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 = '<Jeton d'accès>'
auth_str = 'Bearer %s'%(key)
headers = {'Authorization': auth_str}
cnt = 0
data_list = []
users = defaultdict(int)

Définissez une fonction get_stockers pour obtenir l'utilisateur du stock et le nombre de stocks.

# -------------------Obtenez le nombre de stocks pour chaque article-----------------------#
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

Utilisez la boucle ci-dessous pour obtenir l'ensemble des articles que vous avez publiés, obtenir les informations sur l'utilisateur boursier associées et les conserver dans la liste.

# -------------------Acquisition d'informations sur l'article-----------------------#
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 = []

Extraire les informations nécessaires à partir des données acquises et les organiser. De plus, les articles privés (messages partagés limités) sont exclus.

# -------------------Mise en forme des données-----------------------#
for i, d in enumerate(data_list):
    sys.stdout.write("{}, ".format(i))

    #Exclut les articles privés
    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)

Ci-dessous, nous afficherons l'ensemble des articles, le nombre d'actions et le ratio sous une forme pouvant être collée sous forme de tableau de démarque.

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

cum = 0
print "|Quantité en stock|Pourcentage(%)|Accumulation(%)|Titre|"
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'])

Agréger autour des balises.

#Agrégation de balises
tag_cnt = defaultdict(int)
for r in res:
    for t in r['tags']:
        tag_cnt[t['name']] += 1

#Nombre de stocks par 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

#Traité pour pouvoir être placé dans un DataFrame
tag_list = []
ind_list = []
for k, t in tag_cnt.items():
    ind_list.append(k)
    tag_list.append((t , tag_stock_dict[k]))

#Génération de trames de données
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

#Affichage de la quantité de stock et du ratio de stock par étiquette
df_tag = df.sort(columns='cnt', ascending=False)

print "|marque|Nombre d'articles|Quantité en stock|Stock/Ratio d'article|"
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])



#affichage graphique
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.")

Ensuite, la fonction est agrégée et affichée à l'utilisateur.

#Agrégation d'utilisateurs
id_list = []
cnt_list = []
for _id, cnt in users.items():
    id_list.append((_id, cnt))

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

#Affichage des 20 meilleures personnes
print "|Classement|Quantité en stock|"
print "|:----------:|:----------:|"
for i, d in enumerate(df.sort(columns="cnt", ascending=False)['cnt'][:20]):
    print "| {} | {} |".format(i+1, d)


#Graphique à barres des commandes utilisateur avec le plus de stock
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")


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