explaingit

qinghao-hu/philly-trace-scripts

Analysis updated 2026-08-08 · repo last pushed 2020-11-22

3Jupyter NotebookAudience · researcherComplexity · 2/5DormantSetup · moderate

TLDR

A set of analysis scripts that clean and visualize Microsoft's 2017 Philly dataset, showing how a large AI training GPU cluster was used, how long jobs waited, and how efficiently GPUs ran.

Mindmap

mindmap
  root((repo))
    What it does
      Cleans messy cluster data
      Builds usage timelines
      Generates visual charts
    Inputs
      Microsoft Philly trace
      GPU usage logs
      Job logs
    Outputs
      Corrected machine list
      Cluster usage timeline
      Distribution and utilization charts
    Tech stack
      Jupyter Notebook
      Python
    Audience
      Researchers
      Data scientists
    Notable details
      Found data discrepancies
      Documents accuracy conflict

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Analyze how often AI training jobs were interrupted or waited for resources in a real GPU cluster.

USE CASE 2

Visualize GPU utilization trends across a large AI training cluster over time.

USE CASE 3

Verify the accuracy of Microsoft's published Philly trace dataset against independent analysis.

USE CASE 4

Build a corrected list of active machines from raw GPU usage logs for further research.

What is it built with?

Jupyter NotebookPython

How does it compare?

qinghao-hu/philly-trace-scriptsabdurrafey237/rag-chatbotatcold/figures-yann
Stars333
LanguageJupyter NotebookJupyter NotebookJupyter Notebook
Last pushed2020-11-222023-06-24
MaintenanceDormantDormant
Setup difficultymoderatemoderateeasy
Complexity2/53/51/5
Audienceresearchergeneralgeneral

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · moderate Time to first run · 30min

Requires downloading Microsoft's Philly trace dataset and familiarity with running Jupyter Notebooks.

No license information was provided in the project explanation, so usage terms are unknown.

In plain English

philly-trace-scripts is a collection of analysis scripts that help researchers understand how Microsoft managed a large network of computers equipped with GPUs (specialized chips for heavy-duty math, often used to train artificial intelligence). Microsoft publicly released a dataset, called the Philly trace, that captures the real-world activity of one of their AI training clusters from 2017. This project takes that raw, messy data and turns it into clean summaries and visual charts. The work is split across three Jupyter Notebooks, which are interactive documents that combine code, notes, and output. First, one script figures out which physical machines were actually active in the cluster by looking at GPU usage logs, producing a corrected machine list. Second, another script takes the job logs and that corrected machine list to build a timeline of how the cluster was used over time. Finally, a third script takes those timelines and machine lists and generates visual charts showing how the machines were distributed and how GPU utilization changed across the cluster. The audience for this project is researchers or data scientists studying how large-scale AI infrastructure operates in the real world. For example, if you are trying to understand how often AI training jobs get interrupted, how long they wait for resources, or how efficiently a massive cluster of GPUs is utilized, these scripts help you extract those insights from Microsoft's data. One notable detail is that the author found discrepancies between their own analysis and the official results provided by Microsoft. The project documents this conflict, pointing to an open discussion about the data's accuracy. This transparency makes the scripts valuable not just for generating charts, but for anyone who needs a trusted, independently verified understanding of how the original AI training cluster actually performed.

Copy-paste prompts

Prompt 1
Using the Philly trace dataset from Microsoft, help me write a script that identifies which physical machines were actually active by examining GPU usage logs, similar to the approach in philly-trace-scripts.
Prompt 2
I have job logs and a corrected machine list from the Philly trace. Help me build a timeline showing cluster usage over time, including job arrivals, completions, and interruptions.
Prompt 3
Help me generate visual charts from cluster GPU utilization data that show machine distribution and how GPU usage changes over time, inspired by the philly-trace-scripts analysis.
Prompt 4
I found discrepancies between my analysis of the Philly trace dataset and Microsoft's official results. Help me document and investigate these differences in a reproducible notebook format.

Frequently asked questions

What is philly-trace-scripts?

A set of analysis scripts that clean and visualize Microsoft's 2017 Philly dataset, showing how a large AI training GPU cluster was used, how long jobs waited, and how efficiently GPUs ran.

What language is philly-trace-scripts written in?

Mainly Jupyter Notebook. The stack also includes Jupyter Notebook, Python.

Is philly-trace-scripts actively maintained?

Dormant — no commits in 2+ years (last push 2020-11-22).

What license does philly-trace-scripts use?

No license information was provided in the project explanation, so usage terms are unknown.

How hard is philly-trace-scripts to set up?

Setup difficulty is rated moderate, with roughly 30min to a first successful run.

Who is philly-trace-scripts for?

Mainly researcher.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.