सामुदायिक गणना "क्या?" कहाँ? कब? "(ChGK) या एक मित्र से पहले कितने हैंडशेक?

नमस्कार, हेब्र!

नए साल की छुट्टियां एक बेहतरीन समय है आईटी से ब्रेक लें अपने पसंदीदा शौक में पेशेवर कौशल का उपयोग करें। खेल ChGK रेटिंग की साइट पर चारों ओर घूमते हुए, मुझे एक उत्कृष्ट एपीआई मिला जिससे आप सभी टूर्नामेंटों के सभी खेलों के डेटा प्राप्त कर सकते हैं। इसलिए मुझे विशेषज्ञों के समुदाय का एक ग्राफ बनाने और भौगोलिक रूप से छितरी और सख्ती से ऑफ़लाइन समुदाय पर छह हैंडशेक के सिद्धांत का परीक्षण करने का विचार मिला। रेखांकन और बेकार आँकड़ों के katom चित्रों के तहत।

शुरू करने के लिए, एक संक्षिप्त शैक्षिक कार्यक्रम, खेल ChGK क्या है।

डेटा पुनर्प्राप्ति

हम मानते हैं कि खिलाड़ी एक दूसरे से परिचित हैं यदि वे कम से कम एक बार एक गेम टेबल पर खेले। अच्छे एपीआई के लिए धन्यवाद , सभी टूर्नामेंट और सभी टीमों के बारे में डेटा डाउनलोड करना कोई समस्या नहीं है।

स्पॉइलर के तहत, सुंदर सूप का भी उपयोग नहीं किया जाता है, केवल अनुरोध करता है। सभी स्रोत कोड के साथ एक ज्यूपिटर नोटबुक लेख के अंत में होगा।

url = 'https://rating.chgk.info/api/tournaments.json/?page={}' df = pd.DataFrame(columns=['name', 'start']) for i in range(1, 7): data = requests.get(url.format(i)).json() for item in data["items"]: df.loc[item["idtournament"]] = (item["name"], item["date_start"]) df.to_csv('tournaments.csv') 

यह सभी टूर्नामेंटों के गेम रोस्टर्स को डाउनलोड करने और सभी परिचितों को याद करने के लिए बनी हुई है। प्रारंभ में, मैंने एक डेटा गेम में एक संयुक्त गेम के तथ्यों को संग्रहीत करने की योजना बनाई, लेकिन नए रिकॉर्ड जोड़ने की गति निराशाजनक थी। इसलिए, हम tuples (id1, id2) से सेट करेंगे, जहां id1, id2 खिलाड़ियों के पहचानकर्ता हैं जो एक दूसरे से परिचित हैं। उसी समय, डुप्लिकेट से छुटकारा पाएं।

 df = pd.read_csv('tournaments.csv').set_index('Unnamed: 0') url = 'https://rating.chgk.info/api/tournaments/{}/recaps.json' links = set() for id in df.index: teams = requests.get(url.format(id)).json() for team in teams: t = team["recaps"] for i in range(len(t)): for j in range(i + 1, len(t)): first = int(t[i]["idplayer"]) second = int(t[j]["idplayer"]) if first < second: links.add((first, second)) else: links.add((second, first)) #    sleep(1) clear_output(wait=True) display('Current tournament: ' + str(df.index.get_loc(id) + 1) + '/' + str(len(df))) display('Links total: ' + str(len(links))) 

एक ग्राफ प्राप्त करना और जुड़े घटकों की खोज करना

तो, डेटा तैयारी खत्म हो गई है, यह एक ग्राफ बनाने का समय है! ऐसा करने के लिए, हम नेटवर्कएक्स लाइब्रेरी का उपयोग करेंगे, जिसकी क्षमता हमारे क्लस्टर के लिए काफी पर्याप्त है।

 players = itertools.chain(*links) G = nx.Graph() G.add_nodes_from(players) for t in links: G.add_edge(*t) print(nx.info(G)) 

अब ChGK समुदाय में लगभग दो लाख लोग हैं, और औसतन, एक करियर के विशेषज्ञ ने 12 लोगों के साथ खेला है:

 Number of nodes: 198145 Number of edges: 1206076 Average degree: 12.1737 

यह पता लगाने का समय है कि डेटिंग ग्राफ़ में कितने जुड़े घटक हैं। Networkx के पास एक बढ़िया फ़ंक्शन है, जिसे कनेक्ट किया गया_ कनेक्टर्स कहा जाता है जो आपको केवल वही चाहिए जो:

 clusters_l = [len(c) for c in sorted(nx.connected_components(G), key=len, reverse=True)] print(clusters_l[:20]) 

लगभग तीन-चौथाई खिलाड़ी एक जुड़े हुए घटक में होते हैं, बाकी को बहुत छोटे सबग्राफ में विभाजित किया जाता है। इनमें आठ हजार से ज्यादा हैं।

 [145922, 153, 124, 74, 72, 56, 50, 47, 42, 40, 39, 39, 38, 38, 37, 36, 36, 36, 36, 35] 

यहां तक ​​कि एक लघुगणकीय पैमाने पर, मुख्य घटक का प्रभुत्व प्रभावशाली दिखता है। X अक्ष पर - सबसे बड़ी से छोटी, Y अक्ष पर घटक की संख्या - इसका आकार (अक्ष लघुगणक है)।

जुड़े घटकों में लोगों के असमान वितरण का क्या कारण है? मेरी राय में, मुद्दा यह है:

• लोगों का एक छोटा समूह पहली बार खेल में आता है और इस तरह 4-6 लोगों के लिए एक छोटा समूह बनाता है;
• यदि शहर में पहले से ही एक बड़ा समुदाय है, तो ऐसा क्लस्टर बहुत जल्दी मुख्य के साथ विलीन हो जाएगा - बस एक व्यक्ति को मुख्य क्लस्टर से एक टीम के लिए खेलना होगा;
• अगर ChGK के शहर में बस दिखाई दिया, तो क्लस्टर लंबे समय तक जीवित रहेगा, क्योंकि मुख्य क्लस्टर से एक टीम के लिए खेलना अधिक कठिन है।

यह प्रक्रिया बादलों में बारिश की बूंदों के बनने से मिलती-जुलती है: एक बड़ी बूंद छोटे लोगों को आकर्षित करती है और तेजी से बढ़ती है।

मुख्य घटक से निपटने से पहले, आइए पहले या नौवें स्थान पर घटकों को देखें (मैं मुख्य घटक को शून्य मानता हूं)। हम इस परिकल्पना का परीक्षण करते हैं कि इन घटकों के लोग एक ही शहर के हैं। पारखी को शहर से कोई लगाव नहीं है (जो हमारी आधुनिक दुनिया में तार्किक है)। हालाँकि, आप उस टीम के होम पोर्ट को देख सकते हैं जिसके लिए वह आखिरी बार खेले थे

 for i in range(1, 10): _g = list(sorted(nx.connected_components(G), key=len, reverse=True)[i]) s = pd.Series() p_url = 'https://rating.chgk.info/api/players/{}/tournaments.json' t_url = 'https://rating.chgk.info/api/teams/{}.json' for player in _g: data = requests.get(p_url.format(player)).json() for item in data: team_id = data[item]["tournaments"][0]["idteam"] data = requests.get(t_url.format(team_id)).json() town = data[0]["town"] s.at[len(s)] = town print(' #{}'.format(i)) print(s.value_counts()) 

सारांश प्लेट:

हां, छोटे क्लस्टर लगभग पूरी तरह से एक शहर से हैं। कृपया सत्तर तम्बोव निवासियों के घटक पर ध्यान दें, जो लक्समबर्ग से जुड़ा हुआ है। सातवें और नौवें स्थान पर गोर्नो-अल्टसेक के घटक हैं, जो किसी कारण से परस्पर जुड़े नहीं हैं। मैं आसानी से मॉन्टेक और कैपुलेट जैसे दो ChGK-ash कुलों के संघर्ष की कल्पना करता हूं, जो शहर के नियंत्रण के लिए लड़ रहे हैं।
मुझे लगता है कि निकट भविष्य में ये घटक मुख्य में विलीन हो जाएंगे लेकिन लड़ते रहेंगे ।

कनेक्टिविटी का मुख्य घटक

तो, हम मुख्य घटक के लिए मिला है। हम वांछित सबग्राफ प्राप्त करेंगे और इसके आँकड़ों को देखेंगे:

 subgraph_v = list(sorted(nx.connected_components(G), key=len, reverse=True)[0]) subgraph = G.subgraph(subgraph_v) print(nx.info(subgraph)) 

कनेक्शनों की औसत संख्या अधिक निकली।

 Number of nodes: 145922 Number of edges: 1070504 Average degree: 14.6723 

और प्रति खिलाड़ी कनेक्शन की अधिकतम संख्या क्या है?

 for t in sorted(G.degree, key=lambda x: x[1], reverse=True)[:10]: print(' {}   {} '.format(t[0], t[1])) 

  42511   818   15051   798   29800   678   23020   666   16581   662   5328   657   29887   651   15811   645   30352   605   1055   602  

सच कहूं, मैं संख्या से थोड़ा हैरान हूं। यदि आप हर बार एक नई टीम के साथ खेलते हैं, तो आपको पहले स्थान पर पहुंचने के लिए 818/5 to 164 गेम की आवश्यकता होगी। अतुल्य।
हम इस रेटिंग में पहले दो विशेषज्ञों को याद करेंगे और आगे उनके संचार कौशल का उपयोग करेंगे।
चलिए अनुमान लगाते हैं कि एक औसत विशेषज्ञ के कितने निकटतम परिचित हैं:

 _count = 50 values = nx.degree_histogram(subgraph) plt.figure(figsize=(16, 8), dpi=80) plt.plot(range(_count),values[:_count],'ro-') # in-degree plt.xlabel(' ', fontsize=18) plt.xticks(range(0,_count, 5)) plt.ylabel(' ', fontsize=18) plt.title(' ', fontsize=22) plt.show() 

X- अक्ष पर - Y- अक्ष पर निकटतम परिचितों की संख्या - उन विशेषज्ञों की संख्या जिनके पास परिचितों की संगत संख्या है। उदाहरण के लिए, लगभग 40,000 विशेषज्ञ प्रत्येक के पांच परिचित हैं।
ध्यान दें कि फैशन के 5 परिचित हैं (यह हास्यास्पद है कि मेज पर छह लोग हो सकते हैं)। इसी समय, परिचितों की संख्या का अंकगणितीय औसत 14.67 है, और मंझला है 7. तथ्य यह है कि ऊपर की रेटिंग वाले सज्जन औसत से बहुत अधिक हैं। यदि सौ लोग ChGK में नहीं खेलते हैं, और एक के 800 परिचित हैं, तो औसतन वे ChGK में खेलते हैं।

खिलाड़ियों को दूरियां

क्योंकि इस तरह के ग्राफ के व्यास को गिनना थोड़ा मुश्किल है , चलो इसे आसान करते हैं: कई खिलाड़ियों की सूची लें और उनसे अन्य विशेषज्ञों के लिए सबसे छोटी दूरी का पता लगाएं। इन खिलाड़ियों के रूप में, मैंने कई जाने-माने विशेषज्ञों, अपने आप को, एक यादृच्छिक खिलाड़ी और दो विशेषज्ञों को सबसे बड़ी संख्या में परिचितों (रेटिंग देखें) के साथ लिया। यहाँ क्या हुआ:

 famous_players = {9808: ' ', 5195: ' ', 25882: ' ', 29333: ' ', 118622: ' ', 42511: ' ', 15051: ' ', 118621: ' '} for key in famous_players: print('{}: {} -      ' .format(famous_players[key], nx.eccentricity(subgraph, v=key))) 

  : 12 -        : 12 -        : 12 -        : 12 -        : 13 -        : 12 -        : 13 -        : 13 -       

यह पता चलता है कि छह हैंडशेक (किसी भी दो लोगों को पांच दोस्तों के पांच से अधिक स्तरों से अलग नहीं किया जाता है) के सिद्धांत का एक मजबूत सूत्रीकरण गलत है। ग्राफ का व्यास 13-14 सबसे अधिक संभावना है।
एक कमजोर शब्दांकन के बारे में क्या ( औसतन कोई भी दो व्यक्ति पांच दोस्तों के आपसी स्तर से अलग नहीं होते हैं )?

 for key in famous_players: paths = nx.shortest_path_length(subgraph, source=key).values() print('{}: {} -      ' .format(famous_players[key], sum(paths) / len(paths))) 

  : 3.941461876893135 -        : 3.7971107852140182 -        : 3.89353216101753 -        : 3.8634887131481204 -        : 4.1443373857266215 -        : 3.575478680390894 -        : 3.608674497334192 -        : 4.564102739819904 -       

यदि हम शब्दों को ढीला करते हैं, तो सिद्धांत पूरा हो गया है - विशेषज्ञों के औसतन 4-5 स्तरों पर परिचितों के बीच। हम साजिश करते हैं कि कितने लोग यादृच्छिक पारखी ए ड्रूज़ेम से सीधे परिचित हैं, एक, दो, आदि के माध्यम से। पारखियों।

 paths = nx.shortest_path_length(subgraph, source=9808) neighbours = [0] * 15 for k in paths: neighbours[paths[k]] += 1 _count = 15 plt.figure(figsize=(16, 8), dpi=80) plt.plot(range(_count),neighbours[:_count],'ro-') # in-degree plt.xlabel(' ', fontsize=18) plt.xticks(range(_count)) plt.ylabel(' ', fontsize=18) plt.title('  .', fontsize=22) plt.show() 

एक्स अक्ष पर, वाई अक्ष पर ए। ड्रुज़ेम (सीधे, एक, दो, आदि) के साथ परिचित की डिग्री, उन विशेषज्ञों की संख्या जो इस तरह से ए ड्रूज़ेम से परिचित हैं।

सामाजिक रेखांकन

क्योंकि लगभग 200 हजार लोगों के लिए एक ग्राफ बनाना एक अच्छा विचार नहीं है, हम इसे आसान बना देंगे: हम केर्च कनेक्टिविटी घटक और लेखक से जुड़े लोगों के एक ग्राफ का निर्माण करेंगे।

केर्च घटक

 little_v = list(sorted(nx.connected_components(G), key=len, reverse=True)[1]) little = G.subgraph(little_v) plt.figure(figsize=(24, 12), dpi=200) pos = nx.kamada_kawai_layout(little) nx.draw(little, pos=pos, node_size=100, edge_color='gray', node_color=[val for (node, val) in little.degree()], cmap=plt.cm.jet) plt.show() 

आप टीमों में घटकों के पृथक्करण को देख सकते हैं। इसके अलावा, टीमों को एक या दो मिलनसार पारखी की मदद से, एक नियम के रूप में, परस्पर जुड़े हुए हैं। केंद्र में विशेषज्ञों का एक छोटा सा कोर है जो बड़ी संख्या में अन्य खिलाड़ियों के साथ खेला जाता है।

एक व्यक्ति की गिनती

हम एक व्यक्ति के निकटतम परिचितों को देखेंगे और देखेंगे कि वे कैसे संबंधित हैं। ग्राफ को सरल बनाने के लिए, हम उस व्यक्ति को स्वयं नहीं जोड़ेंगे (वह पहले से ही सभी के साथ जुड़ा हुआ है)

 id = 118622 ego_graph = [n for n in G.neighbors(id)] #ego_graph.append(id) ego_graph = G.subgraph(ego_graph) plt.figure(figsize=(24, 16), dpi=200) pos = nx.kamada_kawai_layout(ego_graph) nx.draw(ego_graph, pos=pos, node_size=100, edge_color='gray', node_color=[val for (node, val) in ego_graph.degree()], cmap=plt.cm.jet) plt.show() 

ग्राफ ज्यादा सघन है, 10-15 लोगों का एक कोर जो एक दूसरे से परिचित हैं वे अलग हैं। अधिकतम क्लिक का आकार 13 है।

निष्कर्ष

• एक सामाजिक नेटवर्क की तुलना में खेल ChGK में किसी व्यक्ति को जानना बहुत मुश्किल है, आपको ऑफ़लाइन जाने और कम से कम अन्य टूर्नामेंट खेलने की आवश्यकता है। इसी समय, विशेषज्ञ दुनिया भर में बिखरे हुए हैं। हालांकि, विशेषज्ञों के बीच औसत दूरी वास्तव में पांच से कम है।
• रेटिंग साइट Snyatkovsky संख्या का उपयोग करती है , जो कि ChGK की दुनिया में Erdös संख्या का एक एनालॉग है । श्री संवतकोवस्की स्वयं सबसे अधिक सामंजस्यपूर्ण पारखी की हमारी रैंकिंग में तीसरे स्थान पर हैं।
• मेरे गितुब के एक लेख का कोड।
• बहुमूल्य टिप्पणियों के लिए, लेखक व्हाइट नॉइज़ और हू फ्रेम्ड रोजर फेडरर, मिखाइल अकुलोव , वेरा टेरेंटेवा और फायरमून का आभारी है ।