From 7424fd45ccab6e9660cd61391eca25cde1bb57ea Mon Sep 17 00:00:00 2001 From: "Asad Iqbal (Saadi)" Date: Wed, 6 May 2026 18:28:46 +0500 Subject: [PATCH 01/12] Merge pull request #22 from tracebloc/chore/sync-from-main-saadqbal-20 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit chore: sync templates + faqs from main → develop (re-authored as @saadqbal) --- create-use-case/templates.mdx | 32 +++++++++++++- tools-help/faqs.mdx | 80 ++++++++++++++++++++--------------- 2 files changed, 76 insertions(+), 36 deletions(-) diff --git a/create-use-case/templates.mdx b/create-use-case/templates.mdx index f83dabd..f5028e5 100644 --- a/create-use-case/templates.mdx +++ b/create-use-case/templates.mdx @@ -1,6 +1,34 @@ --- title: "Templates" -description: "Ready-made use case examples to get started quickly." +description: "Ready-made data ingestion templates for every supported task — clone, configure, deploy." --- -Browse examples at the [template section of the tracebloc website](https://ai.tracebloc.io/explore). +Each task tracebloc supports comes with a runnable data-ingestion template — a working `Dockerfile`, `ingestor.py`, and `ingestor-job.yaml` you can copy, point at your data, and ship. + +## Available templates + +| Task | Template | +|---|---| +| Image classification | [`templates/image_classification`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/image_classification) | +| Object detection | [`templates/object_detection`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/object_detection) | +| Text classification | [`templates/text_classification`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/text_classification) | +| Tabular classification | [`templates/tabular_classification`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/tabular_classification) | +| Tabular regression | [`templates/tabular_regression`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/tabular_regression) | +| Time series forecasting | [`templates/time_series_forecasting`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/time_series_forecasting) | +| Time-to-event prediction | [`templates/time_to_event_prediction`](https://github.com/tracebloc/data-ingestors/tree/develop/templates/time_to_event_prediction) | + +Keypoint detection and semantic segmentation are supported, but ready-made templates are still in flight — contact [support@tracebloc.io](mailto:support@tracebloc.io) for guidance in the meantime. See [Prerequisites](/create-use-case/prerequisites) for the full list of supported tasks and required data formats. + +## How to use a template + +1. **Clone the data-ingestors repo** and copy the template directory you want. +2. **Point it at your data** — set `SRC_PATH` and `LABEL_FILE` in `ingestor-job.yaml`. +3. **Build and deploy** as a Kubernetes Job. See [Prepare Dataset](/create-use-case/prepare-dataset) for the full ingestion workflow. + +## Browse live use cases + +For real examples already running on the platform, see the [explore section on tracebloc](https://ai.tracebloc.io/explore). + +## Need help? + +Email [support@tracebloc.io](mailto:support@tracebloc.io). diff --git a/tools-help/faqs.mdx b/tools-help/faqs.mdx index 289f4c4..a4164ef 100644 --- a/tools-help/faqs.mdx +++ b/tools-help/faqs.mdx @@ -1,51 +1,63 @@ --- title: "Frequently Asked Questions" -description: "Find answers to common questions about using Tracebloc." +description: "Common questions about running tracebloc — privacy, infrastructure, training, and getting help." --- -Find answers to common questions about using Tracebloc. +## Privacy & security -## General Questions +### Can the data scientist see my raw data? +No. Data scientists submit model code; the code runs on your client, against your data, in an isolated sandbox. They only ever see the metrics you decide to expose. Raw data, in-flight model state, and intermediate artifacts never leave your infrastructure. -### What is Tracebloc? -Tracebloc is a platform that enables secure and private AI model evaluation. It allows data owners to test vertical AI models from external vendors while maintaining data privacy. +### What gets shared with the data scientist or with tracebloc? +Only the evaluation metrics you configure on the use case (accuracy, F1, latency, and so on). No raw data, no trained weights, no logs. -### How does data privacy work? -- Data never leaves your infrastructure -- Model weights are encrypted -- No raw data sharing -- Secure communication channels +### Where do trained model weights end up? +On your storage. Trained weights stay on the persistent volume claim attached to your client. Data scientists never receive them. -## Technical Questions +### Is the client's egress restricted? +Yes — the chart applies a Kubernetes `NetworkPolicy` that only allows training pods to reach the tracebloc backend (for orchestration metadata) and the in-cluster proxy that handles result and FLOPs reporting. **The egress lockdown only takes effect on a CNI that enforces NetworkPolicy.** EKS's default VPC CNI does not, out of the box — see the [EKS deployment guide](/environment-setup/eks-client-deployment-guide) for what to install. -### System Requirements -**Q: What are the minimum system requirements?** -A: See our [requirements documentation](/environment-setup/setup-guide#requirements). +## Infrastructure -**Q: Do I need a GPU?** -A: While not mandatory, a GPU is recommended for optimal performance. +### Do I need a GPU? +For most ML workloads, yes. The standalone installer detects NVIDIA and AMD GPUs and installs the right drivers automatically. CPU-only is fine for small tabular and text models, but expect long training times on anything image- or sequence-heavy. -### Training Questions -**Q: How do I start training?** -A: Follow our [training guide](/join-use-case/start-training). +### What Kubernetes versions do you support? +Kubernetes 1.24 and above. See the [setup guide](/environment-setup/setup-guide) for the full prerequisites. -**Q: How do I monitor training progress?** -A: Use the Tracebloc dashboard or API. +### Can I run on-premise only? +Yes. The standalone installer provisions a local cluster on your machine, or you can deploy the unified Helm chart into your existing on-prem Kubernetes. The client never depends on cloud infrastructure for training. -## Troubleshooting +### Do you support air-gapped clusters? +Yes — see the [packaged-chart install path in tracebloc/client INSTALL.md](https://github.com/tracebloc/client/blob/main/docs/INSTALL.md) for the offline flow. -### Common Issues -1. **Connection Problems** - - Check network settings - - Verify firewall rules - - Test connectivity +## Training & models -2. **Resource Issues** - - Check GPU availability - - Monitor memory usage - - Verify storage space +### How do I monitor training? +Through the [tracebloc dashboard](https://ai.tracebloc.io) — every experiment, every model, every metric. Or query the API if you prefer programmatic access. -## Next Steps +### What if a training run fails? +The client retries transient failures automatically. Persistent failures show up in the dashboard with logs and exit codes. For ingestion-time failures, check the Job logs in the namespace you deployed into. -- [Review key terms](/tools-help/key-terms) -- [Check package documentation](/tools-help/tracebloc-package) +### Can I bring my own model? +Yes. Use the [tracebloc Python package](/tools-help/tracebloc-package) to upload a model file (PyTorch, TensorFlow, or a custom container). For ready-made starting points, see the [model zoo](https://github.com/tracebloc/model-zoo). + +### Do you support fine-tuning? +Yes — the same upload flow handles full training, fine-tuning with pretrained weights, and inference-only evaluation. + +## Cost & support + +### How much does it cost? +See the [pricing page](https://tracebloc.io/#pricing) on the website. + +### How do I get help? + +- Email [support@tracebloc.io](mailto:support@tracebloc.io) +- Open an issue on the relevant GitHub repo: [client](https://github.com/tracebloc/client/issues), [data-ingestors](https://github.com/tracebloc/data-ingestors/issues), [docs](https://github.com/tracebloc/docs/issues) +- Join the [Discord](https://discord.gg/tracebloc) + +## Next steps + +- [Get started](/environment-setup/setup-guide) — install the client +- [Browse key terms](/tools-help/key-terms) +- [Use the Python SDK](/tools-help/tracebloc-package) From 8cd57ad7b09aa0b1f3599f8860a21520b1e5b4b8 Mon Sep 17 00:00:00 2001 From: lukasWuttke <54042461+LukasWodka@users.noreply.github.com> Date: Wed, 6 May 2026 17:40:29 +0200 Subject: [PATCH 02/12] ci: add FR-pass comment caller for multi-stage kanban flow --- .github/workflows/fr-pass-comment-caller.yml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 .github/workflows/fr-pass-comment-caller.yml diff --git a/.github/workflows/fr-pass-comment-caller.yml b/.github/workflows/fr-pass-comment-caller.yml new file mode 100644 index 0000000..80192e7 --- /dev/null +++ b/.github/workflows/fr-pass-comment-caller.yml @@ -0,0 +1,14 @@ +name: FR pass comment + +# Per-repo caller. Listens for /fr-pass comments and advances kanban items +# from "FR on dev" → "Ready for staging" or "FR on staging" → "Ready for prod". +# All logic lives in tracebloc/.github/.github/workflows/fr-pass-comment.yml. + +on: + issue_comment: + types: [created] + +jobs: + advance: + uses: tracebloc/.github/.github/workflows/fr-pass-comment.yml@main + secrets: inherit From e8ff81079518f243584da17458f382f2e15c177a Mon Sep 17 00:00:00 2001 From: lukasWuttke <54042461+LukasWodka@users.noreply.github.com> Date: Wed, 6 May 2026 17:40:30 +0200 Subject: [PATCH 03/12] ci: add FR gate caller for staging/main promotions --- .github/workflows/fr-gate-caller.yml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 .github/workflows/fr-gate-caller.yml diff --git a/.github/workflows/fr-gate-caller.yml b/.github/workflows/fr-gate-caller.yml new file mode 100644 index 0000000..b725e2c --- /dev/null +++ b/.github/workflows/fr-gate-caller.yml @@ -0,0 +1,15 @@ +name: FR gate + +# Per-repo caller. Blocks merges to staging/main/master unless every contained +# kanban item is in "Ready for staging" or "Ready for prod" respectively. +# All logic lives in tracebloc/.github/.github/workflows/fr-gate.yml. + +on: + pull_request: + branches: [staging, main, master] + types: [opened, reopened, synchronize, ready_for_review, labeled, unlabeled] + +jobs: + gate: + uses: tracebloc/.github/.github/workflows/fr-gate.yml@main + secrets: inherit From da1c99bbe819e6d442d056218b6cea3c3e322d85 Mon Sep 17 00:00:00 2001 From: Divya Date: Thu, 7 May 2026 15:33:53 +0530 Subject: [PATCH 04/12] docs: add "How training works" page Documents the training and inference pipeline for all nine supported use cases so a user evaluating tracebloc can reproduce a run locally and compare metrics against what the platform reports. Co-Authored-By: Claude Opus 4.7 (1M context) --- docs.json | 1 + tools-help/how-training-works.mdx | 337 ++++++++++++++++++++++++++++++ 2 files changed, 338 insertions(+) create mode 100644 tools-help/how-training-works.mdx diff --git a/docs.json b/docs.json index c948261..858f6ef 100644 --- a/docs.json +++ b/docs.json @@ -84,6 +84,7 @@ "group": "Tools & Help", "pages": [ "tools-help/tracebloc-package", + "tools-help/how-training-works", "tools-help/faqs", "tools-help/key-terms" ] diff --git a/tools-help/how-training-works.mdx b/tools-help/how-training-works.mdx new file mode 100644 index 0000000..d5777f2 --- /dev/null +++ b/tools-help/how-training-works.mdx @@ -0,0 +1,337 @@ +--- +title: "How training works" +description: "What the tracebloc client does to your data and model in each use case, so you can reproduce a run locally and compare results." +--- + +This page documents the training and inference pipeline that the tracebloc client runs for every supported use case. The goal is full transparency: you can read what happens step-by-step, write an equivalent script on your own machine against the same dataset, and compare metrics number-for-number against what the platform reports. + +If something here does not match what you observe in your run, please [open a support ticket](mailto:support@tracebloc.io) — the source of truth is the open client code in [`tracebloc/tracebloc-client`](https://github.com/tracebloc/tracebloc-client). + +## Shared lifecycle + +Every use case runs through the same outer loop, defined in `use_cases/base_use_case.py` and `core/modes/base_training.py` / `base_inference.py`: + + + + The runner reads the experiment configuration (dataset IDs, hyperparameters, framework, mode) and selects the correct framework adapter (PyTorch, TensorFlow, or scikit-learn). + + + Your uploaded model file is downloaded and instantiated. For continued cycles or inference, the latest weights are pulled and loaded into the model. + + + The domain strategy for the use case loads raw data, applies preprocessing, and returns a training/validation `DataLoader` pair (training mode) or a single test loader (inference mode). + + + The parameters manager normalizes hyperparameters, selects the loss function, and constructs the optimizer (and scheduler, if any). + + + For each epoch, the training loop iterates batches, calls the strategy's `_train_step` (forward, loss, backward, step) and then `_eval_step` for validation. Per-batch results feed into the metrics class. + + + After each epoch, the metrics class produces epoch-level numbers. After the cycle ends, it produces cycle-level aggregate metrics (the ones surfaced in the platform UI). Weights are then saved and uploaded. + + + +### Common defaults + +| Setting | Default | Override | +|---|---|---| +| Train/validation split | 80 / 20 | `validation_split` parameter | +| Batch size | 32 | `batch_size` parameter | +| Optimizer | Adam | `optimizer` parameter | +| LR scheduler | `ReduceLROnPlateau` on validation loss | configurable | +| Class weighting | Enabled when class counts are imbalanced | automatic | + +To replicate locally, use the same split ratio and seed when slicing your data, the same loss and optimizer, and the same per-use-case preprocessing described below. + +## Per use case + + + + + +**Frameworks:** PyTorch, TensorFlow + +**Input** +- Image files (JPEG/PNG) plus a metadata table with `data_id` (filename) and `label` (class name). +- Class names are encoded to integer indices. + +**Preprocessing** +- Resize images to `image_size` (model parameter). +- Normalize with ImageNet mean/std (PyTorch) or framework-equivalent. +- Optional augmentation pipeline (rotation, shift, flip, brightness/contrast) applied only on the training split. +- **Stratified** train/val split so class proportions are preserved. + +**Training step** +1. Forward: `logits = model(images)` → shape `(B, num_classes)`. +2. Loss: `CrossEntropyLoss` by default; class weights applied if classes are imbalanced. +3. Backward and optimizer step. +4. Per-batch accuracy = `(argmax(logits) == labels).mean()`. + +**Validation step** +- Same forward pass, no backward; accumulate predictions and probabilities. + +**Cycle metrics** +- `accuracy`, `top_3_accuracy`, `top_5_accuracy` +- `auc_roc` (macro), `auc_pr` (macro) +- `log_loss`, `brier_score` +- `qwk` (quadratic weighted kappa) +- Confusion matrix + +**Inference output** +- Per-image predicted class index and softmax probabilities. + + + + + +**Frameworks:** PyTorch (YOLO and R-CNN families auto-detected) + +**Input** +- Images plus a metadata table grouped by image, with one bounding box per row: `data_id`, `class`, box coordinates. +- Box format is normalized internally to `xyxy`. + +**Preprocessing** +- Resize with letterbox padding to preserve aspect ratio; box coordinates rescaled accordingly. +- Training-only augmentations (flips, color jitter, rotation). +- Train/val split is non-stratified, deduplicated by image filename so a single image is never split across both sets. + +**Training step** +- **R-CNN family:** `model(images, targets)` returns a dict of internal losses (RPN, classification, box regression). Sum and backprop. +- **YOLO family:** `model(images)` returns raw predictions; loss is computed by the model's own loss module. + +**Validation step** +- Forward in eval mode. R-CNN returns `[{boxes, scores, labels}, ...]`; YOLO predictions are converted to that same format. + +**Cycle metrics** (via `torchmetrics.detection.MeanAveragePrecision`) +- `map`, `map_50`, `map_75` +- `mar_1`, `mar_10` +- `iou`, `giou` + +**Inference output** +- Per-image: boxes, scores, class labels. + + + + + +**Frameworks:** PyTorch + +**Input** +- Image plus per-pixel class mask. Metadata: `data_id`, `mask_id`. Masks are integer class indices in `[0, num_classes)`. + +**Preprocessing** +- Image and mask resized together to `image_size`. +- Image-only normalization (ImageNet mean/std). +- Joint augmentation (the same flip/rotation applied to both image and mask). + +**Training step** +1. Forward: `model(images)` returns logits `(B, C, H, W)` or a `{"out": ..., "aux": ...}` dict. +2. Loss: `CrossEntropyLoss` over pixels. If an `aux` head is present, total loss = `loss_main + 0.4 * loss_aux` (torchvision convention). +3. Backward and optimizer step. +4. Per-batch pixel accuracy. + +**Cycle metrics** +- `pixel_accuracy`, `mean_pixel_accuracy` +- `iou`, `mean_iou`, `frequency_weighted_iou` +- `dice` +- `boundary_iou`, `boundary_f1` +- `hausdorff_distance`, `asd` (average surface distance) +- Confusion matrix + + + + + +**Frameworks:** PyTorch (R-CNN, heatmap, and direct-regression families) + +**Input** +- Images and per-image keypoint coordinates (with optional visibility flags). + +**Preprocessing** +- Resize to `image_size`; keypoints rescaled to match. +- ImageNet normalization. +- Train/val split is non-stratified. + +**Training step** +- **R-CNN (KeypointRCNN):** `model(images, targets)` returns a loss dict; sum and backprop. +- **Heatmap:** Predict `(B, K, H, W)` heatmaps; MSE-style loss against target heatmaps. +- **Direct regression:** Predict `(B, K, 2)`; MSE-style loss against ground-truth coordinates. + +**Cycle metrics** +- `pck` (Percentage of Correct Keypoints) at threshold `0.2 * image_size` +- `pck@0.5` (stricter threshold) +- `auc` over PCK thresholds +- `mpjpe` (mean per-joint position error, in pixels) + + + + + +**Frameworks:** PyTorch (HuggingFace Transformers) + +**Input** +- Raw text strings with class labels. Metadata columns: `data_id`, `text`, `label`. + +**Preprocessing** +- Tokenization with the configured tokenizer (typically the one bundled with the base model). +- Padding/truncation to `max_length`. +- Stratified train/val split. + +**Training step** +1. Forward: `model(input_ids=..., attention_mask=..., labels=...)`. HuggingFace models return `(loss, logits)`; custom models compute loss externally with `CrossEntropyLoss`. +2. Backward and optimizer step (gradient clipping enabled). +3. Per-batch accuracy from `argmax(logits)`. + +**Optional model adaptations** +- LoRA fine-tuning when `lora_enabled` is set (with `lora_r`, `lora_alpha`, `lora_dropout`, optional Q-LoRA). +- 4-/8-bit quantization when enabled. + +**Cycle metrics** +- `accuracy` +- `f1_macro`, `f1_weighted` +- `precision_macro`, `recall_macro` +- `auc_roc` (multiclass, macro) +- Confusion matrix + + + + + +**Frameworks:** PyTorch, TensorFlow, scikit-learn (incl. XGBoost / LightGBM) + +**Input** +- A tabular file (CSV) with feature columns plus a `label` column. Categorical features may be strings. + +**Preprocessing** +- Optional feature selection (drop low-variance / highly-missing columns) when not pinned via `feature_columns`. +- Imputation: median (numeric) and mode (categorical). +- Categorical encoding via `LabelEncoder`. +- `StandardScaler` on numeric features for neural network frameworks. +- **Stratified** train/val split on the label. +- Encoders and scalers are persisted in cycle 1 and reused in later cycles and during inference, so transformations are identical across runs. + +**Training step** +1. Forward: `model(X_batch)` → logits `(B, num_classes)`. +2. Loss: `CrossEntropyLoss` (PyTorch), `categorical_crossentropy` (TF), or the estimator's built-in objective (sklearn). Class weights applied for imbalance. +3. Backward + optimizer step (or `estimator.fit(...)` for sklearn). + +**Cycle metrics** +- `accuracy`, `balanced_accuracy` +- `f1_macro`, `f1_weighted`, `f1_micro` +- `precision_macro`, `recall_macro` +- `f_beta_0.5`, `f_beta_2.0` +- `cohen_kappa`, `qwk` +- `auc_roc`, `auc_pr` +- `gini`, `normalized_gini` +- `brier_score`, `hamming_loss`, `jaccard_score`, `npv` +- Confusion matrix + + + + + +**Frameworks:** PyTorch, TensorFlow, scikit-learn + +**Input** +- Tabular features plus a continuous target column. Rows with non-finite targets are dropped. + +**Preprocessing** +- Identical to tabular classification, except: target is **not** encoded, and the train/val split is **not** stratified. + +**Training step** +1. Forward: `model(X_batch)` → predictions `(B,)` or `(B, 1)`. +2. Loss: `MSELoss` by default (configurable to MAE, SmoothL1, Huber). +3. Backward and optimizer step. +4. Per-epoch R² accumulated from running sum-of-squares of residuals and target variance. + +**Cycle metrics** +- `r2`, `explained_variance` +- `mae`, `mse`, `rmse`, `median_absolute_error`, `max_error` +- `mape`, `smape` +- `pearson_r`, `spearman_r` + + + + + +**Frameworks:** PyTorch + +**Input** +- A time-indexed table with feature column(s) and a target column. + +**Preprocessing** +- Sliding-window construction: input sequences of length `seq_length`, targets of length `forecast_horizon`. +- Scaling (MinMax or Standard) fit on the training window only and replayed on validation/inference. +- **Temporal** train/val split (no shuffle) so the validation window is strictly later in time than the training window. + +**Training step** +1. Forward: `model(sequences)` returns predictions of shape `(B, horizon, features)` or `(B, horizon)`. +2. Loss: `MSELoss` by default (MAE / Huber / custom configurable). +3. Backward and optimizer step. +4. Per-batch MAE. + +**Cycle metrics** +- `mae`, `mse`, `rmse` +- `r2` +- `mape` (when targets are non-zero) + + + + + +**Frameworks:** PyTorch (with lifelines / scikit-survival also supported for inference) + +**Input** +- Tabular features plus a `duration` column (time to event or censoring) and an `event` column (1 = observed event, 0 = censored). + +**Preprocessing** +- Same imputation, encoding, and scaling as tabular use cases. +- Rows with non-finite durations are dropped. +- Non-stratified train/val split. + +**Training step** +1. Forward: `risk = model(features)` returns a scalar risk score per sample, `(B,)`. +2. Loss: **Cox partial likelihood** (`cox_ph_loss_torch`). For each event in the batch, the loss term is `risk_i − log(sum(exp(risk_j)) for j in risk set at time_i)`; the loss is the negative mean of these terms. +3. Backward (with gradient clipping) and optimizer step. + +The first `Linear` layer of your model is checked to ensure `in_features` matches the actual number of preprocessed features — this prevents silent mismatches when weights are aggregated across cycles. + +**Cycle metrics** +- `c_index` (concordance index, computed via `lifelines.utils.concordance_index(durations, -risk_scores, events)` — risk scores are negated because higher risk should mean shorter survival). + +**Inference output** +- Per-sample risk score; concordance index over the test set. + + + + + +## Reproducing a run locally + +To validate a result you saw on the platform: + + + + Use the same dataset and the same train/validation split ratio. For stratified splits, stratify on the label column; for time series, split temporally. + + + Match the preprocessing in the table above for your use case — especially scaling and categorical encoding, which materially shift loss values. + + + Run the same model architecture and (where applicable) the same pre-trained weights you uploaded to tracebloc. + + + Read these from the experiment parameters in the platform UI. Default loss/optimizer choices are listed above per use case. + + + Use the metric definitions listed for your use case (e.g., `sklearn.metrics.f1_score(..., average="macro")`, `torchmetrics.detection.MeanAveragePrecision`, `lifelines.utils.concordance_index`). + + + The numbers shown in the tracebloc UI are **cycle-level aggregates**, not per-batch. Run a full cycle locally before comparing. + + + + +The full source for every pipeline above lives in [`tracebloc/tracebloc-client`](https://github.com/tracebloc/tracebloc-client) under `use_cases//main.py` and `core/domains/.../.py`. Cycle-level metric implementations live under `core/metrics/`. + From 3e2fed2ab52b0fbd4ba812c9c35a02ed268256e4 Mon Sep 17 00:00:00 2001 From: Divya Date: Thu, 7 May 2026 15:39:51 +0530 Subject: [PATCH 05/12] docs: strip leading zero-width space from evals.json The file started with U+200B (UTF-8 e2 80 8b) before the opening bracket, which broke JSON parsing and caused mint dev to fail with a YAML parser error. Co-Authored-By: Claude Opus 4.7 (1M context) --- evals.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/evals.json b/evals.json index 758be89..fa6cb59 100644 --- a/evals.json +++ b/evals.json @@ -1,4 +1,4 @@ -​[ +[ { "id": 67, "formula": "{c_index}", From d1f59688fa74cde534f4041599b13571fce705a3 Mon Sep 17 00:00:00 2001 From: Divya Date: Thu, 7 May 2026 15:41:44 +0530 Subject: [PATCH 06/12] docs: move "How training works" into Join a Use Case group Lives between hyperparameters and model optimization, where users are already configuring a run and want to understand what the platform does with their model and data. Co-Authored-By: Claude Opus 4.7 (1M context) --- docs.json | 2 +- {tools-help => join-use-case}/how-training-works.mdx | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename {tools-help => join-use-case}/how-training-works.mdx (100%) diff --git a/docs.json b/docs.json index 858f6ef..7778f05 100644 --- a/docs.json +++ b/docs.json @@ -67,6 +67,7 @@ "join-use-case/join-use-case", "join-use-case/start-training", "join-use-case/hyperparameters", + "join-use-case/how-training-works", "join-use-case/model-optimization", "join-use-case/model-evaluation" ] @@ -84,7 +85,6 @@ "group": "Tools & Help", "pages": [ "tools-help/tracebloc-package", - "tools-help/how-training-works", "tools-help/faqs", "tools-help/key-terms" ] diff --git a/tools-help/how-training-works.mdx b/join-use-case/how-training-works.mdx similarity index 100% rename from tools-help/how-training-works.mdx rename to join-use-case/how-training-works.mdx From e1acae20db7a23ebc1bc95334251ba18d9d3ebc2 Mon Sep 17 00:00:00 2001 From: Divya Date: Thu, 7 May 2026 15:44:40 +0530 Subject: [PATCH 07/12] docs: explicitly ignore .github in .mintignore mint dev was parsing .github/pull_request_template.md as MDX and failing on the HTML comments. The file claims .github is auto-ignored but some CLI versions still scan it; listing it explicitly is harmless and unblocks local preview. Co-Authored-By: Claude Opus 4.7 (1M context) --- .mintignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.mintignore b/.mintignore index 9922f06..87f3598 100644 --- a/.mintignore +++ b/.mintignore @@ -2,6 +2,9 @@ # .git, .github, .claude, .agents, .idea, node_modules, # README.md, LICENSE.md, CHANGELOG.md, CONTRIBUTING.md +# Explicit re-listing — auto-ignore was not catching .github on some CLI versions +.github/ + # Draft content drafts/ *.draft.mdx From d68fe49c03a321893536b56db7b20a1e9af91e0f Mon Sep 17 00:00:00 2001 From: Divya Date: Fri, 8 May 2026 14:38:31 +0530 Subject: [PATCH 08/12] docs: rewrite "How training works" with full per-use-case detail MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Expand the page from a high-level overview into a reference users can match runs against. Each of the nine supported use cases (image classification, object detection, semantic segmentation, keypoint detection, text classification, tabular classification, tabular regression, time series forecasting, time-to-event prediction) now has a consistent plain-English breakdown of preprocessing, train/val split, training step, validation step, cycle metrics, and inference output — including the platform-side defaults and reproduction-load-bearing details (mask handling for SS, OD-vs-YOLO image-size pinning, augmentation pipeline behavior, frozen-in-cycle-1 preprocessing state, scaled-vs-original-target metric scales, etc.). Also adds a shared "Experiment parameters" table grounded in the SDK's actual starting defaults (SGD, lr=0.001, batch_size=16, epochs=10, dynamic per-dataset validation_split) and a tightened "Reproducing a run locally" checklist. .mintignore: consolidate the .github/ entries into a single block so the dev server stops tripping over GitHub PR-template HTML comments. Co-Authored-By: Claude Opus 4.7 (1M context) --- .mintignore | 11 +- join-use-case/how-training-works.mdx | 483 ++++++++++++++++++--------- 2 files changed, 336 insertions(+), 158 deletions(-) diff --git a/.mintignore b/.mintignore index 87f3598..2da84ff 100644 --- a/.mintignore +++ b/.mintignore @@ -1,9 +1,10 @@ -# Mintlify automatically ignores these files and directories: -# .git, .github, .claude, .agents, .idea, node_modules, -# README.md, LICENSE.md, CHANGELOG.md, CONTRIBUTING.md - -# Explicit re-listing — auto-ignore was not catching .github on some CLI versions +# Mintlify is supposed to auto-ignore .git, .github, .claude, .agents, +# .idea, node_modules, README.md, LICENSE.md, CHANGELOG.md, CONTRIBUTING.md +# — but in practice the dev server still tries to MDX-parse files inside +# .github (e.g. pull_request_template.md, which uses HTML