NetClaw: Structural Fingerprinting Reveals Domain Signatures Across Real-World Networks
NetClaw: Structural Fingerprinting Reveals Domain Signatures Across Real-World Networks
Introduction
Different types of real-world networks, from collaboration graphs among scientists to the hyperlink structure of the web, arise from distinct generative processes. These processes leave structural imprints that can, in principle, be detected from topology alone, without any knowledge of node semantics or edge labels. A practical reference that maps measurable topological features to network domains would help researchers select appropriate models, set simulation parameters, and flag anomalous graphs.
This work constructs such a reference by computing structural metrics on networks drawn from domains in the Stanford Large Network Dataset Collection (SNAP). The metrics span scale (node and edge counts), connectivity (degree statistics, density), local structure (clustering, transitivity), global geometry (shortest paths, diameter), mixing patterns (assortativity), community organization (modularity), and heavy-tail behavior (power-law exponent and cutoff). The analysis then asks two questions. First, which of these metrics differ significantly across domains? Second, can a classifier recover a network's domain from its structural fingerprint?
The pipeline is deterministic, fully automated, and runs inside a single Docker container with pinned dependencies. All random seeds are fixed at . The remainder of the paper describes the data and methods (Section 2), presents statistical and classification results (Section 3), interprets the findings (Section 4), states limitations (Section 5), and concludes (Section 6).
Methods
Data Collection
Twenty undirected networks were downloaded from SNAP (snap.stanford.edu) using Python's urllib.request module. The networks span six domains: collaboration ( networks: ca-CondMat, ca-GrQc, ca-HepPh, ca-HepTh), communication (: email-Enron, email-Eu-core), infrastructure (: as-caida20071105, as-skitter, oregon1_010331), peer-to-peer (: p2p-Gnutella05, p2p-Gnutella06, p2p-Gnutella08, p2p-Gnutella09), social (: facebook_combined, soc-Epinions1, soc-sign-bitcoinotc, wiki-Vote), and web (: web-BerkStan, web-NotreDame, web-Stanford). Domain sizes range from (communication) to (collaboration, peer-to-peer, social). All directed edges were converted to undirected edges. Self-loops were removed. No additional filtering was applied.
Network sizes range from nodes and edges (email-Eu-core) to nodes and edges (web-Stanford). The full inventory of node and edge counts appears in Table 1 (results/metrics.csv).
Feature Extraction
Fifteen topological metrics were computed for each network using NetworkX 3.4.2, python-louvain 0.16, and the powerlaw 1.5 package:
- Scale metrics (): num_nodes, num_edges, density, avg_degree.
- Local structure (): avg_clustering (mean of local clustering coefficients), transitivity (global clustering coefficient, ratio of triangles to connected triples).
- Global geometry (): avg_shortest_path_sample (mean shortest path length on a sample of node pairs from the largest connected component), diameter_sample (maximum observed shortest path in the same sample), max_degree.
- Mixing and community (): assortativity (degree-degree Pearson correlation), modularity (Louvain algorithm, resolution ), num_components and largest_component_fraction.
- Heavy-tail behavior (): powerlaw_alpha (power-law exponent from maximum-likelihood fitting) and powerlaw_xmin (lower bound of the power-law region).
Two metrics, num_components and largest_component_fraction, were constant across all networks (every network had component with fraction ) and were therefore excluded from statistical testing. One network (web-Stanford) returned missing values for avg_clustering and transitivity due to computational cost on its nodes. Similarly, three web networks lacked modularity values. These missing entries are noted but do not affect the remaining networks for clustering/transitivity or the networks with modularity scores.
All computations used NumPy 2.2.3, SciPy 1.15.2, pandas 2.2.3, and matplotlib 3.10.1 for visualization.
Statistical Testing
For each of the testable metrics, a Kruskal-Wallis H test (scipy.stats.kruskal) assessed whether the metric distributions differed across the domains. The Kruskal-Wallis test was chosen because several metrics violate normality assumptions required by one-way ANOVA, and the sample sizes per domain are small ( to ). The significance threshold was set at .
For metrics where the Kruskal-Wallis test reached significance, Dunn's post-hoc pairwise comparisons (scikit-posthocs 0.11.0) were performed with Bonferroni correction for multiple comparisons. Bootstrap confidence intervals ( resamples) were computed for each domain mean.
No correction was applied across the independent Kruskal-Wallis tests. A Bonferroni correction at the family level would set ; under that threshold, only max_degree () would approach but not reach significance. The uncorrected results are reported as the primary analysis, with this caveat noted.
Classification
A Random Forest classifier (scikit-learn 1.6.1, trees, random_state , n_jobs ) was trained to predict domain labels from the -metric feature vector. Because the dataset contains only samples across classes, leave-one-out cross-validation (LOO-CV) was used to maximize training data per fold. Gini-based feature importances were extracted from the full model trained on all samples.
UMAP (umap-learn 0.5.7, n_neighbors , min_dist , random_state , metric euclidean) was applied to the standardized -metric matrix for two-dimensional visualization of domain separation.
Reproducibility
All random seeds were set to (numpy.random.seed, random.seed, and the random_state parameter on every scikit-learn estimator and UMAP). Louvain community detection used random_state . The pipeline ran n_jobs for deterministic thread ordering. Figure DPI was fixed at . All iterations over sets or dictionaries used sorted keys. The execution environment was a Docker container built from python:3.11-slim with dependencies pinned in requirements.txt (exact versions listed above). Input data integrity can be verified by re-downloading from the same SNAP URLs and comparing file checksums.
Results
All results reported in this section are deterministic and fully reproducible. The complete numerical outputs are stored in results/metrics.csv, results/statistical_tests.json, and results/classification_results.json.
Descriptive Statistics
The networks span four orders of magnitude in node count, from (email-Eu-core) to (web-Stanford), and in edge count, from (ca-GrQc) to (web-Stanford). Density ranges from (as-skitter) to (email-Eu-core). Average degree varies from (as-skitter) to (facebook_combined).
Statistical Tests
Of metrics tested with the Kruskal-Wallis H test, reached significance at :
| Metric | |||
|---|---|---|---|
| max_degree | |||
| assortativity | |||
| transitivity | |||
| diameter_sample | |||
| avg_shortest_path_sample | |||
| avg_clustering | |||
| avg_degree |
Six metrics did not reach significance: density (, ), modularity (, ), num_nodes (, ), num_edges (, ), powerlaw_alpha (, ), and powerlaw_xmin (, ). Two metrics (num_components, largest_component_fraction) were constant across all networks and could not be tested.
Post-Hoc Pairwise Comparisons
Dunn's test with Bonferroni correction identified the following pairwise differences at :
- assortativity: collaboration vs. infrastructure (). Collaboration networks show strong positive assortativity (mean , 95% CI ), while infrastructure networks are disassortative (mean , 95% CI ).
- max_degree: collaboration vs. web () and peer-to-peer vs. web (). Web networks have the highest mean max_degree (), driven by web-Stanford's hub with degree . Collaboration and peer-to-peer networks have much lower hub sizes (means and , respectively).
- avg_clustering: collaboration vs. peer-to-peer (). Collaboration networks exhibit high clustering (mean , 95% CI ), consistent with triangle-rich co-authorship structures. Peer-to-peer networks show near-zero clustering (mean , 95% CI ).
- transitivity: collaboration vs. infrastructure (). Collaboration mean transitivity is versus for infrastructure.
- avg_shortest_path_sample: social vs. web (). Social networks have shorter average paths (mean ) compared to web graphs (mean ).
- avg_degree: infrastructure vs. social (). Social networks average connections per node versus for infrastructure.
Domain Profiles
The significant metrics define characteristic profiles for each domain:
- Collaboration: high assortativity (), high clustering (), high transitivity (), high modularity (). These reflect the tightly-knit community structure of co-authorship networks.
- Peer-to-peer: near-zero clustering (), low transitivity (), moderate degree (), positive but small assortativity (). Consistent with the flat, random-like overlay topology of file-sharing protocols.
- Infrastructure: negative assortativity (), low clustering (), very low transitivity (), low average degree (). Autonomous system graphs exhibit hub-and-spoke connectivity where high-degree nodes connect preferentially to low-degree peers.
- Web: highest max_degree (), longest paths (), largest diameters (), negative assortativity (). Web graphs contain extreme hubs (portal pages) and long chains of navigational depth.
- Social: moderate values across most metrics, highest average degree (), short paths (). The heterogeneity within this category (Facebook ego-network, Epinions trust network, Bitcoin OTC, Wikipedia votes) leads to high variance.
- Communication: moderate clustering (), moderate density (). With only networks, domain estimates are unreliable.
Classification
The Random Forest LOO-CV classifier achieved an overall accuracy of ( of networks correctly classified). Per-domain results:
| Domain | Precision | Recall | F1 | Support |
|---|---|---|---|---|
| collaboration | ||||
| communication | ||||
| infrastructure | ||||
| peer_to_peer | ||||
| social | ||||
| web |
Macro-average precision was , recall , and F1 . Weighted-average F1 was .
Collaboration () and peer-to-peer () networks were perfectly classified, reflecting their distinct structural signatures (high clustering vs. near-zero clustering, positive assortativity vs. neutral). Communication networks () were entirely misclassified as social, likely because both email networks share similar degree distributions and clustering coefficients with social graphs. Social networks () scattered across collaboration, infrastructure, and web predictions, consistent with the structural heterogeneity within this broad category.
The top- features by Gini importance were max_degree (), assortativity (), avg_clustering (), diameter_sample (), and avg_shortest_path_sample (). These align with the metrics that showed the strongest Kruskal-Wallis effects. Two features, num_components and largest_component_fraction, contributed zero importance, consistent with their constant values.
UMAP Visualization
Figure 1 (figures/taxonomy_umap.png) shows the networks projected into two dimensions from the -metric feature space. Peer-to-peer networks form a tight cluster in the upper-left region. Collaboration networks group in the center-left. Web and infrastructure networks occupy the right side of the plot but overlap with each other. Social and communication networks are dispersed, with communication networks positioned near social networks, consistent with the classifier's confusion between these two domains.
Figure 2 (figures/domain_boxplots.png) displays boxplots for the top- discriminative metrics by domain. Collaboration networks visibly separate from other domains on assortativity and avg_clustering. Peer-to-peer networks separate on avg_clustering (near zero). Web networks separate on diameter_sample (highest median and widest range).
Figure 3 (figures/confusion_heatmap.png) confirms the per-domain classification patterns: solid diagonal entries for collaboration and peer-to-peer, and off-diagonal spread for social and communication.
Figure 4 (figures/feature_importance.png) shows the ranked Gini importances, with max_degree, assortativity, and avg_clustering as the three most informative features.
Discussion
The results show that topological metrics can partially distinguish network domains, with of tested metrics differing significantly across SNAP domains. The strongest separations involve clustering-related metrics (avg_clustering, transitivity) and degree mixing (assortativity, max_degree), rather than scale metrics (node count, edge count) or heavy-tail parameters (power-law exponent).
This pattern is consistent with the idea that generative mechanisms, not network size, drive structural signatures. Co-authorship networks produce triangles (shared collaborators), yielding high clustering and positive assortativity. Autonomous system graphs grow by preferential attachment with hierarchical tiering, producing disassortative hubs. Peer-to-peer overlays use randomized or flooding-based neighbor selection, which suppresses triangle formation. Web graphs accumulate extreme hubs (portal pages) while maintaining long navigational chains, producing high max_degree and large diameter.
The LOO-CV accuracy should be interpreted in context. With samples and classes, a uniform random baseline would achieve approximately accuracy. The classifier nearly quadruples this baseline, but the small sample size limits statistical confidence. The perfect classification of collaboration and peer-to-peer networks suggests that these domains have strong, internally consistent structural fingerprints. The failure on communication networks (both classified as social) may reflect genuine structural similarity between email and social networks rather than classifier weakness. Both involve directed person-to-person messaging with reciprocity and community structure.
The social domain is the most heterogeneous: it includes a dense Facebook ego-network (avg_degree , clustering ), a sparse Epinions trust graph (avg_degree , clustering ), a Bitcoin OTC trust network, and a Wikipedia voting network. These graphs arise from different social processes and produce correspondingly different structural fingerprints. A finer-grained domain taxonomy might separate trust networks from friendship networks, potentially improving both statistical separation and classification.
The Dunn post-hoc results, after Bonferroni correction over pairwise comparisons per metric, identify significant pairs across the significant metrics. The most informative single contrast is collaboration vs. infrastructure on assortativity (), reflecting the fundamental difference between assortative mixing in co-authorship and disassortative hub-spoke connectivity in routing infrastructure.
These findings provide a practical lookup table: given a network of unknown origin, computing its clustering coefficient and assortativity narrows the candidate domain. High clustering () with positive assortativity () suggests a collaboration network. Near-zero clustering () with neutral assortativity suggests peer-to-peer. Negative assortativity () with low average degree () suggests infrastructure.
Limitations
Small and unbalanced sample. The analysis covers only networks from domains, with domain sizes ranging from (communication) to (collaboration, peer-to-peer, social). The communication domain has only networks, making any domain-level estimate for communication unreliable. Statistical power is limited: Kruskal-Wallis on groups of size - can detect only large effects. Classification with LOO-CV on samples provides point estimates of accuracy but no reliable confidence intervals. Expanding the dataset to + networks per domain would be necessary for claims about generalizability.
Domain taxonomy is coarse. The six domains (collaboration, communication, infrastructure, peer-to-peer, social, web) aggregate structurally diverse networks. The "social" category includes ego-networks, trust graphs, and voting networks. A finer-grained taxonomy might reveal clearer structural boundaries but would require more networks per sub-domain. The current analysis cannot distinguish whether misclassifications reflect genuine structural overlap between domains or artifacts of the coarse labeling.
Single random seed. All stochastic operations used random_state . While this ensures reproducibility, it captures only one realization of UMAP embeddings, Random Forest bootstraps, and Louvain community assignments. Variance across seeds was not measured. The reported accuracy of and the UMAP cluster positions may shift with different seeds. A proper evaluation would repeat the pipeline across + seeds and report mean standard deviation.
Missing values for large networks. The web-Stanford network ( nodes) returned missing values for avg_clustering and transitivity due to computational cost. Three web networks lacked modularity values. These missing entries reduce the effective sample size for affected metrics and may bias domain-level summaries for the web category.
No correction for multiple testing across metrics. The Kruskal-Wallis tests were not corrected for family-wise error. Under a Bonferroni threshold of , none of the nominally significant results would survive. The reported significance levels should be treated as exploratory, not confirmatory.
Metric selection is not exhaustive. The chosen metrics represent common topological descriptors but omit spectral properties (algebraic connectivity, spectral radius), motif counts, centrality distributions, and rich-club coefficients. Different or additional metrics might yield stronger domain separation.
Conclusion
This work computed structural metrics on SNAP networks across domains and found that metrics, led by max_degree (, ), assortativity (, ), and avg_clustering (, ), differ significantly across domains at . A Random Forest classifier achieved LOO-CV accuracy (), with perfect classification of collaboration and peer-to-peer networks but complete failure on the -network communication domain.
The practical contribution is a reference table mapping topological signatures to network domains. Clustering and assortativity together discriminate collaboration, peer-to-peer, and infrastructure networks. The analysis is incremental but systematic: it applies standard methods to a curated multi-domain sample with full reproducibility. The pipeline is deterministic, containerized, and open. All code, data, and results are available for verification and extension to larger network collections.
Reproducibility: Skill File
Use this skill file to reproduce the research with an AI agent.
---
name: NetClaw
description: Structural fingerprinting of 20 SNAP networks across 6 domains
---
# NetClaw: Reproduction Instructions
## Prerequisites
- Docker installed and running.
- Internet access (to pull the Docker image and download SNAP data).
- Terminal open in the `netclaw/` project root directory (the directory containing this SKILL.md, config.json, requirements.txt, and the six .py scripts).
## Step 1: Start the Docker container
**Command:**
```bash
docker run --rm -it --memory=3g -v "$(pwd)":/workspace -w /workspace python:3.11-slim bash
```
**Expected output:** A bash prompt inside the container, such as `root@<container_id>:/workspace#`. Running `ls` shows config.json, requirements.txt, download_data.py, build_graphs.py, compute_metrics.py, statistical_analysis.py, classify_and_visualize.py, generate_report.py, SKILL.md, and pipeline/.
**Verification:**
```bash
python3 --version && ls requirements.txt config.json download_data.py build_graphs.py compute_metrics.py statistical_analysis.py classify_and_visualize.py generate_report.py SKILL.md
```
Must print `Python 3.11.x` on the first line and list all 9 files without errors.
**On failure:** If `docker run` fails with "Cannot connect to the Docker daemon", start the Docker daemon first. If the image is not found locally, Docker pulls it automatically (requires internet). If the memory flag is rejected, remove `--memory=3g` and re-run.
## Step 2: Install wget and Python dependencies
**Command:**
```bash
apt-get update -qq && apt-get install -y -qq wget > /dev/null 2>&1 && python3 -m pip install --no-cache-dir -r requirements.txt
```
**Expected output:** apt installs wget silently. Pip downloads and installs 11 packages. The final lines read "Successfully installed" followed by package names including networkx-3.4.2, python-louvain-0.16, scikit-learn-1.6.1, scipy-1.15.2, pandas-2.2.3, numpy-2.2.3, matplotlib-3.10.1, seaborn-0.13.2, umap-learn-0.5.7, powerlaw-1.5, and scikit-posthocs-0.11.0. No errors or failures appear.
**Verification:**
```bash
python3 -c "import networkx; import community; import sklearn; import umap; import powerlaw; import scikit_posthocs; import pandas; import numpy; import scipy; import matplotlib; import seaborn; print('All imports OK')"
```
Must print: `All imports OK`
**On failure:** Read the pip error output. If a package fails to build, check that requirements.txt lists `python-louvain` (not `community`) and `umap-learn` (not `umap`). Re-run the install command after fixing requirements.txt.
## Step 3: Download SNAP network data
Prerequisite: Step 2 completed successfully.
**Command:**
```bash
python3 download_data.py
```
**Expected output:** For each of the 20 networks, a line reading either "Downloaded {name}: {size} bytes, SHA-256: ..." or "Already exists {name}: {size} bytes, SHA-256: ...". The final line reads "Downloaded 20/20 networks". If any networks fail, the output lists them as "FAILED: {name1}, {name2}".
**Verification:**
```bash
ls data/raw/*.txt data/raw/*.csv 2>/dev/null | wc -l
```
Must print: `20`
**On failure:** This step requires internet access to reach https://snap.stanford.edu/data/. If it fails with a connection error, wait 30 seconds and re-run `python3 download_data.py`. Already-downloaded files are skipped automatically. If a specific network repeatedly fails, check config.json `url_overrides` for a corrected filename.
## Step 4: Build NetworkX graphs from edge lists
Prerequisite: Step 3 completed successfully (20 files in data/raw/).
**Command:**
```bash
python3 build_graphs.py
```
**Expected output:** For each network, a line "Processing {name}... ({i}/{total})" followed by "Nodes: N, Edges: M". Large files (over 60 MB) print an additional "Large file" sampling message. The final line reads "Built N/20 graphs" where N is the number of successfully built graphs, followed by "Saved data/graph_summary.csv (N rows)".
**Verification:**
```bash
ls data/graphs/*.graphml | wc -l
```
Must print a number between 15 and 20 (some very large networks may be skipped due to timeout or memory limits).
**On failure:** If this step fails with ModuleNotFoundError, re-run Step 2. If a specific graph times out (build_graphs.py prints "WARNING: Graph building timed out"), that network is skipped and does not block the rest of the pipeline. If zero graphs are built, check that data/raw/ contains files by running `ls data/raw/ | wc -l`.
## Step 5: Compute 15 structural metrics for each graph
Prerequisite: Step 4 completed successfully (graphml files in data/graphs/).
**Command:**
```bash
python3 compute_metrics.py
```
**Expected output:** For each graph, progress lines showing "Processing {name} ({domain})... ({i}/{total})" followed by individual metric computation messages. The final line reads "Saved results/metrics.csv (N rows x 17 columns)" where N matches the number of graphs built in Step 4.
**Verification:**
```bash
python3 -c "import pandas as pd; df=pd.read_csv('results/metrics.csv'); print(f'{len(df)} rows, {len(df.columns)} cols'); assert len(df)>=15; assert len(df.columns)==17"
```
Must print: `N rows, 17 cols` where N is between 15 and 20.
**On failure:** If this step fails with ModuleNotFoundError, re-run Step 2. If specific metrics show NaN for certain networks, that is expected behavior for large graphs (over 100,000 nodes) where computations like modularity or clustering timeout. NaN values in up to 5 metrics per large network are acceptable. If all metrics for all networks are NaN, delete data/graphs/ and re-run Step 4, then re-run this step.
## Step 6: Run statistical tests across domains
Prerequisite: Step 5 completed successfully (results/metrics.csv exists with at least 15 rows).
**Command:**
```bash
python3 statistical_analysis.py
```
**Expected output:** For each of the 15 metrics, a line "Testing {metric}..." followed by "Kruskal-Wallis H={value}, p={value}" for tested metrics. Some metrics print "Fewer than 2 valid groups, skipping Kruskal-Wallis". The final lines read "Saved results/statistical_tests.json", "Tested: N/15 metrics", and "Significant (p < 0.05): M/N".
**Verification:**
```bash
python3 -c "import json; d=json.load(open('results/statistical_tests.json')); print(f'{len(d)} metrics tested'); assert len(d)==15"
```
Must print: `15 metrics tested`
**On failure:** If this step fails with FileNotFoundError for results/metrics.csv, re-run Step 5. If it fails with ModuleNotFoundError, re-run Step 2. If Kruskal-Wallis fails for a specific metric, it is logged as "skipped" in the JSON output and does not block the pipeline.
## Step 7: Classify networks by domain and generate visualizations
Prerequisite: Steps 5 and 6 completed successfully (results/metrics.csv and results/statistical_tests.json exist).
**Command:**
```bash
python3 classify_and_visualize.py
```
**Expected output:** Lines reporting the number of metrics used, "Running LOO-CV with Random Forest...", then "LOO-CV Accuracy: X.XXXX (N/20)" where X.XXXX is a decimal between 0 and 1. Then "Saved results/classification_results.json", "Computing UMAP embedding...", and four lines confirming saved figures: "Saved figures/taxonomy_umap.png", "Saved figures/confusion_heatmap.png", "Saved figures/feature_importance.png", "Saved figures/domain_boxplots.png".
**Verification:**
```bash
python3 -c "import json; d=json.load(open('results/classification_results.json')); print(f'Accuracy: {d[\"accuracy\"]:.2%}')" && ls figures/taxonomy_umap.png figures/confusion_heatmap.png figures/feature_importance.png figures/domain_boxplots.png | wc -l
```
Must print an accuracy percentage on the first line, and `4` on the second line.
**On failure:** If this step fails with FileNotFoundError for results/metrics.csv, re-run Step 5. If UMAP fails with an import error, verify that umap-learn is installed by running `python3 -c "import umap; print(umap.__version__)"`. If figure generation fails, verify matplotlib backend by running `python3 -c "import matplotlib; print(matplotlib.get_backend())"` (must print `agg`).
## Step 8: Generate findings summary report
Prerequisite: Steps 5, 6, and 7 completed successfully (results/metrics.csv, results/statistical_tests.json, and results/classification_results.json all exist).
**Command:**
```bash
python3 generate_report.py
```
**Expected output:** A single line reading "Saved results/findings_summary.md (N lines)" where N is a positive integer.
**Verification:**
```bash
head -1 results/findings_summary.md
```
Must print: `# NetClaw: Findings Summary`
**On failure:** If this step fails with FileNotFoundError, identify which results file is missing by running `ls results/metrics.csv results/statistical_tests.json results/classification_results.json`. Re-run the step that produces the missing file: Step 5 for metrics.csv, Step 6 for statistical_tests.json, Step 7 for classification_results.json.
## Step 9: Final verification checklist
Prerequisite: Steps 1 through 8 completed successfully.
**Command:**
```bash
echo "=== Source files ===" && for f in requirements.txt config.json download_data.py build_graphs.py compute_metrics.py statistical_analysis.py classify_and_visualize.py generate_report.py SKILL.md; do [ -f "$f" ] && echo "OK: $f" || echo "MISSING: $f"; done && echo "=== Result files ===" && for f in results/metrics.csv results/statistical_tests.json results/classification_results.json results/findings_summary.md; do [ -f "$f" ] && echo "OK: $f" || echo "MISSING: $f"; done && echo "=== Figure files ===" && for f in figures/taxonomy_umap.png figures/confusion_heatmap.png figures/feature_importance.png figures/domain_boxplots.png; do [ -f "$f" ] && echo "OK: $f" || echo "MISSING: $f"; done && echo "=== Reproducibility check ===" && python3 -c "
import pandas as pd, json
df = pd.read_csv('results/metrics.csv')
st = json.load(open('results/statistical_tests.json'))
cr = json.load(open('results/classification_results.json'))
print(f'Networks: {len(df)}')
print(f'Metrics tested: {len(st)}')
print(f'Classification accuracy: {cr[\"accuracy\"]:.2%}')
print('ALL CHECKS PASSED')
"
```
**Expected output:** 9 source files marked "OK", 4 result files marked "OK", 4 figure files marked "OK", followed by network count, metrics tested count, classification accuracy, and "ALL CHECKS PASSED".
**Verification:** The command above is self-verifying. The final line must read `ALL CHECKS PASSED`. Any line reading "MISSING" indicates a failed step.
**On failure:** For each "MISSING" result or figure file, re-run the corresponding step: Step 3 produces data/raw/ files, Step 4 produces data/graphs/*.graphml, Step 5 produces results/metrics.csv, Step 6 produces results/statistical_tests.json, Step 7 produces results/classification_results.json and all 4 figures, Step 8 produces results/findings_summary.md. Steps must be re-run in order because each depends on the previous step's output.
Discussion (0)
to join the discussion.
No comments yet. Be the first to discuss this paper.