SYMBOL INDEX (1553 symbols across 149 files)

FILE: optimization/chatllama/artifacts/extend_rlhf_dataset.py
  function _get_template_and_variables (line 8) | def _get_template_and_variables(prompt: str, with_examples: bool):
  function use_langchain_model (line 18) | def use_langchain_model(
  class HuggingFaceChain (line 39) | class HuggingFaceChain:
    method __init__ (line 40) | def __init__(
    method run (line 49) | def run(self, **kwargs):
  function use_huggingface_model (line 58) | def use_huggingface_model(
  function main (line 68) | def main():

FILE: optimization/chatllama/artifacts/generate_actor_dataset.py
  function create_conversation (line 15) | def create_conversation(human_agent: LLMChain, bot_agent: LLMChain):
  function build_agents (line 27) | def build_agents():
  function get_sub_conversations (line 46) | def get_sub_conversations(conversation: str, system_prompt: str):
  function main (line 58) | def main():

FILE: optimization/chatllama/artifacts/generate_rewards.py
  class ScoreGenerator (line 7) | class ScoreGenerator:
    method __init__ (line 8) | def __init__(
    method distill (line 33) | def distill(

FILE: optimization/chatllama/chatllama/llama_model.py
  class MyTokenizer (line 30) | class MyTokenizer:
    method __init__ (line 35) | def __init__(self, model_path: Optional[str] = None):
    method encode (line 47) | def encode(
    method decode (line 62) | def decode(self, t: List[int]) -> str:
  class HFLikeTokenizer (line 68) | class HFLikeTokenizer:
    method __init__ (line 69) | def __init__(self, tokenizer: Tokenizer):
    method create_sequence_mask (line 84) | def create_sequence_mask(self, tokens: torch.Tensor) -> torch.Tensor:
    method __call__ (line 98) | def __call__(self, texts: Union[List[str], str], *args, **kwargs):
    method decode (line 140) | def decode(self, tokens):
  class ModelArgs (line 145) | class ModelArgs:
  class RMSNorm (line 168) | class RMSNorm(torch.nn.Module):
    method __init__ (line 174) | def __init__(self, dim: int, eps: float = 1e-6):
    method _norm (line 179) | def _norm(self, x):
    method forward (line 182) | def forward(self, x):
  function precompute_freqs_cis (line 187) | def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
  function reshape_for_broadcast (line 197) | def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor):
  function apply_rotary_emb (line 207) | def apply_rotary_emb(
  class Attention (line 220) | class Attention(nn.Module):
    method __init__ (line 226) | def __init__(self, args: ModelArgs):
    method forward (line 290) | def forward(
  class FeedForward (line 342) | class FeedForward(nn.Module):
    method __init__ (line 348) | def __init__(
    method forward (line 384) | def forward(self, x):
  class TransformerBlock (line 388) | class TransformerBlock(nn.Module):
    method __init__ (line 394) | def __init__(self, layer_id: int, args: ModelArgs):
    method forward (line 411) | def forward(
  class Transformer (line 438) | class Transformer(nn.Module):
    method __init__ (line 445) | def __init__(self, params: ModelArgs):
    method forward (line 499) | def forward(
    method _forward (line 506) | def _forward(
    method generate (line 550) | def generate(
  function setup_model_parallel (line 580) | def setup_model_parallel() -> Tuple[int, int]:
  function setup_model_deepspeed (line 594) | def setup_model_deepspeed() -> Tuple[int, int]:
  function load_checkpoints (line 606) | def load_checkpoints(
  function load_model (line 622) | def load_model(
  function load_tokenizer (line 649) | def load_tokenizer(tokenizer_path: str):
  function load_tokenizer_test (line 654) | def load_tokenizer_test(tokenizer_path: Optional[str] = None):
  function load_model_test (line 659) | def load_model_test(

FILE: optimization/chatllama/chatllama/rlhf/actor.py
  class ActorModel (line 30) | class ActorModel(torch.nn.Module):
    method __init__ (line 46) | def __init__(self, config: ConfigActor) -> None:
    method load (line 112) | def load(self) -> None:
    method save (line 130) | def save(self) -> None:
    method load_tokenizer (line 147) | def load_tokenizer(config: ConfigActor):
    method parameters (line 178) | def parameters(self):
    method forward (line 183) | def forward(
    method generate (line 211) | def generate(
  class ActorDataset (line 277) | class ActorDataset(Dataset):
    method __init__ (line 292) | def __init__(
    method __getitem__ (line 301) | def __getitem__(self, idx):
    method __len__ (line 304) | def __len__(
  class ActorTrainer (line 310) | class ActorTrainer:
    method __init__ (line 338) | def __init__(self, config: ConfigActor) -> None:
    method save_checkpoint (line 434) | def save_checkpoint(
    method load_checkpoint (line 497) | def load_checkpoint(
    method add_eos_token (line 554) | def add_eos_token(
    method train (line 589) | def train(

FILE: optimization/chatllama/chatllama/rlhf/config.py
  class ConfigReward (line 11) | class ConfigReward:
  class ConfigActor (line 91) | class ConfigActor:
  class ConfigTrainer (line 166) | class ConfigTrainer:
  class Config (line 221) | class Config:
    method __init__ (line 250) | def __init__(

FILE: optimization/chatllama/chatllama/rlhf/dataset.py
  class BaseDataset (line 16) | class BaseDataset:
    method __init__ (line 17) | def __init__(
    method sort_conversation (line 23) | def sort_conversation(
    method take_n_samples (line 77) | def take_n_samples(
    method clean_dataset (line 98) | def clean_dataset(config: ConfigType):
  class StanfordNLPSHPDataset (line 248) | class StanfordNLPSHPDataset(BaseDataset):
    method __init__ (line 251) | def __init__(
    method reformat_dataset (line 258) | def reformat_dataset(self, data: List) -> List[Dict]:
    method save_dataset (line 293) | def save_dataset(
  class AnthropicRLHF (line 343) | class AnthropicRLHF(BaseDataset):
    method __init__ (line 344) | def __init__(
    method reformat_dataset (line 352) | def reformat_dataset(self, data: List) -> List[Dict]:
    method save_dataset (line 388) | def save_dataset(

FILE: optimization/chatllama/chatllama/rlhf/model_loader.py
  class ModelLoader (line 17) | class ModelLoader:
    method __init__ (line 20) | def __init__(
    method get_training_stats_path (line 26) | def get_training_stats_path(config: ConfigType) -> str:
    method look_for_last_checkpoint (line 39) | def look_for_last_checkpoint(
    method look_for_checkpoint_by_name (line 64) | def look_for_checkpoint_by_name(
    method get_checkpoint_name (line 84) | def get_checkpoint_name(config: ConfigType) -> str:
    method get_base_model_folder_from_config (line 91) | def get_base_model_folder_from_config(config: ConfigType) -> str:
    method get_model_type_from_config (line 102) | def get_model_type_from_config(config: ConfigType) -> str:
    method get_model_name_from_config (line 116) | def get_model_name_from_config(config: ConfigType) -> str:
    method delete_old_checkpoints (line 131) | def delete_old_checkpoints(
    method get_model_path (line 159) | def get_model_path(
    method check_model_path (line 253) | def check_model_path(
    method init_critic_from_reward (line 338) | def init_critic_from_reward(config: ConfigCritic) -> None:

FILE: optimization/chatllama/chatllama/rlhf/reward.py
  class RewardModel (line 23) | class RewardModel(torch.nn.Module):
    method __init__ (line 44) | def __init__(self, config: ConfigReward) -> None:
    method load_tokenizer (line 79) | def load_tokenizer(config: ConfigReward):
    method load (line 101) | def load(self) -> None:
    method save (line 120) | def save(self) -> None:
    method parameters (line 137) | def parameters(
    method forward (line 147) | def forward(
    method get_reward (line 177) | def get_reward(
  class RewardDataset (line 200) | class RewardDataset(Dataset):
    method __init__ (line 217) | def __init__(self, path: str) -> None:
    method __getitem__ (line 223) | def __getitem__(self, idx: int):
    method __len__ (line 234) | def __len__(
  class RewardTrainer (line 240) | class RewardTrainer:
    method __init__ (line 272) | def __init__(self, config: ConfigReward) -> None:
    method save_checkpoint (line 370) | def save_checkpoint(
    method load_checkpoint (line 429) | def load_checkpoint(
    method train (line 490) | def train(

FILE: optimization/chatllama/chatllama/rlhf/trainer.py
  function change_tokenization (line 62) | def change_tokenization(tokens, tokenizer1, tokenizer2):
  function check_model_family (line 106) | def check_model_family(config1: ConfigType, config2: ConfigType) -> bool:
  class ActorCritic (line 141) | class ActorCritic(torch.nn.Module):
    method __init__ (line 161) | def __init__(self, config: Config) -> None:
    method load (line 178) | def load(self) -> None:
    method save (line 188) | def save(self) -> None:
    method save_deepspeed (line 223) | def save_deepspeed(
    method forward (line 247) | def forward(
    method generate (line 313) | def generate(
  class ExperienceDataset (line 430) | class ExperienceDataset(Dataset):
    method __init__ (line 433) | def __init__(
    method __len__ (line 441) | def __len__(
    method __getitem__ (line 446) | def __getitem__(self, idx) -> Tuple:
  class ExamplesSampler (line 464) | class ExamplesSampler:
    method __init__ (line 478) | def __init__(
    method sample (line 487) | def sample(self, n: int) -> List:
  class RLTrainer (line 496) | class RLTrainer:
    method __init__ (line 522) | def __init__(
    method initialize_deepspeed_model (line 624) | def initialize_deepspeed_model(
    method save_checkpoint (line 648) | def save_checkpoint(
    method load_checkpoint (line 724) | def load_checkpoint(
    method learn (line 809) | def learn(self, memories: Deque[Memory]) -> None:
    method train (line 1056) | def train(

FILE: optimization/chatllama/chatllama/rlhf/utils.py
  class TrainingStats (line 7) | class TrainingStats:
    method __init__ (line 18) | def __init__(self, path: str):
    method plot (line 31) | def plot(self):
    method save (line 59) | def save(
    method load (line 82) | def load(
    method clear (line 94) | def clear(
  class ConversationLog (line 107) | class ConversationLog:
    method __init__ (line 113) | def __init__(self, path: str):
    method append (line 120) | def append(
    method save (line 146) | def save(self):
    method load (line 158) | def load(self):
    method clear (line 162) | def clear(self):
    method show (line 169) | def show(self, current_iteration: int = None):

FILE: optimization/forward_forward/forward_forward/api/functions.py
  function train_with_forward_forward_algorithm (line 9) | def train_with_forward_forward_algorithm(

FILE: optimization/forward_forward/forward_forward/app.py
  class ForwardForwardApp (line 6) | class ForwardForwardApp(App):
    method __init__ (line 7) | def __init__(self):
    method execute (line 11) | def execute(self, *args, **kwargs):

FILE: optimization/forward_forward/forward_forward/operations/build_models.py
  class BaseModelBuildOperation (line 14) | class BaseModelBuildOperation(Operation, ABC):
    method __init__ (line 15) | def __init__(self):
    method execute (line 20) | def execute(
    method get_result (line 32) | def get_result(self):
  class FCNetFFProgressiveBuildOperation (line 36) | class FCNetFFProgressiveBuildOperation(BaseModelBuildOperation):
    method __init__ (line 37) | def __init__(self):
    method execute (line 40) | def execute(
  class RecurrentFCNetFFBuildOperation (line 65) | class RecurrentFCNetFFBuildOperation(BaseModelBuildOperation):
    method __init__ (line 66) | def __init__(self):
    method execute (line 69) | def execute(
  class LMFFNetBuildOperation (line 89) | class LMFFNetBuildOperation(BaseModelBuildOperation):
    method __init__ (line 90) | def __init__(self):
    method execute (line 93) | def execute(

FILE: optimization/forward_forward/forward_forward/operations/data.py
  class MNISTDataLoaderOperation (line 10) | class MNISTDataLoaderOperation(Operation):
    method __init__ (line 13) | def __init__(self):
    method get_result (line 18) | def get_result(self) -> Any:
    method execute (line 24) | def execute(self, batch_size: int, shuffle: bool):
  function download_fables (line 58) | def download_fables():
  function get_fables (line 65) | def get_fables():
  function tokenize (line 108) | def tokenize(fable, max_len=100):
  function get_tokenized_fables (line 117) | def get_tokenized_fables():
  function get_dataloader (line 130) | def get_dataloader(batch_size=32, test_size=0.2, shuffle=True):
  class AesopFablesDataLoaderOperation (line 144) | class AesopFablesDataLoaderOperation(Operation):
    method __init__ (line 147) | def __init__(self):
    method get_result (line 152) | def get_result(self) -> Any:
    method execute (line 158) | def execute(self, batch_size: int, shuffle: bool):

FILE: optimization/forward_forward/forward_forward/operations/fetch_operations.py
  class FetchTrainingDataFromLocal (line 7) | class FetchTrainingDataFromLocal(Operation):
    method get_result (line 8) | def get_result(self) -> Any:
    method execute (line 11) | def execute(self, train_data: DataLoader, test_data: DataLoader):
    method get_train_data (line 15) | def get_train_data(self) -> DataLoader:
    method get_test_data (line 18) | def get_test_data(self) -> DataLoader:

FILE: optimization/forward_forward/forward_forward/operations/trainers.py
  class BaseForwardForwardTrainer (line 21) | class BaseForwardForwardTrainer(Operation, ABC):
    method __init__ (line 22) | def __init__(self):
    method get_result (line 31) | def get_result(self):
    method execute (line 35) | def execute(
    method _train (line 63) | def _train(self, *args, **kwargs):
  class ForwardForwardTrainer (line 67) | class ForwardForwardTrainer(BaseForwardForwardTrainer):
    method _train (line 68) | def _train(self, epochs: int, theta: float, device: str, **kwargs):
  class RecurrentForwardForwardTrainer (line 111) | class RecurrentForwardForwardTrainer(BaseForwardForwardTrainer):
    method _train (line 112) | def _train(self, epochs: int, theta: float, device: str, **kwargs):
  class NLPForwardForwardTrainer (line 150) | class NLPForwardForwardTrainer(BaseForwardForwardTrainer):
    method _train (line 151) | def _train(

FILE: optimization/forward_forward/forward_forward/root_op.py
  class ForwardForwardModelType (line 21) | class ForwardForwardModelType(Enum):
  class ForwardForwardRootOp (line 27) | class ForwardForwardRootOp(Operation):
    method __init__ (line 28) | def __init__(self, model_type: ForwardForwardModelType):
    method execute (line 44) | def execute(
    method get_result (line 92) | def get_result(self):

FILE: optimization/forward_forward/forward_forward/utils/labels.py
  class LabelsInjector (line 6) | class LabelsInjector:
    method __init__ (line 7) | def __init__(self, labels: List):
    method inject_train (line 20) | def inject_train(self, input_image: torch.Tensor, labels: torch.Tensor):
    method inject_eval (line 45) | def inject_eval(self, input_image: torch.Tensor):
  function select_random_different_label (line 58) | def select_random_different_label(labels: torch.Tensor, n_classes: int):

FILE: optimization/forward_forward/forward_forward/utils/modules.py
  function loss_fn (line 10) | def loss_fn(y, theta, sign):
  function probabilistic_loss_fn (line 19) | def probabilistic_loss_fn(y, theta, sign):
  function alternative_loss_fn (line 29) | def alternative_loss_fn(y, theta, sign):
  class BaseFFLayer (line 40) | class BaseFFLayer(torch.nn.Module, ABC):
    method ff_train (line 42) | def ff_train(
    method positive_eval (line 48) | def positive_eval(self, input_tensor: torch.Tensor, theta: float):
    method requires_training (line 52) | def requires_training(self):
  class FFLayer (line 56) | class FFLayer(BaseFFLayer):
    method __init__ (line 59) | def __init__(
    method forward (line 78) | def forward(self, x):
    method ff_train (line 81) | def ff_train(
    method positive_eval (line 110) | def positive_eval(self, input_tensor: torch.Tensor, theta: float):
  class FFNormalization (line 116) | class FFNormalization(BaseFFLayer):
    method __init__ (line 117) | def __init__(self):
    method forward (line 120) | def forward(self, x):
    method ff_train (line 127) | def ff_train(
    method positive_eval (line 135) | def positive_eval(self, input_tensor: torch.Tensor, theta: float):
    method requires_training (line 144) | def requires_training(self):
  class LinearReLU (line 148) | class LinearReLU(torch.nn.Module):
    method __init__ (line 149) | def __init__(self, in_features, out_features):
    method forward (line 154) | def forward(self, x):
  class FCNetFFProgressive (line 158) | class FCNetFFProgressive(BaseFFLayer):
    method __init__ (line 164) | def __init__(
    method forward (line 186) | def forward(self, x):
    method progressive_train (line 191) | def progressive_train(self, dl: torch.utils.data.DataLoader, theta: fl...
    method ff_train (line 231) | def ff_train(
    method positive_eval (line 248) | def positive_eval(self, input_tensor: torch.Tensor, theta: float):
    method device (line 260) | def device(self):
  class NormLinearReLU (line 264) | class NormLinearReLU(torch.nn.Module):
    method __init__ (line 265) | def __init__(self, in_features, out_features):
    method forward (line 270) | def forward(self, x):
  class RecurrentFFLayer (line 274) | class RecurrentFFLayer(BaseFFLayer):
    method __init__ (line 275) | def __init__(
    method forward (line 289) | def forward(self, x_prev, x_same, x_next):
    method ff_train (line 295) | def ff_train(
    method positive_eval (line 315) | def positive_eval(
  class RecurrentProjectionFFLayer (line 327) | class RecurrentProjectionFFLayer(BaseFFLayer):
    method __init__ (line 328) | def __init__(
    method forward (line 343) | def forward(self, x: torch.Tensor):
    method ff_train (line 346) | def ff_train(
    method positive_eval (line 364) | def positive_eval(self, x: torch.Tensor, theta: float):
  class RecurrentProjectedSoftmaxFFLayer (line 370) | class RecurrentProjectedSoftmaxFFLayer(BaseFFLayer):
    method __init__ (line 371) | def __init__(
    method forward (line 388) | def forward(self, x: torch.Tensor):
    method ff_train (line 394) | def ff_train(
    method positive_eval (line 412) | def positive_eval(self, x: torch.Tensor, theta: float):
  class RecurrentFCNetFF (line 418) | class RecurrentFCNetFF(BaseFFLayer):
    method __init__ (line 421) | def __init__(
    method device (line 468) | def device(self):
    method bottom_up (line 472) | def bottom_up(self, x: torch.Tensor, y: torch.Tensor):
    method forward (line 502) | def forward(self, x: torch.Tensor, prev_states: List[torch.Tensor]):
    method ff_train (line 517) | def ff_train(
    method positive_eval (line 585) | def positive_eval(self, input_tensor: torch.Tensor, theta: float):
  class LMFFLinearSoftmax (line 634) | class LMFFLinearSoftmax(BaseFFLayer):
    method __init__ (line 635) | def __init__(
    method forward (line 651) | def forward(self, x: torch.Tensor):
    method ff_train (line 657) | def ff_train(
    method positive_eval (line 681) | def positive_eval(self, x: torch.Tensor):
  class LMFFNet (line 686) | class LMFFNet(BaseFFLayer):
    method __init__ (line 687) | def __init__(
    method forward (line 727) | def forward(self, input_tensor: torch.Tensor):
    method ff_train (line 737) | def ff_train(
    method LM_ff_train (line 781) | def LM_ff_train(self, input_tensor: torch.Tensor, theta: float):
    method positive_eval (line 803) | def positive_eval(self, input_tensor: torch.Tensor, theta: float):

FILE: optimization/forward_forward/forward_forward/utils/utils.py
  class ProgressiveTrainingDataset (line 6) | class ProgressiveTrainingDataset(torch.utils.data.Dataset):
    method __init__ (line 9) | def __init__(self, dataset_generator: Generator):
    method __getitem__ (line 17) | def __getitem__(self, index):
    method __len__ (line 20) | def __len__(self):
  function compute_perplexity (line 24) | def compute_perplexity(tensor: torch.Tensor):

FILE: optimization/nebullvm/nebullvm/apps/base.py
  class App (line 4) | class App(abc.ABC):
    method __init__ (line 5) | def __init__(self):
    method execute (line 9) | def execute(self, **kwargs):

FILE: optimization/nebullvm/nebullvm/core/models.py
  class DeepLearningFramework (line 13) | class DeepLearningFramework(Enum):
  class QuantizationType (line 19) | class QuantizationType(Enum):
  class Status (line 25) | class Status(Enum):
  class DeviceType (line 30) | class DeviceType(Enum):
  class DataType (line 37) | class DataType(str, Enum):
    method from_framework_format (line 44) | def from_framework_format(
    method to_torch_format (line 56) | def to_torch_format(self):
    method to_tf_format (line 63) | def to_tf_format(self):
    method to_numpy_format (line 70) | def to_numpy_format(self):
  class ModelCompiler (line 78) | class ModelCompiler(Enum):
  class ModelCompressor (line 99) | class ModelCompressor(Enum):
  class OptimizationTime (line 104) | class OptimizationTime(Enum):
  class HardwareSetup (line 110) | class HardwareSetup:
  class OptimizedModel (line 118) | class OptimizedModel:
  class OriginalModel (line 129) | class OriginalModel:
  class BenchmarkOriginalModelResult (line 139) | class BenchmarkOriginalModelResult:
  class OptimizeInferenceResult (line 147) | class OptimizeInferenceResult:
    method metric_drop (line 155) | def metric_drop(self) -> Optional[float]:
    method latency_improvement_rate (line 161) | def latency_improvement_rate(self) -> Optional[float]:
    method throughput_improvement_rate (line 172) | def throughput_improvement_rate(self) -> Optional[float]:
    method size_improvement_rate (line 180) | def size_improvement_rate(self) -> Optional[float]:
  class InputInfo (line 188) | class InputInfo:
    method __init__ (line 201) | def __init__(self, size: Tuple[int, ...], dtype: str, **extra_info):
    method __getattr__ (line 206) | def __getattr__(self, item):
    method dict (line 209) | def dict(self):
  class DynamicAxisInfo (line 216) | class DynamicAxisInfo:
    method dict (line 220) | def dict(self):
    method retrieve_output_dim (line 225) | def retrieve_output_dim(
  class ModelParams (line 243) | class ModelParams:
    method __post_init__ (line 250) | def __post_init__(self):
    method dict (line 259) | def dict(self):
    method input_sizes (line 274) | def input_sizes(self):
  class Device (line 279) | class Device:
    method __init__ (line 280) | def __init__(self, type: DeviceType, idx: int = 0):
    method from_str (line 285) | def from_str(cls, string: str) -> "Device":
    method to_torch_format (line 299) | def to_torch_format(self) -> str:
    method to_tf_format (line 307) | def to_tf_format(self) -> str:
    method get_total_memory (line 313) | def get_total_memory(self) -> int:
    method get_free_memory (line 335) | def get_free_memory(self) -> int:

FILE: optimization/nebullvm/nebullvm/core/tests/test_models.py
  class TestOptimizeInferenceResult (line 7) | class TestOptimizeInferenceResult(unittest.TestCase):
    method test_latency_improvement_rate__optimized_model_is_none (line 8) | def test_latency_improvement_rate__optimized_model_is_none(self):
    method test_latency_improvement_rate__optimized_latency_is_zero (line 16) | def test_latency_improvement_rate__optimized_latency_is_zero(self):
    method test_latency_improvement_rate__original_latency_is_zero (line 26) | def test_latency_improvement_rate__original_latency_is_zero(self):
    method test_latency_improvement_rate__rate_gt_1 (line 36) | def test_latency_improvement_rate__rate_gt_1(self):
    method test_latency_improvement_rate__rate_lt_1 (line 46) | def test_latency_improvement_rate__rate_lt_1(self):
    method test_th_improvement_rate__optimized_model_is_none (line 56) | def test_th_improvement_rate__optimized_model_is_none(self):
    method test_th_improvement_rate__optimized_th_is_zero (line 64) | def test_th_improvement_rate__optimized_th_is_zero(self):
    method test_th_improvement_rate__original_th_is_zero (line 74) | def test_th_improvement_rate__original_th_is_zero(self):
    method test_th_improvement_rate__rate_gt_1 (line 84) | def test_th_improvement_rate__rate_gt_1(self):
    method test_th_improvement_rate__rate_lt_1 (line 94) | def test_th_improvement_rate__rate_lt_1(self):
    method test_size_improvement_rate__optimized_model_is_none (line 104) | def test_size_improvement_rate__optimized_model_is_none(self):
    method test_size_improvement_rate__optimized_size_is_zero (line 112) | def test_size_improvement_rate__optimized_size_is_zero(self):
    method test_size_improvement_rate__original_size_is_zero (line 122) | def test_size_improvement_rate__original_size_is_zero(self):
    method test_size_improvement_rate__rate_gt_1 (line 132) | def test_size_improvement_rate__rate_gt_1(self):
    method test_size_improvement_rate__rate_lt_1 (line 142) | def test_size_improvement_rate__rate_lt_1(self):
    method test_metric_drop__optimized_model_is_none (line 152) | def test_metric_drop__optimized_model_is_none(self):
    method test_metric_drop (line 160) | def test_metric_drop(self):

FILE: optimization/nebullvm/nebullvm/installers/auto_installer.py
  function select_frameworks_to_install (line 47) | def select_frameworks_to_install(
  function select_compilers_to_install (line 96) | def select_compilers_to_install(
  function auto_install_libraries (line 137) | def auto_install_libraries(
  function main (line 160) | def main():

FILE: optimization/nebullvm/nebullvm/installers/installers.py
  function get_cpu_arch (line 25) | def get_cpu_arch():
  function _get_os (line 33) | def _get_os():
  function install_tvm (line 37) | def install_tvm(
  function install_bladedisc (line 82) | def install_bladedisc():
  function install_torch_tensor_rt (line 100) | def install_torch_tensor_rt():
  function install_tf2onnx (line 159) | def install_tf2onnx():
  function install_tensor_rt (line 182) | def install_tensor_rt():
  function install_openvino (line 205) | def install_openvino(with_optimization: bool = True):
  function install_onnxruntime (line 246) | def install_onnxruntime():
  function install_deepsparse (line 268) | def install_deepsparse():
  function install_intel_neural_compressor (line 303) | def install_intel_neural_compressor():
  function install_onnx_simplifier (line 327) | def install_onnx_simplifier():
  function install_faster_transformer (line 343) | def install_faster_transformer(
  class BaseInstaller (line 384) | class BaseInstaller(ABC):
    method __init__ (line 385) | def __init__(self, module_list: List[str]):
    method install_compilers (line 388) | def install_compilers(
    method install_dependencies (line 418) | def install_dependencies(include_framework: List[str]):
    method check_framework (line 422) | def check_framework():
    method install_framework (line 426) | def install_framework():
  class PytorchInstaller (line 430) | class PytorchInstaller(BaseInstaller):
    method install_dependencies (line 432) | def install_dependencies(include_framework: List[str]):
    method check_framework (line 436) | def check_framework():
    method install_framework (line 456) | def install_framework():
  class TensorflowInstaller (line 468) | class TensorflowInstaller(BaseInstaller):
    method install_dependencies (line 470) | def install_dependencies(include_framework: List[str]):
    method check_framework (line 475) | def check_framework():
    method install_framework (line 493) | def install_framework():
  class ONNXInstaller (line 515) | class ONNXInstaller(BaseInstaller):
    method install_dependencies (line 517) | def install_dependencies(include_framework: List[str]):
    method check_framework (line 524) | def check_framework():
    method install_framework (line 542) | def install_framework():
  class HuggingFaceInstaller (line 558) | class HuggingFaceInstaller(BaseInstaller):
    method install_dependencies (line 560) | def install_dependencies(include_framework: List[str]):
    method check_framework (line 564) | def check_framework():
    method install_framework (line 573) | def install_framework():
  class DiffusersInstaller (line 585) | class DiffusersInstaller(BaseInstaller):
    method install_dependencies (line 587) | def install_dependencies(include_framework: List[str]):
    method check_framework (line 608) | def check_framework():
    method install_framework (line 620) | def install_framework():

FILE: optimization/nebullvm/nebullvm/installers/tests/test_install_frameworks.py
  function test_install_default_option (line 7) | def test_install_default_option():
  function test_install_torch_full (line 24) | def test_install_torch_full():
  function test_install_torch_base (line 35) | def test_install_torch_base():
  function test_install_tensorflow_full (line 46) | def test_install_tensorflow_full():
  function test_install_tensorflow_base (line 57) | def test_install_tensorflow_base():
  function test_install_onnx_full (line 68) | def test_install_onnx_full():
  function test_install_onnx_base (line 79) | def test_install_onnx_base():
  function test_install_diffusers_full (line 90) | def test_install_diffusers_full():
  function test_install_huggingface_full (line 101) | def test_install_huggingface_full():
  function test_install_huggingface_full_tf (line 112) | def test_install_huggingface_full_tf():
  function test_install_huggingface_full_torch (line 123) | def test_install_huggingface_full_torch():
  function test_install_huggingface_tf (line 134) | def test_install_huggingface_tf():
  function test_install_huggingface_torch (line 145) | def test_install_huggingface_torch():
  function test_install_huggingface_compilers_all (line 156) | def test_install_huggingface_compilers_all():
  function test_install_huggingface_torch_compilers_all (line 167) | def test_install_huggingface_torch_compilers_all():
  function test_install_torch_compilers_all (line 184) | def test_install_torch_compilers_all():
  function test_install_torch_compilers_deepsparse (line 201) | def test_install_torch_compilers_deepsparse():
  function test_install_torch_compilers_invalid (line 212) | def test_install_torch_compilers_invalid():
  function test_install_torch_onnx_compilers_all (line 223) | def test_install_torch_onnx_compilers_all():
  function test_install_tensorflow_compilers_all (line 241) | def test_install_tensorflow_compilers_all():

FILE: optimization/nebullvm/nebullvm/operations/base.py
  class Operation (line 11) | class Operation(abc.ABC):
    method __init__ (line 12) | def __init__(self):
    method set_feedback_collector (line 19) | def set_feedback_collector(self, feedback_collector: FeedbackCollector):
    method execute (line 26) | def execute(self, **kwargs):
    method state (line 30) | def state(self) -> Dict[str, any]:
    method to (line 33) | def to(self, device: Union[str, Device]):

FILE: optimization/nebullvm/nebullvm/operations/conversions/converters.py
  class Converter (line 15) | class Converter(Operation, abc.ABC):
    method __init__ (line 21) | def __init__(self, model_name: Optional[str] = None):
    method set_state (line 30) | def set_state(
    method get_result (line 37) | def get_result(self) -> List:
  class PytorchConverter (line 41) | class PytorchConverter(Converter):
    method execute (line 44) | def execute(
    method onnx_conversion (line 60) | def onnx_conversion(self, save_path, model_params):
    method tensorflow_conversion (line 74) | def tensorflow_conversion(self):
  class TensorflowConverter (line 79) | class TensorflowConverter(Converter):
    method execute (line 82) | def execute(
    method onnx_conversion (line 98) | def onnx_conversion(self, save_path, model_params):
    method pytorch_conversion (line 110) | def pytorch_conversion(self):
  class ONNXConverter (line 115) | class ONNXConverter(Converter):
    method execute (line 118) | def execute(self, save_path, model_params):
    method tensorflow_conversion (line 132) | def tensorflow_conversion(self):
    method pytorch_conversion (line 136) | def pytorch_conversion(self):

FILE: optimization/nebullvm/nebullvm/operations/conversions/huggingface.py
  class _HFTextDataset (line 26) | class _HFTextDataset(Sequence):
    method __init__ (line 27) | def __init__(
    method __getitem__ (line 47) | def __getitem__(self, item: int):
    method __len__ (line 61) | def __len__(self):
  class _HFDictDataset (line 65) | class _HFDictDataset(Sequence):
    method __init__ (line 66) | def __init__(
    method __getitem__ (line 76) | def __getitem__(self, item: int):
    method __len__ (line 90) | def __len__(self):
    method _concatenate (line 94) | def _concatenate(mini_batch, key):
  function convert_hf_model (line 103) | def convert_hf_model(

FILE: optimization/nebullvm/nebullvm/operations/conversions/pytorch.py
  function convert_torch_to_onnx (line 16) | def convert_torch_to_onnx(

FILE: optimization/nebullvm/nebullvm/operations/conversions/tensorflow.py
  function convert_tf_to_onnx (line 15) | def convert_tf_to_onnx(
  function convert_tf_saved_model_to_onnx (line 44) | def convert_tf_saved_model_to_onnx(
  function convert_keras_to_onnx (line 78) | def convert_keras_to_onnx(

FILE: optimization/nebullvm/nebullvm/operations/conversions/utils.py
  function get_conversion_op (line 10) | def get_conversion_op(framework: DeepLearningFramework) -> Converter:

FILE: optimization/nebullvm/nebullvm/operations/fetch_operations/local.py
  class FetchModelFromLocal (line 6) | class FetchModelFromLocal(Operation):
    method execute (line 7) | def execute(self, model: Any):
    method get_model (line 10) | def get_model(self) -> any:
    method get_result (line 13) | def get_result(self) -> Any:
  class FetchDataFromLocal (line 17) | class FetchDataFromLocal(Operation):
    method execute (line 18) | def execute(self, data: Union[Iterable, Sequence]):
    method get_data (line 21) | def get_data(self) -> any:
    method get_result (line 24) | def get_result(self) -> Any:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/base.py
  class BuildInferenceLearner (line 26) | class BuildInferenceLearner(Operation, ABC):
    method __init__ (line 27) | def __init__(self):
    method execute (line 32) | def execute(self, **kwargs):
    method get_result (line 35) | def get_result(self) -> Any:
  class BaseInferenceLearner (line 40) | class BaseInferenceLearner(ABC):
    method name (line 51) | def name(self) -> str:
    method __post_init__ (line 54) | def __post_init__(self, input_data):
    method _store_file (line 60) | def _store_file(self, file_path: Union[str, Path]):
    method _store_dir (line 63) | def _store_dir(self, dir_path: Union[str, Path]):
    method __del__ (line 75) | def __del__(self, shutil=shutil):
    method predict_from_files (line 81) | def predict_from_files(
    method predict_from_listified_tensors (line 100) | def predict_from_listified_tensors(self, *listified_tensors: List):
    method list2tensor (line 123) | def list2tensor(self, listified_tensor: List) -> Any:
    method tensor2list (line 134) | def tensor2list(self, tensor: Any) -> List:
    method _read_file (line 145) | def _read_file(self, input_file: str) -> Any:
    method _save_file (line 155) | def _save_file(self, prediction: Any, output_file: str):
    method predict (line 164) | def predict(self, *args, **kwargs) -> Any:
    method run (line 175) | def run(self, *args, **kwargs) -> Any:
    method forward (line 179) | def forward(self, *args, **kwargs):
    method __call__ (line 183) | def __call__(self, *args, **kwargs):
    method save (line 188) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 197) | def load(cls, path: Union[Path, str], **kwargs):
    method get_size (line 209) | def get_size(self):
    method free_gpu_memory (line 214) | def free_gpu_memory(self):
    method get_inputs_example (line 219) | def get_inputs_example(self):
    method output_format (line 227) | def output_format(self):
    method input_format (line 232) | def input_format(self):
  class LearnerMetadata (line 236) | class LearnerMetadata:
    method __init__ (line 257) | def __init__(
    method __getitem__ (line 279) | def __getitem__(self, item):
    method from_model (line 289) | def from_model(cls, model: BaseInferenceLearner, **kwargs):
    method from_dict (line 316) | def from_dict(cls, dictionary: Dict):
    method to_dict (line 337) | def to_dict(self) -> Dict:
    method read (line 355) | def read(cls, path: Union[Path, str]):
    method save (line 369) | def save(self, path: Union[Path, str]):
    method load_model (line 381) | def load_model(
  class PytorchBaseInferenceLearner (line 403) | class PytorchBaseInferenceLearner(BaseInferenceLearner, ABC):
    method input_format (line 405) | def input_format(self):
    method output_format (line 409) | def output_format(self):
    method list2tensor (line 412) | def list2tensor(self, listified_tensor: List) -> torch.Tensor:
    method tensor2list (line 423) | def tensor2list(self, tensor: torch.Tensor) -> List:
    method free_gpu_memory (line 434) | def free_gpu_memory(self):
    method set_model_on_gpu (line 438) | def set_model_on_gpu(self):
    method _read_file (line 442) | def _read_file(self, input_file: Union[str, Path]) -> torch.Tensor:
    method _save_file (line 446) | def _save_file(
    method get_inputs_example (line 451) | def get_inputs_example(self, random=False):
    method get_size (line 461) | def get_size(self):
  class TensorflowBaseInferenceLearner (line 478) | class TensorflowBaseInferenceLearner(BaseInferenceLearner, ABC):
    method input_format (line 480) | def input_format(self):
    method output_format (line 484) | def output_format(self):
    method free_gpu_memory (line 487) | def free_gpu_memory(self):
    method set_model_on_gpu (line 491) | def set_model_on_gpu(self):
    method list2tensor (line 494) | def list2tensor(self, listified_tensor: List) -> tf.Tensor:
    method tensor2list (line 505) | def tensor2list(self, tensor: tf.Tensor) -> List:
    method _read_file (line 516) | def _read_file(self, input_file: Union[str, Path]) -> tf.Tensor:
    method _save_file (line 521) | def _save_file(self, prediction: tf.Tensor, output_file: Union[str, Pa...
    method get_inputs_example (line 524) | def get_inputs_example(self, random=False):
  class NumpyBaseInferenceLearner (line 535) | class NumpyBaseInferenceLearner(BaseInferenceLearner, ABC):
    method input_format (line 537) | def input_format(self):
    method output_format (line 541) | def output_format(self):
    method list2tensor (line 544) | def list2tensor(self, listified_tensor: List) -> np.ndarray:
    method tensor2list (line 555) | def tensor2list(self, tensor: np.ndarray) -> List:
    method _read_file (line 566) | def _read_file(self, input_file: Union[str, Path]) -> np.ndarray:
    method _save_file (line 570) | def _save_file(
    method get_inputs_example (line 575) | def get_inputs_example(self, random=False):
  class InferenceLearnerWrapper (line 586) | class InferenceLearnerWrapper(BaseInferenceLearner, ABC):
    method __init__ (line 602) | def __init__(self, core_inference_learner: BaseInferenceLearner):
    method list2tensor (line 608) | def list2tensor(self, listified_tensor: List) -> Any:
    method tensor2list (line 611) | def tensor2list(self, tensor: Any) -> List:
    method _read_file (line 614) | def _read_file(self, input_file: str) -> Any:
    method _save_file (line 617) | def _save_file(self, prediction: Any, output_file: str):
    method save (line 620) | def save(self, path: Union[str, Path], **kwargs):
    method _get_extra_metadata_kwargs (line 629) | def _get_extra_metadata_kwargs(self) -> Dict:
    method _save_wrapper_extra_info (line 632) | def _save_wrapper_extra_info(self):
    method _convert_metadata_to_inputs (line 636) | def _convert_metadata_to_inputs(metadata: LearnerMetadata) -> Dict:
    method _load_wrapper_extra_info (line 640) | def _load_wrapper_extra_info(builder_inputs: Dict) -> Dict:
    method load (line 644) | def load(cls, path: Union[Path, str], **kwargs):
    method free_gpu_memory (line 655) | def free_gpu_memory(self):
    method get_inputs_example (line 658) | def get_inputs_example(self):
    method output_format (line 662) | def output_format(self):
    method input_format (line 666) | def input_format(self):

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/blade_disc.py
  class BladeDISCInferenceLearner (line 12) | class BladeDISCInferenceLearner(TorchScriptInferenceLearner):
    method from_torch_model (line 16) | def from_torch_model(

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/builders.py
  class TorchScriptBuildInferenceLearner (line 64) | class TorchScriptBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 65) | def execute(
  class TorchXLABuildInferenceLearner (line 80) | class TorchXLABuildInferenceLearner(BuildInferenceLearner):
    method execute (line 81) | def execute(
  class TorchNeuronBuildInferenceLearner (line 96) | class TorchNeuronBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 97) | def execute(
  class TorchDynamoBuildInferenceLearner (line 112) | class TorchDynamoBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 113) | def execute(
  class TensorflowBuildInferenceLearner (line 128) | class TensorflowBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 129) | def execute(
  class TFLiteBuildInferenceLearner (line 144) | class TFLiteBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 145) | def execute(
  class DeepSparseBuildInferenceLearner (line 160) | class DeepSparseBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 161) | def execute(
  class ONNXBuildInferenceLearner (line 179) | class ONNXBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 180) | def execute(
  class OpenVINOBuildInferenceLearner (line 203) | class OpenVINOBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 204) | def execute(
  class PyTorchTensorRTBuildInferenceLearner (line 223) | class PyTorchTensorRTBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 224) | def execute(
  class ONNXTensorRTBuildInferenceLearner (line 239) | class ONNXTensorRTBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 240) | def execute(
  class IntelNeuralCompressorBuildInferenceLearner (line 270) | class IntelNeuralCompressorBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 271) | def execute(
  class PyTorchApacheTVMBuildInferenceLearner (line 288) | class PyTorchApacheTVMBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 289) | def execute(
  class ONNXApacheTVMBuildInferenceLearner (line 321) | class ONNXApacheTVMBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 322) | def execute(
  class FasterTransformerBuildInferenceLearner (line 360) | class FasterTransformerBuildInferenceLearner(BuildInferenceLearner):
    method execute (line 361) | def execute(

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/deepsparse.py
  class DeepSparseInferenceLearner (line 22) | class DeepSparseInferenceLearner(BaseInferenceLearner, ABC):
    method __init__ (line 38) | def __init__(
    method get_size (line 61) | def get_size(self):
    method save (line 64) | def save(self, path: Union[str, Path], **kwargs):
    method free_gpu_memory (line 86) | def free_gpu_memory(self):
    method load (line 90) | def load(cls, path: Union[Path, str], **kwargs):
    method _predict_arrays (line 124) | def _predict_arrays(self, input_arrays: Generator[np.ndarray, None, No...
  class PytorchDeepSparseInferenceLearner (line 130) | class PytorchDeepSparseInferenceLearner(
    method run (line 146) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor]:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/faster_transformer.py
  class FasterTransformerInferenceLearner (line 6) | class FasterTransformerInferenceLearner(TorchScriptInferenceLearner):

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/huggingface.py
  class HuggingFaceInferenceLearner (line 19) | class HuggingFaceInferenceLearner(InferenceLearnerWrapper):
    method name (line 40) | def name(self) -> str:
    method __init__ (line 43) | def __init__(
    method _save_wrapper_extra_info (line 55) | def _save_wrapper_extra_info(self):
    method get_size (line 58) | def get_size(self):
    method _load_wrapper_extra_info (line 62) | def _load_wrapper_extra_info(builder_inputs: Dict) -> Dict:
    method run (line 65) | def run(self, *args, **kwargs) -> Any:
    method _get_extra_metadata_kwargs (line 92) | def _get_extra_metadata_kwargs(self) -> Dict:
    method _convert_metadata_to_inputs (line 108) | def _convert_metadata_to_inputs(metadata: LearnerMetadata) -> Dict:
  class DiffusionInferenceLearner (line 128) | class DiffusionInferenceLearner(BaseInferenceLearner, ABC):
    method name (line 130) | def name(self) -> str:
    method __init__ (line 133) | def __init__(self, pipeline: StableDiffusionPipeline):
    method __call__ (line 136) | def __call__(self, *args, **kwargs):
    method run (line 139) | def run(self, *args, **kwargs) -> Any:
    method save (line 142) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 146) | def load(
    method get_size (line 162) | def get_size(self):
    method free_gpu_memory (line 175) | def free_gpu_memory(self):
    method get_inputs_example (line 178) | def get_inputs_example(self):
    method output_format (line 182) | def output_format(self):
    method input_format (line 186) | def input_format(self):
    method list2tensor (line 189) | def list2tensor(self, listified_tensor: List) -> Any:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/neural_compressor.py
  class NeuralCompressorInferenceLearner (line 34) | class NeuralCompressorInferenceLearner(BaseInferenceLearner, ABC):
    method __init__ (line 45) | def __init__(
    method get_size (line 57) | def get_size(self):
    method save (line 62) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 81) | def load(cls, path: Union[Path, str], **kwargs):
  class PytorchNeuralCompressorInferenceLearner (line 147) | class PytorchNeuralCompressorInferenceLearner(
    method free_gpu_memory (line 158) | def free_gpu_memory(self):
    method run (line 163) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor]:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/onnx.py
  function _running_on_intel_cpu (line 40) | def _running_on_intel_cpu(use_gpu):
  function _get_ort_session_options (line 49) | def _get_ort_session_options(use_gpu) -> ort.SessionOptions:
  class ONNXInferenceLearner (line 67) | class ONNXInferenceLearner(BaseInferenceLearner, ABC):
    method __init__ (line 82) | def __init__(
    method _setup_tensorrt (line 114) | def _setup_tensorrt(quantization_type: QuantizationType, device: Device):
    method get_size (line 153) | def get_size(self):
    method free_gpu_memory (line 160) | def free_gpu_memory(self):
    method set_model_on_gpu (line 164) | def set_model_on_gpu(self):
    method save (line 187) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 228) | def load(cls, path: Union[Path, str], **kwargs):
    method _predict_arrays (line 269) | def _predict_arrays(self, input_arrays: Generator[np.ndarray, None, No...
  class PytorchONNXInferenceLearner (line 278) | class PytorchONNXInferenceLearner(
    method run (line 293) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor]:
  class TensorflowONNXInferenceLearner (line 324) | class TensorflowONNXInferenceLearner(
    method run (line 339) | def run(self, *input_tensors: tf.Tensor) -> Tuple[tf.Tensor, ...]:
  class NumpyONNXInferenceLearner (line 370) | class NumpyONNXInferenceLearner(
    method run (line 385) | def run(self, *input_tensors: np.ndarray) -> Tuple[np.ndarray, ...]:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/openvino.py
  class OpenVinoInferenceLearner (line 31) | class OpenVinoInferenceLearner(BaseInferenceLearner, ABC):
    method __init__ (line 52) | def __init__(
    method load (line 73) | def load(cls, path: Union[Path, str], **kwargs):
    method get_size (line 106) | def get_size(self):
    method free_gpu_memory (line 109) | def free_gpu_memory(self):
    method from_model_name (line 113) | def from_model_name(
    method _get_dynamic_shape (line 173) | def _get_dynamic_shape(
    method _get_metadata (line 209) | def _get_metadata(self, **kwargs) -> LearnerMetadata:
    method save (line 217) | def save(self, path: Union[str, Path], **kwargs):
    method _predict_array (line 238) | def _predict_array(
  class PytorchOpenVinoInferenceLearner (line 259) | class PytorchOpenVinoInferenceLearner(
    method run (line 280) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor, ...]:
  class TensorflowOpenVinoInferenceLearner (line 308) | class TensorflowOpenVinoInferenceLearner(
    method run (line 330) | def run(self, *input_tensors: tf.Tensor) -> Tuple[tf.Tensor, ...]:
  class NumpyOpenVinoInferenceLearner (line 357) | class NumpyOpenVinoInferenceLearner(
    method run (line 379) | def run(self, *input_tensors: np.ndarray) -> Tuple[np.ndarray, ...]:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/tensor_rt.py
  class ONNXTensorRTInferenceLearner (line 35) | class ONNXTensorRTInferenceLearner(BaseInferenceLearner, ABC):
    method __init__ (line 54) | def __init__(
    method _get_metadata (line 75) | def _get_metadata(self, **kwargs) -> LearnerMetadata:
    method _synchronize_stream (line 82) | def _synchronize_stream(self):
    method stream_ptr (line 86) | def stream_ptr(self):
    method _get_default_cuda_stream (line 90) | def _get_default_cuda_stream() -> Any:
    method check_env (line 94) | def check_env(use_gpu):
    method _set_cuda_env (line 101) | def _set_cuda_env(self, use_gpu):
    method from_engine_path (line 109) | def from_engine_path(
    method _predict_tensors (line 171) | def _predict_tensors(
    method get_size (line 200) | def get_size(self):
    method free_gpu_memory (line 203) | def free_gpu_memory(self):
    method save (line 207) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 226) | def load(cls, path: Union[Path, str], **kwargs):
  class PytorchTensorRTInferenceLearner (line 257) | class PytorchTensorRTInferenceLearner(PytorchBaseInferenceLearner):
    method __init__ (line 261) | def __init__(
    method get_size (line 277) | def get_size(self):
    method run (line 286) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor, ...]:
    method save (line 305) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 313) | def load(cls, path: Union[Path, str], **kwargs):
  class PytorchONNXTensorRTInferenceLearner (line 328) | class PytorchONNXTensorRTInferenceLearner(
    method _synchronize_stream (line 348) | def _synchronize_stream(self):
    method _get_default_cuda_stream (line 352) | def _get_default_cuda_stream() -> Any:
    method stream_ptr (line 356) | def stream_ptr(self):
    method run (line 359) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor, ...]:
  class BaseArrayONNXTensorRTInferenceLearner (line 433) | class BaseArrayONNXTensorRTInferenceLearner(ONNXTensorRTInferenceLearner...
    method _synchronize_stream (line 438) | def _synchronize_stream(self):
    method _get_default_cuda_stream (line 442) | def _get_default_cuda_stream() -> Any:
    method stream_ptr (line 446) | def stream_ptr(self):
    method _convert_to_array_and_free_memory (line 450) | def _convert_to_array_and_free_memory(cuda_array) -> np.ndarray:
    method _predict_array (line 455) | def _predict_array(
  class TensorflowONNXTensorRTInferenceLearner (line 505) | class TensorflowONNXTensorRTInferenceLearner(
    method run (line 526) | def run(self, *input_tensors: tf.Tensor) -> Tuple[tf.Tensor, ...]:
  class NumpyONNXTensorRTInferenceLearner (line 560) | class NumpyONNXTensorRTInferenceLearner(
    method run (line 581) | def run(self, *input_tensors: np.ndarray) -> Tuple[np.ndarray, ...]:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/tensorflow.py
  class TensorflowBackendInferenceLearner (line 14) | class TensorflowBackendInferenceLearner(TensorflowBaseInferenceLearner):
    method __init__ (line 17) | def __init__(self, tf_model: tf.Module, device: Device, **kwargs):
    method get_size (line 23) | def get_size(self):
    method run (line 26) | def run(self, *input_tensors: tf.Tensor) -> Tuple[tf.Tensor, ...]:
    method save (line 35) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 43) | def load(cls, path: Union[Path, str], **kwargs):
  class TFLiteBackendInferenceLearner (line 60) | class TFLiteBackendInferenceLearner(TensorflowBaseInferenceLearner):
    method __init__ (line 63) | def __init__(self, tflite_file: bytes, device: Device, **kwargs):
    method get_size (line 69) | def get_size(self):
    method free_gpu_memory (line 72) | def free_gpu_memory(self):
    method run (line 77) | def run(self, *input_tensors: tf.Tensor):
    method save (line 97) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 107) | def load(cls, path: Union[Path, str], **kwargs):

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/torch_dynamo.py
  class TorchDynamoInferenceLearner (line 9) | class TorchDynamoInferenceLearner(TorchScriptInferenceLearner):
    method save (line 12) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 19) | def load(cls, path: Union[Path, str], **kwargs):

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/torch_neuron.py
  class TorchNeuronInferenceLearner (line 10) | class TorchNeuronInferenceLearner(TorchScriptInferenceLearner):
    method get_size (line 13) | def get_size(self):

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/torch_xla.py
  class TorchXLAInferenceLearner (line 18) | class TorchXLAInferenceLearner(PytorchBaseInferenceLearner):
    method __init__ (line 22) | def __init__(self, torch_model: torch.nn.Module, device: Device, **kwa...
    method run (line 30) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor, ...]:
    method get_size (line 43) | def get_size(self):
    method save (line 59) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 68) | def load(cls, path: Union[Path, str], **kwargs):

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/torchscript.py
  class TorchScriptInferenceLearner (line 19) | class TorchScriptInferenceLearner(PytorchBaseInferenceLearner):
    method __init__ (line 23) | def __init__(self, torch_model: ScriptModule, device: Device, **kwargs):
    method run (line 31) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor, ...]:
    method save (line 45) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 54) | def load(cls, path: Union[Path, str], **kwargs):
    method from_torch_model (line 69) | def from_torch_model(

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/tvm.py
  class ApacheTVMInferenceLearner (line 35) | class ApacheTVMInferenceLearner(BaseInferenceLearner, ABC):
    method __init__ (line 57) | def __init__(
    method get_size (line 79) | def get_size(self):
    method _has_half_precision_transformation (line 88) | def _has_half_precision_transformation(self):
    method _predict_array (line 94) | def _predict_array(
    method free_gpu_memory (line 117) | def free_gpu_memory(self):
    method save (line 121) | def save(self, path: Union[str, Path], **kwargs):
    method load (line 142) | def load(cls, path: Union[Path, str], **kwargs):
    method from_runtime_module (line 177) | def from_runtime_module(
  class BaseArrayApacheTVMInferenceLearner (line 218) | class BaseArrayApacheTVMInferenceLearner(ApacheTVMInferenceLearner, ABC):
    method _inner_predict (line 223) | def _inner_predict(
  class PytorchApacheTVMInferenceLearner (line 273) | class PytorchApacheTVMInferenceLearner(
    method run (line 294) | def run(self, *input_tensors: torch.Tensor) -> Tuple[torch.Tensor, ...]:
    method _convert_device (line 328) | def _convert_device(device: Any):
  class TensorflowApacheTVMInferenceLearner (line 334) | class TensorflowApacheTVMInferenceLearner(
    method run (line 356) | def run(self, *input_tensors: tf.Tensor) -> Tuple[tf.Tensor, ...]:
  class NumpyApacheTVMInferenceLearner (line 386) | class NumpyApacheTVMInferenceLearner(
    method run (line 408) | def run(self, *input_tensors: np.ndarray) -> Tuple[np.ndarray, ...]:

FILE: optimization/nebullvm/nebullvm/operations/inference_learners/utils.py
  function load_model (line 9) | def load_model(path: Union[Path, str], pipe: StableDiffusionPipeline = N...
  function save_model (line 30) | def save_model(model: Any, path: Union[Path, str]):

FILE: optimization/nebullvm/nebullvm/operations/measures/base.py
  class Measure (line 6) | class Measure(Operation, abc.ABC):
    method __init__ (line 7) | def __init__(self):
    method execute (line 12) | def execute(self, **kwargs):

FILE: optimization/nebullvm/nebullvm/operations/measures/measures.py
  class MetricDropMeasure (line 36) | class MetricDropMeasure(Measure):
    method __init__ (line 37) | def __init__(self):
    method execute (line 41) | def execute(
    method get_result (line 72) | def get_result(self) -> Tuple[bool, float]:
  class LatencyOriginalModelMeasure (line 76) | class LatencyOriginalModelMeasure(Measure):
    method __init__ (line 77) | def __init__(self):
    method execute (line 81) | def execute(

FILE: optimization/nebullvm/nebullvm/operations/measures/utils.py
  function compute_torch_latency (line 20) | def compute_torch_latency(
  function compute_tf_latency (line 62) | def compute_tf_latency(
  function compute_onnx_latency (line 97) | def compute_onnx_latency(
  function compute_optimized_running_time (line 153) | def compute_optimized_running_time(
  function compute_relative_difference (line 203) | def compute_relative_difference(
  function compute_accuracy_drop (line 228) | def compute_accuracy_drop(tensor_1: Any, tensor_2: Any, y: Any) -> float:

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/base.py
  class Compiler (line 8) | class Compiler(Operation, abc.ABC):
    method __init__ (line 11) | def __init__(self):
    method execute (line 16) | def execute(self, **kwargs):
    method _compile_model (line 20) | def _compile_model(self, **kwargs) -> Any:
    method _quantize_model (line 24) | def _quantize_model(self, **kwargs) -> Any:
    method get_result (line 27) | def get_result(self) -> Any:

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/deepsparse.py
  class DeepSparseCompiler (line 19) | class DeepSparseCompiler(Compiler):
    method __init__ (line 25) | def __init__(self):
    method execute (line 29) | def execute(
    method _compile_model (line 66) | def _compile_model(
    method _quantize_model (line 82) | def _quantize_model(**kwargs):

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/__init__.py
  function detect_and_swap_model (line 31) | def detect_and_swap_model(model, data_type="fp16", remove_padding=False):
  class FasterTransformerCompiler (line 48) | class FasterTransformerCompiler(TorchScriptCompiler):
    method _compile_model (line 58) | def _compile_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/bert/__init__.py
  function swap_bert_encoder (line 25) | def swap_bert_encoder(model, data_type, lib_path, remove_padding=False):
  function swap_model (line 53) | def swap_model(
  function detect_and_swap_bert_model (line 64) | def detect_and_swap_bert_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/bert/checkpoint_quantization.py
  function checkpoint_quantization (line 29) | def checkpoint_quantization(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/bert/modeling_bert.py
  class EncoderWeights (line 35) | class EncoderWeights(object):
    method __init__ (line 36) | def __init__(
    method listed_weights (line 162) | def listed_weights(self):
    method to_cuda (line 722) | def to_cuda(self):
    method to_half (line 736) | def to_half(self):
    method to_bfloat16 (line 744) | def to_bfloat16(self):
    method to_int8 (line 752) | def to_int8(self, sparse=False, ths_path="./lib/libth_transformer.so"):
  class CustomEncoder (line 861) | class CustomEncoder(torch.nn.Module):
    method __init__ (line 862) | def __init__(
    method forward (line 965) | def forward(self, hidden_states, attention_mask, sequence_lengths):
  class HuggingFaceEncoder (line 970) | class HuggingFaceEncoder(torch.nn.Module):
    method __init__ (line 971) | def __init__(self, layer_num, head_num, head_size, weights=None):
    method forward (line 993) | def forward(self, hidden_states, attention_mask):
  class BertModel (line 1022) | class BertModel(BertPreTrainedModel):
    method __init__ (line 1023) | def __init__(self, config):
    method forward (line 1034) | def forward(
    method replace_encoder (line 1147) | def replace_encoder(self, new_encoder):

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/gpt/__init__.py
  class FasterTransformerGPT2Wrapper (line 39) | class FasterTransformerGPT2Wrapper(torch.nn.Module):
    method __init__ (line 40) | def __init__(self, model: gpt_decoder.Gpt, config):
    method generate (line 47) | def generate(
  function convert_gpt2_lm_head_model (line 166) | def convert_gpt2_lm_head_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/gpt/utils/gpt_decoder.py
  function to_numpy_dtype (line 33) | def to_numpy_dtype(maybe_str_dtype: Union[str, np.dtype]):
  function to_torch_dtype (line 52) | def to_torch_dtype(maybe_str_dtype: Union[str, torch.dtype]):
  function load_weight_from_bin (line 73) | def load_weight_from_bin(
  class GptLayerWeights (line 93) | class GptLayerWeights:
    method __init__ (line 94) | def __init__(
    method from_config (line 226) | def from_config(cls, config: GptInitModelParameters):
    method dtype (line 240) | def dtype(self):
    method device (line 244) | def device(self):
    method _map (line 247) | def _map(self, func):
    method _map_int8 (line 255) | def _map_int8(self, func):
    method float (line 270) | def float(self):
    method half (line 275) | def half(self):
    method bfloat16 (line 282) | def bfloat16(self):
    method cuda (line 289) | def cuda(self, device=None):
    method to (line 294) | def to(self, device=None):
    method is_valid_pp_group (line 299) | def is_valid_pp_group(self, layer, pp_rank):
    method load (line 302) | def load(
  class FtModuleBase (line 511) | class FtModuleBase:
    method __init__ (line 512) | def __init__(self):
    method from_config (line 517) | def from_config(cls, config: GptInitModelParameters, **kwargs):
    method _initialize_model (line 521) | def _initialize_model(self, force_init=False):
    method forward (line 525) | def forward(self, *args, **kwargs):
    method set_weight (line 528) | def set_weight(self, weight: GptLayerWeights):
    method dtype (line 537) | def dtype(self):
    method device (line 542) | def device(self):
    method cuda (line 546) | def cuda(self, device=None):
    method to (line 551) | def to(self, device=None):
    method float (line 555) | def float(self):
    method half (line 560) | def half(self):
    method bfloat16 (line 565) | def bfloat16(self):
  class GptContextDecoder (line 571) | class GptContextDecoder(FtModuleBase):
    method __init__ (line 572) | def __init__(
    method __repr__ (line 614) | def __repr__(self):
    method from_config (line 636) | def from_config(cls, config: GptInitModelParameters, **kwargs):
    method _initialize_model (line 654) | def _initialize_model(self, force_init=False):
    method forward (line 693) | def forward(
  class GptDecoder (line 752) | class GptDecoder(FtModuleBase):
    method __init__ (line 753) | def __init__(
    method __repr__ (line 789) | def __repr__(self):
    method from_config (line 811) | def from_config(cls, config: GptInitModelParameters, **kwargs):
    method _initialize_model (line 828) | def _initialize_model(self, force_init=False):
    method forward (line 863) | def forward(
  class Gpt (line 923) | class Gpt:
    method __init__ (line 924) | def __init__(
    method from_config (line 1085) | def from_config(cls, config: GptInitModelParameters, **kwargs):
    method load (line 1110) | def load(
    method dtype (line 1219) | def dtype(self):
    method device (line 1224) | def device(self):
    method cuda (line 1228) | def cuda(self, device=None):
    method to (line 1234) | def to(self, device=None):
    method float (line 1239) | def float(self):
    method half (line 1244) | def half(self):
    method bfloat16 (line 1249) | def bfloat16(self):
    method _mask_padded_vocab_weights (line 1254) | def _mask_padded_vocab_weights(self, weight: torch.Tensor):
    method generate_pad_mask (line 1259) | def generate_pad_mask(self, input_lengths, memory_length, init_step=0):
    method get_local_batch_size (line 1291) | def get_local_batch_size(self, batch_size):
    method generate (line 1303) | def generate(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/faster_transformer/gpt/utils/huggingface_gpt_convert.py
  function get_weight_data_type (line 36) | def get_weight_data_type(data_type):
  function split_and_convert_process (line 45) | def split_and_convert_process(i, saved_dir, factor, key, args, val):
  function split_and_convert (line 115) | def split_and_convert(args):
  function main (line 128) | def main(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/intel_neural_compressor.py
  class IntelNeuralCompressorCompiler (line 17) | class IntelNeuralCompressorCompiler(Compiler):
    method __init__ (line 26) | def __init__(self):
    method execute (line 30) | def execute(
    method _compile_model (line 77) | def _compile_model(self, model: Union[str, Path]):
    method _quantize_model (line 81) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/onnxruntime.py
  class ONNXCompiler (line 20) | class ONNXCompiler(Compiler):
    method execute (line 33) | def execute(
    method _compile_model (line 81) | def _compile_model(self, model: Union[str, Path]):
    method _quantize_model (line 84) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/openvino.py
  class OpenVINOCompiler (line 25) | class OpenVINOCompiler(Compiler):
    method __init__ (line 35) | def __init__(self):
    method execute (line 38) | def execute(
    method _compile_model (line 117) | def _compile_model(
    method _quantize_model (line 134) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/intel_neural_compressor.py
  function _prepare_quantization_config (line 20) | def _prepare_quantization_config(model: Any, tmp_dir: str, approach: str):
  function _prepare_mixed_precision_config (line 40) | def _prepare_mixed_precision_config(model: Any, tmp_dir: str):
  function _get_dataloader (line 60) | def _get_dataloader(input_data: DataManager):
  function _quantize_static (line 67) | def _quantize_static(model: Module, input_data: DataManager) -> GraphMod...
  function _quantize_dynamic (line 81) | def _quantize_dynamic(model: Module) -> GraphModule:
  function _mixed_precision (line 93) | def _mixed_precision(
  function quantize_neural_compressor (line 107) | def quantize_neural_compressor(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/onnx.py
  class _IterableCalibrationDataReader (line 26) | class _IterableCalibrationDataReader(CalibrationDataReader):
    method __init__ (line 27) | def __init__(
    method get_next (line 42) | def get_next(self) -> dict:
    method from_dataloader (line 46) | def from_dataloader(
  function _quantize_dynamic (line 55) | def _quantize_dynamic(model_path: str) -> str:
  function _get_quantization_type_for_static (line 69) | def _get_quantization_type_for_static(use_gpu) -> Tuple[QuantType, Quant...
  function _quantize_static (line 89) | def _quantize_static(
  function _convert_to_half_precision (line 113) | def _convert_to_half_precision(
  function quantize_onnx (line 136) | def quantize_onnx(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/openvino.py
  class _CalibrationDataLoader (line 15) | class _CalibrationDataLoader(DataLoader):
    method __init__ (line 16) | def __init__(
    method __len__ (line 22) | def __len__(self):
    method __getitem__ (line 25) | def __getitem__(self, item):
  function quantize_openvino (line 35) | def quantize_openvino(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/pytorch.py
  class _QuantWrapper (line 26) | class _QuantWrapper(Module):
    method __init__ (line 27) | def __init__(self, model: Module):
    method forward (line 34) | def forward(self, *inputs: torch.Tensor):
  function _quantize_dynamic_torch (line 40) | def _quantize_dynamic_torch(model: Module):
  function _quantize_dynamic_torch_fx (line 51) | def _quantize_dynamic_torch_fx(
  function _quantize_static_torch (line 65) | def _quantize_static_torch(
  function _quantize_static_torch_fx (line 81) | def _quantize_static_torch_fx(
  function _quantize_static (line 98) | def _quantize_static(
  function _quantize_dynamic (line 121) | def _quantize_dynamic(
  function _half_precision (line 144) | def _half_precision(model: Module):
  function quantize_pytorch (line 148) | def quantize_pytorch(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/tensor_rt.py
  function quantize_tensorrt (line 16) | def quantize_tensorrt(
  class TensorRTCalibrator (line 42) | class TensorRTCalibrator(IInt8EntropyCalibrator2):
    method __init__ (line 43) | def __init__(
    method get_batch (line 50) | def get_batch(self, names):
    method get_batch_size (line 69) | def get_batch_size(self):
    method read_calibration_cache (line 72) | def read_calibration_cache(self):
    method write_calibration_cache (line 75) | def write_calibration_cache(self, cache):

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/tensorflow.py
  function _quantize_dynamic (line 7) | def _quantize_dynamic(model: tf.Module):
  function _quantize_static (line 14) | def _quantize_static(model: tf.Module, dataset: List[Tuple[tf.Tensor, .....
  function _half_precision (line 26) | def _half_precision(model: tf.Module):
  function quantize_tensorflow (line 34) | def quantize_tensorflow(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/tvm.py
  class TVMCalibrator (line 16) | class TVMCalibrator(DataManager):
    method __init__ (line 17) | def __init__(self, data_reader: Sequence, input_names: List[str]):
    method __getitem__ (line 21) | def __getitem__(self, item: int):
  function quantize_apache_tvm (line 26) | def quantize_apache_tvm(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/quantizations/utils.py
  function check_quantization (line 6) | def check_quantization(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/tensor_rt.py
  class TensorRTCompiler (line 36) | class TensorRTCompiler(Compiler, abc.ABC):
    method __init__ (line 46) | def __init__(self):
    method _extract_dynamic_shape_ranges (line 51) | def _extract_dynamic_shape_ranges(model_params: ModelParams):
    method execute (line 96) | def execute(self, *args, **kwargs):
  class PyTorchTensorRTCompiler (line 100) | class PyTorchTensorRTCompiler(TensorRTCompiler):
    method execute (line 101) | def execute(
    method _compile_model (line 191) | def _compile_model(
    method _quantize_model (line 255) | def _quantize_model(**kwargs) -> Any:
  class ONNXTensorRTCompiler (line 259) | class ONNXTensorRTCompiler(TensorRTCompiler):
    method __init__ (line 260) | def __init__(self):
    method execute (line 266) | def execute(
    method _compile_model (line 416) | def _compile_model(
    method _quantize_model (line 450) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/tensorflow.py
  class TensorflowBackendCompiler (line 18) | class TensorflowBackendCompiler(Compiler):
    method execute (line 24) | def execute(
    method _compile_model (line 64) | def _compile_model(self):
    method _quantize_model (line 68) | def _quantize_model(**kwargs):
  class TFLiteBackendCompiler (line 72) | class TFLiteBackendCompiler(Compiler):
    method execute (line 83) | def execute(
    method _compile_model (line 133) | def _compile_model(
    method _quantize_model (line 142) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/torch_dynamo.py
  class TorchDynamoCompiler (line 15) | class TorchDynamoCompiler(Compiler):
    method execute (line 21) | def execute(
    method _compile_model (line 59) | def _compile_model(
    method _quantize_model (line 69) | def _quantize_model(self, **kwargs) -> Any:

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/torch_neuron.py
  class TorchNeuronCompiler (line 17) | class TorchNeuronCompiler(Compiler):
    method _check_dynamic_shape (line 25) | def _check_dynamic_shape(network_parameters: ModelParams) -> bool:
    method execute (line 54) | def execute(
    method _compile_model (line 102) | def _compile_model(
    method _quantize_model (line 151) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/torch_xla.py
  class TorchXLACompiler (line 11) | class TorchXLACompiler(TorchScriptCompiler):
    method _compile_model (line 19) | def _compile_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/torchscript.py
  class TorchScriptCompiler (line 24) | class TorchScriptCompiler(Compiler):
    method execute (line 33) | def execute(
    method _compile_model (line 84) | def _compile_model(
    method _quantize_model (line 123) | def _quantize_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/tvm.py
  class ApacheTVMCompiler (line 42) | class ApacheTVMCompiler(Compiler, ABC):
    method __init__ (line 58) | def __init__(self):
    method execute (line 62) | def execute(
    method _build_tvm_model (line 113) | def _build_tvm_model(self, model: Any, model_params: ModelParams):
    method _build_tvm_model_from_torch (line 117) | def _build_tvm_model_from_torch(
    method _build_tvm_model_from_onnx (line 143) | def _build_tvm_model_from_onnx(
    method _quantize (line 157) | def _quantize(
    method _get_target (line 175) | def _get_target(device) -> str:
    method _tune_tvm_model (line 182) | def _tune_tvm_model(
    method _compile_model (line 220) | def _compile_model(self, model: Any, params: Any) -> ExecutorFactoryMo...
    method _quantize_model (line 233) | def _quantize_model(
  class PyTorchApacheTVMCompiler (line 245) | class PyTorchApacheTVMCompiler(ApacheTVMCompiler):
    method _build_tvm_model (line 246) | def _build_tvm_model(self, model: Any, model_params: ModelParams):
  class ONNXApacheTVMCompiler (line 252) | class ONNXApacheTVMCompiler(ApacheTVMCompiler):
    method _build_tvm_model (line 253) | def _build_tvm_model(self, model: Any, model_params: ModelParams):

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compilers/utils.py
  function onnxruntime_is_available (line 7) | def onnxruntime_is_available() -> bool:
  function tvm_is_available (line 16) | def tvm_is_available() -> bool:
  function bladedisc_is_available (line 26) | def bladedisc_is_available() -> bool:
  function tensorrt_is_available (line 35) | def tensorrt_is_available() -> bool:
  function torch_tensorrt_is_available (line 45) | def torch_tensorrt_is_available() -> bool:
  function openvino_is_available (line 54) | def openvino_is_available() -> bool:
  function deepsparse_is_available (line 63) | def deepsparse_is_available() -> bool:
  function intel_neural_compressor_is_available (line 72) | def intel_neural_compressor_is_available() -> bool:
  function torch_xla_is_available (line 81) | def torch_xla_is_available():
  function torch_neuron_is_available (line 90) | def torch_neuron_is_available():
  function get_faster_transformer_repo_path (line 99) | def get_faster_transformer_repo_path() -> Path:
  function faster_transformer_is_available (line 103) | def faster_transformer_is_available() -> bool:
  function select_compilers_from_hardware_onnx (line 111) | def select_compilers_from_hardware_onnx(device: Device):
  function select_compilers_from_hardware_torch (line 127) | def select_compilers_from_hardware_torch(device: Device):
  function select_compilers_from_hardware_tensorflow (line 151) | def select_compilers_from_hardware_tensorflow():

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compressors/base.py
  class Compressor (line 10) | class Compressor(Operation, ABC):
    method __init__ (line 11) | def __init__(self, config_file: str = None):
    method execute (line 18) | def execute(
    method _read_config (line 28) | def _read_config(self, config_file: Optional[str]) -> Dict:
    method _get_default_config (line 38) | def _get_default_config() -> Dict:
    method config_key (line 43) | def config_key(self) -> str:
    method get_result (line 46) | def get_result(self) -> Tuple[Any, Optional[float]]:

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compressors/intel.py
  function _get_model_framework (line 18) | def _get_model_framework(model: Any) -> str:
  class IntelPruningCompressor (line 27) | class IntelPruningCompressor(Compressor, ABC):
    method __init__ (line 28) | def __init__(self, config_file: str = None):
    method config_key (line 33) | def config_key(self) -> str:
    method _get_default_config (line 37) | def _get_default_config() -> Dict:
    method _prepare_pruning_config (line 76) | def _prepare_pruning_config(self, model: Any):
    method execute (line 107) | def execute(
    method _compute_error (line 132) | def _compute_error(
    method _get_dataloader (line 143) | def _get_dataloader(input_data: DataManager):
  class INCDataset (line 147) | class INCDataset(Dataset):
    method __init__ (line 148) | def __init__(self, input_data: DataManager):
    method __len__ (line 152) | def __len__(self):
    method __getitem__ (line 155) | def __getitem__(self, idx):
  class TorchIntelPruningCompressor (line 162) | class TorchIntelPruningCompressor(IntelPruningCompressor):
    method _get_dataloader (line 164) | def _get_dataloader(input_data: DataManager):
    method _compute_error (line 170) | def _compute_error(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compressors/scripts/__init__.py
  function _export_model_onnx (line 41) | def _export_model_onnx(
  class RecipeBuilder (line 62) | class RecipeBuilder:
    method __init__ (line 63) | def __init__(self, model_path):
    method _make_analysis (line 66) | def _make_analysis(self):
    method _compute_loss_sensitivity (line 70) | def _compute_loss_sensitivity(self):
    method build_recipe (line 123) | def build_recipe(self, epochs_pruning_window=None, training_epochs=10):
  class PruningTrainer (line 181) | class PruningTrainer:
    method __init__ (line 182) | def __init__(self, model, bs):
    method _setup_training (line 188) | def _setup_training(self, loss_fn=None, lr=1e-3, momentum=0.9):
    method _run_model_one_epoch (line 198) | def _run_model_one_epoch(self, train=False):
    method train (line 236) | def train(
  function _load_config (line 277) | def _load_config(config_file: str):
  function _load_data (line 283) | def _load_data(data_dir: str):
  function _load_model (line 288) | def _load_model(model_file: str):
  function _train_model (line 302) | def _train_model(
  function _save_model (line 332) | def _save_model(model: torch.nn.Module, path: str):
  function main (line 339) | def main(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compressors/scripts/neural_magic_training.py
  function _export_model_onnx (line 41) | def _export_model_onnx(
  class RecipeBuilder (line 62) | class RecipeBuilder:
    method __init__ (line 63) | def __init__(self, model_path):
    method _make_analysis (line 66) | def _make_analysis(self):
    method _compute_loss_sensitivity (line 70) | def _compute_loss_sensitivity(self):
    method build_recipe (line 123) | def build_recipe(self, epochs_pruning_window=None, training_epochs=10):
  class PruningTrainer (line 181) | class PruningTrainer:
    method __init__ (line 182) | def __init__(self, model, bs):
    method _setup_training (line 188) | def _setup_training(self, loss_fn=None, lr=1e-3, momentum=0.9):
    method _run_model_one_epoch (line 198) | def _run_model_one_epoch(self, train=False):
    method train (line 236) | def train(
  function _load_config (line 277) | def _load_config(config_file: str):
  function _load_data (line 283) | def _load_data(data_dir: str):
  function _load_model (line 288) | def _load_model(model_file: str):
  function _train_model (line 302) | def _train_model(
  function _save_model (line 332) | def _save_model(model: torch.nn.Module, path: str):
  function main (line 339) | def main(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/compressors/sparseml.py
  function _save_model (line 16) | def _save_model(model: Module, path: Path):
  function _load_model (line 31) | def _load_model(path: Path):
  function _save_dataset (line 38) | def _save_dataset(input_data: DataManager, path: Path):
  function _save_json (line 44) | def _save_json(dictionary: Dict, path: Path):
  function _write_requirements_file (line 49) | def _write_requirements_file(path: Path):
  class SparseMLCompressor (line 55) | class SparseMLCompressor(Compressor):
    method execute (line 56) | def execute(
    method _compute_error (line 114) | def _compute_error(
    method _get_default_config (line 136) | def _get_default_config() -> Dict:
    method config_key (line 146) | def config_key(self) -> str:

FILE: optimization/nebullvm/nebullvm/operations/optimizations/optimize_inference.py
  class OptimizeInferenceOp (line 59) | class OptimizeInferenceOp(Operation):
    method __init__ (line 60) | def __init__(self):
    method _as_data_manager (line 67) | def _as_data_manager(data) -> DataManager:
    method _check_inputs (line 88) | def _check_inputs(model: Any, input_data: types.InputData):
    method execute (line 94) | def execute(
    method _optimize (line 276) | def _optimize(
    method _extract_lowest_latency_model (line 332) | def _extract_lowest_latency_model(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/optimizers/base.py
  class Optimizer (line 89) | class Optimizer(Operation, abc.ABC):
    method __init__ (line 90) | def __init__(self):
    method execute (line 99) | def execute(
    method _select_compilers_from_hardware (line 153) | def _select_compilers_from_hardware(self):
    method _load_compilers (line 157) | def _load_compilers(
    method free_model_gpu (line 176) | def free_model_gpu(self, model: Any):
    method _optimize (line 189) | def _optimize(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/optimizers/optimizers.py
  class PytorchOptimizer (line 31) | class PytorchOptimizer(Optimizer):
    method __init__ (line 32) | def __init__(self):
    method _select_compilers_from_hardware (line 36) | def _select_compilers_from_hardware(self):
  class TensorflowOptimizer (line 86) | class TensorflowOptimizer(Optimizer):
    method __init__ (line 87) | def __init__(self):
    method _select_compilers_from_hardware (line 91) | def _select_compilers_from_hardware(self):
  class ONNXOptimizer (line 99) | class ONNXOptimizer(Optimizer):
    method __init__ (line 100) | def __init__(self):
    method _select_compilers_from_hardware (line 104) | def _select_compilers_from_hardware(self):

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_deepsparse.py
  function test_deepsparse (line 44) | def test_deepsparse(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_intel_neural_compressor.py
  function test_neural_compressor (line 47) | def test_neural_compressor(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_onnxruntime.py
  function test_onnxruntime (line 51) | def test_onnxruntime(
  function test_onnxruntime_quantization (line 210) | def test_onnxruntime_quantization(
  function test_onnxruntime_half (line 373) | def test_onnxruntime_half(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_openvino.py
  function test_openvino (line 70) | def test_openvino(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_tensor_rt.py
  function test_tensorrt_onnx (line 67) | def test_tensorrt_onnx(
  function test_tensorrt_torch (line 219) | def test_tensorrt_torch(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_tensorflow.py
  function test_tensorflow_backend (line 44) | def test_tensorflow_backend(
  function test_tf_lite (line 171) | def test_tf_lite(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_torch_dynamo.py
  function run_test_torch_dynamo (line 34) | def run_test_torch_dynamo(
  function test_torch_dynamo_fp32 (line 154) | def test_torch_dynamo_fp32(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_torchscript.py
  function run_test_torchscript (line 34) | def run_test_torchscript(
  function test_torchscript_no_quantization (line 145) | def test_torchscript_no_quantization(
  function test_torchscript_half_quantization (line 183) | def test_torchscript_half_quantization(
  function test_torchscript_int8_quantization (line 228) | def test_torchscript_int8_quantization(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/test_tvm.py
  function test_tvm_onnx (line 75) | def test_tvm_onnx(
  function test_tvm_torch (line 209) | def test_tvm_torch(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/tests/utils.py
  class TestModel (line 37) | class TestModel(torch.nn.Module):
    method __init__ (line 38) | def __init__(self):
    method forward (line 50) | def forward(self, input_tensor_0, input_tensor_1):
  function tensorflow_model (line 58) | def tensorflow_model():
  function _build_static_model (line 70) | def _build_static_model(
  function _build_dynamic_model (line 94) | def _build_dynamic_model(
  function get_torch_model (line 138) | def get_torch_model(dynamic: bool = False):
  function get_tensorflow_model (line 150) | def get_tensorflow_model(dynamic: bool = False):
  function get_huggingface_model (line 162) | def get_huggingface_model(temp_dir: str, dl_framework: DeepLearningFrame...
  function initialize_model (line 217) | def initialize_model(
  function check_model_validity (line 287) | def check_model_validity(

FILE: optimization/nebullvm/nebullvm/operations/optimizations/utils.py
  function map_compilers_and_compressors (line 4) | def map_compilers_and_compressors(ignore_list: List, enum_class: Callable):

FILE: optimization/nebullvm/nebullvm/optional_modules/dummy.py
  class DummyClass (line 1) | class DummyClass:

FILE: optimization/nebullvm/nebullvm/optional_modules/tensorflow.py
  class Keras (line 11) | class Keras:
  class data (line 15) | class data:
  class dtypes (line 19) | class dtypes:
  class Tensorflow (line 23) | class Tensorflow:
    method function (line 32) | def function(**kwargs):

FILE: optimization/nebullvm/nebullvm/optional_modules/torch.py
  class nn (line 20) | class nn:
  class jit (line 23) | class jit:
  class fx (line 26) | class fx:
  class torch (line 29) | class torch:
    method no_grad (line 41) | def no_grad():
    method inference_mode (line 45) | def inference_mode():

FILE: optimization/nebullvm/nebullvm/optional_modules/utils.py
  function torch_is_available (line 21) | def torch_is_available() -> bool:
  function tensorflow_is_available (line 45) | def tensorflow_is_available() -> bool:
  function onnx_is_available (line 61) | def onnx_is_available() -> bool:
  function _onnxmltools_is_available (line 76) | def _onnxmltools_is_available():
  function _onnxsim_is_available (line 93) | def _onnxsim_is_available():
  function _polygraphy_is_available (line 102) | def _polygraphy_is_available():
  function tf2onnx_is_available (line 111) | def tf2onnx_is_available():
  function check_dependencies (line 120) | def check_dependencies(device: Device):

FILE: optimization/nebullvm/nebullvm/tools/adapters.py
  class ModelAdapter (line 37) | class ModelAdapter(abc.ABC):
    method adapted_model (line 40) | def adapted_model(self):
    method adapted_data (line 45) | def adapted_data(self):
    method adapt_inference_learner (line 49) | def adapt_inference_learner(
    method adapt_original_model (line 55) | def adapt_original_model(
  class DiffusionAdapter (line 61) | class DiffusionAdapter(ModelAdapter):
    method __init__ (line 62) | def __init__(
    method __benchmark_pipeline (line 76) | def __benchmark_pipeline(
    method __adapt (line 96) | def __adapt(self):
    method adapted_model (line 125) | def adapted_model(self):
    method adapted_data (line 131) | def adapted_data(self):
    method adapt_inference_learner (line 136) | def adapt_inference_learner(
    method adapt_original_model (line 170) | def adapt_original_model(
  class HuggingFaceAdapter (line 193) | class HuggingFaceAdapter(ModelAdapter):
    method __init__ (line 194) | def __init__(self, model: Any, data: List, device: Device, **kwargs):
    method __adapt_model (line 206) | def __adapt_model(self):
    method adapted_model (line 229) | def adapted_model(self):
    method adapted_data (line 235) | def adapted_data(self):
    method adapt_inference_learner (line 240) | def adapt_inference_learner(
    method adapt_original_model (line 256) | def adapt_original_model(

FILE: optimization/nebullvm/nebullvm/tools/benchmark.py
  function _get_dl_framework (line 25) | def _get_dl_framework(model: Any):
  function _create_model_inputs (line 42) | def _create_model_inputs(
  class BaseBenchmark (line 57) | class BaseBenchmark(ABC):
    method __init__ (line 58) | def __init__(self, model, input_tensors, device, n_warmup=50, n_runs=1...
    method benchmark (line 66) | def benchmark(self):
  class PytorchBenchmark (line 70) | class PytorchBenchmark(BaseBenchmark):
    method benchmark (line 71) | def benchmark(self):
  class TensorflowBenchmark (line 117) | class TensorflowBenchmark(BaseBenchmark):
    method benchmark (line 118) | def benchmark(self):
  class NumpyBenchmark (line 159) | class NumpyBenchmark(BaseBenchmark):
    method benchmark (line 160) | def benchmark(self):
  function benchmark (line 204) | def benchmark(

FILE: optimization/nebullvm/nebullvm/tools/data.py
  class DataManager (line 12) | class DataManager:
    method __init__ (line 21) | def __init__(self, data_reader: Sequence):
    method __getitem__ (line 27) | def __getitem__(self, item):
    method __len__ (line 30) | def __len__(self):
    method __iter__ (line 33) | def __iter__(self):
    method __next__ (line 37) | def __next__(self):
    method get_numpy_list (line 45) | def get_numpy_list(
    method get_list (line 63) | def get_list(
    method from_iterable (line 93) | def from_iterable(cls, iterable: Iterable, max_length: int = 500):
    method from_dataloader (line 97) | def from_dataloader(
    method get_split (line 158) | def get_split(self, split_type="train"):
    method split (line 165) | def split(self, split_pct: float, shuffle: bool = False):
  class PytorchDataset (line 188) | class PytorchDataset(Dataset):
    method __init__ (line 189) | def __init__(self, input_data: DataManager, has_labels: bool = False):
    method __len__ (line 194) | def __len__(self):
    method __getitem__ (line 197) | def __getitem__(self, idx):

FILE: optimization/nebullvm/nebullvm/tools/diffusers.py
  function get_unet_inputs (line 38) | def get_unet_inputs(
  class DiffusionUNetWrapper (line 122) | class DiffusionUNetWrapper(torch.nn.Module):
    method __init__ (line 123) | def __init__(self, model):
    method forward (line 127) | def forward(self, *x, **kwargs):
  class OptimizedDiffusionWrapper (line 133) | class OptimizedDiffusionWrapper(torch.nn.Module):
    method __init__ (line 134) | def __init__(self, model):
    method forward (line 138) | def forward(self, *x, **kwargs):
  function is_diffusion_model_pipe (line 148) | def is_diffusion_model_pipe(model):
  function get_default_dynamic_info (line 152) | def get_default_dynamic_info(input_shape: List[Tuple[int, ...]]):
  function preprocess_diffusers (line 189) | def preprocess_diffusers(pipe: DiffusionPipeline) -> torch.nn.Module:
  function postprocess_diffusers (line 196) | def postprocess_diffusers(
  class Optimizer (line 213) | class Optimizer:
    method __init__ (line 214) | def __init__(self, onnx_graph, verbose=False):
    method info (line 218) | def info(self, prefix):
    method cleanup (line 224) | def cleanup(self, return_onnx=False):
    method select_outputs (line 229) | def select_outputs(self, keep, names=None):
    method fold_constants (line 235) | def fold_constants(self, return_onnx=False):
    method infer_shapes (line 244) | def infer_shapes(self, return_onnx=False):
  function get_path (line 256) | def get_path(version, inpaint=False):
  function get_embedding_dim (line 285) | def get_embedding_dim(version):
  class BaseModel (line 294) | class BaseModel:
    method __init__ (line 295) | def __init__(
    method get_model (line 323) | def get_model(self):
    method get_input_names (line 326) | def get_input_names(self):
    method get_output_names (line 329) | def get_output_names(self):
    method get_dynamic_axes (line 332) | def get_dynamic_axes(self):
    method get_sample_input (line 335) | def get_sample_input(self, batch_size, image_height, image_width):
    method get_input_profile (line 338) | def get_input_profile(
    method get_shape_dict (line 343) | def get_shape_dict(self, batch_size, image_height, image_width):
    method optimize (line 346) | def optimize(self, onnx_graph):
    method check_dims (line 359) | def check_dims(self, batch_size, image_height, image_width):
    method get_minmax_dims (line 374) | def get_minmax_dims(
  class CLIP (line 415) | class CLIP(BaseModel):
    method __init__ (line 416) | def __init__(
    method get_model (line 429) | def get_model(self):
    method get_input_names (line 434) | def get_input_names(self):
    method get_output_names (line 437) | def get_output_names(self):
    method get_dynamic_axes (line 440) | def get_dynamic_axes(self):
    method get_input_profile (line 443) | def get_input_profile(
    method get_shape_dict (line 458) | def get_shape_dict(self, batch_size, image_height, image_width):
    method get_sample_input (line 469) | def get_sample_input(self, batch_size, image_height, image_width):
    method optimize (line 475) | def optimize(self, onnx_graph):
  function make_CLIP (line 494) | def make_CLIP(
  class UNet (line 507) | class UNet(BaseModel):
    method __init__ (line 508) | def __init__(
    method get_model (line 533) | def get_model(self):
    method get_input_names (line 546) | def get_input_names(self):
    method get_output_names (line 549) | def get_output_names(self):
    method get_dynamic_axes (line 552) | def get_dynamic_axes(self):
    method get_input_profile (line 559) | def get_input_profile(
    method get_shape_dict (line 602) | def get_shape_dict(self, batch_size, image_height, image_width):
    method get_sample_input (line 621) | def get_sample_input(self, batch_size, image_height, image_width):
  function make_UNet (line 646) | def make_UNet(
  class VAE (line 661) | class VAE(BaseModel):
    method __init__ (line 662) | def __init__(
    method get_model (line 675) | def get_model(self):
    method get_input_names (line 682) | def get_input_names(self):
    method get_output_names (line 685) | def get_output_names(self):
    method get_dynamic_axes (line 688) | def get_dynamic_axes(self):
    method get_input_profile (line 694) | def get_input_profile(
    method get_shape_dict (line 722) | def get_shape_dict(self, batch_size, image_height, image_width):
    method get_sample_input (line 731) | def get_sample_input(self, batch_size, image_height, image_width):
  function make_VAE (line 745) | def make_VAE(
  class TorchVAEEncoder (line 758) | class TorchVAEEncoder(torch.nn.Module):
    method __init__ (line 759) | def __init__(self, token, device, path):
    method forward (line 766) | def forward(self, x):
  class VAEEncoder (line 770) | class VAEEncoder(BaseModel):
    method __init__ (line 771) | def __init__(
    method get_model (line 784) | def get_model(self):
    method get_input_names (line 788) | def get_input_names(self):
    method get_output_names (line 791) | def get_output_names(self):
    method get_dynamic_axes (line 794) | def get_dynamic_axes(self):
    method get_input_profile (line 800) | def get_input_profile(
    method get_shape_dict (line 830) | def get_shape_dict(self, batch_size, image_height, image_width):
    method get_sample_input (line 839) | def get_sample_input(self, batch_size, image_height, image_width):
  function make_VAEEncoder (line 851) | def make_VAEEncoder(
  function make_tokenizer (line 864) | def make_tokenizer(version, hf_token):
  function is_diffusion_model (line 870) | def is_diffusion_model(model) -> bool:

FILE: optimization/nebullvm/nebullvm/tools/feedback_collector.py
  class FeedbackCollector (line 13) | class FeedbackCollector:
    method __init__ (line 14) | def __init__(
    method _store_ip_address (line 27) | def _store_ip_address(self):
    method is_active (line 36) | def is_active(self):
    method _inform_user (line 39) | def _inform_user(self):
    method store_info (line 47) | def store_info(self, key: str, value: Any):
    method send_feedback (line 53) | def send_feedback(self, timeout: int = 30):
    method get (line 70) | def get(self, key: str, default: Any = None):
    method reset (line 73) | def reset(self, key: str):

FILE: optimization/nebullvm/nebullvm/tools/hardware_utils.py
  function get_hw_setup (line 22) | def get_hw_setup(device: Device = None) -> HardwareSetup:
  function _get_gpu_name (line 44) | def _get_gpu_name() -> str:
  function _get_neuron_device_name (line 54) | def _get_neuron_device_name() -> str:
  function _get_tpu_device_name (line 66) | def _get_tpu_device_name() -> str:

FILE: optimization/nebullvm/nebullvm/tools/huggingface.py
  class PyTorchTransformerWrapper (line 29) | class PyTorchTransformerWrapper(Module):
    method __init__ (line 36) | def __init__(
    method forward (line 47) | def forward(self, *args: torch.Tensor):
  class TensorFlowTransformerWrapper (line 56) | class TensorFlowTransformerWrapper(tf.keras.Model):
    method __init__ (line 57) | def __init__(
    method call (line 68) | def call(self, *args: tf.Tensor):
  function flatten_outputs (line 77) | def flatten_outputs(
  function get_size_recursively (line 90) | def get_size_recursively(
  function get_output_structure_from_text (line 100) | def get_output_structure_from_text(
  function get_output_structure_from_dict (line 132) | def get_output_structure_from_dict(
  function restructure_output (line 167) | def restructure_output(

FILE: optimization/nebullvm/nebullvm/tools/logger.py
  function debug_mode_enabled (line 18) | def debug_mode_enabled():
  function setup_logger (line 22) | def setup_logger():
  class LoggingContext (line 41) | class LoggingContext(object):
    method __init__ (line 42) | def __init__(
    method __enter__ (line 54) | def __enter__(self):
    method __exit__ (line 59) | def __exit__(self, et: Any, ev: Any, tb: Any):

FILE: optimization/nebullvm/nebullvm/tools/onnx.py
  function convert_to_numpy (line 20) | def convert_to_numpy(tensor: Any):
  function convert_to_target_framework (line 33) | def convert_to_target_framework(
  function get_input_names (line 44) | def get_input_names(onnx_model: str):
  function get_output_names (line 50) | def get_output_names(onnx_model: str):
  function run_onnx_model (line 56) | def run_onnx_model(
  function _extract_dynamic_axis (line 85) | def _extract_dynamic_axis(
  function extract_info_from_np_data (line 117) | def extract_info_from_np_data(
  function get_output_info_onnx (line 149) | def get_output_info_onnx(
  function create_model_inputs_onnx (line 160) | def create_model_inputs_onnx(input_infos: List[InputInfo]) -> List[np.nd...
  function onnx_is_gpu_available (line 174) | def onnx_is_gpu_available():

FILE: optimization/nebullvm/nebullvm/tools/pytorch.py
  function save_with_torch_fx (line 14) | def save_with_torch_fx(model: torch.nn.Module, path: Path):
  function load_with_torch_fx (line 19) | def load_with_torch_fx(
  function get_output_info_torch (line 31) | def get_output_info_torch(
  function create_model_inputs_torch (line 58) | def create_model_inputs_torch(
  function run_torch_model (line 74) | def run_torch_model(
  function _extract_dynamic_axis (line 103) | def _extract_dynamic_axis(
  function extract_info_from_torch_data (line 133) | def extract_info_from_torch_data(
  function torch_is_gpu_available (line 187) | def torch_is_gpu_available():
  function torch_get_device_name (line 191) | def torch_get_device_name():
  function get_torch_model_size (line 195) | def get_torch_model_size(

FILE: optimization/nebullvm/nebullvm/tools/tests/test_data.py
  function test_custom_input_data (line 7) | def test_custom_input_data():
  function test_torch_dataloader_single_input_with_label (line 24) | def test_torch_dataloader_single_input_with_label():
  function test_torch_dataloader_two_inputs_with_label (line 38) | def test_torch_dataloader_two_inputs_with_label():
  function test_torch_dataloader_three_inputs_with_label (line 54) | def test_torch_dataloader_three_inputs_with_label():
  function test_torch_dataloader_single_input_without_label (line 73) | def test_torch_dataloader_single_input_without_label():
  function test_tensorflow_dataloader_single_input_with_label (line 84) | def test_tensorflow_dataloader_single_input_with_label():
  function test_tensorflow_dataloader_two_inputs_with_label (line 97) | def test_tensorflow_dataloader_two_inputs_with_label():
  function test_tensorflow_dataloader_three_inputs_with_label (line 115) | def test_tensorflow_dataloader_three_inputs_with_label():
  function test_tensorflow_dataloader_single_input_without_label (line 135) | def test_tensorflow_dataloader_single_input_without_label():

FILE: optimization/nebullvm/nebullvm/tools/tests/test_hardware_utils.py
  class TestGetHwSetup (line 7) | class TestGetHwSetup(unittest.TestCase):
    method test_hw_setup__gpu_not_available (line 17) | def test_hw_setup__gpu_not_available(self, *_):
    method test_hw_setup__gpu_is_available (line 28) | def test_hw_setup__gpu_is_available(self, *_):

FILE: optimization/nebullvm/nebullvm/tools/tests/test_utils.py
  class TestGetThroughput (line 8) | class TestGetThroughput(unittest.TestCase):
    method test_latency_is_zero (line 9) | def test_latency_is_zero(self):
  class TestCheckDevice (line 13) | class TestCheckDevice(unittest.TestCase):
    method test_device_is_none_no_device_available (line 17) | def test_device_is_none_no_device_available(self, *_):
    method test_device_is_none_gpu_is_available (line 25) | def test_device_is_none_gpu_is_available(self, *_):
    method test_device_is_none_tpu_is_available (line 33) | def test_device_is_none_tpu_is_available(self, *_):
    method test_device_is_none_neuron_is_available (line 41) | def test_device_is_none_neuron_is_available(self, *_):
    method test_device_is_cpu (line 46) | def test_device_is_cpu(self):
    method test_device_is_gpu_no_gpu_available (line 52) | def test_device_is_gpu_no_gpu_available(self, _):
    method test_device_is_gpu_gpu_is_available (line 70) | def test_device_is_gpu_gpu_is_available(self, _):
    method test_device_is_tpu_no_tpu_available (line 88) | def test_device_is_tpu_no_tpu_available(self, _):
    method test_device_is_tpu_tpu_is_available (line 98) | def test_device_is_tpu_tpu_is_available(self, _):
    method test_device_is_neuron_no_neuron_available (line 108) | def test_device_is_neuron_no_neuron_available(self, _):
    method test_device_is_neuron_neuron_is_available (line 118) | def test_device_is_neuron_neuron_is_available(self, _):

FILE: optimization/nebullvm/nebullvm/tools/tf.py
  function get_output_info_tf (line 10) | def get_output_info_tf(
  function create_model_inputs_tf (line 30) | def create_model_inputs_tf(input_infos: List[InputInfo]) -> List[tf.Tens...
  function run_tf_model (line 54) | def run_tf_model(
  function _extract_dynamic_axis (line 66) | def _extract_dynamic_axis(
  function extract_info_from_tf_data (line 96) | def extract_info_from_tf_data(
  function tensorflow_is_gpu_available (line 129) | def tensorflow_is_gpu_available():
  function tensorflow_get_gpu_name (line 133) | def tensorflow_get_gpu_name():

FILE: optimization/nebullvm/nebullvm/tools/transformations.py
  class BaseTransformation (line 11) | class BaseTransformation(ABC):
    method _transform (line 13) | def _transform(self, _input: Any, **kwargs) -> Any:
    method __call__ (line 16) | def __call__(self, _input: Any, **kwargs):
    method to_dict (line 19) | def to_dict(self):
    method from_dict (line 26) | def from_dict(cls, tfm_dict: Dict):
  class MultiStageTransformation (line 30) | class MultiStageTransformation(BaseTransformation):
    method __init__ (line 31) | def __init__(self, transformations: List[BaseTransformation]):
    method _transform (line 34) | def _transform(self, _input: Any, **kwargs) -> Any:
    method append (line 39) | def append(self, __tfm: BaseTransformation):
    method extend (line 42) | def extend(self, tfms: List[BaseTransformation]):
    method to_dict (line 45) | def to_dict(self) -> Dict:
    method to_list (line 48) | def to_list(self):
    method from_dict (line 52) | def from_dict(cls, tfms_dict: Dict):
    method copy (line 60) | def copy(self):
    method __len__ (line 64) | def __len__(self):
  class HalfPrecisionTransformation (line 68) | class HalfPrecisionTransformation(BaseTransformation):
    method _transform_numpy (line 70) | def _transform_numpy(_input: np.ndarray) -> np.ndarray:
    method _transform_tf (line 74) | def _transform_tf(_input: tf.Tensor) -> tf.Tensor:
    method _transform_torch (line 78) | def _transform_torch(_input: torch.Tensor) -> torch.Tensor:
    method _transform (line 81) | def _transform(self, _input: Any, **kwargs) -> Any:
  class NoOp (line 108) | class NoOp(BaseTransformation):
    method _transform (line 109) | def _transform(self, _input: Any, **kwargs):
  class VerifyContiguity (line 113) | class VerifyContiguity(BaseTransformation):
    method _transform (line 114) | def _transform(self, _input: Any, **kwargs) -> Any:

FILE: optimization/nebullvm/nebullvm/tools/utils.py
  function get_model_size_mb (line 46) | def get_model_size_mb(model: Any) -> float:
  function get_model_name (line 60) | def get_model_name(model: Any) -> str:
  function generate_model_id (line 68) | def generate_model_id(model: Any) -> str:
  function get_throughput (line 73) | def get_throughput(latency: float, batch_size: int = 1) -> float:
  function ifnone (line 79) | def ifnone(target, new_value):
  function inspect_dynamic_size (line 86) | def inspect_dynamic_size(
  function gpu_is_available (line 101) | def gpu_is_available():
  function neuron_is_available (line 109) | def neuron_is_available():
  function tpu_is_available (line 117) | def tpu_is_available():
  function check_module_version (line 128) | def check_module_version(
  function is_python_version_3_10 (line 144) | def is_python_version_3_10():
  function get_dl_framework (line 151) | def get_dl_framework(model: Any):
  function check_input_data (line 168) | def check_input_data(input_data: Union[Iterable, Sequence]):
  function is_data_subscriptable (line 187) | def is_data_subscriptable(input_data: Union[Iterable, Sequence]):
  function check_dynamic_info_inputs (line 196) | def check_dynamic_info_inputs(
  function extract_info_from_data (line 220) | def extract_info_from_data(
  function is_huggingface_data (line 255) | def is_huggingface_data(data_sample: Any) -> bool:
  function is_dict_type (line 265) | def is_dict_type(data_sample: Any):
  function _get_idx (line 274) | def _get_idx(device: str) -> int:
  function _set_device (line 283) | def _set_device(
  function check_device (line 301) | def check_device(device: Optional[str] = None) -> Device:
  function get_gpu_compute_capability (line 336) | def get_gpu_compute_capability(gpu_idx: int) -> float:

FILE: optimization/nebullvm/nebullvm/tools/venv.py
  class EnvBuilder (line 8) | class EnvBuilder(venv.EnvBuilder):
    method __init__ (line 9) | def __init__(self, *args, **kwargs):
    method post_setup (line 13) | def post_setup(self, context):
  function run_in_different_venv (line 17) | def run_in_different_venv(

FILE: optimization/open_alpha_tensor/main.py
  function _compute_largest_divisor (line 9) | def _compute_largest_divisor(n: int) -> int:
  function main (line 17) | def main():

FILE: optimization/open_alpha_tensor/open_alpha_tensor/api/functions.py
  function train_alpha_tensor (line 6) | def train_alpha_tensor(

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/actors/stage.py
  function game_is_finished (line 12) | def game_is_finished(state):
  function remove_duplicates (line 22) | def remove_duplicates(reducing_tensor: torch.Tensor):
  function extract_children_states_from_actions (line 60) | def extract_children_states_from_actions(
  function _reduce_memory_consumption_before_storing (line 117) | def _reduce_memory_consumption_before_storing(
  function _recompose_possible_states (line 134) | def _recompose_possible_states(reduced_memory_states_dict: Dict):
  function extract_present_state (line 155) | def extract_present_state(state: torch.Tensor) -> torch.Tensor:
  function to_hash (line 159) | def to_hash(tensor: torch.Tensor) -> str:
  function from_hash (line 171) | def from_hash(hashable_tensor: str, shape: tuple) -> torch.Tensor:
  function record_action (line 183) | def record_action(tree_dict: Dict, state: str, action: str):
  function select_future_state (line 197) | def select_future_state(
  function simulate_game (line 228) | def simulate_game(
  function backward_pass (line 313) | def backward_pass(trajectory, states_dict, leaf_q_value: torch.Tensor):
  function monte_carlo_tree_search (line 342) | def monte_carlo_tree_search(
  function compute_improved_policy (line 389) | def compute_improved_policy(
  function actor_prediction (line 420) | def actor_prediction(

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/data/basis_change.py
  function get_change_basis_matrix (line 8) | def get_change_basis_matrix(
  function cob_entry_prob_distribution (line 36) | def cob_entry_prob_distribution(size):
  class ChangeOfBasis (line 47) | class ChangeOfBasis:
    method __init__ (line 52) | def __init__(
    method __call__ (line 83) | def __call__(self, tensor: torch.Tensor, return_basis: bool = False):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/data/dataset.py
  function compute_move (line 21) | def compute_move(triplets: Tuple[torch.Tensor, torch.Tensor, torch.Tenso...
  class SyntheticDataBuffer (line 33) | class SyntheticDataBuffer(Dataset):
    method __init__ (line 36) | def __init__(
    method __len__ (line 95) | def __len__(self):
    method __getitem__ (line 99) | def __getitem__(self, idx):
    method _apply_moves (line 146) | def _apply_moves(
  class GameDataBuffer (line 165) | class GameDataBuffer(Dataset):
    method __init__ (line 168) | def __init__(self, device: str, max_buffer_size: int):
    method __del__ (line 181) | def __del__(self):
    method add_game (line 184) | def add_game(
    method __len__ (line 215) | def __len__(self):
    method __getitem__ (line 219) | def __getitem__(self, idx):
    method save_game_data (line 234) | def save_game_data(self, path: str):
    method load_game_data (line 242) | def load_game_data(self, path: str):
  class TensorGameDataset (line 252) | class TensorGameDataset(Dataset):
    method __init__ (line 259) | def __init__(
    method change_training_split (line 303) | def change_training_split(self, pct_synth, pct_best_game):
    method recompute_synthetic_indexes (line 307) | def recompute_synthetic_indexes(self):
    method __getitem__ (line 354) | def __getitem__(self, idx):
    method __len__ (line 378) | def __len__(self):
    method add_game (line 381) | def add_game(
    method add_best_game (line 389) | def add_best_game(
    method save_game_data (line 397) | def save_game_data(self, path):
    method load_game_data (line 403) | def load_game_data(self, path):
    method input_tensor (line 410) | def input_tensor(self) -> torch.Tensor:
    method _build_tensor_game_input (line 440) | def _build_tensor_game_input(
    method games_are_good (line 459) | def games_are_good(self):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/data/generation.py
  function generate_synthetic_data (line 6) | def generate_synthetic_data(
  function f_prob_distribution (line 48) | def f_prob_distribution(size):
  function z2_prob_distribution (line 64) | def z2_prob_distribution(size):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/data/utils.py
  function get_scalars (line 6) | def get_scalars(input_tensor: torch.Tensor, t_step: int, with_bs: bool =...
  function map_triplet_to_action (line 25) | def map_triplet_to_action(
  function _single_action_to_triplet (line 60) | def _single_action_to_triplet(
  function map_action_to_triplet (line 92) | def map_action_to_triplet(

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/modules/alpha_tensor.py
  class AlphaTensorModel (line 11) | class AlphaTensorModel(torch.nn.Module):
    method __init__ (line 12) | def __init__(
    method device (line 47) | def device(self):
    method _train_forward (line 50) | def _train_forward(
    method _eval_forward (line 71) | def _eval_forward(self, x: torch.Tensor, s: torch.Tensor):
    method forward (line 78) | def forward(
    method n_logits (line 92) | def n_logits(self):
    method n_steps (line 96) | def n_steps(self):
    method n_samples (line 100) | def n_samples(self):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/modules/attention.py
  class AttentionHead (line 5) | class AttentionHead(torch.nn.Module):
    method __init__ (line 6) | def __init__(self, x_size: int, y_size: int, proj_dim: int):
    method forward (line 16) | def forward(self, x: torch.Tensor, y: torch.Tensor, mask: bool = False):
  class AttentionDenseBlock (line 31) | class AttentionDenseBlock(torch.nn.Module):
    method __init__ (line 32) | def __init__(self, inner_size: int, multiplier: int = 4):
    method forward (line 41) | def forward(self, x: torch.Tensor):
  class AlphaMultiHeadAttention (line 46) | class AlphaMultiHeadAttention(torch.nn.Module):
    method __init__ (line 47) | def __init__(
    method forward (line 67) | def forward(

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/modules/extras.py
  class QuantileLoss (line 4) | class QuantileLoss(torch.nn.Module):
    method __init__ (line 5) | def __init__(self, delta: float = 1.0):
    method forward (line 9) | def forward(self, q: torch.Tensor, g: torch.Tensor):
  class ValueRiskManagement (line 17) | class ValueRiskManagement(torch.nn.Module):
    method __init__ (line 18) | def __init__(self, u_q: float = 0.75):
    method forward (line 22) | def forward(self, q: torch.Tensor):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/modules/heads.py
  class PositionEncoding (line 9) | class PositionEncoding(torch.nn.Module):
    method __init__ (line 10) | def __init__(self, d_model: int, max_len: int = 5000):
    method forward (line 22) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class PolicyHeadDoubleAttention (line 31) | class PolicyHeadDoubleAttention(torch.nn.Module):
    method __init__ (line 32) | def __init__(
    method forward (line 49) | def forward(self, x: torch.Tensor, e: torch.Tensor):
  class PolicyHeadCore (line 61) | class PolicyHeadCore(torch.nn.Module):
    method __init__ (line 62) | def __init__(
    method forward (line 86) | def forward(self, a: torch.Tensor, e: torch.Tensor):
  function sample_from_logits (line 94) | def sample_from_logits(a):
  class PolicyHead (line 108) | class PolicyHead(torch.nn.Module):
    method __init__ (line 109) | def __init__(
    method _train_forward (line 123) | def _train_forward(self, e: torch.Tensor, g: torch.Tensor):
    method _eval_forward (line 135) | def _eval_forward(self, e: torch.Tensor):
    method forward (line 158) | def forward(self, e: torch.Tensor, g: torch.Tensor = None):
  class ValueHeadCore (line 164) | class ValueHeadCore(torch.nn.Module):
    method __init__ (line 165) | def __init__(self, input_size: int, output_size: int):
    method forward (line 170) | def forward(self, x: torch.Tensor):
  class ValueHead (line 174) | class ValueHead(torch.nn.Module):
    method __init__ (line 175) | def __init__(
    method forward (line 187) | def forward(self, x: torch.Tensor):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/modules/torso.py
  class TorsoAttentiveModes (line 6) | class TorsoAttentiveModes(torch.nn.Module):
    method __init__ (line 7) | def __init__(self, input_dim: int):
    method forward (line 15) | def forward(self, x1, x2, x3):
  class TorsoModel (line 29) | class TorsoModel(torch.nn.Module):
    method __init__ (line 40) | def __init__(
    method forward (line 68) | def forward(self, x: torch.Tensor, scalars: torch.Tensor):

FILE: optimization/open_alpha_tensor/open_alpha_tensor/core/training.py
  function _single_act (line 21) | def _single_act(
  function swap_data (line 62) | def swap_data(
  class Trainer (line 100) | class Trainer:
    method __init__ (line 107) | def __init__(
    method train_step (line 198) | def train_step(self):
    method act_step (line 218) | def act_step(
    method train (line 310) | def train(

FILE: optimization/open_alpha_tensor/open_alpha_tensor/operations/checkpoint_op.py
  function optimizer_to (line 15) | def optimizer_to(optim: torch.optim.Optimizer, device: str):
  class LoadCheckPointOp (line 30) | class LoadCheckPointOp(Operation):
    method __init__ (line 34) | def __init__(self):
    method execute (line 40) | def execute(
    method get_last_epoch (line 81) | def get_last_epoch(self) -> int:
    method get_model (line 85) | def get_model(self) -> AlphaTensorModel:
    method get_optimizer (line 89) | def get_optimizer(self) -> torch.optim.Optimizer:
    method get_result (line 93) | def get_result(self) -> Any:
  class LoadCheckpointDataOp (line 97) | class LoadCheckpointDataOp(Operation):
    method __init__ (line 101) | def __init__(self):
    method execute (line 105) | def execute(self, games_store_dir: Path, trainer: Trainer):
    method get_result (line 121) | def get_result(self) -> bool:

FILE: optimization/open_alpha_tensor/open_alpha_tensor/operations/model_op.py
  class BuildModelOp (line 11) | class BuildModelOp(Operation):
    method __init__ (line 14) | def __init__(self):
    method execute (line 18) | def execute(
    method get_model (line 52) | def get_model(self) -> AlphaTensorModel:
    method get_result (line 56) | def get_result(self) -> Any:
  class BuildOptimizerOp (line 60) | class BuildOptimizerOp(Operation):
    method __init__ (line 63) | def __init__(self):
    method execute (line 67) | def execute(
    method get_optimizer (line 94) | def get_optimizer(self) -> torch.optim.Optimizer:
    method get_result (line 98) | def get_result(self) -> Any:
  class SaveModelOp (line 102) | class SaveModelOp(Operation):
    method get_result (line 107) | def get_result(self) -> Any:
    method execute (line 110) | def execute(

FILE: optimization/open_alpha_tensor/open_alpha_tensor/operations/training_op.py
  class TrainingOperation (line 12) | class TrainingOperation(Operation):
    method __init__ (line 16) | def __init__(self):
    method execute (line 22) | def execute(
    method get_trained_model (line 137) | def get_trained_model(self):
    method get_result (line 141) | def get_result(self) -> Any:

FILE: optimization/open_alpha_tensor/open_alpha_tensor/root_op.py
  class TrainAlphaTensorRootOp (line 15) | class TrainAlphaTensorRootOp(Operation):
    method __init__ (line 19) | def __init__(self):
    method execute (line 30) | def execute(
    method get_result (line 181) | def get_result(self) -> AlphaTensorModel:

FILE: optimization/speedster/notebooks/huggingface/faster_transformer_bert.py
  function prepare_examples (line 39) | def prepare_examples(tokenizer, len_dataset=1000):
  function optimize_no_trace (line 91) | def optimize_no_trace(model, data_type="fp16"):
  function optimize_with_trace (line 104) | def optimize_with_trace(
  function benchmark (line 126) | def benchmark(model, model_desc="original BERT"):

FILE: optimization/speedster/speedster/api/functions.py
  function optimize_model (line 22) | def optimize_model(

FILE: optimization/speedster/speedster/api/tests/test_huggingface.py
  function test_torch_huggingface_ort_input_text (line 14) | def test_torch_huggingface_ort_input_text():
  function test_torch_huggingface_ort_input_tensors (line 88) | def test_torch_huggingface_ort_input_tensors():
  function test_torch_huggingface_torchscript_input_tensors (line 152) | def test_torch_huggingface_torchscript_input_tensors():
  function test_tensorflow_huggingface_ort_input_text_np (line 196) | def test_tensorflow_huggingface_ort_input_text_np():
  function test_tensorflow_huggingface_ort_input_tensors_np (line 266) | def test_tensorflow_huggingface_ort_input_tensors_np():
  function test_tensorflow_huggingface_ort_input_text_tf (line 324) | def test_tensorflow_huggingface_ort_input_text_tf():
  function test_tensorflow_huggingface_ort_input_tensors_tf (line 394) | def test_tensorflow_huggingface_ort_input_tensors_tf():

FILE: optimization/speedster/speedster/api/tests/test_onnx.py
  function test_onnx_ort (line 27) | def test_onnx_ort():
  function test_onnx_ort_quant (line 75) | def test_onnx_ort_quant():
  function test_onnx_tensorrt (line 118) | def test_onnx_tensorrt():
  function test_onnx_openvino (line 160) | def test_onnx_openvino():
  function test_onnx_tvm (line 202) | def test_onnx_tvm():

FILE: optimization/speedster/speedster/api/tests/test_pytorch.py
  function test_torch_ort (line 40) | def test_torch_ort():
  function test_torch_ort_quant (line 72) | def test_torch_ort_quant():
  function test_torch_torchscript (line 98) | def test_torch_torchscript():
  function test_torch_torch_dynamo (line 127) | def test_torch_torch_dynamo():
  function test_torch_tensorrt (line 162) | def test_torch_tensorrt():
  function test_torch_openvino (line 192) | def test_torch_openvino():
  function test_torch_tvm (line 220) | def test_torch_tvm():
  function test_torch_bladedisc (line 249) | def test_torch_bladedisc():

FILE: optimization/speedster/speedster/api/tests/test_tensorflow.py
  function test_tensorflow_ort (line 46) | def test_tensorflow_ort():
  function test_tensorflow_tf_backend (line 78) | def test_tensorflow_tf_backend():
  function test_tensorflow_tflite (line 107) | def test_tensorflow_tflite():
  function test_tensorflow_tensorrt (line 137) | def test_tensorflow_tensorrt():
  function test_tensorflow_openvino (line 166) | def test_tensorflow_openvino():
  function test_tensorflow_tvm (line 195) | def test_tensorflow_tvm():

FILE: optimization/speedster/speedster/api/tests/utils.py
  function torch_to_onnx (line 10) | def torch_to_onnx(model, input_data, output_path):

FILE: optimization/speedster/speedster/root_op.py
  function _convert_technique (line 40) | def _convert_technique(technique: str):
  function _get_model_len (line 52) | def _get_model_len(model: Any):
  class SpeedsterRootOp (line 64) | class SpeedsterRootOp(Operation):
    method __init__ (line 65) | def __init__(self):
    method _send_feedback (line 70) | def _send_feedback(
    method execute (line 115) | def execute(

FILE: optimization/speedster/speedster/speedster.py
  class SpeedsterApp (line 6) | class SpeedsterApp(App):
    method __init__ (line 7) | def __init__(self):
    method execute (line 11) | def execute(self, *args, **kwargs):

FILE: optimization/speedster/speedster/tests/test_root_op.py
  function test_root_op_no_optim_model (line 6) | def test_root_op_no_optim_model(mocker):
  function test_root_op_optim_model (line 35) | def test_root_op_optim_model(mocker):