[nightshift] Remove dead functions and orphaned imports (#4390)

> *Dead branches pruned—*
> *the forest breathes easier,*
> *roots drink deeper now.*

## Summary

Removed 5 private functions (85 lines) that are defined but never called
anywhere in the
codebase, confirmed via whole-repo grep. Also removed 3 imports (`re`,
`jax`, `jax.numpy`)
and 1 import (`get_scheduling_strategy`) that only served the dead code.

| File | Removed | Age |
|---|---|---|
| `rl/environments/inference_ctx/vllm.py` |
`_convert_vllm_state_dict_to_trainer_keys` (39 lines),
`_check_weight_differences` (12 lines) + imports `re`, `jax`,
`jax.numpy` | Nov 2025 — leftover debugging helpers from initial vLLM RL
integration |
| `processing/classification/autoscaler.py` |
`_cleanup_completed_futures` (14 lines) | Nov 2025 — superseded by
`_result_collector_loop` |
| `evaluation/evaluators/evaluator.py` | `_get_scheduling_strategy` (4
lines) + import `get_scheduling_strategy` | Nov 2025 — never called by
any `Evaluator` subclass |
| `profiling/ingest.py` | `_active_category` (5 lines) | Feb 2026 —
superseded by `_active_device_category` |

Author: github-actions[bot]

lib/marin/src/marin/evaluation/evaluators/evaluator.py

@@ -7,7 +7,6 @@
 from typing import Any
 
 from fray.v1.cluster import Entrypoint, EnvironmentConfig, JobRequest, ResourceConfig, current_cluster
-from fray.v1.cluster.ray import get_scheduling_strategy
 
 from marin.evaluation.evaluation_config import EvalTaskConfig
 from marin.utils import remove_tpu_lockfile_on_exit
@@ -58,11 +57,6 @@ class ModelConfig:
 
 
 class Evaluator(ABC):
-    def _get_scheduling_strategy(self, resource_config: ResourceConfig | None):
-        if resource_config is None:
-            return None
-        return get_scheduling_strategy(resource_config)
-
     @abstractmethod
     def launch_evaluate_with_ray(
         self,

lib/marin/src/marin/processing/classification/autoscaler.py

@@ -373,22 +373,6 @@ def _dispatch_task(self, task: list[dict[str, Any]]) -> ray.ObjectRef:
             logger.debug(f"Assigning to actor: {actor} for task: {task}")
             return future
 
-    def _cleanup_completed_futures(self):
-        """Remove completed futures from tracking."""
-        with self.actor_task_metadata_lock:
-            for actor in self.actors:
-                if actor in self.actor_futures:
-                    # Filter out completed futures
-                    pending = []
-                    for future in self.actor_futures[actor]:
-                        ready, _ = ray.wait([future], timeout=0)
-                        if not ready:
-                            pending.append(future)
-                        else:
-                            self.future_to_actor.pop(future, None)
-                            self.future_to_task.pop(future, None)
-                    self.actor_futures[actor] = pending
-
     def shutdown(self):
         """Shutdown the actor pool and clean up resources."""
         logger.info("Shutting down actor pool...")

lib/marin/src/marin/profiling/ingest.py

@@ -1533,13 +1533,6 @@ def _estimate_periodicity(steps: list[int]) -> int | None:
     return best_diff
 
 
-def _active_category(active: dict[str, int]) -> str | None:
-    for category in ("communication", "compute", "stall", "host", "other"):
-        if active[category] > 0:
-            return category
-    return None
-
-
 def _active_device_category(active: dict[str, int]) -> str | None:
     for category in ("communication", "compute"):
         if active[category] > 0:

lib/marin/src/marin/rl/environments/inference_ctx/vllm.py

@@ -5,9 +5,6 @@
 import logging
 import os
 import time
-import re
-import jax
-import jax.numpy as jnp
 import numpy as np
 from enum import StrEnum
 from dataclasses import dataclass
@@ -150,59 +147,6 @@ def _get_llm_engine(inference_config: vLLMInferenceContextConfig):
             enforce_eager=inference_config.enforce_eager,
         )
 
-    def _convert_vllm_state_dict_to_trainer_keys(
-        self, state_dict_trainer: dict, state_dict_vllm: dict, mapping: dict
-    ) -> dict:
-        state_dict_vllm_with_trainer_keys = {}
-        for src_path, _ in state_dict_trainer.items():
-            src_key = ".".join(str(p) for p in src_path)
-
-            # Try to find a matching pattern
-            matched = False
-            for src_pattern, (dst_pattern, _) in mapping.items():
-
-                if not re.match(src_pattern, src_key):
-                    continue
-
-                match_layer_number = re.match(r".*layers\.(\d+).*", src_key)
-                if match_layer_number:
-                    layer_number = int(match_layer_number.group(1))
-                    dst_path = []
-                    for part in dst_pattern.split("."):
-                        if part == "*":
-                            dst_path.append(layer_number)
-                        else:
-                            dst_path.append(part)
-                    dst_path = tuple(dst_path)
-                    if dst_path in state_dict_vllm:
-                        state_dict_vllm_with_trainer_keys[src_path] = state_dict_vllm[dst_path]
-                        matched = True
-                        break
-                else:
-                    dst_path = tuple(dst_pattern.split("."))
-                    if dst_path in state_dict_vllm:
-                        state_dict_vllm_with_trainer_keys[src_path] = state_dict_vllm[dst_path]
-                        matched = True
-                        break
-
-            if not matched:
-                print(f"Warning: No mapping found for {src_key}")
-
-        return state_dict_vllm_with_trainer_keys
-
-    def _check_weight_differences(self, state_dict: dict, state_dict_other: dict):
-        for key in state_dict:
-            if key in state_dict_other:
-                assert (
-                    state_dict[key].shape == state_dict_other[key].shape
-                ), f"Shape mismatch for key {key}: {state_dict[key].shape} != {state_dict_other[key].shape}"
-                weight = jax.device_get(state_dict[key]).astype(jnp.bfloat16)
-                weight_other = jax.device_get(state_dict_other[key]).astype(jnp.bfloat16)
-                print(
-                    f"Weight {key}, max diff: {jnp.max(jnp.abs(weight - weight_other))}, \
-                    mean diff: {jnp.mean(jnp.abs(weight - weight_other))}"
-                )
-
     def tokenize_prompt(self, prompt: str, choice: Choice | None = None, system_prompt: str | None = None) -> np.ndarray:
         """Tokenize the prompt with the choice's prompt token IDs.