GraphAcademy
Course

Analyze Graph Data with Python

Workshop: analyze graphs in Python with the GDS client and Aura Graph Analytics. Run PageRank, Louvain, FastRP embeddings, and pathfinding at scale.

4 hours13 lessons across 2 modules
About this workshop

In this 4-hour workshop, you will learn

Analyze Graph Data with Python is the companion course to an instructor-led GraphAcademy workshop. Over roughly four hours, you move graph data scienceAnalysing data through the structure of its connections. Also the name of the Neo4j library that implements it. out of Neo4j Browser and into Python: running centralityHow important a node is within a graph. Each centrality algorithm defines importance differently., community detectionA family of algorithms that group nodes by how they connect. Each algorithm defines a community differently., and embeddingInformation represented as a numerical vector, positioned so that similar information sits close together. algorithms on a citation network with the GDS Python client, then scaling up to pathfindingA family of algorithms that find routes through a graph. What counts as the best route differs by algorithm. on a logistics dataset with Aura Graph AnalyticsThe Aura service that runs graph algorithms in a separate session, with no plugin to install..

The premise is simple: most real-world data science happens in Python. The Graph Data Science (GDS) Python client wraps the same algorithms and the same project-run-write workflow you already know in a Pythonic interface that returns Pandas DataFrames, so your graph analytics results flow straight into the rest of your data science stack. Aura Graph Analytics then removes the infrastructure question entirely, running those algorithms in on-demand, session-based compute.

  • GDS Python Client

    Install and configure the GDS Python client to connect to Neo4j and run graph algorithms programmatically from a Python environment.

  • Aura Graph Analytics

    Use Neo4j Aura Graph Analytics to execute graph algorithms at scale without managing a dedicated GDS server or local infrastructure.

  • PageRank

    Apply the PageRank algorithm to identify the most influential nodes in a graph and interpret the resulting scores for real-world datasets.

  • Betweenness Centrality

    Compute betweenness centrality to discover nodes that act as critical bridges in a network and understand their role in information flow.

  • FastRP

    Generate node embeddings with FastRP to represent graph structure as numerical vectors, enabling downstream machine learning tasks.

Before you start

What you need to take part.

  • A GraphAcademy account

    The workshop is delivered here on GraphAcademy, so you need to be signed in to work through the lessons and keep your progress. Creating an account is free.

    Sign in or create an account

  • A GitHub account, or Git on your own machine

    You write code against the workshop-gds-python-aga repository. The quickest route is a GitHub Codespace, an online editor that clones the code and installs everything for you — that needs a GitHub account.

    If you would rather work locally, clone the repository with Git and run it in your own editor instead. No GitHub account is needed for that.

Course content

2 modules, 4 hours.

  1. 9 lessons
    1. Introduction to the Python GDS Client5 min
    2. GDS Workflows in Python5 min
    3. From Cypher to Native Projection5 min
    4. Running Algorithms5 min
    5. Citation Networks5 min
    6. PageRank5 min
    7. Betweenness Centrality5 min
    8. Louvain Community Detection5 min
    9. Scaled Properties and FastRP Embeddings5 min
  2. 4 lessons
    1. Introduction to Aura Graph Analytics5 min
    2. Dijkstra's Shortest Path5 min
    3. Yen's K-Shortest Paths5 min
    4. Workshop Complete!5 min

  • Who this workshop is for

    This course accompanies a live, instructor-led workshop: if you are attending one, work through the lessons alongside the instructor; if not, every step is in the course and you can complete it self-paced. It is for data scientists and analysts who have learned GDSAnalysing data through the structure of its connections. Also the name of the Neo4j library that implements it. basics in Neo4j Browser and want to work the way they normally do — in Python, with DataFrames and notebooks — and for engineers evaluating Aura Graph AnalyticsThe Aura service that runs graph algorithms in a separate session, with no plugin to install. for running graph algorithms at scale without managing GDS installations. You should first complete Graph Data Science in Practice, the preceding workshop, or have equivalent experience with graph projectionsAn in-memory copy of part of your database that graph algorithms run against. You choose which nodes and relationships it holds. and the project-run-write workflow, and be familiar with Python and Pandas DataFrames.

  • What you'll do

    This is a hands-on workshop. You open a pre-configured GitHub Codespace containing the workshop repository and a ready-to-run Python environment, so there is nothing to install locally. From there, every lesson has you executing real code: connecting the GDSAnalysing data through the structure of its connections. Also the name of the Neo4j library that implements it. Python client to Neo4j, projecting graphs, running algorithms, and reading the results back as DataFrames.

    In the first half you analyze a citation network, scoring papers with PageRankA centrality algorithm that scores a node by the number of nodes pointing at it and by how important those nodes are. and Betweenness CentralityA score for each node equal to how often it lies on the shortest paths between other nodes., finding research communities with LouvainA community detection algorithm that repeatedly merges nodes into groups for as long as merging raises modularity., and generating FastRPA node embedding algorithm, short for Fast Random Projection. It builds each node's vector by combining random vectors drawn from the nodes around it. node embeddingsA list of numbers that stands in for a node's position in the graph, so that nodes in similar positions get similar lists. you can feed to downstream machine learning. In the second half you create ephemeral Aura Graph AnalyticsThe Aura service that runs graph algorithms in a separate session, with no plugin to install. sessions and run DijkstraAn algorithm that finds the cheapest route between two nodes.'s and Yen's pathfindingA family of algorithms that find routes through a graph. What counts as the best route differs by algorithm. algorithms against the Cargo 2000 logistics dataset — five months of air cargo shipping data from a real freight forwarder — to find inefficiencies in its routing decisions.

  • Where to go next

    The natural next step is Aura Graph Analytics fundamentals, which goes deeper on the session model you used in the final module. From there, Understand centrality algorithms sharpens the judgement side of the centralityHow important a node is within a graph. Each centrality algorithm defines importance differently. work you did here. When you are ready to validate your skills, the Neo4j Graph Data Science certification covers projectionsAn in-memory copy of part of your database that graph algorithms run against. You choose which nodes and relationships it holds., algorithm selection, and result interpretation across the categories you practised in both workshop modules. GraphAcademy also runs workshops on graph fundamentals, data import, and generative AIModels that produce new content rather than classifying or scoring content that already exists. throughout the year — find upcoming sessions on the workshops page.