diff --git a/configs/_cluster/entropy.yaml b/configs/_cluster/entropy.yaml index 76aaec2e..105a5d99 100644 --- a/configs/_cluster/entropy.yaml +++ b/configs/_cluster/entropy.yaml @@ -34,4 +34,4 @@ cluster_switch: train_path_c4: "/storage_nvme_1/llm-random/datasets/c4/train" eval_path_c4: "/storage_nvme_1/llm-random/datasets/c4/validation" train_path_fineweb: "/storage_nvme_4/llm-random/datasets/fineweb/train" - eval_path_fineweb: "/storage_nvme_4/llm-random/datasets/fineweb/train" + eval_path_fineweb: "/storage_nvme_4/llm-random/datasets/fineweb/train" \ No newline at end of file diff --git a/configs/_cluster/helios.yaml b/configs/_cluster/helios.yaml index 83f692c6..bac89976 100644 --- a/configs/_cluster/helios.yaml +++ b/configs/_cluster/helios.yaml @@ -47,4 +47,4 @@ cluster_switch: train_path_c4: "/net/storage/pr3/plgrid/plggllmeffi3/datasets/c4/train" eval_path_c4: "/net/storage/pr3/plgrid/plggllmeffi3/datasets/c4/validation" train_path_fineweb: "/net/storage/pr3/plgrid/plggllmeffi3/datasets/fineweb/train" - eval_path_fineweb: "/net/storage/pr3/plgrid/plggllmeffi3/datasets/fineweb/train" + eval_path_fineweb: "/net/storage/pr3/plgrid/plggllmeffi3/datasets/fineweb/train" \ No newline at end of file diff --git a/configs/_model/context_scaling/k4.yaml b/configs/_model/context_scaling/k4.yaml new file mode 100644 index 00000000..40c4a7e4 --- /dev/null +++ b/configs/_model/context_scaling/k4.yaml @@ -0,0 +1,24 @@ +defaults: + - swiglu_dense_template + - _self_ + +common: + _target_: src.definitions.Common + dmodel: 256 + dff: 640 + datt: 256 + n_blocks: 4 + q_heads: 4 + kv_heads: 4 + vocab_size: 50304 + sequence_length: 256 + head_norm: true + init_scale: 0.1 + init_type: truncated_normal_fixed + model_type: gpt + +model: + encoder: + block_fn: + attention_fn: + compile: false \ No newline at end of file diff --git a/configs/_model/context_scaling/k8.yaml b/configs/_model/context_scaling/k8.yaml new file mode 100644 index 00000000..609ef2ac --- /dev/null +++ b/configs/_model/context_scaling/k8.yaml @@ -0,0 +1,24 @@ +defaults: + - swiglu_dense_template + - _self_ + +common: + _target_: src.definitions.Common + dmodel: 512 + dff: 1280 + datt: 512 + n_blocks: 8 + q_heads: 8 + kv_heads: 8 + vocab_size: 50304 + sequence_length: 256 + head_norm: true + init_scale: 0.1 + init_type: truncated_normal_fixed + model_type: gpt + +model: + encoder: + block_fn: + attention_fn: + compile: false \ No newline at end of file diff --git a/configs/_model/context_scaling/template.yaml b/configs/_model/context_scaling/template.yaml index d78d9a91..79edb3a8 100644 --- a/configs/_model/context_scaling/template.yaml +++ b/configs/_model/context_scaling/template.yaml @@ -1,5 +1,5 @@ -# Abstract model — does not work alone. Compose with a _feedforward and _attention group. defaults: + - /ff_layer@model.encoder.block_fn.ff_layer_fn: swiglu - _self_ common: diff --git a/configs/simpleP_dense/k12.yaml b/configs/simpleP_dense/k12.yaml new file mode 100644 index 00000000..231446c3 --- /dev/null +++ b/configs/simpleP_dense/k12.yaml @@ -0,0 +1,35 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: entropy + - ../_model/context_scaling@_here_: k12 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +infrastructure: + metric_logger: + name: simpleP_dense_k12 + tags: + - nano + - simpleP_dense + - k12 + + slurm: + time: "0-03:00:00" + gres: gpu:2 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_dense/k16.yaml b/configs/simpleP_dense/k16.yaml new file mode 100644 index 00000000..0ccf45b9 --- /dev/null +++ b/configs/simpleP_dense/k16.yaml @@ -0,0 +1,35 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: lem + - ../_model/context_scaling@_here_: k16 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +infrastructure: + metric_logger: + name: simpleP_dense_k16 + tags: + - nano + - simpleP_dense + - k16 + + slurm: + time: "0-03:00:00" + gres: gpu:hopper:4 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_dense/k20.yaml b/configs/simpleP_dense/k20.yaml new file mode 100644 index 00000000..8fe62d22 --- /dev/null +++ b/configs/simpleP_dense/k20.yaml @@ -0,0 +1,35 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: lem + - ../_model/context_scaling@_here_: k20 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +infrastructure: + metric_logger: + name: simpleP_dense_k20 + tags: + - nano + - simpleP_dense + - k20 + + slurm: + time: "0-04:00:00" + gres: gpu:hopper:4 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_dense/k24.yaml b/configs/simpleP_dense/k24.yaml new file mode 100644 index 00000000..1bad8209 --- /dev/null +++ b/configs/simpleP_dense/k24.yaml @@ -0,0 +1,35 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: lem + - ../_model/context_scaling@_here_: k24 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +infrastructure: + metric_logger: + name: simpleP_dense_k24 + tags: + - nano + - simpleP_dense + - k24 + + slurm: + time: "0-04:00:00" + gres: gpu:hopper:4 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_dense/k4.yaml b/configs/simpleP_dense/k4.yaml new file mode 100644 index 00000000..90c993df --- /dev/null +++ b/configs/simpleP_dense/k4.yaml @@ -0,0 +1,35 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: entropy + - ../_model/context_scaling@_here_: k4 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +infrastructure: + metric_logger: + name: simpleP_dense_k4 + tags: + - nano + - simpleP_dense + - k4 + + slurm: + time: "0-04:00:00" + gres: gpu:1 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_dense/k8.yaml b/configs/simpleP_dense/k8.yaml new file mode 100644 index 00000000..ca3b863e --- /dev/null +++ b/configs/simpleP_dense/k8.yaml @@ -0,0 +1,35 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: entropy + - ../_model/context_scaling@_here_: k8 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +infrastructure: + metric_logger: + name: simpleP_dense_k8 + tags: + - nano + - simpleP_dense + - k8 + + slurm: + time: "0-04:00:00" + gres: gpu:1 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_dense/run_simpleP_dense_sweep.sh b/configs/simpleP_dense/run_simpleP_dense_sweep.sh new file mode 100755 index 00000000..fadcbb36 --- /dev/null +++ b/configs/simpleP_dense/run_simpleP_dense_sweep.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +# Launches k4, k8, k12, k16, k20, k24 in the simpleP_dense variant via run_exp.py. +# Vanilla baselines were already run separately and are not re-launched here. +set -euo pipefail + +# MODELS=(k4 k8 k12 k16 k20 k24) +MODELS=(k4 k12 k24) + +for model in "${MODELS[@]}"; do + echo "=== launching simpleP_dense ${model} ===" + pixi run python run_exp.py --config-name="simpleP_dense/${model}" +done diff --git a/configs/simpleP_moe/k12.yaml b/configs/simpleP_moe/k12.yaml new file mode 100644 index 00000000..7f9b6bc5 --- /dev/null +++ b/configs/simpleP_moe/k12.yaml @@ -0,0 +1,49 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: entropy + - ../_model/context_scaling@_here_: k12 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - override /ff_layer@model.encoder.block_fn.ff_layer_fn: moe + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +model: + encoder: + block_fn: + ff_layer_fn: + num_experts: 8 + topk: 1 + capacity_factor: 1.25 + moe_load_balancing_loss_factor: 0.01 + moe_router_z_loss_factor: 0.001 + normalize_router_logits: false + activation_function: swiglu + init_scale: ${common.init_scale} + +infrastructure: + metric_logger: + name: simpleP_moe_k12 + tags: + - nano + - simpleP_moe + - k12 + + slurm: + time: "0-03:00:00" + gres: gpu:2 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_moe/k16.yaml b/configs/simpleP_moe/k16.yaml new file mode 100644 index 00000000..7f9a362e --- /dev/null +++ b/configs/simpleP_moe/k16.yaml @@ -0,0 +1,49 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: lem + - ../_model/context_scaling@_here_: k16 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - override /ff_layer@model.encoder.block_fn.ff_layer_fn: moe + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +model: + encoder: + block_fn: + ff_layer_fn: + num_experts: 8 + topk: 1 + capacity_factor: 1.25 + moe_load_balancing_loss_factor: 0.01 + moe_router_z_loss_factor: 0.001 + normalize_router_logits: false + activation_function: swiglu + init_scale: ${common.init_scale} + +infrastructure: + metric_logger: + name: simpleP_moe_k16 + tags: + - nano + - simpleP_moe + - k16 + + slurm: + time: "0-03:00:00" + gres: gpu:hopper:4 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_moe/k20.yaml b/configs/simpleP_moe/k20.yaml new file mode 100644 index 00000000..41bb8d39 --- /dev/null +++ b/configs/simpleP_moe/k20.yaml @@ -0,0 +1,49 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: lem + - ../_model/context_scaling@_here_: k20 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - override /ff_layer@model.encoder.block_fn.ff_layer_fn: moe + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +model: + encoder: + block_fn: + ff_layer_fn: + num_experts: 8 + topk: 1 + capacity_factor: 1.25 + moe_load_balancing_loss_factor: 0.01 + moe_router_z_loss_factor: 0.001 + normalize_router_logits: false + activation_function: swiglu + init_scale: ${common.init_scale} + +infrastructure: + metric_logger: + name: simpleP_moe_k20 + tags: + - nano + - simpleP_moe + - k20 + + slurm: + time: "0-04:00:00" + gres: gpu:hopper:4 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_moe/k24.yaml b/configs/simpleP_moe/k24.yaml new file mode 100644 index 00000000..945d39c4 --- /dev/null +++ b/configs/simpleP_moe/k24.yaml @@ -0,0 +1,49 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: lem + - ../_model/context_scaling@_here_: k24 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - override /ff_layer@model.encoder.block_fn.ff_layer_fn: moe + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +model: + encoder: + block_fn: + ff_layer_fn: + num_experts: 8 + topk: 1 + capacity_factor: 1.25 + moe_load_balancing_loss_factor: 0.01 + moe_router_z_loss_factor: 0.001 + normalize_router_logits: false + activation_function: swiglu + init_scale: ${common.init_scale} + +infrastructure: + metric_logger: + name: simpleP_moe_k24 + tags: + - nano + - simpleP_moe + - k24 + + slurm: + time: "0-04:00:00" + gres: gpu:hopper:4 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_moe/k4.yaml b/configs/simpleP_moe/k4.yaml new file mode 100644 index 00000000..a1f0840d --- /dev/null +++ b/configs/simpleP_moe/k4.yaml @@ -0,0 +1,49 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: entropy + - ../_model/context_scaling@_here_: k4 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - override /ff_layer@model.encoder.block_fn.ff_layer_fn: moe + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +model: + encoder: + block_fn: + ff_layer_fn: + num_experts: 8 + topk: 1 + capacity_factor: 1.25 + moe_load_balancing_loss_factor: 0.01 + moe_router_z_loss_factor: 0.001 + normalize_router_logits: false + activation_function: swiglu + init_scale: ${common.init_scale} + +infrastructure: + metric_logger: + name: simpleP_moe_k4 + tags: + - nano + - simpleP_moe + - k4 + + slurm: + time: "0-04:00:00" + gres: gpu:1 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_moe/k8.yaml b/configs/simpleP_moe/k8.yaml new file mode 100644 index 00000000..42df9920 --- /dev/null +++ b/configs/simpleP_moe/k8.yaml @@ -0,0 +1,49 @@ +# @package _global_ +defaults: + - ../_cluster@_here_: entropy + - ../_model/context_scaling@_here_: k8 + - ../_trainer@_here_: context_scaling + - ../_dataset@_here_: ctx_scl_dataset + - ../_checkpoints@_here_: none + - ../_misc@_here_: default + - override /ff_layer@model.encoder.block_fn.ff_layer_fn: moe + - _self_ + +common: + sequence_length: 1024 + batch_size: 64 + +trainer: + gradient_accumulation_steps: 1 + n_steps: 5_001 + ^learning_rate: [4, 5, 6, 7, 8, 9, 10, 11] + eval_interval: 500 + +simpleP: + base_dmodel: 256 + +model: + encoder: + block_fn: + ff_layer_fn: + num_experts: 8 + topk: 1 + capacity_factor: 1.25 + moe_load_balancing_loss_factor: 0.01 + moe_router_z_loss_factor: 0.001 + normalize_router_logits: false + activation_function: swiglu + init_scale: ${common.init_scale} + +infrastructure: + metric_logger: + name: simpleP_moe_k8 + tags: + - nano + - simpleP_moe + - k8 + + slurm: + time: "0-04:00:00" + gres: gpu:1 + job-name: ${infrastructure.metric_logger.name} diff --git a/configs/simpleP_moe/run_simpleP_moe_sweep.sh b/configs/simpleP_moe/run_simpleP_moe_sweep.sh new file mode 100755 index 00000000..0ef59eeb --- /dev/null +++ b/configs/simpleP_moe/run_simpleP_moe_sweep.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +# Launches k4, k8, k12, k16, k20, k24 in both simpleP_moe and vanilla_moe variants via run_exp.py. +# At k4 (dmodel == base_dmodel) every simpleP scale is 1.0, so simpleP_moe and vanilla_moe +# should produce identical curves — useful as a sanity check on the plumbing. +set -euo pipefail + +# MODELS=(k4 k8 k12 k16 k20 k24) +MODELS=(k12 k4 k24) + +for model in "${MODELS[@]}"; do + echo "=== launching simpleP_moe ${model} ===" + pixi run python run_exp.py --config-name="simpleP_moe/${model}" + + echo "=== launching vanilla_moe ${model} ===" + pixi run python run_exp.py --config-name="simpleP_moe/${model}" \ + ~simpleP \ + infrastructure.metric_logger.name="vanilla_moe_${model}" \ + "infrastructure.metric_logger.tags=[nano, vanilla_moe, ${model}]" +done diff --git a/jupyter_notebooks/mfu.ipynb b/jupyter_notebooks/mfu.ipynb index 6da86e2e..8b134b80 100644 --- a/jupyter_notebooks/mfu.ipynb +++ b/jupyter_notebooks/mfu.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "id": "443035c5", "metadata": {}, "outputs": [ @@ -10,13 +10,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "dmodel: 1024\n", - "2.5 dff: 2560\t4 dff 4096\n" + "dmodel: 1536\n", + "2.5 dff: 3840\t4 dff 6144\n" ] } ], "source": [ - "n_layers = 16\n", + "n_layers = 24\n", "dmodel = 64 * n_layers\n", "n_experts = 1\n", "top_k = 1\n", @@ -28,17 +28,7 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "47d89bb1", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "id": "931d6c40", "metadata": {}, "outputs": [ @@ -46,8 +36,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "active / total: 0.24B / 0.30B\n", - "active / total: 244.45M / 295.96M\n" + "active / total: 0.73B / 0.81B\n", + "active / total: 728.43M / 805.70M\n" ] } ], diff --git a/jupyter_notebooks/plots_wandb.ipynb b/jupyter_notebooks/plots_wandb.ipynb index ad75b386..e69de29b 100644 --- a/jupyter_notebooks/plots_wandb.ipynb +++ b/jupyter_notebooks/plots_wandb.ipynb @@ -1,1328 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "from pathlib import Path\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import wandb\n", - "import math\n", - "\n", - "REPO_ROOT = Path.cwd().parent\n", - "sys.path.insert(0, str(REPO_ROOT / \"src\" / \"context_scaling\" / \"scripts\"))\n", - "sys.path.insert(0, str(REPO_ROOT / \"src\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Helpers" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "def get_wandb_table(\n", - " tags,\n", - " project=\"ideas_cv/llm-random-test\",\n", - " negative_tags=None,\n", - " columns=None,\n", - " print_columns=False,\n", - "):\n", - " # WandB automatically looks for the WANDB_API_KEY environment variable.\n", - " api = wandb.Api()\n", - "\n", - " print(f\"tags: {tags}\")\n", - "\n", - " if isinstance(tags, str):\n", - " tags = [tags]\n", - "\n", - " # $and ensures the run contains ALL of the specified positive tags.\n", - " filters = {\"$and\": [{\"tags\": tag} for tag in tags]} if tags else {}\n", - "\n", - " runs = api.runs(path=project, filters=filters)\n", - "\n", - " runs_data = []\n", - " for run in runs:\n", - " run_dict = {\n", - " \"sys/id\": run.id,\n", - " \"sys/name\": run.name,\n", - " \"sys/state\": run.state,\n", - " \"sys/tags\": run.tags,\n", - " }\n", - " run_dict.update({f\"config/{k}\": v for k, v in run.config.items()})\n", - " run_dict.update({f\"summary/{k}\": v for k, v in run.summary._json_dict.items()})\n", - "\n", - " runs_data.append(run_dict)\n", - "\n", - " runs_table = pd.DataFrame(runs_data)\n", - "\n", - " if runs_table.empty:\n", - " print(\"df shape: (0, 0)\")\n", - " return runs_table\n", - "\n", - " if columns:\n", - " cols_to_keep = set(columns)\n", - " if negative_tags:\n", - " cols_to_keep.add(\"sys/tags\")\n", - "\n", - " available_cols = [col for col in cols_to_keep if col in runs_table.columns]\n", - " runs_table = runs_table[available_cols]\n", - "\n", - " if negative_tags:\n", - " if isinstance(negative_tags, str):\n", - " negative_tags = [negative_tags]\n", - "\n", - " for neg_tag in negative_tags:\n", - " runs_table = runs_table[\n", - " ~runs_table[\"sys/tags\"].apply(\n", - " lambda x: neg_tag in x if isinstance(x, list) else False\n", - " )\n", - " ]\n", - "\n", - " if print_columns:\n", - " print(\"\\n=== Available columns ===\")\n", - " for col in sorted(runs_table.columns):\n", - " print(f\"\\t{col}\")\n", - " print(\"========================\\n\")\n", - "\n", - " print(f\"df shape: {runs_table.shape}\")\n", - "\n", - " return runs_table\n", - "\n", - "\n", - "def solve_config_lr(\n", - " config_lr: float,\n", - ") -> tuple[\n", - " float, float\n", - "]: # TODO temporary place - move to devinitions eval+ when created\n", - " ret_lr, ret_exp_lr = None, None\n", - " if config_lr < 1.0:\n", - " ret_lr = config_lr\n", - " ret_exp_lr = -1 * math.log(config_lr) / math.log(2)\n", - " if config_lr >= 1.0:\n", - " ret_lr = 2**-config_lr\n", - " ret_exp_lr = ret_exp_lr\n", - " return ret_lr, ret_exp_lr\n", - "\n", - "\n", - "def flatten_config_columns(df: pd.DataFrame, sep: str = \"/\") -> pd.DataFrame:\n", - " \"\"\"Expand dict-valued `config/*` columns into flat columns.\n", - "\n", - " wandb stores the nested OmegaConf config, so `run.config.items()` yields\n", - " top-level keys like `common`, `trainer` with dict values. This walks those\n", - " dicts and produces columns like `config/trainer/learning_rate`.\n", - " \"\"\"\n", - " df = df.copy()\n", - "\n", - " def walk(prefix, value, out):\n", - " if isinstance(value, dict):\n", - " for k, v in value.items():\n", - " walk(f\"{prefix}{sep}{k}\", v, out)\n", - " else:\n", - " out[prefix] = value\n", - "\n", - " config_cols = [c for c in df.columns if c.startswith(\"config/\")]\n", - " new_rows = []\n", - " for _, row in df.iterrows():\n", - " flat = {}\n", - " for c in config_cols:\n", - " walk(c, row[c], flat)\n", - " new_rows.append(flat)\n", - "\n", - " flat_df = pd.DataFrame(new_rows, index=df.index)\n", - " df = df.drop(columns=config_cols)\n", - " return pd.concat([df, flat_df], axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "def get_final_loss_values(runs_table, lr_col, loss_col, main_variables):\n", - " rows = []\n", - " for _, run_row in runs_table.iterrows():\n", - " row = {\n", - " \"run_id\": run_row[\"sys/id\"],\n", - " \"lr\": run_row[lr_col],\n", - " \"final_loss\": run_row[loss_col],\n", - " }\n", - " for i, mv in enumerate(main_variables):\n", - " row[f\"grid_val_{i}\"] = run_row[mv]\n", - " rows.append(row)\n", - " return pd.DataFrame(rows)\n", - "\n", - "\n", - "def plot_loss_vs_lr(\n", - " runs_table,\n", - " main_variables,\n", - " lr_col=\"config/trainer/learning_rate\",\n", - " loss_col=\"summary/steps/eval/loss\",\n", - " n_steps_col=\"config/trainer/n_steps\",\n", - " step_col=\"summary/step\",\n", - " ylim=None,\n", - " title=None,\n", - " ax=None,\n", - " ax_labels_font=12,\n", - " tick_font=12,\n", - " title_font=12,\n", - " var_labels=None,\n", - " color_map=None,\n", - " legend_loc=\"best\",\n", - "):\n", - " \"\"\"Plot final eval loss vs learning rate, one line per `main_variables` combo.\n", - "\n", - " Expects a wandb-style dataframe (columns prefixed `config/` and `summary/`).\n", - " Finished runs (step+1 >= n_steps) are drawn with circles + solid lines;\n", - " running runs are drawn with squares + dashed lines.\n", - "\n", - " `color_map`, if given, maps grid-value tuples to colors so multiple calls\n", - " can share a consistent palette across subplots.\n", - " \"\"\"\n", - " color_dict = {\n", - " 0: \"#1f78b4\", 1: \"#33a02c\", 2: \"#e31a1c\", 3: \"#ff7f00\",\n", - " 4: \"#6a3d9a\", 5: \"#a65628\", 6: \"#000000\",\n", - " }\n", - "\n", - " required = [\"sys/id\", lr_col, loss_col, n_steps_col, step_col, *main_variables]\n", - " missing = [c for c in required if c not in runs_table.columns]\n", - " if missing:\n", - " raise ValueError(f\"Missing columns: {missing}\")\n", - "\n", - " final_loss_df = get_final_loss_values(\n", - " runs_table, lr_col=lr_col, loss_col=loss_col, main_variables=main_variables\n", - " )\n", - " final_loss_df = final_loss_df[final_loss_df[\"final_loss\"].notnull()]\n", - "\n", - " completion_map = {\n", - " r[\"sys/id\"]: \"complete\" if (r[step_col] + 1 >= r[n_steps_col]) else \"running\"\n", - " for _, r in runs_table.iterrows()\n", - " }\n", - " final_loss_df[\"status\"] = final_loss_df[\"run_id\"].map(completion_map)\n", - "\n", - " grid_cols = [f\"grid_val_{i}\" for i in range(len(main_variables))]\n", - " grid_val_sets = (\n", - " final_loss_df[grid_cols]\n", - " .drop_duplicates()\n", - " .sort_values(grid_cols)\n", - " .itertuples(index=False, name=None)\n", - " )\n", - "\n", - " var_labels = var_labels or {}\n", - "\n", - " for color_num, grid_vals in enumerate(grid_val_sets):\n", - " mask = (final_loss_df[grid_cols] == grid_vals).all(axis=1)\n", - " subset = final_loss_df[mask]\n", - " color = color_map.get(grid_vals) if color_map is not None else color_dict.get(color_num)\n", - "\n", - " label = \", \".join(\n", - " f\"{var_labels.get(name, name)}: {value}\"\n", - " for name, value in zip(main_variables, grid_vals)\n", - " )\n", - "\n", - " target = ax if ax is not None else plt\n", - "\n", - " finished = subset[subset[\"status\"] == \"complete\"]\n", - " if not finished.empty:\n", - " means = finished.sort_values(\"lr\").groupby(\"lr\")[\"final_loss\"].mean()\n", - " target.plot(means.index.to_numpy(), means.values, marker=\"o\",\n", - " color=color, label=label, linestyle=\"-\")\n", - "\n", - " running = subset[subset[\"status\"] != \"complete\"]\n", - " if not running.empty:\n", - " means = running.sort_values(\"lr\").groupby(\"lr\")[\"final_loss\"].mean()\n", - " target.plot(means.index.to_numpy(), means.values, marker=\"s\",\n", - " color=color, label=label, linestyle=\"--\", markersize=6)\n", - "\n", - " if ax is None:\n", - " plt.legend(loc=legend_loc)\n", - " plt.tick_params(axis=\"both\", labelsize=tick_font)\n", - " plt.xlabel(\"Learning Rate\", fontsize=ax_labels_font)\n", - " plt.ylabel(\"Final Eval Loss\", fontsize=ax_labels_font)\n", - " plt.title(title or \"Final Loss vs Learning Rate\", fontsize=title_font)\n", - " plt.grid(True)\n", - " plt.xscale(\"log\", base=2)\n", - " if ylim is not None:\n", - " plt.ylim(ylim)\n", - " plt.show()\n", - " else:\n", - " ax.legend(loc=legend_loc)\n", - " ax.set_xlabel(\"Learning Rate\", fontsize=ax_labels_font)\n", - " ax.set_ylabel(\"Final Eval Loss\", fontsize=ax_labels_font)\n", - " ax.tick_params(axis=\"both\", labelsize=tick_font)\n", - " ax.set_xscale(\"log\", base=2)\n", - " ax.set_title(title or \"Final Loss vs Learning Rate\", fontsize=title_font)\n", - " ax.grid(True)\n", - " if ylim is not None:\n", - " ax.set_ylim(ylim)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [], - "source": [ - "KEEP_COLS_DEFAULT = [\n", - " \"sys/id\", \"sys/name\", \"sys/state\", \"sys/tags\",\n", - " \"config/trainer/learning_rate\",\n", - " \"config/trainer/n_steps\",\n", - " \"config/common/batch_size\",\n", - " \"config/common/dmodel\",\n", - " \"summary/step\",\n", - " \"summary/steps/eval/loss\",\n", - "]\n", - "\n", - "\n", - "def augment_with_midway_loss(\n", - " df,\n", - " project,\n", - " pcts=(50,),\n", - " metric_key=\"steps/eval/loss\",\n", - " n_steps_col=\"config/trainer/n_steps\",\n", - " cache_path=None,\n", - " keep_cols=None,\n", - "):\n", - " \"\"\"Add `eval@` columns for eval loss at each pct% through training.\n", - "\n", - " Cache: if `cache_path` exists, values are read from CSV first; wandb history is\n", - " only fetched for runs missing the requested pcts. The augmented df is then\n", - " written back to `cache_path` with `keep_cols + eval@` columns.\n", - " \"\"\"\n", - " pcts = list(pcts)\n", - " target_cols = [f\"eval@{p}\" for p in pcts]\n", - "\n", - " cache = pd.DataFrame()\n", - " if cache_path is not None and Path(cache_path).exists():\n", - " cache = pd.read_csv(cache_path)\n", - " cache_by_id = (\n", - " {row[\"sys/id\"]: row.to_dict() for _, row in cache.iterrows()}\n", - " if \"sys/id\" in cache.columns\n", - " else {}\n", - " )\n", - "\n", - " api = wandb.Api()\n", - " new_vals = {col: [] for col in target_cols}\n", - "\n", - " for _, run_row in df.iterrows():\n", - " run_id = run_row[\"sys/id\"]\n", - " cached = cache_by_id.get(run_id, {})\n", - " n_steps = run_row[n_steps_col]\n", - "\n", - " history = None\n", - " for pct, col in zip(pcts, target_cols):\n", - " cached_val = cached.get(col, np.nan)\n", - " if pd.notnull(cached_val):\n", - " new_vals[col].append(cached_val)\n", - " continue\n", - "\n", - " if history is None:\n", - " run = api.run(f\"{project}/{run_id}\")\n", - " history = run.history(keys=[metric_key], samples=10000, pandas=True)\n", - "\n", - " if metric_key not in history.columns:\n", - " new_vals[col].append(np.nan)\n", - " continue\n", - "\n", - " h = history.dropna(subset=[metric_key])\n", - " if h.empty:\n", - " new_vals[col].append(np.nan)\n", - " continue\n", - "\n", - " target_step = int(n_steps * pct / 100)\n", - " idx = (h[\"_step\"] - target_step).abs().idxmin()\n", - " new_vals[col].append(h.loc[idx, metric_key])\n", - "\n", - " df = df.copy()\n", - " for col in target_cols:\n", - " df[col] = new_vals[col]\n", - "\n", - " if cache_path is not None:\n", - " cols = list(keep_cols or KEEP_COLS_DEFAULT) + target_cols\n", - " cols = [c for c in cols if c in df.columns]\n", - " Path(cache_path).parent.mkdir(parents=True, exist_ok=True)\n", - " df[cols].to_csv(cache_path, index=False)\n", - "\n", - " return df" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## critical Batch Size" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['critical_batch_size', 'dense', 'mha']\n", - "df shape: (45, 323)\n", - "df_dense_mha: (45, 516)\n", - "tags: ['critical_batch_size', 'dense', 'mqa']\n", - "df shape: (41, 323)\n", - "df_dense_mqa: (41, 516)\n", - "tags: ['critical_batch_size', 'moe', 'mha']\n", - "df shape: (39, 331)\n", - "df_moe_mha: (39, 512)\n", - "tags: ['critical_batch_size', 'moe', 'mqa']\n", - "df shape: (39, 331)\n", - "df_moe_mqa: (39, 512)\n" - ] - } - ], - "source": [ - "tags_dense_mha = [\"critical_batch_size\", \"dense\", \"mha\"]\n", - "tags_dense_mqa = [\"critical_batch_size\", \"dense\", \"mqa\"]\n", - "tags_moe_mha = [\"critical_batch_size\", \"moe\", \"mha\"]\n", - "tags_moe_mqa = [\"critical_batch_size\", \"moe\", \"mqa\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "CACHE_DIR = REPO_ROOT / \"jupyter_notebooks\" / \"cache\"\n", - "PCTS = [50]\n", - "\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "\n", - "def load_critical_bs(tags, cache_name):\n", - " df = get_wandb_table(tags, project=project, negative_tags=negative_tags)\n", - " df = resolve_lr(flatten_config_columns(df))\n", - " df = augment_with_midway_loss(\n", - " df, project=project, pcts=PCTS,\n", - " cache_path=CACHE_DIR / f\"{cache_name}.csv\",\n", - " )\n", - " return df\n", - "\n", - "\n", - "df_dense_mha = load_critical_bs(tags_dense_mha, \"cb_dense_mha\")\n", - "print(\"df_dense_mha:\", df_dense_mha.shape)\n", - "\n", - "df_dense_mqa = load_critical_bs(tags_dense_mqa, \"cb_dense_mqa\")\n", - "print(\"df_dense_mqa:\", df_dense_mqa.shape)\n", - "\n", - "df_moe_mha = load_critical_bs(tags_moe_mha, \"cb_moe_mha\")\n", - "print(\"df_moe_mha:\", df_moe_mha.shape)\n", - "\n", - "df_moe_mqa = load_critical_bs(tags_moe_mqa, \"cb_moe_mqa\")\n", - "print(\"df_moe_mqa:\", df_moe_mqa.shape)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/batch_size\"\n", - "loss_col = f\"eval@{PCTS[0]}\"\n", - "\n", - "# Collect all dmodel values across the 4 dataframes so colors are consistent.\n", - "dfs = {\n", - " \"dense mha\": df_dense_mha,\n", - " \"dense mqa\": df_dense_mqa,\n", - " \"moe mha\": df_moe_mha,\n", - " \"moe mqa\": df_moe_mqa,\n", - "}\n", - "\n", - "all_vals = sorted(\n", - " set().union(*[\n", - " set(df[mv].dropna())\n", - " for df in dfs.values()\n", - " if mv in df.columns\n", - " ])\n", - ")\n", - "\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "\n", - "ylim = (3.35, 3.7)\n", - "\n", - "fig, axes = plt.subplots(2, 2, figsize=(12, 10), sharey=True)\n", - "\n", - "plot_loss_vs_lr(\n", - " df_dense_mha,\n", - " main_variables=[mv],\n", - " loss_col=loss_col,\n", - " legend_loc=\"upper left\",\n", - " title=\"dense mha\",\n", - " ax=axes[0, 0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "\n", - "plot_loss_vs_lr(\n", - " df_dense_mqa,\n", - " main_variables=[mv],\n", - " loss_col=loss_col,\n", - " legend_loc=\"upper left\",\n", - " title=\"dense mqa\",\n", - " ax=axes[0, 1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "\n", - "plot_loss_vs_lr(\n", - " df_moe_mha,\n", - " main_variables=[mv],\n", - " loss_col=loss_col,\n", - " legend_loc=\"upper left\",\n", - " title=\"moe mha\",\n", - " ax=axes[1, 0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "\n", - "plot_loss_vs_lr(\n", - " df_moe_mqa,\n", - " main_variables=[mv],\n", - " loss_col=loss_col,\n", - " legend_loc=\"upper left\",\n", - " title=\"moe mqa\",\n", - " ax=axes[1, 1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### testing" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['critical_batch_size_test', '2026-04-27']\n", - "df shape: (14, 323)\n", - "testing_df: (14, 517)\n" - ] - } - ], - "source": [ - "tags_testing = [\"critical_batch_size_test\", \"2026-04-27\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "testing_df = get_wandb_table(tags_testing, project=project, negative_tags=negative_tags)\n", - "testing_df = resolve_lr(flatten_config_columns(testing_df))\n", - "print(\"testing_df:\", testing_df.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/batch_size\"\n", - "\n", - "dfs = {\n", - " \"dense mha\": testing_df,\n", - "}\n", - "\n", - "all_vals = sorted(\n", - " set().union(*[\n", - " set(df[mv].dropna())\n", - " for df in dfs.values()\n", - " if mv in df.columns\n", - " ])\n", - ")\n", - "\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "\n", - "ylim = None\n", - "\n", - "fig, axes = plt.subplots(1, figsize=(6, 5))\n", - "\n", - "plot_loss_vs_lr(\n", - " testing_df,\n", - " main_variables=[mv],\n", - " title=\"dense mha\",\n", - " ax=axes,\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## simpleP dense" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['simpleP_dense2']\n", - "df shape: (24, 610)\n", - "simpleP: (24, 804)\n", - "tags: ['vanilla2']\n", - "df shape: (63, 609)\n", - "vanilla: (63, 806)\n" - ] - } - ], - "source": [ - "tags1 = [\"simpleP_dense2\"]\n", - "tags2 = [\"vanilla2\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "df_simpleP_raw = get_wandb_table(tags1, project=project, negative_tags=negative_tags)\n", - "df_simpleP_dense = resolve_lr(flatten_config_columns(df_simpleP_raw))\n", - "print(\"simpleP:\", df_simpleP_dense.shape)\n", - "\n", - "df_vanilla_raw = get_wandb_table(tags2, project=project, negative_tags=negative_tags)\n", - "df_vanilla_dense = resolve_lr(flatten_config_columns(df_vanilla_raw))\n", - "print(\"vanilla:\", df_vanilla_dense.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/dmodel\"\n", - "all_vals = sorted(set(df_simpleP_dense[mv].dropna()) | set(df_vanilla_dense[mv].dropna()))\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "ylim=(3.5, 4.5)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 6), sharey=True)\n", - "plot_loss_vs_lr(\n", - " df_simpleP_dense,\n", - " main_variables=[mv],\n", - " title=\"simpleP dense\",\n", - " ax=axes[0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plot_loss_vs_lr(\n", - " df_vanilla_dense,\n", - " main_variables=[mv],\n", - " title=\"vanilla dense\",\n", - " ax=axes[1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### long warmup" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['long_warmup', 'simpleP_dense3']\n", - "df shape: (8, 610)\n", - "simpleP: (8, 804)\n" - ] - } - ], - "source": [ - "tags1 = [\"long_warmup\", \"simpleP_dense3\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "df_simpleP_raw = get_wandb_table(tags1, project=project, negative_tags=negative_tags)\n", - "df_simpleP_dense_long_warmup = resolve_lr(flatten_config_columns(df_simpleP_raw))\n", - "print(\"simpleP:\", df_simpleP_dense_long_warmup.shape)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/dmodel\"\n", - "all_vals = sorted(set(df_simpleP_dense_long_warmup[mv].dropna()) | set(df_vanilla_dense[mv].dropna()))\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "ylim=(3.5, 4.5)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 6), sharey=True)\n", - "plot_loss_vs_lr(\n", - " df_simpleP_dense_long_warmup,\n", - " main_variables=[mv],\n", - " title=\"simpleP dense\",\n", - " ax=axes[0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plot_loss_vs_lr(\n", - " df_vanilla_dense,\n", - " main_variables=[mv],\n", - " title=\"vanilla dense\",\n", - " ax=axes[1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## simpleP MoE" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['simpleP_moe2']\n", - "df shape: (24, 618)\n", - "simpleP: (24, 800)\n", - "tags: ['vanilla_moe2']\n", - "df shape: (24, 617)\n", - "vanilla: (24, 799)\n" - ] - } - ], - "source": [ - "tags1 = [\"simpleP_moe2\"]\n", - "tags2 = [\"vanilla_moe2\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "df_simpleP_raw = get_wandb_table(tags1, project=project, negative_tags=negative_tags)\n", - "df_simpleP_moe = resolve_lr(flatten_config_columns(df_simpleP_raw))\n", - "print(\"simpleP:\", df_simpleP_moe.shape)\n", - "\n", - "df_vanilla_raw = get_wandb_table(tags2, project=project, negative_tags=negative_tags)\n", - "df_vanilla_moe = resolve_lr(flatten_config_columns(df_vanilla_raw))\n", - "print(\"vanilla:\", df_vanilla_moe.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/dmodel\"\n", - "all_vals = sorted(set(df_simpleP_moe[mv].dropna()) | set(df_vanilla_moe[mv].dropna()))\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "ylim = (3.5, 5.2)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 6), sharey=True)\n", - "plot_loss_vs_lr(\n", - " df_simpleP_moe,\n", - " main_variables=[mv],\n", - " title=\"simpleP MoE long warmup\",\n", - " ax=axes[0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plot_loss_vs_lr(\n", - " df_vanilla_moe,\n", - " main_variables=[mv],\n", - " title=\"vanilla MoE\",\n", - " ax=axes[1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### long warmup" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['long_warmup', 'simpleP_moe']\n", - "df shape: (8, 618)\n", - "simpleP: (8, 800)\n" - ] - } - ], - "source": [ - "tags1 = [\"long_warmup\", \"simpleP_moe\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "df_simpleP_raw = get_wandb_table(tags1, project=project, negative_tags=negative_tags)\n", - "df_simpleP_moe_long_warmup = resolve_lr(flatten_config_columns(df_simpleP_raw))\n", - "print(\"simpleP:\", df_simpleP_moe_long_warmup.shape)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/dmodel\"\n", - "all_vals = sorted(set(df_simpleP_moe_long_warmup[mv].dropna()) | set(df_vanilla_moe[mv].dropna()))\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "ylim = (3.5, 5.2)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 6), sharey=True)\n", - "plot_loss_vs_lr(\n", - " df_simpleP_moe_long_warmup,\n", - " main_variables=[mv],\n", - " title=\"simpleP MoE short seq\",\n", - " ax=axes[0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plot_loss_vs_lr(\n", - " df_vanilla_moe,\n", - " main_variables=[mv],\n", - " title=\"vanilla MoE\",\n", - " ax=axes[1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### short seq" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['short_seq', 'simpleP_moe']\n", - "df shape: (7, 618)\n", - "simpleP: (7, 800)\n" - ] - } - ], - "source": [ - "tags1 = [\"short_seq\", \"simpleP_moe\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "df_simpleP_raw = get_wandb_table(tags1, project=project, negative_tags=negative_tags)\n", - "df_simpleP_moe_short_seq = resolve_lr(flatten_config_columns(df_simpleP_raw))\n", - "print(\"simpleP:\", df_simpleP_moe_short_seq.shape)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/dmodel\"\n", - "all_vals = sorted(set(df_simpleP_moe_short_seq[mv].dropna()) | set(df_vanilla_moe[mv].dropna()))\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "ylim = (3.5, 5.2)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 6), sharey=True)\n", - "plot_loss_vs_lr(\n", - " df_simpleP_moe_short_seq,\n", - " main_variables=[mv],\n", - " title=\"simpleP MoE short seq\",\n", - " ax=axes[0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plot_loss_vs_lr(\n", - " df_vanilla_moe,\n", - " main_variables=[mv],\n", - " title=\"vanilla MoE\",\n", - " ax=axes[1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1B tokens" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['1B', 'simpleP_moe']\n", - "df shape: (7, 618)\n", - "simpleP: (7, 800)\n" - ] - } - ], - "source": [ - "tags1 = [\"1B\", \"simpleP_moe\"]\n", - "negative_tags = [\"remove\"]\n", - "project = \"ideas_cv/llm-random-test\"\n", - "\n", - "def resolve_lr(df):\n", - " # config/trainer/learning_rate is the raw config value; solve_config_lr\n", - " # maps x>=1 to 2**-x so the axis reflects the effective LR used in training.\n", - " df = df.copy()\n", - " df[\"config/trainer/learning_rate\"] = df[\"config/trainer/learning_rate\"].apply(\n", - " lambda x: solve_config_lr(x)[0] if pd.notnull(x) else x\n", - " )\n", - " return df\n", - "\n", - "df_simpleP_raw = get_wandb_table(tags1, project=project, negative_tags=negative_tags)\n", - "df_simpleP_moe_1B = resolve_lr(flatten_config_columns(df_simpleP_raw))\n", - "print(\"simpleP:\", df_simpleP_moe_1B.shape)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels = {\n", - " \"config/common/dmodel\": \"dmodel\",\n", - "}\n", - "\n", - "mv = \"config/common/dmodel\"\n", - "all_vals = sorted(set(df_simpleP_moe_1B[mv].dropna()) | set(df_vanilla_moe[mv].dropna()))\n", - "palette = [\"#1f78b4\", \"#33a02c\", \"#e31a1c\", \"#ff7f00\", \"#6a3d9a\", \"#a65628\", \"#000000\"]\n", - "color_map = {(v,): palette[i % len(palette)] for i, v in enumerate(all_vals)}\n", - "ylim = (3.0, 5.2)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 6), sharey=True)\n", - "plot_loss_vs_lr(\n", - " df_simpleP_moe_1B,\n", - " main_variables=[mv],\n", - " title=\"simpleP MoE short seq\",\n", - " ax=axes[0],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plot_loss_vs_lr(\n", - " df_vanilla_moe,\n", - " main_variables=[mv],\n", - " title=\"vanilla MoE\",\n", - " ax=axes[1],\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels,\n", - " color_map=color_map,\n", - " ylim=ylim,\n", - ")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### PK grid" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tags: ['2026.04.19']\n", - "df shape: (12, 423)\n", - "simpleP_bsgrid: (12, 598)\n" - ] - } - ], - "source": [ - "df_pkgrid_raw = get_wandb_table([\"2026.04.19\"], project=\"ideas_cv/tml-bgw\", negative_tags=['No_QKNorm'])\n", - "df_pkgrid = resolve_lr(flatten_config_columns(df_pkgrid_raw))\n", - "print(\"simpleP_bsgrid:\", df_pkgrid.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var_labels_bs = {\"config/infrastructure/metric_logger/name\": \"type\"}\n", - "\n", - "plot_loss_vs_lr(\n", - " df_pkgrid,\n", - " main_variables=[\"config/infrastructure/metric_logger/name\"],\n", - " title=\"Loss vs LR (simpleP_bsgrid)\",\n", - " ax_labels_font=18,\n", - " tick_font=15,\n", - " title_font=20,\n", - " var_labels=var_labels_bs,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "default", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/main.py b/main.py index a69f9c16..857f256a 100644 --- a/main.py +++ b/main.py @@ -383,7 +383,9 @@ def initialize_training_components(cfg: OmegaConf, metric_logger=None): simpleP_cfg = cfg.get("simpleP", None) if simpleP_cfg: scale = simpleP_cfg.base_dmodel / cfg.common.dmodel - param_groups = build_simpleP_param_groups(model, learning_rate, scale) + param_groups = build_simpleP_param_groups( + model, learning_rate, scale + ) optimizer = torch.optim.AdamW( param_groups, weight_decay=cfg.trainer.weight_decay, diff --git a/pixi.lock b/pixi.lock index 8a852dde..f4749700 100644 --- a/pixi.lock +++ b/pixi.lock @@ -59,7 +59,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl - pypi: https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/4e/ef/79a463eb0fff7f96afa04c1d4c51f8fc85426f918db467854bfb6a569ce3/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl - - pypi: https://files.pythonhosted.org/packages/ba/6c/ff8bf52315064dbeb55cb5067e191120a5b2e58bb648d0d34cf7969dc2c2/choreographer-1.3.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl @@ -122,11 +121,9 @@ environments: - pypi: https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/18/78/08cec00ea05fd2469f9395da0306bb368c4ed275693be8d31473eafaf90c/kagglehub-1.0.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/69/6b/db30f17ad132391ac37a751fa45b32fd954a7ffa484fa3550eee9678334d/kagglesdk-0.1.16-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9e/b9/a6d8bb7d228940f01885bd9f327ab7f9d366a9be775c4bf366bf9d9477ae/kaleido-1.3.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl - pypi: https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/df/b3/8c2923ad4c4d911307e20ab9c7d7869d3811b5a76fe6dbe53678aafbeb04/lm_eval-0.4.11-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/20/6aa79ba3570bddd1bf7e951c6123f806751e58e8cce736bad77b2cf348d7/logistro-2.0.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c6/d1/232b3309a02d60f11e71857778bfcd4acbdb86c07db8260caf7d008b08f8/lxml-6.0.2-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl - pypi: https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl - pypi: https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl @@ -163,7 +160,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/03/f8/9d85593582bd99b8d7c65634d2304780aefade049b2b94d96e44084be90b/nvidia_nvjitlink_cu12-12.8.61-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl - pypi: https://files.pythonhosted.org/packages/8d/cd/0e8c51b2ae3a58f054f2e7fe91b82d201abfb30167f2431e9bd92d532f42/nvidia_nvtx_cu12-12.8.55-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl - pypi: https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/0e/a4/82b7a2fe5d8a67a59ed831b24d59a3d46ea7d207b66e1602d376541d94a6/orjson-3.11.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - pypi: https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/3d/fe/89d77e424365280b79d99b3e1e7d606f5165af2f2ecfaf0c6d24c799d607/pandas-3.0.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl - pypi: https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl @@ -215,7 +211,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl - pypi: https://files.pythonhosted.org/packages/9a/66/20465097782d7e1e742d846407ea7262d338c6e876ddddad38ca8907b38f/sentry_sdk-2.55.0-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/0c/b6/156a8de1e1b47694f0e7de6675866936608d45dc68388fd017d36f8693be/simplejson-4.1.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl - pypi: https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl @@ -322,7 +317,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl - pypi: https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/a8/37/bdca6613c2e3c58c7421891d80cc3efa1d32e882f7c4a7ee6039c3fc951a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl - - pypi: https://files.pythonhosted.org/packages/ba/6c/ff8bf52315064dbeb55cb5067e191120a5b2e58bb648d0d34cf7969dc2c2/choreographer-1.3.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl @@ -385,11 +379,9 @@ environments: - pypi: https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/18/78/08cec00ea05fd2469f9395da0306bb368c4ed275693be8d31473eafaf90c/kagglehub-1.0.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/69/6b/db30f17ad132391ac37a751fa45b32fd954a7ffa484fa3550eee9678334d/kagglesdk-0.1.16-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9e/b9/a6d8bb7d228940f01885bd9f327ab7f9d366a9be775c4bf366bf9d9477ae/kaleido-1.3.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/df/b3/8c2923ad4c4d911307e20ab9c7d7869d3811b5a76fe6dbe53678aafbeb04/lm_eval-0.4.11-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/20/6aa79ba3570bddd1bf7e951c6123f806751e58e8cce736bad77b2cf348d7/logistro-2.0.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c8/20/a7760713e65888db79bbae4f6146a6ae5c04e4a204a3c48896c408cd6ed2/lxml-6.0.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl @@ -412,7 +404,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/7b/12/8c9f0c6c95f76aeb20fc4a699c33e9f827fa0d0f857747c73bb7b17af945/numpy-2.4.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/ab/86/1c3a47df3bc8191ea9ac51603bbb872a95167a364320c269f2557911f406/orjson-3.11.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl - pypi: https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/d7/39/327802e0b6d693182403c144edacbc27eb82907b57062f23ef5a4c4a5ea7/pandas-3.0.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl @@ -463,7 +454,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/9a/66/20465097782d7e1e742d846407ea7262d338c6e876ddddad38ca8907b38f/sentry_sdk-2.55.0-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/86/1c/e4d0eab695be3eb21d0f46bce820752031f03e7113f9c80a9b3c73ee7157/simplejson-4.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl - pypi: https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl @@ -547,7 +537,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/e5/62/c0815c992c9545347aeea7859b50dc9044d147e2e7278329c6e02ac9a616/charset_normalizer-3.4.6-cp312-cp312-macosx_10_13_universal2.whl - - pypi: https://files.pythonhosted.org/packages/ba/6c/ff8bf52315064dbeb55cb5067e191120a5b2e58bb648d0d34cf7969dc2c2/choreographer-1.3.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl @@ -610,11 +599,9 @@ environments: - pypi: https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/18/78/08cec00ea05fd2469f9395da0306bb368c4ed275693be8d31473eafaf90c/kagglehub-1.0.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/69/6b/db30f17ad132391ac37a751fa45b32fd954a7ffa484fa3550eee9678334d/kagglesdk-0.1.16-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9e/b9/a6d8bb7d228940f01885bd9f327ab7f9d366a9be775c4bf366bf9d9477ae/kaleido-1.3.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/df/b3/8c2923ad4c4d911307e20ab9c7d7869d3811b5a76fe6dbe53678aafbeb04/lm_eval-0.4.11-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/20/6aa79ba3570bddd1bf7e951c6123f806751e58e8cce736bad77b2cf348d7/logistro-2.0.1-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/f3/c8/8ff2bc6b920c84355146cd1ab7d181bc543b89241cfb1ebee824a7c81457/lxml-6.0.2-cp312-cp312-macosx_10_13_universal2.whl - pypi: https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl @@ -637,7 +624,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/74/1b/ee2abfc68e1ce728b2958b6ba831d65c62e1b13ce3017c13943f8f9b5b2e/numpy-2.4.3-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/16/6d/11867a3ffa3a3608d84a4de51ef4dd0896d6b5cc9132fbe1daf593e677bc/orjson-3.11.9-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl - pypi: https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/7c/f1/e2567ffc8951ab371db2e40b2fe068e36b81d8cf3260f06ae508700e5504/pandas-3.0.1-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl @@ -689,7 +675,6 @@ environments: - pypi: https://files.pythonhosted.org/packages/19/84/42eb3ce4796777a1b5d3699dfd4dca85113e68b637f194a6c8d786f16a04/sentencepiece-0.2.1-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/9a/66/20465097782d7e1e742d846407ea7262d338c6e876ddddad38ca8907b38f/sentry_sdk-2.55.0-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/b8/78/fc060d2e3b13c6ec59288574b8efac64075e316b2afba4396a56b2422f78/simplejson-4.1.1-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl @@ -1226,15 +1211,6 @@ packages: version: 3.4.6 sha256: 2ef7fedc7a6ecbe99969cd09632516738a97eeb8bd7258bf8a0f23114c057dab requires_python: '>=3.7' -- pypi: https://files.pythonhosted.org/packages/ba/6c/ff8bf52315064dbeb55cb5067e191120a5b2e58bb648d0d34cf7969dc2c2/choreographer-1.3.0-py3-none-any.whl - name: choreographer - version: 1.3.0 - sha256: cea4cb739e4f61625e4b53888a8d3fa1d3bf73948b56753e460ab44da7d8d44f - requires_dist: - - logistro>=2.0.1 - - platformdirs>=4.3.6 - - simplejson>=3.19.3 - requires_python: '>=3.8' - pypi: https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl name: click version: 8.3.1 @@ -2937,16 +2913,6 @@ packages: - protobuf - requests requires_python: '>=3.9' -- pypi: https://files.pythonhosted.org/packages/9e/b9/a6d8bb7d228940f01885bd9f327ab7f9d366a9be775c4bf366bf9d9477ae/kaleido-1.3.0-py3-none-any.whl - name: kaleido - version: 1.3.0 - sha256: 52714dfd38e8f2a114831826200c40bb10d0ca0c11d4272f3f48ad499cd8f8ea - requires_dist: - - choreographer>=1.3.0 - - logistro>=1.0.8 - - orjson>=3.10.15 - - packaging - requires_python: '>=3.8' - pypi: https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl name: kiwisolver version: 1.5.0 @@ -3442,11 +3408,6 @@ packages: - lm-eval[multilingual] ; extra == 'tasks' - lm-eval[ruler] ; extra == 'tasks' requires_python: '>=3.10' -- pypi: https://files.pythonhosted.org/packages/54/20/6aa79ba3570bddd1bf7e951c6123f806751e58e8cce736bad77b2cf348d7/logistro-2.0.1-py3-none-any.whl - name: logistro - version: 2.0.1 - sha256: 06ffa127b9fb4ac8b1972ae6b2a9d7fde57598bf5939cd708f43ec5bba2d31eb - requires_python: '>=3.8' - pypi: https://files.pythonhosted.org/packages/c6/d1/232b3309a02d60f11e71857778bfcd4acbdb86c07db8260caf7d008b08f8/lxml-6.0.2-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl name: lxml version: 6.0.2 @@ -4038,21 +3999,6 @@ packages: purls: [] size: 3104268 timestamp: 1769556384749 -- pypi: https://files.pythonhosted.org/packages/0e/a4/82b7a2fe5d8a67a59ed831b24d59a3d46ea7d207b66e1602d376541d94a6/orjson-3.11.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - name: orjson - version: 3.11.9 - sha256: be4fa4f0af7fa18951f7ab3fc2148e223af211bf03f59e1c6034ec3f97f21d61 - requires_python: '>=3.10' -- pypi: https://files.pythonhosted.org/packages/16/6d/11867a3ffa3a3608d84a4de51ef4dd0896d6b5cc9132fbe1daf593e677bc/orjson-3.11.9-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl - name: orjson - version: 3.11.9 - sha256: 9ef6fe90aadef185c7b128859f40beb24720b4ecea95379fc9000931179c3a49 - requires_python: '>=3.10' -- pypi: https://files.pythonhosted.org/packages/ab/86/1c3a47df3bc8191ea9ac51603bbb872a95167a364320c269f2557911f406/orjson-3.11.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl - name: orjson - version: 3.11.9 - sha256: 26a473dbb4162108b27901492546f83c76fdcea3d0eadff00ae7a07e18dcce09 - requires_python: '>=3.10' - pypi: https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl name: packaging version: '26.0' @@ -5933,21 +5879,6 @@ packages: - pkg:pypi/setuptools?source=hash-mapping size: 639697 timestamp: 1773074868565 -- pypi: https://files.pythonhosted.org/packages/0c/b6/156a8de1e1b47694f0e7de6675866936608d45dc68388fd017d36f8693be/simplejson-4.1.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl - name: simplejson - version: 4.1.1 - sha256: 45ec18e337fec538b7e902d489505c450b2454653d1290f3f50385e6fd8aa607 - requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*' -- pypi: https://files.pythonhosted.org/packages/86/1c/e4d0eab695be3eb21d0f46bce820752031f03e7113f9c80a9b3c73ee7157/simplejson-4.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl - name: simplejson - version: 4.1.1 - sha256: 820c69a4710400e9b248d5670647d60be58824369282d3925e516b3ff1a7cd82 - requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*' -- pypi: https://files.pythonhosted.org/packages/b8/78/fc060d2e3b13c6ec59288574b8efac64075e316b2afba4396a56b2422f78/simplejson-4.1.1-cp312-cp312-macosx_11_0_arm64.whl - name: simplejson - version: 4.1.1 - sha256: 67341c95c0a168ab4a6d1e807e50463f1c8da932c3286d81e201266c427061fa - requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*' - pypi: https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl name: six version: 1.17.0