fast-nnt 0.2.4

Rust implementation of the SplitsTree NeighborNet algorithm.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#! /usr/bin/env python3

import argparse
import csv
import os
import resource
import subprocess
import sys
import tempfile
import time

import pandas as pd

import fastnntpy as fn


def max_rss_mib():
    usage = resource.getrusage(resource.RUSAGE_SELF)
    # On macOS ru_maxrss is bytes; on Linux it's kilobytes.
    if sys.platform == "darwin":
        return usage.ru_maxrss / (1024 * 1024)
    return usage.ru_maxrss / 1024


def run_once(threads, data, labels):
    t0 = time.perf_counter()
    cpu0 = time.process_time()
    rss0 = max_rss_mib()

    fn.set_fastnnt_threads(threads)
    fn.run_neighbour_net(
        data,
        max_iterations=5000,
        ordering_method="splitstree4",
        inference_method="active-set",
        labels=labels,
    )

    elapsed = time.perf_counter() - t0
    cpu = time.process_time() - cpu0
    rss1 = max_rss_mib()
    peak_rss = max(rss0, rss1)

    return {
        "threads": threads,
        "elapsed_sec": elapsed,
        "cpu_sec": cpu,
        "peak_ram_mib": peak_rss,
    }


def single_mode(args):
    data = pd.read_csv("test/data/large/large_dist_matrix.csv")
    labels = list(data.columns)
    result = run_once(args.threads, data, labels)
    with open(args.out_csv, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=result.keys())
        writer.writeheader()
        writer.writerow(result)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--single", action="store_true", help="Run a single benchmark in-process.")
    parser.add_argument("--threads", type=int, help="Thread count for --single.")
    parser.add_argument("--out-csv", help="Output CSV path for --single.")
    args = parser.parse_args()

    if args.single:
        if args.threads is None or args.out_csv is None:
            raise SystemExit("--single requires --threads and --out-csv")
        single_mode(args)
        return

    thread_counts = [1, 2, 4, 8]
    repeats = 3
    out_path = "test/python/fastnnt_threads_benchmark.csv"

    results = []
    for threads in thread_counts:
        for _ in range(repeats):
            with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as tmp:
                tmp_path = tmp.name
            try:
                subprocess.run(
                    [sys.executable, __file__, "--single", "--threads", str(threads), "--out-csv", tmp_path],
                    check=True,
                )
                with open(tmp_path, "r", newline="") as f:
                    reader = csv.DictReader(f)
                    for row in reader:
                        results.append(row)
            finally:
                if os.path.exists(tmp_path):
                    os.remove(tmp_path)

    with open(out_path, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["threads", "elapsed_sec", "cpu_sec", "peak_ram_mib"])
        writer.writeheader()
        writer.writerows(results)

    for row in results:
        print(row)


if __name__ == "__main__":
    main()