เห็นภาพกราฟอิทธิพลของภาษาโปรแกรม

บทแนะนำการสร้างภาพเครือข่ายด้วย Gephi และ Sigma.js

นี่คือตัวอย่างสิ่งที่เราจะทำในวันนี้:กราฟอิทธิพลภาษาโปรแกรม ดูลิงก์เพื่อสำรวจความสัมพันธ์ "อิทธิพลการออกแบบ" ระหว่างภาษาโปรแกรมกว่า 250 ภาษาทั้งในอดีตและปัจจุบัน!

ตาคุณ!

ในโลกที่เชื่อมต่อกันมากเกินไปในปัจจุบัน เครือข่ายเป็นแง่มุมที่แพร่หลายของชีวิตสมัยใหม่

เริ่มต้นวันใหม่เลย — ฉันใช้เครือข่ายการขนส่งของลอนดอน เพื่อเดินทางเข้าเมือง จากนั้นฉันก็เดินเข้าไปในสาขา ของร้านกาแฟที่ฉันชื่นชอบและใช้ Chromebook เพื่อเชื่อมต่อกับเครือข่าย Wi-Fi . ต่อไป ฉันลงชื่อเข้าใช้ โซเชียลเน็ตเวิร์ก . ต่างๆ ไซต์ที่ฉันใช้บ่อย

ไม่เป็นความลับที่บริษัทที่มีอิทธิพลมากที่สุดในช่วงสองสามทศวรรษที่ผ่านมาเป็นหนี้ความสำเร็จของพวกเขาจากพลังของเครือข่าย

Facebook, Twitter, Instagram, LinkedIn และแพลตฟอร์มโซเชียลมีเดียอื่นๆ อาศัยคุณสมบัติในโลกใบเล็กของโซเชียลเน็ตเวิร์ก ซึ่งช่วยให้เชื่อมต่อผู้ใช้ระหว่างกัน (และผู้โฆษณา) ได้อย่างมีประสิทธิภาพ

Google เป็นหนี้ความสำเร็จส่วนใหญ่ในปัจจุบันจากการครอบงำตลาดเสิร์ชเอ็นจิ้นในช่วงแรก ส่วนหนึ่งมาจากความสามารถในการแสดงผลลัพธ์ที่เกี่ยวข้องด้วยความช่วยเหลือของอัลกอริธึมเครือข่าย Page Rank

เครือข่ายการจัดจำหน่ายที่มีประสิทธิภาพของ Amazon ช่วยให้สามารถจัดส่งได้ภายในวันเดียวกันในเมืองใหญ่บางแห่ง

เครือข่ายมีความสำคัญอย่างยิ่งในด้านต่างๆ เช่น ปัญญาประดิษฐ์และการเรียนรู้ของเครื่อง โครงข่ายประสาทเทียมเป็นสาขาการวิจัยที่มีความกระตือรือร้นอย่างมาก อัลกอริธึมการตรวจจับฟีเจอร์จำนวนมากซึ่งจำเป็นใน Computer Vision นั้นอาศัยการใช้เครือข่ายเพื่อสร้างแบบจำลองส่วนต่างๆ ของรูปภาพเป็นอย่างมาก

ปรากฏการณ์ทางวิทยาศาสตร์ที่หลากหลายสามารถเข้าใจได้ในแง่ของโมเดลเครือข่าย ซึ่งรวมถึงกลศาสตร์ควอนตัม วิถีทางชีวเคมี และระบบนิเวศและเศรษฐกิจสังคม

เมื่อพิจารณาถึงความสำคัญที่ปฏิเสธไม่ได้แล้ว เราจะเข้าใจเครือข่ายและคุณสมบัติของเครือข่ายได้ดีขึ้นได้อย่างไร

การศึกษาทางคณิตศาสตร์ของเครือข่ายเรียกว่า "ทฤษฎีกราฟ" และเป็นหนึ่งในสาขาคณิตศาสตร์ที่เข้าถึงได้ง่ายขึ้น บทความนี้มีจุดมุ่งหมายเพื่อเป็นการแนะนำ โดยอาศัยความรู้หรือประสบการณ์เพียงเล็กน้อย

เราจะใช้ Python 3.x และซอฟต์แวร์โอเพนซอร์ซที่ยอดเยี่ยมที่เรียกว่า Gephi เพื่อรวบรวมภาพเครือข่ายว่าภาษาโปรแกรมต่างๆ ในอดีตและปัจจุบันเชื่อมโยงกันด้วยอิทธิพลอย่างไร

แต่ก่อน…

เครือข่ายคืออะไรกันแน่

ตัวอย่างที่อธิบายข้างต้นให้เบาะแสบางอย่างแก่เรา เครือข่ายการขนส่งประกอบด้วย ปลายทาง เชื่อมต่อด้วย เส้นทาง . โซเชียลเน็ตเวิร์กประกอบด้วย บุคคล เชื่อมต่อผ่านความสัมพันธ์ กับอีกคนหนึ่ง. อัลกอริธึมของเครื่องมือค้นหาของ Google ประเมิน "อันดับ" ของ หน้าเว็บต่างๆ โดยดูที่หน้า ลิงก์ ออกสู่ผู้อื่น

โดยทั่วไป เครือข่ายคือระบบใดๆ ก็ตามที่สามารถอธิบายเป็นโหนด และ ขอบ หรือในภาษาพูดคือ “จุดและเส้น”

ระบบบางระบบสามารถสรุปได้ง่ายในลักษณะนี้ เครือข่ายสังคมอาจเป็นตัวอย่างที่ชัดเจนที่สุด ระบบไฟล์ของคอมพิวเตอร์เป็นอีกระบบหนึ่ง — โฟลเดอร์และไฟล์เชื่อมโยงกันด้วยความสัมพันธ์แบบ “แม่” และ “ลูก”

แต่พลังที่แท้จริงของเครือข่ายมาจากข้อเท็จจริงที่ว่าระบบจำนวนมากหลายระบบสามารถสรุปและสร้างแบบจำลองในแง่ของเครือข่ายได้ แม้ว่าในตอนแรกจะยังไม่ชัดเจนว่าเป็นอย่างไร

เป็นตัวแทนของเครือข่าย

เราจำเป็นต้องไปไกลกว่าภาพร่างด้วยปากกาและกระดาษเพื่อวิเคราะห์และอธิบายเครือข่ายทางคณิตศาสตร์ เราจะเปลี่ยนรูปภาพของจุดและเส้นให้เป็นตัวเลขได้อย่างไร

ทางออกหนึ่งคือการวาด เมทริกซ์ที่อยู่ติดกัน เพื่อเป็นตัวแทนของเครือข่ายของเรา

เมทริกซ์เป็นหนึ่งในแนวคิดที่อาจฟังดูน่ากลัวเล็กน้อยหากคุณไม่คุ้นเคย แต่อย่ากลัวเลย คิดว่าเป็นตารางของตัวเลขที่สามารถใช้คำนวณได้หลายอย่างพร้อมกัน นี่คือตัวอย่างด้านล่าง:

      Python Java Scala C#
Python     0    1     0  0
Java       0    0     0  1
Scala      0    1     0  0
C#         0    1     0  0

ในเมทริกซ์นี้ จุดตัดของแต่ละแถวและคอลัมน์จะเป็น 0 หรือ 1 ขึ้นอยู่กับว่าภาษานั้นเชื่อมโยงกันหรือไม่ คุณสามารถตรวจสอบสิ่งนี้กับภาพประกอบด้านบน!

สำหรับวัตถุประสงค์ส่วนใหญ่ เมทริกซ์ที่อยู่ติดกันเป็นวิธีที่ดีในการแสดงเครือข่ายทางคณิตศาสตร์ อย่างไรก็ตาม จากมุมมองของการคำนวณ บางครั้งอาจยุ่งยากเล็กน้อย

ตัวอย่างเช่น ด้วยจำนวนโหนดที่ค่อนข้างเจียมเนื้อเจียมตัว (เช่น 1000) จะมีองค์ประกอบจำนวนมากขึ้นในเมทริกซ์ (เช่น 1000² =1,000,000)

ระบบในโลกแห่งความเป็นจริงจำนวนมากให้เครือข่ายกระจัดกระจาย . ในเครือข่ายเหล่านี้ โหนดส่วนใหญ่จะเชื่อมต่อกับส่วนอื่นๆ เพียงเล็กน้อยเท่านั้น

ถ้าเราแสดงเครือข่ายกระจัดกระจาย 1,000 โหนดในหน่วยความจำคอมพิวเตอร์เป็นเมทริกซ์ที่อยู่ติดกัน เราจะมีข้อมูล 1,000,000 ไบต์ที่จัดเก็บไว้ใน RAM ส่วนใหญ่จะเป็นศูนย์ ต้องมีวิธีที่มีประสิทธิภาพมากกว่านี้

อีกวิธีหนึ่งคือการทำงานกับ รายการขอบ แทนที่. สิ่งเหล่านี้เป็นสิ่งที่พวกเขากล่าวว่าเป็น เป็นเพียงรายการที่คู่โหนดเชื่อมโยงถึงกัน

ตัวอย่างเช่น เครือข่ายภาษาโปรแกรมด้านบนสามารถแสดงได้ดังนี้:

Java, Python
Java, Scala
Java, C#
C#, Java

สำหรับเครือข่ายขนาดใหญ่ นี่เป็นวิธีการที่มีประสิทธิภาพในการคำนวณมากกว่าในการแสดงเครือข่ายเหล่านี้ แน่นอนว่าเป็นไปได้ที่จะสร้างเมทริกซ์ที่อยู่ติดกันจากรายการขอบ (และในทางกลับกัน) ไม่ใช่ว่าเราต้องเลือกอย่างใดอย่างหนึ่ง

อีกวิธีในการแสดงเครือข่ายคือรายการที่อยู่ติดกัน รายการนี้จะแสดงรายการทุกโหนดตามด้วยโหนดที่ลิงก์ไป ตัวอย่างเช่น:

Java: Python, Scala, C#
C#: Java

การรวบรวมข้อมูล การสร้างการเชื่อมต่อ

โมเดลเครือข่ายและการแสดงภาพใดๆ จะดีเท่ากับข้อมูลที่ใช้สร้างเท่านั้น ซึ่งหมายความว่า เช่นเดียวกับการทำให้มั่นใจว่าข้อมูลมีความถูกต้องและสมบูรณ์ เรายังต้องปรับวิธีการอนุมานขอบระหว่างโหนดด้วย

ในหลาย ๆ ด้าน นี่คือ the ขั้นตอนที่สำคัญ การวิเคราะห์และการอนุมานที่ตามมาใดๆ เกี่ยวกับเครือข่ายจะขึ้นอยู่กับความสามารถในการปรับ “เกณฑ์การเชื่อมโยง”

ตัวอย่างเช่น ในการวิเคราะห์เครือข่ายสังคม คุณอาจเชื่อมโยงผู้คนโดยพิจารณาจากว่าพวกเขาติดตามกันบนโซเชียลมีเดียหรือไม่ ในอณูชีววิทยา คุณอาจเชื่อมโยงยีนโดยอาศัยการแสดงออกร่วมของพวกมัน

บ่อยครั้ง วิธีที่ใช้ในการเชื่อมโยงโหนดจะช่วยให้น้ำหนัก กำหนดขอบให้วัด “ความแรง”

ตัวอย่างเช่น ในบริบทของการขายปลีกออนไลน์ คุณสามารถเชื่อมโยงผลิตภัณฑ์ตามความถี่ที่ซื้อร่วมกันได้ ผลิตภัณฑ์ที่ซื้อร่วมกันบ่อยๆ จะเชื่อมโยงด้วยขอบที่ถ่วงน้ำหนัก มากกว่าสินค้าที่ซื้อด้วยกันเป็นบางครั้งเท่านั้น ผลิตภัณฑ์ที่ซื้อร่วมกันไม่บ่อยเกินกว่าที่คาดไว้จะไม่ถูกเชื่อมโยงเลย

อย่างที่คุณคิด วิธีเชื่อมโยงโหนดเข้าด้วยกันอาจซับซ้อนเท่าที่คุณต้องการ

อย่างไรก็ตาม สำหรับบทช่วยสอนนี้ เราจะใช้วิธีการที่ง่ายกว่าในการเชื่อมต่อภาษาโปรแกรม เราจะอาศัยความถูกต้องของวิกิพีเดีย

สำหรับจุดประสงค์ของเรา สิ่งนี้น่าจะใช้ได้ ความสำเร็จของวิกิพีเดียเป็นเครื่องพิสูจน์ว่าต้องทำในสิ่งที่ถูกต้อง วิธีโอเพนซอร์สและการทำงานร่วมกันในการเขียนบทความควรรับรองความเที่ยงธรรมในระดับหนึ่ง

นอกจากนี้ โครงสร้างหน้าที่ค่อนข้างสม่ำเสมอทำให้เป็นสนามเด็กเล่นที่สะดวกสำหรับการลองใช้เทคนิคการขูดเว็บ

โบนัสอีกประการหนึ่งคือ Wikipedia API ที่กว้างขวางและมีเอกสารประกอบอย่างดี ซึ่งทำให้การดึงข้อมูลทำได้ง่ายขึ้น มาเริ่มกันเลย

ขั้นตอนที่ 1 — การติดตั้ง Gephi

Gephi พร้อมใช้งานบน Linux, Mac และ Windows ดาวน์โหลดได้ที่นี่

สำหรับโครงการนี้ ฉันใช้ Lubuntu หากคุณใช้ Ubuntu/Debian คุณสามารถทำตามขั้นตอนด้านล่างเพื่อให้ Gephi ทำงานได้ มิฉะนั้น ขั้นตอนการติดตั้งจะเหมือนกับสิ่งที่คุณคุ้นเคย

ดาวน์โหลด Gephi เวอร์ชันล่าสุด (ในขณะที่เขียนนี่คือ v.0.9.1) สำหรับระบบของคุณ เมื่อพร้อมแล้ว คุณจะต้องแตกไฟล์

cd Downloads
tar -xvzf gephi-0.9.1-linux.tar.gz
cd gephi-0.9.1/bin./gephi

คุณอาจต้องตรวจสอบเวอร์ชันของ Java JRE Gephi ต้องการเวอร์ชันล่าสุด ในการติดตั้ง Lubuntu ที่ค่อนข้างใหม่ของฉัน ฉันเพียงแค่ติดตั้ง default-jre และทุกอย่างก็ใช้งานได้จากที่นั่น

apt install default-jre
./gephi

มีอีกขั้นตอนหนึ่งก่อนที่คุณจะพร้อมที่จะเริ่มดำเนินการ คุณสามารถใช้ปลั๊กอิน Sigma.js สำหรับ Gephi เพื่อส่งออกกราฟไปยังเว็บได้

จากแถบเมนูของ Gephi ให้เลือกตัวเลือก "เครื่องมือ" แล้วเลือก "ปลั๊กอิน"

คลิกที่แท็บ "ปลั๊กอินที่มี" และเลือก "SigmaExporter" (ฉันติดตั้ง JSON Exporter ด้วยเพราะเป็นปลั๊กอินที่มีประโยชน์อีกตัวหนึ่ง)

กดปุ่ม "ติดตั้ง" แล้วคุณจะเข้าสู่กระบวนการ คุณจะต้องรีสตาร์ท Gephi เมื่อเสร็จแล้ว

ขั้นตอนที่ 2 — การเขียนสคริปต์ Python

บทช่วยสอนนี้จะใช้ Python 3.x บวกกับโมดูลบางส่วนเพื่อทำให้ชีวิตง่ายขึ้น ใช้ตัวติดตั้งโมดูล pip รันคำสั่งต่อไปนี้:

pip3 install wikipedia

ในไดเร็กทอรีใหม่ ให้สร้างไฟล์ชื่อ script.py และเปิดขึ้นในโปรแกรมแก้ไขโค้ด/IDE ที่คุณชื่นชอบ ด้านล่างนี้คือโครงร่างของตรรกะหลัก:

1. ขั้นแรก คุณต้องมีรายการภาษาการเขียนโปรแกรมเพื่อรวมไว้
2. ถัดไป ไปที่รายการนั้นและดึง HTML ของบทความ Wikipedia ที่เกี่ยวข้อง
3. จากนี้ แยกรายการภาษาโปรแกรมที่แต่ละภาษาได้รับอิทธิพล นี่จะเป็นเกณฑ์ในการเชื่อมโยงคร่าวๆ
4. ในขณะที่คุณทำอยู่ คุณควรคว้าข้อมูลเมตาเกี่ยวกับแต่ละภาษามาด้วย
5. สุดท้าย คุณจะต้องเขียนข้อมูลทั้งหมดที่คุณรวบรวมเป็นไฟล์ .csv

สามารถอ่านสคริปต์ฉบับเต็มได้ในสาระสำคัญนี้

นำเข้าบางโมดูล

ใน script.py เริ่มต้นด้วยการนำเข้าโมดูลสองสามตัวซึ่งจะทำให้สิ่งต่างๆ ง่ายขึ้น:

import csv
import wikipedia
import urllib.request
from bs4 import BeautifulSoup as BS
import re

ตกลง — เริ่มต้นด้วยการสร้างรายการโหนดที่จะรวม นี่คือจุดที่โมดูล Wikipedia มีประโยชน์ ทำให้การเข้าถึง Wikipedia API เป็นเรื่องง่ายมาก

เพิ่มรหัสต่อไปนี้:

pageTitle = "List of programming languages"
nodes = list(wikipedia.page(pageTitle).links)
print(nodes)

หากคุณบันทึกและเรียกใช้สคริปต์นี้ คุณจะเห็นสคริปต์พิมพ์ลิงก์ทั้งหมดจากบทความ Wikipedia "รายการภาษาโปรแกรม" เยี่ยมเลย!

อย่างไรก็ตาม การตรวจสอบข้อมูลที่รวบรวมโดยอัตโนมัติด้วยตนเองเป็นเรื่องที่สมเหตุสมผลเสมอ เมื่อเหลือบมองอย่างรวดเร็วจะเผยให้เห็นว่า สคริปต์ยังได้รวบรวมลิงก์เพิ่มเติมอีกสองสามลิงก์ เช่นเดียวกับภาษาการเขียนโปรแกรมจริงหลายๆ ภาษา

ตัวอย่างเช่น คุณอาจเห็น "รายการภาษามาร์กอัป" "การเปรียบเทียบภาษาโปรแกรม" และอื่นๆ ในนั้น

แม้ว่า Gephi จะให้คุณลบโหนดที่คุณไม่ต้องการรวมไว้ แต่ก็ไม่เสียหายที่จะ "ล้าง" ข้อมูลก่อนดำเนินการต่อ หากมีสิ่งใด สิ่งนี้จะช่วยประหยัดเวลาได้ในภายหลัง

removeList = [
    "List of",
    "Lists of",
    "Timeline",
    "Comparison of",
    "History of",
    "Esoteric programming language"
    ]

nodes = [i for i in nodes if not any(r in i for r in removeList)]

บรรทัดเหล่านี้กำหนดรายการของสตริงย่อยที่จะลบออกจากข้อมูล จากนั้นสคริปต์จะผ่านข้อมูล โดยลบองค์ประกอบใดๆ ที่มีสตริงย่อยที่ไม่ต้องการ

ใน Python ต้องใช้โค้ดเพียงบรรทัดเดียว!

ฟังก์ชันตัวช่วยบางอย่าง

ตอนนี้คุณสามารถเริ่มขูด Wikipedia เพื่อสร้างรายการขอบ (และรวบรวมเมตาดาต้า) เพื่อให้ง่ายขึ้น ขั้นแรกให้กำหนดฟังก์ชันบางอย่าง

คว้า HTML

ฟังก์ชันแรกใช้โมดูล BeautifulSoup เพื่อรับ HTML สำหรับหน้า Wikipedia ของแต่ละภาษา

base = "https://en.wikipedia.org/wiki/"

def getSoup(n):
    try:
        with urllib.request.urlopen(base+n) as response:
            soup = BS(response.read(),'html.parser')
            table = soup.find_all("table",class_="infobox vevent")[0]                return table
     except:
         pass

ฟังก์ชันนี้ใช้โมดูล urllib.request เพื่อรับ HTML สำหรับหน้าเว็บที่ “https://en.wikipedia.org/wiki/” + “programming language” .

จากนั้นจะส่งต่อไปยัง BeautifulSoup ซึ่งจะอ่านและแยกวิเคราะห์ HTML ให้เป็นวัตถุที่เราสามารถใช้เพื่อค้นหาข้อมูลได้

ต่อไป ใช้ find_all() วิธีการแยกองค์ประกอบ HTML ที่คุณสนใจ

นี่จะเป็นตารางสรุปที่ด้านบนของบทความภาษาโปรแกรมแต่ละบทความ จะระบุสิ่งเหล่านี้ได้อย่างไร

วิธีที่ง่ายที่สุดคือไปที่หน้าภาษาโปรแกรม คุณสามารถใช้เครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ของเบราว์เซอร์เพื่อตรวจสอบองค์ประกอบที่สนใจได้ที่นี่

ตารางสรุปมีแท็ก HTML <tab le> และ CSS classes "in fobox" and "v เหตุการณ์" เพื่อให้คุณสามารถใช้สิ่งเหล่านี้เพื่อระบุตารางใน HTML

ระบุสิ่งนี้ด้วยอาร์กิวเมนต์:

• "table" และ
• class_="infobox vevent"

find_all() ส่งคืนรายการองค์ประกอบทั้งหมดที่ตรงกับเกณฑ์ หากต้องการระบุองค์ประกอบที่คุณสนใจจริงๆ ให้เพิ่มดัชนี [0] . หากฟังก์ชันสำเร็จ จะส่งคืน table วัตถุ. มิฉะนั้น จะส่งคืน None .

ด้วยขั้นตอนการรวบรวมข้อมูลอัตโนมัติ การจัดการข้อยกเว้นอย่างละเอียดจึงเป็นสิ่งสำคัญเสมอ หากไม่เป็นเช่นนั้น ในกรณีที่ดีที่สุด สคริปต์จะขัดข้องและคุณจะต้องเริ่มต้นใหม่

ในกรณีที่เลวร้ายที่สุด คุณจะจบลงด้วยชุดข้อมูลที่เต็มไปด้วยความไม่สอดคล้องกันและข้อผิดพลาด นี้จะทำให้ฝันร้ายในการทำงานกับสายเกินไป

ดึงข้อมูลเมตา

ฟังก์ชันถัดไปใช้ table วัตถุเพื่อค้นหาข้อมูลเมตาบางอย่าง ที่นี่จะค้นหาตารางสำหรับปีที่ภาษาปรากฏเป็นครั้งแรก

def getYear(t):
    try:
        t = t.get_text()
        year = t[t.find("appear"):t.find("appear")+30]
        year = re.match(r'.*([1-3][0-9]{3})',year).group(1)
        return int(year)
    except:
        return "Could not determine"

ฟังก์ชันสั้นๆ นี้ใช้ table วัตถุเป็นอาร์กิวเมนต์ และใช้ get_text() . ของ BeautifulSoup ทำหน้าที่สร้างสตริง

ขั้นตอนต่อไปคือการสร้างสตริงย่อยชื่อ year . ใช้อักขระ 30 ตัวหลังจากการปรากฏครั้งแรกของคำว่า "appear" . สตริงนี้ควรมีปีที่ภาษาปรากฏขึ้นครั้งแรก

หากต้องการแยกเฉพาะปี ให้ใช้นิพจน์ทั่วไป (ได้รับความอนุเคราะห์จาก re โมดูล) เพื่อจับคู่อักขระใดๆ ที่ขึ้นต้นด้วยตัวเลขระหว่าง 1 ถึง 3 และตามด้วยตัวเลขสามหลัก

re.match(r'.*([1-3][0-9]{3})',year)

หากสำเร็จ ฟังก์ชันจะส่งกลับ year เป็นจำนวนเต็ม มิฉะนั้น จะแสดงข้อความที่ดูเศร้าว่า "ไม่สามารถระบุได้" คุณอาจต้องการขูดข้อมูลเมตาเพิ่มเติม เช่น กระบวนทัศน์ นักออกแบบ หรือวินัยในการพิมพ์

การรวบรวมลิงก์

อีกหนึ่งฟังก์ชันสำหรับคุณ คราวนี้คุณจะป้อน table วัตถุสำหรับภาษาที่กำหนด และหวังว่าจะได้รับรายชื่อภาษาโปรแกรมอื่นๆ

def getLinks(t):
    try:
        table_rows = t.find_all("tr")
        for i in range(0,len(table_rows)-1):
            try:
                if table_rows[i].get_text() == "\nInfluenced\n":
                    out = []
                    for j in table_rows[i+1].find_all("a"):
                        try:
                            out.append(j['title'])
                        except:
                            continue
                    return out
            except:
                continue
        return
    except:
        return

ว้าว ดูรังนั่นสิ… เกิดอะไรขึ้นที่นี่จริง ๆ

ฟังก์ชันนี้ใช้ประโยชน์จากข้อเท็จจริงที่ว่า table วัตถุมีโครงสร้างที่สม่ำเสมอ ข้อมูลในตารางถูกจัดเก็บไว้ในแถว (แท็ก HTML ที่เกี่ยวข้องคือ < tr> ). หนึ่งในแถวเหล่านี้จะมี`ข้อความ "\nInfluenced\n" . ส่วนแรกของฟังก์ชันจะค้นหาว่าแถวนี้คือแถวใด

เมื่อพบแถวนี้แล้ว คุณก็มั่นใจได้ในลำดับต่อไป แถวมีลิงก์ไปยังภาษาการเขียนโปรแกรมแต่ละภาษาที่ได้รับอิทธิพลจากภาษาปัจจุบัน ค้นหาลิงก์เหล่านี้โดยใช้ find_all("a") — โดยที่อาร์กิวเมนต์ "a" สอดคล้องกับแท็ก HTML <a> .

สำหรับแต่ละลิงค์ j ต่อท้าย ["title"] ให้กับรายการที่เรียกว่า out . เหตุผลที่สนใจ ["title"] เนื่องจากแอตทริบิวต์นี้จะตรงกับ ทุกประการ ชื่อภาษาที่เก็บไว้ใน nodes .

ตัวอย่างเช่น Java ถูกเก็บไว้ใน nodes เป็น "Java (programming language)" ดังนั้น คุณจึงต้องใช้ชื่อที่แน่นอนนี้ตลอดทั้งชุดข้อมูล

ถ้าสำเร็จ getLinks() ส่งคืนรายการภาษาโปรแกรม ส่วนที่เหลือของฟังก์ชันเกี่ยวข้องกับการจัดการข้อยกเว้น ในกรณีที่มีข้อผิดพลาดเกิดขึ้นในทุกขั้นตอน

การรวบรวมข้อมูล

ในที่สุด คุณเกือบจะพร้อมที่จะนั่งลงและปล่อยให้สคริปต์ทำหน้าที่ของมัน มันจะรวบรวมข้อมูลและเก็บไว้ในวัตถุสองรายการ

edgeList = [["Source,Target"]]
meta = [["Id","Year"]]

ตอนนี้เขียนลูปที่จะใช้ฟังก์ชั่นที่กำหนดไว้ก่อนหน้านี้กับทุกรายการใน nodes และเก็บผลลัพธ์ใน edgeList และ meta .

for n in nodes:
    try:
        temp = getSoup(n)
    except:
        continue
    try:
        influenced = getLinks(temp)
        for link in influenced:
            if link in nodes:
                edgeList.append([n+","+link])
                print([n+","+link])
    except:
        continue
    year = getYear(temp)
    meta.append([n,year])

ฟังก์ชันนี้ใช้แต่ละภาษาใน nodes และพยายามดึงตารางสรุปจากหน้า Wikipedia

จากนั้นจะดึงข้อมูลภาษาทั้งหมดที่ตารางระบุว่าได้รับอิทธิพลจากภาษาที่เป็นปัญหา

สำหรับแต่ละภาษาที่ปรากฏใน nodes รายการ ผนวกองค์ประกอบเพื่อ edgeList ในรูปแบบ ["source,target"] . ด้วยวิธีนี้ คุณจะสร้างรายการขอบเพื่อป้อนเข้าสู่ Gephi

เพื่อการดีบัก ให้พิมพ์แต่ละองค์ประกอบที่เพิ่มลงใน edgeList — เพื่อให้แน่ใจว่าทุกอย่างทำงานตามที่ควรจะเป็น หากคุณละเอียดถี่ถ้วนเป็นพิเศษ คุณสามารถเพิ่มคำสั่งการพิมพ์ลงใน except อนุประโยคด้วย

ต่อไป หาชื่อและปีของภาษา แล้วต่อท้าย meta รายการ

การเขียนเป็น CSV

เมื่อวนรอบแล้ว ขั้นตอนสุดท้ายคือการเขียนเนื้อหาของ edgeList และ meta เป็นไฟล์ค่าที่คั่นด้วยเครื่องหมายจุลภาค (CSV) ทำได้ง่ายๆ ด้วย csv โมดูลนำเข้าก่อนหน้านี้

with open("edge_list.csv","w") as f: 
    wr = csv.writer(f)
    for e in edgeList:
        wr.writerow(e)

with open("metadata.csv","w") as f2:
    wr = csv.writer(f2)
    for m in meta:
        wr.writerow(m)

เสร็จแล้ว! บันทึกสคริปต์และจากการรันเทอร์มินัล:

$ python3 script.py

คุณควรเห็นสคริปต์พิมพ์แต่ละคู่ของเป้าหมายต้นทางในขณะที่สร้างรายการขอบ ตรวจสอบให้แน่ใจว่าการเชื่อมต่ออินเทอร์เน็ตของคุณมั่นคง และนั่งลงในขณะที่สคริปต์ใช้เวทย์มนตร์

ขั้นตอนที่ 3 — การสร้างกราฟด้วย Gephi

หวังว่าคุณจะติดตั้งและใช้งาน Gephi ก่อนหน้านี้ ตอนนี้คุณสามารถสร้างโครงการใหม่และใช้ข้อมูลที่คุณรวบรวมเพื่อสร้างกราฟโดยตรง นี่จะแสดงให้เห็นว่าภาษาโปรแกรมต่างๆ มีอิทธิพลต่อกันและกันอย่างไร!

เริ่มต้นด้วยการสร้างโปรเจ็กต์ใหม่ใน Gephi และเปลี่ยนไปใช้มุมมอง "Data Laboratory" นี่เป็นอินเทอร์เฟซแบบสเปรดชีตสำหรับจัดการข้อมูลใน Gephi สิ่งแรกที่ต้องทำคือนำเข้ารายการขอบ

• คลิก “นำเข้าสเปรดชีต”
• เลือก edge_list.csv ไฟล์ที่สร้างโดยสคริปต์ Python ตรวจสอบให้แน่ใจว่าเกฟีรู้ที่จะใช้เครื่องหมายจุลภาคเป็นตัวคั่น
• เลือก “รายการขอบ” จากประเภทรายการ
• คลิก "ถัดไป" และตรวจสอบว่าคุณกำลังนำเข้าทั้งคอลัมน์ต้นทางและคอลัมน์เป้าหมายเป็นสตริง

สิ่งนี้ควรอัปเดต Data Lab ด้วยรายการโหนด ตอนนี้ นำเข้า metadata.csv ไฟล์. คราวนี้ อย่าลืมเลือก “รายการโหนด” จากประเภทรายการ

สลับไปที่แท็บ "ดูตัวอย่าง" และดูว่าเครือข่ายมีลักษณะอย่างไร

อา… มันเป็นเพียงเล็กน้อย… ขาวดำ และยุ่ง เหมือนปาเก็ตตี้จานนึง มาแก้ไขปัญหานี้กันเถอะ

ทำให้สวยขึ้น

มีหลายวิธีที่คุณสามารถทำงานในการนำเสนอ และนี่คือที่มาของอิสระในการสร้างสรรค์ ด้วยการสร้างภาพข้อมูลเครือข่าย มีสามสิ่งที่ต้องคำนึงถึงเป็นหลัก:

1. การวางตำแหน่ง มีอัลกอริธึมหลายอย่างที่สามารถสร้างรูปแบบโครงร่างสำหรับเครือข่ายได้ ตัวเลือกยอดนิยมคืออัลกอริทึม Fruchterman-Reingold ซึ่งมีอยู่ใน Gephi
2. การปรับขนาด ขนาดของโหนดในกราฟสามารถใช้เพื่อแสดงคุณสมบัติที่น่าสนใจบางอย่างได้ บ่อยครั้ง นี่เป็นการวัดศูนย์กลาง . มีหลายวิธีในการวัดศูนย์กลาง แต่ทั้งหมดสะท้อนถึง "ความสำคัญ" ของโหนดที่กำหนดในแง่ของความเชื่อมโยงที่ดีกับส่วนที่เหลือของเครือข่าย
3. ระบายสี นอกจากนี้ยังสามารถใช้สีเพื่อแสดงคุณสมบัติบางอย่างของโหนดได้อีกด้วย มักใช้สีเพื่อบ่งบอกถึงโครงสร้างชุมชน . มีการกำหนดอย่างกว้างๆ ว่าเป็น "กลุ่มของโหนดที่เชื่อมต่อกันมากกว่าส่วนอื่นๆ ของกราฟ" ในโซเชียลเน็ตเวิร์ก ข้อมูลนี้สามารถเปิดเผยมิตรภาพ ครอบครัว หรือกลุ่มอาชีพได้ มีอัลกอริธึมหลายอย่างที่สามารถตรวจจับโครงสร้างชุมชนได้ Gephi มาพร้อมกับวิธี Louvain ในตัว

ในการเปลี่ยนแปลงเหล่านี้ คุณจะต้องคำนวณสถิติบางอย่าง สลับไปที่หน้าต่าง "ภาพรวม" ที่นี่คุณจะเห็นแผงด้านขวา ควรมีแท็บ "สถิติ" เปิดสิ่งนี้แล้วคุณจะเห็นตัวเลือกมากมาย

Gephi มาพร้อมกับความสามารถทางสถิติในตัวมากมาย สำหรับแต่ละรายการ การคลิก "เรียกใช้" จะสร้างรายงานที่จะเปิดเผยข้อมูลเชิงลึกเกี่ยวกับเครือข่าย

ข้อมูลที่เป็นประโยชน์ที่ควรทราบ ได้แก่:

• ระดับเฉลี่ย ภาษาเฉลี่ยเชื่อมต่อกับคนอื่นประมาณสี่คน รายงานยังแสดงกราฟการแจกแจงองศาอีกด้วย สิ่งนี้แสดงให้เห็นว่าภาษาส่วนใหญ่มีการเชื่อมต่อน้อยมาก ในขณะที่ส่วนน้อยมีจำนวนมาก นี่แสดงให้เห็นว่านี่เป็นไม่มีขนาด เครือข่าย . มีการค้นคว้าวิจัยมากมายเกี่ยวกับเครือข่ายที่ไม่มีขนาดและกระบวนการที่สร้างเครือข่ายเหล่านี้
• เส้นผ่านศูนย์กลาง เครือข่ายนี้มีเส้นผ่านศูนย์กลาง 12 ซึ่งหมายความว่านี่คือการเชื่อมต่อระหว่างสองภาษาที่ "กว้างที่สุด" ความยาวพาธเฉลี่ยต่ำกว่าสี่ ซึ่งหมายความว่า โดยเฉลี่ยแล้ว สองภาษาใดๆ จะถูกคั่นด้วยสี่ขอบ ตัวเลขเหล่านี้เป็นตัววัด "ขนาด" ของเครือข่าย
• โมดูลาร์ นี่คือคะแนนที่แสดงให้เห็นว่าเครือข่าย "แบ่งส่วน" เป็นอย่างไร ที่นี่ คะแนนโมดูลาร์ประมาณ 0.53 ซึ่งค่อนข้างสูง แสดงว่ามีโมดูลที่แตกต่างกันภายในเครือข่ายนี้ อีกครั้ง สิ่งนี้บ่งชี้ถึงสิ่งที่น่าสนใจเกี่ยวกับระบบพื้นฐาน ภาษามักจะตกอยู่ใน “กลุ่มอิทธิพล” ที่แตกต่างกัน

อย่างไรก็ตาม หากต้องการปรับเปลี่ยนรูปลักษณ์ของเครือข่าย ให้ไปที่แผงด้านซ้าย

ในแท็บ "เลย์เอาต์" คุณสามารถเลือกอัลกอริทึมเลย์เอาต์ที่จะใช้ได้ กด "วิ่ง" และดูการเปลี่ยนแปลงของกราฟแบบเรียลไทม์! ดูอัลกอริธึมเค้าโครงที่คุณคิดว่าใช้ได้ผลดีที่สุด

เหนือแท็บเค้าโครงคือแท็บ "ลักษณะที่ปรากฏ" ที่นี่ คุณสามารถเล่นกับการตั้งค่าต่างๆ สำหรับโหนดและสีขอบ ขนาด และป้ายกำกับ สิ่งเหล่านี้สามารถกำหนดค่าได้ตามแอตทริบิวต์ (รวมถึงสถิติที่คุณได้รับจาก Gephi เพื่อคำนวณ)

คุณสามารถ:

• ระบายสีโหนดด้วยแอตทริบิวต์โมดูลาร์ของพวกมัน ซึ่งจะแต่งแต้มสีตามความเป็นสมาชิกชุมชน
• กำหนดขนาดโหนดตามระดับ โหนดที่เชื่อมต่อที่ดีกว่าจะมีขนาดใหญ่กว่าโหนดที่เชื่อมต่อน้อยกว่า

อย่างไรก็ตาม คุณควรทดลองและสร้างเลย์เอาต์ที่คุณชอบที่สุด

เมื่อคุณพอใจกับลักษณะที่ปรากฏของกราฟแล้ว ก็ถึงเวลาไปยังขั้นตอนสุดท้าย — ส่งออกไปยังเว็บ!

ขั้นตอนที่ 4 — Sigma.js

คุณได้สร้างภาพข้อมูลเครือข่ายที่สามารถสำรวจได้ใน Gephi แล้ว คุณสามารถเลือกที่จะถ่ายภาพหน้าจอหรือบันทึกกราฟในรูปแบบ SVG, PDF หรือ PNG

อย่างไรก็ตาม หากคุณติดตั้งปลั๊กอิน Sigma.js ก่อนหน้านี้ ทำไมไม่ส่งออกกราฟเป็น HTML ล่ะ ซึ่งจะสร้างภาพข้อมูลเชิงโต้ตอบที่คุณสามารถโฮสต์ออนไลน์ หรืออัปโหลดไปยัง GitHub และแชร์กับผู้อื่นได้

ในการดำเนินการนี้ ให้เลือก “ส่งออก> เทมเพลต Sigma.js…” จากแถบเมนูของ Gephi

กรอกรายละเอียดตามต้องการ ตรวจสอบให้แน่ใจว่าได้เลือกไดเร็กทอรีที่คุณส่งออกโครงการไป คุณสามารถเปลี่ยนชื่อ คำอธิบาย คำอธิบาย ลักษณะการทำงานโฮเวอร์ และรายละเอียดอื่นๆ ได้มากมาย เมื่อพร้อมแล้ว คลิก “ตกลง”

ตอนนี้ หากคุณไปที่ไดเร็กทอรีที่คุณส่งออกโปรเจ็กต์ไป คุณจะเห็นโฟลเดอร์ที่มีไฟล์ทั้งหมดที่สร้างโดย Sigma.js

เปิด index.html ในเบราว์เซอร์ที่คุณชื่นชอบ ทาดา! มีเครือข่ายของคุณ! หากคุณรู้จัก CSS และ JavaScript เพียงเล็กน้อย คุณสามารถเจาะลึกไฟล์ที่สร้างขึ้นต่างๆ เพื่อปรับแต่งเอาต์พุตได้ตามที่คุณต้องการ

และนั่นคือบทสรุปของบทช่วยสอนนี้!

สรุป

• ระบบจำนวนมากสามารถสร้างแบบจำลองและแสดงภาพเป็นเครือข่ายได้ ทฤษฎีกราฟเป็นสาขาหนึ่งของคณิตศาสตร์ที่มีเครื่องมือที่ช่วยให้เข้าใจโครงสร้างและคุณสมบัติของเครือข่าย
• คุณใช้ Python ขูดข้อมูลจาก Wikipedia เพื่อสร้างกราฟอิทธิพลของภาษาโปรแกรม เกณฑ์ความเชื่อมโยงคือว่าภาษาหนึ่งๆ ถูกระบุว่ามีอิทธิพลต่อการออกแบบของผู้อื่นหรือไม่
• Gephi และ Sigma.js เป็นเครื่องมือโอเพนซอร์สที่ช่วยให้คุณวิเคราะห์และแสดงภาพเครือข่ายได้ ช่วยให้คุณส่งออกเครือข่ายในรูปแบบรูปภาพ PDF หรือเว็บได้

ขอขอบคุณที่อ่าน - ฉันหวังว่าจะมีความคิดเห็นหรือคำถามใด ๆ ที่คุณอาจมี! สำหรับแหล่งข้อมูลที่ยอดเยี่ยมในการเรียนรู้เพิ่มเติมเกี่ยวกับทฤษฎีกราฟ โปรดดูหนังสือออนไลน์เชิงโต้ตอบของ Albert-László Barabási

รหัสเต็มสำหรับบทช่วยสอนนี้สามารถพบได้ที่นี่