Zadanie

Mamy serwis internetowy dla Informatyków.

Chcemy określić najważniejsze osoby wchodzące w skład użytkowników serwisu.
W tym celu dostajemy zbiór danych całej sieci użytkowników informatyk.pl.
Zrzut wygląda w ten sposób:
users=[
{'id':0, "name":'Adam'},
{'id':1, "name":'Paweł'},
{'id':2, "name":'Anna'},
{'id':3, "name":'Monika'},
{'id':4, "name":'Patrycja'},
{'id':5, "name":'Mateusz'},
{'id':6, "name":'Krzysztof'},
{'id':7, "name":'Maciej'},
{'id':8, "name":'Agnieszka'},
{'id':9, "name":'Martyna'}
]

Jest on opisany przy pomocy słownika i zawiera id oraz imię użytkownika.

Dodatkowo dostajemy dane dotyczące znajomości czyli zbiór smarownych

identyfikatorów osób, które znają się nawzajem.

friendships=[(0,1),(0,2),(1,2),(1,3),(2,3),(3,4),(4,5),(5,6),(5,7),(6,8),(7,8),(8,9)]

Jest to lista, której krótka (0,1) oznacza że użytkownik o id = 0 zna użytkownika o

id = 1.

do każdego użytkownika możemy teraz stworzyć listę jego znajomych.

Zaczynamy od przypisania do atrybutu "friends" pustej listy

for user in users:

user["friends"]=[]

listy wypełniamy danymi ze zbioru "friendships"

for i, j in friendships:
 users[i]["friends"].append(users[j]) #dodaje i do listy znajomych j
users[j]["friends"].append(users[i]) #dodaje j do listy znajomych i

Sumujemy długość wszystkich list znajomych, żeby później określić średnią liczbę
znajomych użytkowników naszego serwisu

#sumowanie wszytkich list znajomych

def number_of_friends(user):
"""ilu znajomych ma użytkownik"""
return len(user["friends"]) #długość listy "frieds"

total_connections=sum(number_of_friends(user) for user in users)

total_connections

Teraz dzielimy tę wartość przez liczbę użytkowników

#teraz tę liczbę dzielimy prze liczbę naszych użytkowników

from __future__ import division

num_users=len(users) #długość listy
avg_connections=total_connections/num_users

avg_connections

num_users

użytkowicy którzy mają najwięcej znajomych

num_friends_by_id=[(user["id"],number_of_friends(user))
for user in users]

num_friends_by_id

policzyliśmy w ten sposób współczynnik centralności sieci – który wskazuje na

najważniejsze filary naszej sieci.

Informatycy, których możesz znać. Tworzenie mechanizmu który sugeruje

znajomych informatyków.
Dokonujemy iteracji po listach znajomych wybranego użytkownika i zapisujemy
zebrane dane.

#iteracja po listach znajomych wybranego użytkownika i zapis zebranych danych

def friends_of_fried_ids(user):
return[potencial["id"]
for friend in user["friends"] #dla każdego przyjaciela
for potencial in friend["friends"]] #odczytaj listę jego przyjaciół

friends_of_fried_ids(users[1])

Po wywołaniu funkcji dla użytkownika 1 (Paweł) zwrócona została następująca

lista:
[1, 2, 0, 1, 3, 1, 2, 4]

Co to oznacza:
Użytkownik o id = 1 jest wymieniony trzykrotnie czyli jest on znajomym dwóch
przyjaciół Pawła. Lista zawiera użytkownika o id=4,3 i 0 którzy występują na
liście raz czyli są już znajomymi Pawła. A użytkownik o id= 2 występuje dwa razy
ponieważ znajduje się on na liście znajomych dwóch różnych przyjaciół.

Generujemy sumę zbiorów wspólnych znajomych i usuwamy z tej listy osoby

należące już do listy znajomych danego użytkownika.

Pobieramy pakiet Counter z biblioteki collections

from collections import Counter

def not_the_same(user, other_user):

"""użytkownicy other_user muszą posiadać różne id"""
return user["id"] != other_user["id"]

def not_friends(user, other_user):

"""użytkownik other_user nie jest znajomym jeżeli nie należy do listy
user["friends"]
 a więc jego nazwa nie pokrywa się z nazwą żadnego z użytkowników
umieszczonych na liście"""
return all(not_the_same(friend, other_user)
for friend in user["friends"])

def friend_of_friend_ids(user):
return Counter(potencial["id"]
for friend in user["friends"] #dla każdego z moich znajomych
for potencial in friend["friends"] #wybierz ich znajomych
if not_the_same(user, potencial) #którzy nie są mną
and not_friends(user, potencial)) #i nie są moimi znajomymi

print(friend_of_friend_ids(users[3]))

Mechanizm ten wskazuje użytkownikowi 3 (Monika) że ma dwóch wspólnych

znajomych z użytkownikiem Paweł i jednego z użytkownikiem Mateusz.

Badanie podobnych zainteresowań

Tworzymy listę par składającą się z id i zainteresowania
interests = [
(0,'Hadoop'),(0,'Big data'),(0,'HBase'),(0,'Java'),(0,'Spark'),(0,'Storm'),
(0,'Cassandra'),
(1,'NoSQL'),(1,'MongoDB'),(1,'Cassandra'),(1,'HBase'),(1,'Postgres'),
(2,'Python'),(2,'scikit-learn'),(2,'scipy'),(2,'numpy'),(2,'statsmodels'),(2,'pandas'),
(3,'R'),(3,'Python'),(3,'statistics'),(3,'regression'),(3,'probability'),
(4,'machine learning'),(4,'regression'),(4,'decision trees'),(4,'libsvm'),
(5,'Python'),(5,'R'),(5,'Java'),(5,'C++'),(5,'Hskell'),(5,'programming languages'),
(6,'statistics'),(6,'probability'),(6,'mathematics'),(6,'theory'),
(7,'machine learning'),(7,'scikit-learn'),(7,'Mahout'),(7,'neural networks'),
(8,'neural networks'),(8,'deep learning'),(8,'Big Data'),(8,'artificial intelligence'),
(9,'Hadoop'),(9,'Java'),(9,'MapReduce'),(9,'Big Data')
]

Tworzymy funkcję znajdującą użytkowników o podobnych zainteresowaniach

I możemy to zrobić w ten sposób ale taka funkcja będzie przeszukiwała cały czas
całą listę
def data_scientists_who_like(target_interst):
return [user_is
for user_id, user_interest in interests
if user_interest == target_interest]

i zadziała dla naszej małej liczby użytkowników, gdybyśmy mieli wielu

użytkowników to lepiej skorzystać z indeksowania
from collections import defaultdict
#klucze będą zainteresowaniami, a wartości będą listami identyfikatorów
użytkowników interesujących się danym
#tematem

user_ids_by_interest=defaultdict(list)

for id, interest in interests:

user_ids_by_interest[interest].append(id)

user_ids_by_interest
defaultdict(list,
{'Hadoop': [0, 9],
'Big data': [0],
'HBase': [0, 1],
'Java': [0, 5, 9],
'Spark': [0],
'Storm': [0],
'Cassandra': [0, 1],
'NoSQL': [1],
'MongoDB': [1],
'Postgres': [1],
'Python': [2, 3, 5],
'scikit-learn': [2, 7],
'scipy': [2],
'numpy': [2],
'statsmodels': [2],
'pandas': [2],
'R': [3, 5],
'statistics': [3, 6],
'regression': [3, 4],
'probability': [3, 6],
'machine learning': [4, 7],
'decision trees': [4],
'libsvm': [4],
'C++': [5],
'Hskell': [5],
'programming languages': [5],
'mathematics': [6],
'theory': [6],
'Mahout': [7],
'neural networks': [7, 8],
'deep learning': [8],
'Big Data': [8, 9],
'artificial intelligence': [8],
'MapReduce': [9]})

#ponadto możemy przypisać użytkowników do zainteresowań

#klucze są identyfikatorami użytkownika, a wartości to lista zainteresowań

interests_by_user_id=defaultdict(list)
for id, interest in interests:
interests_by_user_id[id].append(interest)

interests_by_user_id
defaultdict(list,
{0: ['Hadoop',
'Big data',
'HBase',
'Java',
'Spark',
'Storm',
'Cassandra'],
1: ['NoSQL', 'MongoDB', 'Cassandra', 'HBase', 'Postgres'],
2: ['Python',
'scikit-learn',
'scipy',
'numpy',
'statsmodels',
'pandas'],
3: ['R', 'Python', 'statistics', 'regression',
'probability'],
4: ['machine learning', 'regression', 'decision trees',
'libsvm'],
5: ['Python',
'R',
'Java',
'C++',
'Hskell',
'programming languages'],
6: ['statistics', 'probability', 'mathematics', 'theory'],
7: ['machine learning',
'scikit-learn',
'Mahout',
'neural networks'],
8: ['neural networks',
'deep learning',
'Big Data',
'artificial intelligence'],
9: ['Hadoop', 'Java', 'MapReduce', 'Big Data']})

Teraz możemy ustalić osoby, które mają najwięcej wspólnych zainteresowań I

zapisać liczbę wystąpień poszczególnych użytkowników:

def most_common_interests_with(id):
return Counter(interested_user_id
for interest in interests_by_user_id[id]
for interested_user_id in user_ids_by_interest[interest]
if interested_user_id != id)

most_common_interests_with(0)

Dla użytkownika 0 wspólne zaiteresowania ma 9,1 i 5

zrobić jeżeli nie będzie działało
for interest in interests_by_user_id[0]:
print(interest)
for interest_user_id in user_ids_by_interest[interest]:
print(interest_user_id)

Na podstawie naszej listy zainteresowań możemy sobie wyobrazić jeszcze że szefowa

prosi nas o zaplanowanie strategii publikowania treści na blogu względem
najpopularniejszych zainteresowań użytkowników.

1. traktujemy teraz wszystkie zainteresowania na naszej liście jako słowa dlatego

musimy zmienić nazwy na małe litery
2. podzielić frazy na słowa
3. policzyć wystąpienia poszczególnych słów

words_and_counts=Counter(word
 for user, interest in interests
for word in interest.lower().split())

words_and_counts
Counter({'hadoop': 2,
'big': 3,
'data': 3,
'hbase': 2,
'java': 3,
'spark': 1,
'storm': 1,
'cassandra': 2,
'nosql': 1,
'mongodb': 1,
'postgres': 1,
'python': 3,
'scikit-learn': 2,
'scipy': 1,
'numpy': 1,
'statsmodels': 1,
'pandas': 1,
'r': 2,
'statistics': 2,
'regression': 2,
'probability': 2,
'machine': 2,
'learning': 3,
'decision': 1,
'trees': 1,
'libsvm': 1,
'c++': 1,
'hskell': 1,
'programming': 1,
'languages': 1,
'mathematics': 1,
'theory': 1,
'mahout': 1,
'neural': 2,
'networks': 2,
'deep': 1,
'artificial': 1,
'intelligence': 1,
'mapreduce': 1})

Wyświetlanie listy słów które pojawiają się najczęściej

for word, count in words_and_counts.most_common():

if count > 1:
print(word, count)

big 3
data 3
java 3
python 3
learning 3
hadoop 2
hbase 2
cassandra 2
scikit-learn 2
r 2
statistics 2
regression 2
probability 2
machine 2
neural 2
networks 2