Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

[Bug]: prepare() type annotation example_inputs: tuple[torch.Tensor] restricts inputs to 1-tuple, breaking static analysis for multi-input models

Cerrado Apto para principiantes
  • ¿Algo no está bien?
#124 1 comentario 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 2 días

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
2/5
Tiempo estimado
1-3 horas
Aptitud para principiantes
88/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
python, pytorch
Área
developer-experience, machine-learning

Línea de trabajo

Comienza con los métodos prepare de src/coreai_opt/quantization/_eager/quantizer.py, src/coreai_opt/palettization/kmeans/palettizer.py y src/coreai_opt/pruning/magnitude_pruner.py, comparándolos con las anotaciones tuple[Any, ...] existentes en la fachada y el cuantizador de grafos. Verifica las anotaciones con typing.get_type_hints y ejecuta la reproducción del modelo con múltiples entradas; se considera terminado cuando la comprobación de tipos acepta tuplas de múltiples entradas y los modelos siguen ejecutándose.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

Summary

In _EagerQuantizer.prepare, KMeansPalettizer.prepare, and MagnitudePruner.prepare, the example_inputs parameter is type-annotated as:

def prepare(self, example_inputs: tuple[torch.Tensor]) -> nn.Module:

According to PEP 484 and PEP 585, tuple[T] specifies a fixed-length tuple of exactly one element of type T. To denote a variable-length or multi-element tuple, Python typing requires tuple[T, ...] or tuple[Any, ...].

Because tuple[torch.Tensor] is used instead of tuple[Any, ...], static type checkers (mypy, pyright, VS Code Pylance) reject valid calls passing multi-input models (e.g. (input_ids, attention_mask) or (x, y)), emitting type errors.

At runtime, all compressors unpack *example_inputs via TorchFunctionEagerHandler.prepare(model, example_inputs), which natively supports arbitrary tuple lengths. Furthermore, the top-level Quantizer.prepare facade and _GraphQuantizer.prepare already use tuple[Any, ...].

Affected Locations
  1. src/coreai_opt/quantization/_eager/quantizer.py:L174 
    def prepare(self, example_inputs: tuple[torch.Tensor]) -> nn.Module:
  2. src/coreai_opt/palettization/kmeans/palettizer.py:L153 
    def prepare(
    self,
    example_inputs: tuple[torch.Tensor],
    sensitivity_path: str | None = None,
    num_workers: int = 1,
) -> torch.nn.Module:
  3. src/coreai_opt/pruning/magnitude_pruner.py:L97 
    def prepare(self, example_inputs: tuple[torch.Tensor]) -> torch.nn.Module:
    (and its docstring at L101: example_inputs (tuple[torch.Tensor]): ...)

In contrast, the following locations already correctly use tuple[Any, ...]:

Step-by-Step Reproduction
Minimal Reproduction Script
import torch
import torch.nn as nn
from coreai_opt.palettization import KMeansPalettizer, KMeansPalettizerConfig
from coreai_opt.pruning import MagnitudePruner, MagnitudePrunerConfig
from coreai_opt.quantization import ExecutionMode, Quantizer, QuantizerConfig


class TwoInputModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(4, 4)
        self.fc2 = nn.Linear(4, 4)

    def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
        return self.fc1(x) + self.fc2(y)


model = TwoInputModel()
example_inputs: tuple[torch.Tensor, torch.Tensor] = (torch.randn(1, 4), torch.randn(1, 4))

# 1. Eager Quantizer
q_eager = Quantizer(model, QuantizerConfig(execution_mode=ExecutionMode.EAGER))
q_eager._quantizer.prepare(example_inputs)

# 2. Palettizer
pal = KMeansPalettizer(TwoInputModel(), KMeansPalettizerConfig())
pal.prepare(example_inputs)

# 3. Pruner
pruner = MagnitudePruner(TwoInputModel(), MagnitudePrunerConfig())
pruner.prepare(example_inputs)
Actual Output (Static Type Analysis):

When running pyright or mypy:

error: Argument of type "tuple[Tensor, Tensor]" cannot be assigned to parameter "example_inputs" of type "tuple[Tensor]" in function "prepare"
  "tuple[Tensor, Tensor]" is incompatible with "tuple[Tensor]"
Expected Behavior:

example_inputs in _EagerQuantizer.prepare, KMeansPalettizer.prepare, and MagnitudePruner.prepare should accept variable-length tuples (tuple[Any, ...]), allowing multi-input models to pass static analysis without type errors.

Proposed Fix
  1. Update _EagerQuantizer.prepare in src/coreai_opt/quantization/_eager/quantizer.py: 
    def prepare(self, example_inputs: tuple[Any, ...]) -> nn.Module:
  2. Update KMeansPalettizer.prepare in src/coreai_opt/palettization/kmeans/palettizer.py: 
    def prepare(
    self,
    example_inputs: tuple[Any, ...],
    sensitivity_path: str | None = None,
    num_workers: int = 1,
) -> torch.nn.Module:
  3. Update MagnitudePruner.prepare in src/coreai_opt/pruning/magnitude_pruner.py: 
    def prepare(self, example_inputs: tuple[Any, ...]) -> torch.nn.Module:
  4. Add automated tests verifying type hints via typing.get_type_hints and multi-input model execution.
Lenguaje dominante
Python
Estrellas
136
Forks
37
Merge medio
2 d 11 h
PR fusionados (30 d)
30

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de apple/coreai-optimization

Todos los issues de apple/coreai-optimization

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.