deepaksamuel-cuk

trackfit-llm-large

Detector and encoding

12 layers (0–11), 32 strips per layer (0–31), one view (x or y) at a time.
Each hit is one integer: hit = layer * 32 + strip, so hits are in [0, 383]. Decode with strip = hit % 32, layer = hit // 32.
A track is the line strip = slp * layer + icpt (slope in strips per layer, intercept = strip at layer 0). It produces a hit at round(slp * layer + icpt) in every layer where that value is inside 0–31.

The output call gen_evt(slp=[...], icpt=[...], add=[...], rem=[...]) means:

Table with columns: field, meaning
field	meaning
`slp`, `icpt`	one slope and one intercept per track (1, 2 or 3 tracks)
`add`	input hits that are noise (not on any track)
`rem`	hits the tracks cross that are missing from the input (detector inefficiency)

Slopes and intercepts are single vocabulary tokens taken from a fixed grid (allowed.csv, 41,497 (slope, intercept) pairs, |slope| ≤ 8.17 strips/layer), so the model can only output values on that grid.

Files

Table with columns: file, content
file	content
`model.safetensors`, `config.json`, `generation_config.json`	the model (`LlamaForCausalLM`: hidden 1024, 12 layers, 16 heads)
`vocab.json`, `tokenizer_config.json`	the word-level tokenizer (9,772 tokens)
`trackfit.py`	tokenizer class `TrackCallTokenizer`, batched `predict`, `parse_call`, `gen_evt`, `score`, `decode`
`examples.jsonl`	sample inputs: synthetic 1-, 2- and 3-track events (with the true call) and one real cosmic-muon event (x and y views)
`allowed.csv`	the (slope, intercept) grid the model was trained on

Quick start

bash

pip install torch "transformers>=4.45" huggingface_hub

python

import json, sys, torchfrom huggingface_hub import snapshot_downloadfrom transformers import LlamaForCausalLM path = snapshot_download("deepaksamuel-cuk/trackfit-llm-large")sys.path.insert(0, path)                      # makes trackfit.py importablefrom trackfit import TrackCallTokenizer, predict, score, parse_call device = "cuda" if torch.cuda.is_available() else "cpu"tokenizer = TrackCallTokenizer.from_pretrained(path)model = LlamaForCausalLM.from_pretrained(path, dtype=torch.bfloat16 if device == "cuda" else torch.float32).to(device).eval() hits = [21, 54, 86, 119, 151, 184, 217, 249, 282, 314, 347, 380]   # one event, one viewcall = predict(model, tokenizer, [hits])[0]print(call)                   # gen_evt (slp=[0.6], icpt=[21.01], add=[], rem=[])print(parse_call(call))       # {'slp': [0.6], 'icpt': [21.01], 'add': [], 'rem': []}print(score(hits, call))      # (1.0, 0.0)  -> S, D

(With transformers < 5, pass torch_dtype= instead of dtype=.) The model runs on CPU as well; a GPU is only needed for large batches.

Run the examples

python

examples = [json.loads(line) for line in open(f"{path}/examples.jsonl")]calls = predict(model, tokenizer, [e["input_hits"] for e in examples])   # batched greedy decodingfor e, call in zip(examples, calls):    S, D = score(e["input_hits"], call)    print(f"{e['name']}  ({e['description']})")    print(f"  input : {e['input_hits']}")    print(f"  model : {call}   S={S:.3f} D={D:.3f}")    if "target_call" in e:        print(f"  truth : {e['target_call']}")

Expected output (identical on GPU in bfloat16 and on CPU in float32):

Table with columns: example, model output, S, D
example	model output	S
`synthetic_test_2` (1 track, clean)	`gen_evt (slp=[0.6], icpt=[21.01], add=[], rem=[])`	1
`synthetic_test_1` (1 track, noisy)	`gen_evt (slp=[1.8], icpt=[6.68], add=[73, 278, 310, 344], rem=[7, 40, 108, 142, 176, 209, 378])`	1
`synthetic_test_0` (2 tracks, noisy)	`gen_evt (slp=[-0.3, 0.22], icpt=[9.64, 22.57], add=[56, 138, 233, 294, 314, 315], rem=[23, 55, 73, 87, 168, 200, 248, 280, 327, 358])`	1
`synthetic_test_6` (3 tracks, noisy)	`gen_evt (slp=[0.74, -1.25, -5.74], icpt=[4.13, 24.5, 65.76], add=[23, 27, 54, 87, 118, 222, 239, 277, 298, 300, 365], rem=[55, 70, 102, 117, 135, 201, 266, 270, 299, 301, 363, 364])`	1
`real_..._event1_x` (real muon, x view)	`gen_evt (slp=[1.43], icpt=[-2.98], add=[100, 123, 197, 230, 232], rem=[64, 231, 264, 331, 365])`	1
`real_..._event1_y` (real muon, y view)	`gen_evt (slp=[2.1], icpt=[1.44], add=[29, 114, 120, 239, 261], rem=[1, 36, 70, 104, 308, 342, 377])`	1

On noisy events the predicted slope/intercept can differ slightly from the true values (for example icpt=9.64 instead of 9.89) while still reproducing every hit exactly (S = 1, D = 0): several nearby lines on the grid give the same strips in every layer, and the add/rem lists adjust accordingly.

Using your own data

Split each event into its x-view and y-view hits and encode each as layer * 32 + strip (0–383). Run the two views separately.
Pass a list of events (each a list of ints) to predict; it sorts the hits, left-pads the batch and decodes greedily. Batches of a few hundred to a few thousand events work well on a GPU.
Parse the calls with parse_call. For a single track per view, the slopes m_x, m_y (strips/layer) give the zenith angle θ = arctan((pitch / layer_gap) · sqrt(m_x² + m_y²)) and azimuth φ = atan2(m_y, m_x); for the detector used here, pitch = 3.0 cm and layer gap = 16.8 cm.

Plot one event:

python

import matplotlib.pyplot as plt, numpy as npfrom trackfit import decode p = parse_call(call)strips, layers = zip(*(decode(h) for h in hits))plt.scatter(strips, layers, color="k", label="hits")lay = np.array([-0.5, 11.5])for s, i in zip(p["slp"], p["icpt"]):    plt.plot(s * lay + i, lay, label=f"slp={s}, icpt={i}")plt.xlim(-0.5, 31.5); plt.ylim(-0.5, 11.5); plt.xlabel("strip"); plt.ylabel("layer"); plt.legend(); plt.show()

Training

Architecture: LlamaForCausalLM, hidden size 1024, 12 layers, 16 attention heads, intermediate size 2816, 174,179,328 parameters, trained from scratch.
Data: synthetic events generated on the fly (120,000 new events per epoch), one third each 1-, 2- and 3-track, with tracks drawn uniformly from allowed.csv. Per track: noise class clean : add : rem : add+rem = 1 : 1 : 1 : 8; 1–5 noise hits and up to 7 missing hits per track, at least 5 hits kept on every track. Maximum per event: 15 noise hits and 21 missing hits (3 tracks).
Objective: next-token prediction on the call, weighted cross-entropy, warmup–stable–decay learning-rate schedule.
Checkpoint: epoch 320, selected by the best mean similarity on 10,000 real cosmic-muon events (x and y views).

Results

Synthetic test set (20,000 events, never seen in training):

Table with columns: events, perfect (S=1, D=0), mean S, mean D, correct number of tracks
events	perfect (S=1, D=0)	mean S	mean D	correct number of tracks
all	92.83%	0.9971	0.0028	98.68%
1 track	97.12%	0.9967	0.0035	99.88%
2 tracks	95.74%	0.9984	0.0016	98.34%
3 tracks	85.61%	0.9962	0.0034	97.83%

Real cosmic-muon data (703,694 events from one run, x and y views):

Table with columns: view, perfect (S=1, D=0), mean S, mean D
view	perfect (S=1, D=0)	mean S	mean D
x	95.70%	0.9961	0.0055
y	94.58%	0.9933	0.0066

The zenith angle from the model's x/y slopes agrees with an independent RANSAC fit to a median of 0.51°.

Result files

Per-event results behind the numbers above are in results/. Load them with pandas.read_csv; hit lists are stored as JSON-style strings.

Table with columns: file, rows, content
file	rows	content
`results/cosmic_INORUN_20160718_211418_predictions.csv`	703,694	every event of the real cosmic-muon file, x and y views: model, OLS and RANSAC (469 MB)
`results/test_mixedtrack_extended_results.csv`	20,000	the synthetic test set (`test-mixedtrack-extended` in `trkfit-llm-datasets`): model, OLS and RANSAC, with the truth

Cosmic file columns (_x / _y = detector view):

filename, eventid, x_hits, y_hits, n_hits_*, n_layers_*: the event and its hits.
predicted_target_*, parsed_*, similarity_*, dissimilarity_*, perfect_*, pred_mult_* (number of predicted tracks), model_slopes_*, model_icpts_* (all tracks), model_slope_*, model_icpt_* (first track), n_add_pred_*, n_rem_pred_*, notrack_* (a predicted track has no hit inside the detector): the model's call and its scores.
ols_slope_*, ols_icpt_*: ordinary least squares over every hit.
ransac_slope_*, ransac_icpt_*, ransac_n_inliers_*: RANSAC (residual threshold 1 strip, 100 trials).
zenith_deg_model/ols/ransac, azimuth_deg_model/ols/ransac: angles from each method's x and y slopes (the model's first track in each view).

Test file columns:

event, n_tracks, n_hits, input_hits, target_call, true_slopes, true_icpts: the event and its truth.
predicted_target, parsed, similarity, dissimilarity, perfect, pred_mult, mult_ok (correct number of tracks), exact (all slopes and intercepts equal the truth), model_slopes, model_icpts, model_slope, model_icpt, n_add_pred, n_rem_pred, notrack: the model's call and its scores.
ols_slope, ols_icpt, ols_slope_err, ols_icpt_err, ols_rms: ordinary least squares over every hit.
ransac_slope, ransac_icpt, ransac_n_inliers: RANSAC with the settings above.

OLS and RANSAC fit a single straight line to all hits of an event. On 2- and 3-track test events they therefore describe at most one of the tracks; compare them with the model on the n_tracks == 1 rows.

Limitations

Slope limit. Slopes are capped at |slope| = 8.17 strips/layer (θ ≈ 55.6° from one view). Real tracks steeper than this are clipped to the limit, and on some short, sparse events the model falls back to a near-limit slope through one or two hits and labels the rest as noise. Both pile up at θ ≈ 52–58°. Such events have low S / high D in that view and can be flagged.
Split single muons. On real data a muon that fires two neighbouring strips per layer is sometimes predicted as two nearly parallel tracks. About 3–5% of real events get a 2-track prediction in one view, but only a few tens show two clearly separated tracks in both views.
Grid values. Slopes and intercepts are restricted to the allowed.csv grid; the model is a pattern-recognition step, not a precision fit. A least-squares refit on the hits the model assigns to each track gives continuous parameters.
Geometry. Trained for a 12-layer, 32-strip view only; other geometries need retraining.

Available on FriendliAI

Dedicated Endpoints

Run this model inference on single tenant GPU with unmatched speed and reliability at scale.

Learn more

Model Details

Model Provider

deepaksamuel-cuk

Model Tree

Base

this model

Input Modalities

Text

Output Modalities

Text

Supported Functionality

Dedicated Endpoints

Explore FriendliAI today

Get started Talk to an engineer

Detector and encoding

12 layers (0–11), 32 strips per layer (0–31), one view (x or y) at a time.
Each hit is one integer: hit = layer * 32 + strip, so hits are in [0, 383]. Decode with strip = hit % 32, layer = hit // 32.
A track is the line strip = slp * layer + icpt (slope in strips per layer, intercept = strip at layer 0). It produces a hit at round(slp * layer + icpt) in every layer where that value is inside 0–31.

The output call gen_evt(slp=[...], icpt=[...], add=[...], rem=[...]) means:

Table with columns: field, meaning
field	meaning
`slp`, `icpt`	one slope and one intercept per track (1, 2 or 3 tracks)
`add`	input hits that are noise (not on any track)
`rem`	hits the tracks cross that are missing from the input (detector inefficiency)

Files

Table with columns: file, content
file	content
`model.safetensors`, `config.json`, `generation_config.json`	the model (`LlamaForCausalLM`: hidden 1024, 12 layers, 16 heads)
`vocab.json`, `tokenizer_config.json`	the word-level tokenizer (9,772 tokens)
`trackfit.py`	tokenizer class `TrackCallTokenizer`, batched `predict`, `parse_call`, `gen_evt`, `score`, `decode`
`examples.jsonl`	sample inputs: synthetic 1-, 2- and 3-track events (with the true call) and one real cosmic-muon event (x and y views)
`allowed.csv`	the (slope, intercept) grid the model was trained on

Quick start

bash

pip install torch "transformers>=4.45" huggingface_hub

python

import json, sys, torchfrom huggingface_hub import snapshot_downloadfrom transformers import LlamaForCausalLM path = snapshot_download("deepaksamuel-cuk/trackfit-llm-large")sys.path.insert(0, path)                      # makes trackfit.py importablefrom trackfit import TrackCallTokenizer, predict, score, parse_call device = "cuda" if torch.cuda.is_available() else "cpu"tokenizer = TrackCallTokenizer.from_pretrained(path)model = LlamaForCausalLM.from_pretrained(path, dtype=torch.bfloat16 if device == "cuda" else torch.float32).to(device).eval() hits = [21, 54, 86, 119, 151, 184, 217, 249, 282, 314, 347, 380]   # one event, one viewcall = predict(model, tokenizer, [hits])[0]print(call)                   # gen_evt (slp=[0.6], icpt=[21.01], add=[], rem=[])print(parse_call(call))       # {'slp': [0.6], 'icpt': [21.01], 'add': [], 'rem': []}print(score(hits, call))      # (1.0, 0.0)  -> S, D

import json, sys, torchfrom huggingface_hub import snapshot_downloadfrom transformers import LlamaForCausalLM path = snapshot_download("deepaksamuel-cuk/trackfit-llm-large")sys.path.insert(0, path)                      # makes trackfit.py importablefrom trackfit import TrackCallTokenizer, predict, score, parse_call device = "cuda" if torch.cuda.is_available() else "cpu"tokenizer = TrackCallTokenizer.from_pretrained(path)model = LlamaForCausalLM.from_pretrained(path, dtype=torch.bfloat16 if device == "cuda" else torch.float32).to(device).eval() hits = [21, 54, 86, 119, 151, 184, 217, 249, 282, 314, 347, 380]   # one event, one viewcall = predict(model, tokenizer, [hits])[0]print(call)                   # gen_evt (slp=[0.6], icpt=[21.01], add=[], rem=[])print(parse_call(call))       # {'slp': [0.6], 'icpt': [21.01], 'add': [], 'rem': []}print(score(hits, call))      # (1.0, 0.0)  -> S, D

(With transformers < 5, pass torch_dtype= instead of dtype=.) The model runs on CPU as well; a GPU is only needed for large batches.

Run the examples

python

examples = [json.loads(line) for line in open(f"{path}/examples.jsonl")]calls = predict(model, tokenizer, [e["input_hits"] for e in examples])   # batched greedy decodingfor e, call in zip(examples, calls):    S, D = score(e["input_hits"], call)    print(f"{e['name']}  ({e['description']})")    print(f"  input : {e['input_hits']}")    print(f"  model : {call}   S={S:.3f} D={D:.3f}")    if "target_call" in e:        print(f"  truth : {e['target_call']}")

examples = [json.loads(line) for line in open(f"{path}/examples.jsonl")]calls = predict(model, tokenizer, [e["input_hits"] for e in examples])   # batched greedy decodingfor e, call in zip(examples, calls):    S, D = score(e["input_hits"], call)    print(f"{e['name']}  ({e['description']})")    print(f"  input : {e['input_hits']}")    print(f"  model : {call}   S={S:.3f} D={D:.3f}")    if "target_call" in e:        print(f"  truth : {e['target_call']}")

Expected output (identical on GPU in bfloat16 and on CPU in float32):

Table with columns: example, model output, S, D
example	model output	S
`synthetic_test_2` (1 track, clean)	`gen_evt (slp=[0.6], icpt=[21.01], add=[], rem=[])`	1
`synthetic_test_1` (1 track, noisy)	`gen_evt (slp=[1.8], icpt=[6.68], add=[73, 278, 310, 344], rem=[7, 40, 108, 142, 176, 209, 378])`	1
`synthetic_test_0` (2 tracks, noisy)	`gen_evt (slp=[-0.3, 0.22], icpt=[9.64, 22.57], add=[56, 138, 233, 294, 314, 315], rem=[23, 55, 73, 87, 168, 200, 248, 280, 327, 358])`	1
`synthetic_test_6` (3 tracks, noisy)	`gen_evt (slp=[0.74, -1.25, -5.74], icpt=[4.13, 24.5, 65.76], add=[23, 27, 54, 87, 118, 222, 239, 277, 298, 300, 365], rem=[55, 70, 102, 117, 135, 201, 266, 270, 299, 301, 363, 364])`	1
`real_..._event1_x` (real muon, x view)	`gen_evt (slp=[1.43], icpt=[-2.98], add=[100, 123, 197, 230, 232], rem=[64, 231, 264, 331, 365])`	1
`real_..._event1_y` (real muon, y view)	`gen_evt (slp=[2.1], icpt=[1.44], add=[29, 114, 120, 239, 261], rem=[1, 36, 70, 104, 308, 342, 377])`	1

Using your own data

Split each event into its x-view and y-view hits and encode each as layer * 32 + strip (0–383). Run the two views separately.
Pass a list of events (each a list of ints) to predict; it sorts the hits, left-pads the batch and decodes greedily. Batches of a few hundred to a few thousand events work well on a GPU.
Parse the calls with parse_call. For a single track per view, the slopes m_x, m_y (strips/layer) give the zenith angle θ = arctan((pitch / layer_gap) · sqrt(m_x² + m_y²)) and azimuth φ = atan2(m_y, m_x); for the detector used here, pitch = 3.0 cm and layer gap = 16.8 cm.

Plot one event:

python

import matplotlib.pyplot as plt, numpy as npfrom trackfit import decode p = parse_call(call)strips, layers = zip(*(decode(h) for h in hits))plt.scatter(strips, layers, color="k", label="hits")lay = np.array([-0.5, 11.5])for s, i in zip(p["slp"], p["icpt"]):    plt.plot(s * lay + i, lay, label=f"slp={s}, icpt={i}")plt.xlim(-0.5, 31.5); plt.ylim(-0.5, 11.5); plt.xlabel("strip"); plt.ylabel("layer"); plt.legend(); plt.show()

import matplotlib.pyplot as plt, numpy as npfrom trackfit import decode p = parse_call(call)strips, layers = zip(*(decode(h) for h in hits))plt.scatter(strips, layers, color="k", label="hits")lay = np.array([-0.5, 11.5])for s, i in zip(p["slp"], p["icpt"]):    plt.plot(s * lay + i, lay, label=f"slp={s}, icpt={i}")plt.xlim(-0.5, 31.5); plt.ylim(-0.5, 11.5); plt.xlabel("strip"); plt.ylabel("layer"); plt.legend(); plt.show()

Training

Architecture: LlamaForCausalLM, hidden size 1024, 12 layers, 16 attention heads, intermediate size 2816, 174,179,328 parameters, trained from scratch.
Data: synthetic events generated on the fly (120,000 new events per epoch), one third each 1-, 2- and 3-track, with tracks drawn uniformly from allowed.csv. Per track: noise class clean : add : rem : add+rem = 1 : 1 : 1 : 8; 1–5 noise hits and up to 7 missing hits per track, at least 5 hits kept on every track. Maximum per event: 15 noise hits and 21 missing hits (3 tracks).
Objective: next-token prediction on the call, weighted cross-entropy, warmup–stable–decay learning-rate schedule.
Checkpoint: epoch 320, selected by the best mean similarity on 10,000 real cosmic-muon events (x and y views).

Results

Synthetic test set (20,000 events, never seen in training):

Table with columns: events, perfect (S=1, D=0), mean S, mean D, correct number of tracks
events	perfect (S=1, D=0)	mean S	mean D	correct number of tracks
all	92.83%	0.9971	0.0028	98.68%
1 track	97.12%	0.9967	0.0035	99.88%
2 tracks	95.74%	0.9984	0.0016	98.34%
3 tracks	85.61%	0.9962	0.0034	97.83%

Real cosmic-muon data (703,694 events from one run, x and y views):

Table with columns: view, perfect (S=1, D=0), mean S, mean D
view	perfect (S=1, D=0)	mean S	mean D
x	95.70%	0.9961	0.0055
y	94.58%	0.9933	0.0066

The zenith angle from the model's x/y slopes agrees with an independent RANSAC fit to a median of 0.51°.

Result files

Per-event results behind the numbers above are in results/. Load them with pandas.read_csv; hit lists are stored as JSON-style strings.

Table with columns: file, rows, content
file	rows	content
`results/cosmic_INORUN_20160718_211418_predictions.csv`	703,694	every event of the real cosmic-muon file, x and y views: model, OLS and RANSAC (469 MB)
`results/test_mixedtrack_extended_results.csv`	20,000	the synthetic test set (`test-mixedtrack-extended` in `trkfit-llm-datasets`): model, OLS and RANSAC, with the truth

Cosmic file columns (_x / _y = detector view):

filename, eventid, x_hits, y_hits, n_hits_*, n_layers_*: the event and its hits.
predicted_target_*, parsed_*, similarity_*, dissimilarity_*, perfect_*, pred_mult_* (number of predicted tracks), model_slopes_*, model_icpts_* (all tracks), model_slope_*, model_icpt_* (first track), n_add_pred_*, n_rem_pred_*, notrack_* (a predicted track has no hit inside the detector): the model's call and its scores.
ols_slope_*, ols_icpt_*: ordinary least squares over every hit.
ransac_slope_*, ransac_icpt_*, ransac_n_inliers_*: RANSAC (residual threshold 1 strip, 100 trials).
zenith_deg_model/ols/ransac, azimuth_deg_model/ols/ransac: angles from each method's x and y slopes (the model's first track in each view).

Test file columns:

event, n_tracks, n_hits, input_hits, target_call, true_slopes, true_icpts: the event and its truth.
predicted_target, parsed, similarity, dissimilarity, perfect, pred_mult, mult_ok (correct number of tracks), exact (all slopes and intercepts equal the truth), model_slopes, model_icpts, model_slope, model_icpt, n_add_pred, n_rem_pred, notrack: the model's call and its scores.
ols_slope, ols_icpt, ols_slope_err, ols_icpt_err, ols_rms: ordinary least squares over every hit.
ransac_slope, ransac_icpt, ransac_n_inliers: RANSAC with the settings above.

Limitations

Slope limit. Slopes are capped at |slope| = 8.17 strips/layer (θ ≈ 55.6° from one view). Real tracks steeper than this are clipped to the limit, and on some short, sparse events the model falls back to a near-limit slope through one or two hits and labels the rest as noise. Both pile up at θ ≈ 52–58°. Such events have low S / high D in that view and can be flagged.
Split single muons. On real data a muon that fires two neighbouring strips per layer is sometimes predicted as two nearly parallel tracks. About 3–5% of real events get a 2-track prediction in one view, but only a few tens show two clearly separated tracks in both views.
Grid values. Slopes and intercepts are restricted to the allowed.csv grid; the model is a pattern-recognition step, not a precision fit. A least-squares refit on the hits the model assigns to each track gives continuous parameters.
Geometry. Trained for a 12-layer, 32-strip view only; other geometries need retraining.

trackfit-llm-large

README

Detector and encoding

Files

Quick start

Run the examples

Using your own data

Training

Results

Result files

Limitations

Explore FriendliAI today

README

Detector and encoding

Files

Quick start

Run the examples

Using your own data

Training

Results

Result files

Limitations