En recherchant le mot-clé «apprentissage automatique», j'ai trouvé 246 632 référentiels d'apprentissage automatique. Comme ils sont tous liés à cette industrie, je m'attendais à ce que leurs propriétaires soient des experts ou au moins suffisamment compétents en apprentissage automatique. Par conséquent, j'ai décidé d'analyser les profils de ces utilisateurs et de montrer les résultats de l'analyse.
Comment j'ai travaillé
Outils
J'ai utilisé trois outils de grattage:
- Beautiful Soup pour récupérer l'URL de tous les référentiels balisés avec l'apprentissage automatique. C'est une bibliothèque Python qui facilite le scraping.
- PyGithub . Python- Github API v3. Github- (, , ..) Python-.
- Requests .
Les méthodes que
j'ai analysées loin de tout, mais uniquement les propriétaires et les 30 contributeurs les plus actifs des 90 principaux référentiels apparus dans les résultats de recherche.
Après avoir supprimé les doublons et les profils d'organisations comme udacity, j'ai obtenu une liste de 1208 utilisateurs. Pour chacun d'eux, j'ai analysé les informations pour 20 paramètres clés.
new_profile.info ()
Les 13 premiers paramètres ont été obtenus à partir d'ici.
Le reste, j'ai pris des référentiels de l'utilisateur:
- total_stars nombre total d'étoiles de tous les référentiels
- max_star nombre maximum d'étoiles de tous les référentiels
- fourches nombre total de fourchettes de tous les référentiels
- descriptions descriptions de tous les référentiels d'utilisateurs de tous les référentiels
- contribution nombre de contributions pour la dernière année
Visualiser les données
Histogrammes
Après avoir nettoyé les données, c'était au tour de l'étape la plus intéressante: la visualisation des données. J'ai utilisé Plotly pour cela.
import matplotlib.pyplot as plt
import numpy as np
import plotly.express as px # for plotting
import altair as alt # for plotting
import datapane as dp # for creating a report for your findings
top_followers = new_profile.sort_values(by='followers', axis=0, ascending=False)
fig = px.bar(top_followers,
x='user_name',
y='followers',
hover_data=['followers'],
)
fig.show()
Voici ce qui s'est passé .
L'histogramme est un peu gênant car il a une très longue queue d'utilisateurs avec moins de 100 abonnés. Il est donc préférable de le mettre à l'échelle.
Comme vous pouvez le voir, llSourcell (Siraj Raval) a le plus de followers (36261). Le deuxième plus populaire a trois fois moins d'abonnés (12682).
Nous pouvons aller de l'avant et découvrir que 1% des profils ont 41% de tous les abonnés!
>>> top_n = int(len(top_followers) * 0.01)12>>> sum(top_followers.iloc[0: top_n,:].loc[:, 'followers'])/sum(top_followers.followers)0.41293075864408607
Ensuite, nous visualisons les informations sur total_stars, max_star, fourches en utilisant une échelle logarithmique.
figs = [] # list to save all the plots and table
features = ['followers',
'following',
'total_stars',
'max_star',
'forks',
'contribution']
for col in features:
top_col = new_profile.sort_values(by=col, axis=0, ascending=False)
log_y = False
#change scale of y-axis of every feature to log except contribution
if col != 'contribution':
log_y = True
fig = px.bar(top_col,
x='user_name',
y=col,
hover_data=[col],
log_y = log_y
)
fig.update_layout({'plot_bgcolor': 'rgba(36, 83, 97, 0.06)'}) #change background coor
fig.show()
figs.append(dp.Plot(fig))
C'est comme ça .
L'image résultante est très proche de la distribution selon la loi de Zipf. Nous parlons du modèle empirique de la distribution de la fréquence des mots dans une langue naturelle: si tous les mots de la langue sont classés par ordre décroissant de fréquence d'utilisation. Nous avons une dépendance similaire ici.
Corrélation
Mais qu'en est-il des dépendances entre les points de données clés? Et quelle est la force de ces dépendances? J'ai utilisé scatter_matrix pour comprendre cela.
correlation = px.scatter_matrix(new_profile, dimensions=['forks', 'total_stars', 'followers',
'following', 'max_star','contribution'],
title='Correlation between datapoints',
width=800, height=800)
correlation.show()
corr = new_profile.corr()
figs.append(dp.Plot(correlation))
figs.append(dp.Table(corr))
corr
C'est comme ça et ainsi de suite .
Les relations positives les plus fortes se forment entre:
- Nombre maximum d'étoiles et nombre total d'étoiles (0,939)
- Fourchettes et étoiles au total (0,929)
- Le nombre de fourches et le nombre d'adeptes (0,774)
- Abonnés et nombre total d'étoiles (0,632)
Langages de programmation
Afin de savoir quels langages de programmation sont les plus courants parmi les propriétaires de profils GitHub, j'ai effectué une analyse supplémentaire.
# Collect languages from all repos of al users
languages = []
for language in list(new_profile['languages']):
try:
languages += language
except:
languages += ['None']
# Count the frequency of each language
from collections import Counter
occ = dict(Counter(languages))
# Remove languages below count of 10
top_languages = [(language, frequency) for language, frequency in occ.items() if frequency > 10]
top_languages = list(zip(*top_languages))
language_df = pd.DataFrame(data = {'languages': top_languages[0],
'frequency': top_languages[1]})
language_df.sort_values(by='frequency', axis=0, inplace=True, ascending=False)
language = px.bar(language_df, y='frequency', x='languages',
title='Frequency of languages')
figs.append(dp.Plot(language))
language.show()
En conséquence, les 10 principales langues comprennent:
- Python
- JavaScript
- HTML
- Cahier Jupyter
- Shell, etc.
Emplacement
Afin de comprendre dans quelles parties du monde se trouvent les propriétaires de profils, vous devez effectuer la tâche suivante: visualiser l'emplacement des utilisateurs. Parmi les profils analysés, la géographie est indiquée pour 31%. Pour la visualisation, nous utilisons geopy.geocoders.Nominatim
from geopy.geocoders import Nominatim
import folium
geolocator = Nominatim(user_agent='my_app')
locations = list(new_profile['location'])
# Extract lats and lons
lats = []
lons = []
exceptions = []
for loc in locations:
try:
location = geolocator.geocode(loc)
lats.append(location.latitude)
lons.append(location.longitude)
print(location.address)
except:
print('exception', loc)
exceptions.append(loc)
print(len(exceptions)) # output: 17
# Remove the locations not found in map
location_df = new_profile[~new_profile.location.isin(exceptions)]
location_df['latitude'] = lats
location_df['longitude'] = lons
Eh bien, pour créer une carte, utilisez le scatter_geo de Plotly
# Visualize with Plotly's scatter_geo
m = px.scatter_geo(location_df, lat='latitude', lon='longitude',
color='total_stars', size='forks',
hover_data=['user_name','followers'],
title='Locations of Top Users')
m.show()
figs.append(dp.Plot(m))
Selon ce lien est disponible la carte originale avec un zoom.
Description des utilisateurs repo et bio
De nombreux utilisateurs laissent une description de leurs référentiels et fournissent également leur propre biographie. Afin de visualiser tout cela, nous utilisons W ordCloud! pour Python.
import string
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
nltk.download('stopwords')
nltk.download('punkt')
nltk.download('wordnet')
def process_text(features):
'''Function to process texts'''
features = [row for row in features if row != None]
text = ' '.join(features)
# lowercase
text = text.lower()
#remove punctuation
text = text.translate(str.maketrans('', '', string.punctuation))
#remove stopwords
stop_words = set(stopwords.words('english'))
#tokenize
tokens = word_tokenize(text)
new_text = [i for i in tokens if not i in stop_words]
new_text = ' '.join(new_text)
return new_text
def make_wordcloud(new_text):
'''Function to make wordcloud'''
wordcloud = WordCloud(width = 800, height = 800,
background_color ='white',
min_font_size = 10).generate(new_text)
fig = plt.figure(figsize = (8, 8), facecolor = None)
plt.imshow(wordcloud)
plt.axis("off")
plt.tight_layout(pad = 0)
plt.show()
return fig
descriptions = []
for desc in new_profile['descriptions']:
try:
descriptions += desc
except:
pass
descriptions = process_text(descriptions)
cloud = make_wordcloud(descriptions)
figs.append(dp.Plot(cloud))
Et la même chose pour la bio
bios = []
for bio in new_profile['bio']:
try:
bios.append(bio)
except:
pass
text = process_text(bios)
cloud = make_wordcloud(text)
figs.append(dp.Plot(cloud))
Comme vous pouvez le voir, les mots-clés sont assez cohérents avec ce que vous pouvez attendre des spécialistes de l'apprentissage automatique.
résultats
Les données ont été reçues des utilisateurs et des auteurs de 90 référentiels avec la meilleure correspondance pour la clé «apprentissage automatique». Mais rien ne garantit que tous les principaux propriétaires de profils figurent sur la liste des experts en apprentissage automatique.
Néanmoins, cet article est un bon exemple de la façon dont les données collectées peuvent être nettoyées et visualisées. Très probablement, le résultat vous surprendra. Et ce n'est pas étrange, car la science des données aide à appliquer vos connaissances pour analyser votre environnement.
Eh bien, si nécessaire, vous pouvez bifurquer le code de cet article et en faire ce que vous voulez, voici le repo </ a.
, Data Science AR- Banuba - Skillbox.
, «» github- . , , ..
:
1) , , . ( , 'contribution'). , .
'contribution' , . .
, , . , , ().
2) , . , . , , . , , - . ( ), - , , .
: , . .