{
"mindformers.ModelRunner": {
"signature": "(model_path, npu_mem_size, cpu_mem_size, block_size, rank_id=0, world_size=1, npu_device_ids=None, plugin_params=None)"
},
"mindformers.run_check": {
"signature": "()"
},
"mindformers.pipeline": {
"signature": "(task: str = None, model: Union[NoneType, Tuple[str, str], mindformers.models.modeling_utils.PreTrainedModel, mindspore.train.model.Model, str] = None, tokenizer: Optional[mindformers.models.tokenization_utils_base.PreTrainedTokenizerBase] = None, image_processor: Optional[mindformers.models.image_processing_utils.BaseImageProcessor] = None, audio_processor: Optional[mindformers.models.base_processor.BaseAudioProcessor] = None, backend: Optional[str] = 'ms', **kwargs: Any)"
},
"mindformers.MultiModalToTextPipeline": {
"signature": "(model: Union[mindformers.models.modeling_utils.PreTrainedModel, mindspore.train.model.Model], processor: Optional[mindformers.models.multi_modal.base_multi_modal_processor.BaseXModalToTextProcessor] = None, **kwargs)"
},
"mindformers.MultiModalToTextPipeline.preprocess": {
"signature": "(self, inputs: Union[List[Dict[str, str]], List[List[Dict[str, str]]]], **preprocess_params)"
},
"mindformers.MultiModalToTextPipeline.postprocess": {
"signature": "(self, model_outputs, **postprocess_params)"
},
"mindformers.AdamW": {
"signature": "(params, learning_rate=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.0, use_fused=False, amsgrad=False, maximize=False, swap=False)"
},
"mindformers.AdamW.get_actual_adamw_cls": {
"signature": "(use_fused)"
},
"mindformers.CheckpointMonitor": {
"signature": "(prefix='CKP', directory=None, config=None, save_checkpoint_steps=1, save_checkpoint_seconds=0, keep_checkpoint_max=5, keep_checkpoint_per_n_minutes=0, integrated_save=True, save_network_params=False, save_trainable_params=False, async_save=False, saved_network=None, append_info=None, enc_key=None, enc_mode='AES-GCM', exception_save=False, global_batch_size=None, checkpoint_format='ckpt', remove_redundancy=False, embedding_size=4096, embedding_local_norm_threshold=1.0, use_checkpoint_health_monitor=False, health_ckpts_record_dir='./output', use_legacy_format=True, save_optimizer=True)"
},
"mindformers.CheckpointMonitor.print_savetime": {
"signature": "(self, record_step, batch_num)"
},
"mindformers.CheckpointMonitor.get_checkpoint_health_info": {
"signature": "(self, cb_params)"
},
"mindformers.CheckpointMonitor.create_group_pipeline": {
"signature": "(self, rank_list)"
},
"mindformers.CheckpointMonitor.save_checkpoint": {
"signature": "(self, cb_params)"
},
"mindformers.CheckpointMonitor.remove_redundancy": {
"signature": "(self, network, cur_file, append_dict, train_network)"
},
"mindformers.CheckpointMonitor.save_checkpoint_network": {
"signature": "(self, cb_params)"
},
"mindformers.CheckpointMonitor.record_last_ckpt_to_json": {
"signature": "(self, epoch, step, ckpt_file)"
},
"mindformers.CheckpointMonitor.step_end": {
"signature": "(self, run_context)"
},
"mindformers.CheckpointMonitor.end": {
"signature": "(self, run_context)"
},
"mindformers.CheckpointMonitor.on_train_step_begin": {
"signature": "(self, run_context)"
},
"mindformers.CheckpointMonitor.on_train_end": {
"signature": "(self, run_context)"
},
"mindformers.EvalCallBack": {
"signature": "(eval_func: Callable, step_interval: int = 100, epoch_interval: int = -1)"
},
"mindformers.EvalCallBack.on_train_epoch_end": {
"signature": "(self, run_context)"
},
"mindformers.EvalCallBack.on_train_step_end": {
"signature": "(self, run_context)"
},
"mindformers.MFLossMonitor": {
"signature": "(learning_rate: Union[NoneType, float, mindspore.nn.learning_rate_schedule.LearningRateSchedule] = None, per_print_times: int = 1, micro_batch_num: int = 1, micro_batch_interleave_num: int = 1, origin_epochs: int = None, dataset_size: int = None, initial_epoch: int = 0, initial_step: int = 0, global_batch_size: int = 0, gradient_accumulation_steps: int = 1, check_for_nan_in_loss_and_grad: bool = False, calculate_per_token_loss: bool = False, print_separate_loss: bool = False, **kwargs)"
},
"mindformers.MFLossMonitor.on_train_epoch_begin": {
"signature": "(self, run_context)"
},
"mindformers.MFLossMonitor.on_train_step_begin": {
"signature": "(self, run_context)"
},
"mindformers.MFLossMonitor.on_train_step_end": {
"signature": "(self, run_context)"
},
"mindformers.MFLossMonitor.print_output_info": {
"signature": "(self, cb_params, cur_epoch_num, origin_epochs, throughput, cur_step_num, steps_per_epoch, loss, per_step_seconds, overflow, scaling_sens, time_remain, percent, global_norm, main_loss, extra_loss, mtp_loss, indexer_loss)"
},
"mindformers.ProfileMonitor": {
"signature": "(start_step=1, stop_step=10, output_path=None, start_profile=True, profile_rank_ids=None, profile_pipeline=False, profile_communication=False, profile_memory=False, config=None, profiler_level=0, with_stack=False, data_simplification=True, mstx=False, **kwargs)"
},
"mindformers.ProfileMonitor.on_train_step_begin": {
"signature": "(self, run_context)"
},
"mindformers.ProfileMonitor.on_train_step_end": {
"signature": "(self, run_context)"
},
"mindformers.SummaryMonitor": {
"signature": "(summary_dir=None, collect_freq=10, collect_specified_data=None, keep_default_action=True, custom_lineage_data=None, collect_tensor_freq=None, max_file_size=None, export_options=None)"
},
"mindformers.TrainingStateMonitor": {
"signature": "(origin_epochs: int, config: dict = None, step_interval: int = 1, dataset_size: int = None, initial_epoch: int = 0, initial_step: int = 0, micro_batch_num: int = 0, global_batch_size: int = 0, tensor_model_parallel_size: int = 0, check_for_nan_in_loss_and_grad: bool = False, use_skip_data_by_global_norm: bool = False, embedding_size: int = 4096, use_local_norm: bool = False)"
},
"mindformers.TrainingStateMonitor.on_train_epoch_begin": {
"signature": "(self, run_context)"
},
"mindformers.TrainingStateMonitor.on_train_step_begin": {
"signature": "(self, run_context)"
},
"mindformers.TrainingStateMonitor.on_train_step_end": {
"signature": "(self, run_context)"
},
"mindformers.TrainingStateMonitor.abnormal_global_norm_check": {
"signature": "(self, cb_params)"
},
"mindformers.build_context": {
"signature": "(config: Union[dict, mindformers.tools.register.config.MindFormerConfig])"
},
"mindformers.get_context": {
"signature": "(attr_key)"
},
"mindformers.init_context": {
"signature": "(use_parallel=False, context_config=None, parallel_config=None)"
},
"mindformers.set_context": {
"signature": "(run_mode=None, **kwargs)"
},
"mindformers.CrossEntropyLoss": {
"signature": "(parallel_config=<mindformers.modules.transformer.op_parallel_config.OpParallelConfig object>, calculate_per_token_loss=False, seq_split_num=1, **kwargs)"
},
"mindformers.CrossEntropyLoss.construct": {
"signature": "(self, logits, label, input_mask)"
},
"mindformers.LearningRateWiseLayer": {
"signature": "(base_lr, lr_scale)"
},
"mindformers.LearningRateWiseLayer.construct": {
"signature": "(self, global_step)"
},
"mindformers.ConstantWarmUpLR": {
"signature": "(learning_rate: float, warmup_steps: int = None, warmup_lr_init: float = 0.0, warmup_ratio: float = None, total_steps: int = None, **kwargs)"
},
"mindformers.ConstantWarmUpLR.construct": {
"signature": "(self, global_step)"
},
"mindformers.LinearWithWarmUpLR": {
"signature": "(learning_rate: float, total_steps: int, warmup_steps: int = None, warmup_lr_init: float = 0.0, warmup_ratio: float = None, **kwargs)"
},
"mindformers.LinearWithWarmUpLR.construct": {
"signature": "(self, global_step)"
},
"mindformers.CosineWithWarmUpLR": {
"signature": "(learning_rate: float, warmup_steps: int = 0, total_steps: int = None, num_cycles: float = 0.5, lr_end: float = 0.0, warmup_lr_init: float = 0.0, warmup_ratio: float = None, decay_steps: int = None, decay_ratio: float = None, **kwargs)"
},
"mindformers.CosineWithWarmUpLR.construct": {
"signature": "(self, global_step)"
},
"mindformers.CosineWithRestartsAndWarmUpLR": {
"signature": "(learning_rate: float, warmup_steps: int = None, total_steps: int = None, num_cycles: float = 1.0, lr_end: float = 0.0, warmup_lr_init: float = 0.0, warmup_ratio: float = None, decay_steps: int = None, **kwargs)"
},
"mindformers.CosineWithRestartsAndWarmUpLR.construct": {
"signature": "(self, global_step)"
},
"mindformers.PolynomialWithWarmUpLR": {
"signature": "(learning_rate: float, total_steps: int, warmup_steps: int = None, lr_end: float = 1e-07, power: float = 1.0, warmup_lr_init: float = 0.0, warmup_ratio: float = None, decay_steps: int = None, **kwargs)"
},
"mindformers.PolynomialWithWarmUpLR.construct": {
"signature": "(self, global_step)"
},
"mindformers.CosineAnnealingLR": {
"signature": "(base_lr: float, t_max: int, eta_min: float = 0.0, **kwargs)"
},
"mindformers.CosineAnnealingLR.construct": {
"signature": "(self, global_step)"
},
"mindformers.CosineAnnealingWarmRestarts": {
"signature": "(base_lr: float, t_0: int, t_mult: int = 1, eta_min: float = 0.0, **kwargs)"
},
"mindformers.CosineAnnealingWarmRestarts.construct": {
"signature": "(self, global_step)"
},
"mindformers.EmF1Metric": {
"signature": "()"
},
"mindformers.EmF1Metric.clear": {
"signature": "(self)"
},
"mindformers.EmF1Metric.update": {
"signature": "(self, *inputs)"
},
"mindformers.EmF1Metric.eval": {
"signature": "(self)"
},
"mindformers.EmF1Metric.mixed_segmentation": {
"signature": "(self, in_str, rm_punc=False)"
},
"mindformers.EmF1Metric.remove_punctuation": {
"signature": "(self, in_str)"
},
"mindformers.EmF1Metric.find_lcs": {
"signature": "(self, s1, s2)"
},
"mindformers.EmF1Metric.calc_f1_score": {
"signature": "(self, answers, prediction)"
},
"mindformers.EmF1Metric.calc_em_score": {
"signature": "(self, answers, prediction)"
},
"mindformers.EmF1Metric.evaluate_pairs": {
"signature": "(self, pred_, ans_)"
},
"mindformers.EntityScore": {
"signature": "()"
},
"mindformers.EntityScore.clear": {
"signature": "(self)"
},
"mindformers.EntityScore.update": {
"signature": "(self, *inputs)"
},
"mindformers.EntityScore.eval": {
"signature": "(self)"
},
"mindformers.EntityScore.compute": {
"signature": "(self, origin, found, right)"
},
"mindformers.EntityScore.get_entities_bios": {
"signature": "(self, seq)"
},
"mindformers.PerplexityMetric": {
"signature": "()"
},
"mindformers.PerplexityMetric.clear": {
"signature": "(self)"
},
"mindformers.PerplexityMetric.update": {
"signature": "(self, *inputs)"
},
"mindformers.PerplexityMetric.eval": {
"signature": "(self)"
},
"mindformers.PromptAccMetric": {
"signature": "()"
},
"mindformers.PromptAccMetric.clear": {
"signature": "(self)"
},
"mindformers.PromptAccMetric.calculate_circle": {
"signature": "(self, *inputs)"
},
"mindformers.PromptAccMetric.update": {
"signature": "(self, *inputs)"
},
"mindformers.PromptAccMetric.eval": {
"signature": "(self)"
},
"mindformers.CausalLanguageModelDataset": {
"signature": "(dataset_config: Optional[dict] = None, data_loader: Union[Callable, dict] = None, input_columns: List[str] = None, output_columns: List[str] = None, batch_size: int = 8, drop_remainder: bool = True, num_parallel_workers: int = 8, python_multiprocessing: bool = False, repeat: int = 1, seed: int = 0, prefetch_size: int = 1, numa_enable: bool = False, eod_reset: bool = False, eod_token_id: Optional[int] = None, auto_tune: bool = False, filepath_prefix: str = './autotune', autotune_per_step: int = 10, profile: bool = False, token_monitor: bool = False, token_monitor_config: Optional[dict] = None, **kwargs)"
},
"mindformers.CausalLanguageModelDataset.perform_token_counting": {
"signature": "(top_n=10, min_token_id=0, max_token_id=inf, save_path='output/token_counts_output_csv/')"
},
"mindformers.KeyWordGenDataset": {
"signature": "(dataset_config: Optional[dict] = None, data_loader: Union[Callable, dict] = None, tokenizer: Union[Callable, dict] = None, input_columns: List[str] = None, batch_size: int = 8, drop_remainder: bool = True, num_parallel_workers: int = 8, repeat: int = 1, ignore_pad_token_for_loss: bool = True, max_source_length: int = None, max_target_length: int = None, phase: str = 'train', version: int = 1, seed: int = 0, prefetch_size: int = 1, numa_enable: bool = False, auto_tune: bool = False, filepath_prefix: str = './autotune', autotune_per_step: int = 10, profile: bool = False, **kwargs)"
},
"mindformers.MultiTurnDataset": {
"signature": "(dataset_config: dict)"
},
"mindformers.GenerationConfig": {
"signature": "(**kwargs)"
},
"mindformers.GenerationConfig.from_dict": {
"signature": "(config_dict: Dict[str, Any], **kwargs)"
},
"mindformers.GenerationConfig.from_pretrained": {
"signature": "(pretrained_model_name: Union[os.PathLike, str], config_file_name: Union[NoneType, os.PathLike, str] = None, **kwargs) -> 'GenerationConfig'"
},
"mindformers.GenerationConfig.from_model_config": {
"signature": "(model_config: mindformers.models.configuration_utils.PretrainedConfig) -> 'GenerationConfig'"
},
"mindformers.GenerationConfig.update": {
"signature": "(self, **kwargs)"
},
"mindformers.GenerationConfig.to_dict": {
"signature": "(self) -> Dict[str, Any]"
},
"mindformers.GenerationMixin": {
"signature": "()"
},
"mindformers.GenerationMixin.prepare_inputs_for_generation": {
"signature": "(self, input_ids, **kwargs)"
},
"mindformers.GenerationMixin.update_padding_index_to_inputs": {
"signature": "(self, model_inputs)"
},
"mindformers.GenerationMixin.add_flags_custom": {
"signature": "(self, is_first_iteration)"
},
"mindformers.GenerationMixin.add_flags_custom_mcore": {
"signature": "(self, is_prefill)"
},
"mindformers.GenerationMixin.update_model_kwargs_before_generate": {
"signature": "(input_ids, model_kwargs: dict)"
},
"mindformers.GenerationMixin.slice_incremental_inputs": {
"signature": "(model_inputs: dict, current_index, need_flatten: bool = False)"
},
"mindformers.GenerationMixin.process_logits": {
"signature": "(logits, current_index=None, keep_all=False)"
},
"mindformers.GenerationMixin.get_logits_processor": {
"signature": "(self, generation_config: mindformers.generation.generation_config.GenerationConfig, input_ids_seq_length: int, logits_processor: Optional[mindformers.generation.logits_process.LogitsProcessorList])"
},
"mindformers.GenerationMixin.get_logits_warper": {
"signature": "(generation_config: mindformers.generation.generation_config.GenerationConfig)"
},
"mindformers.GenerationMixin.generate": {
"signature": "(self, input_ids: Union[List[List[int]], List[int], NoneType], generation_config: Optional[mindformers.generation.generation_config.GenerationConfig] = None, logits_processor: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, streamer: Optional[mindformers.generation.streamers.BaseStreamer] = None, seed: Optional[int] = None, **kwargs)"
},
"mindformers.GenerationMixin.infer": {
"signature": "(self, input_ids: Union[List[List[int]], List[int]], valid_length_each_example: numpy.ndarray, generation_config: mindformers.generation.generation_config.GenerationConfig = None, logits_processor: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, logits_warper: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, block_tables: Optional[mindspore.common.tensor.Tensor] = None, slot_mapping: Optional[mindspore.common.tensor.Tensor] = None, prefill: bool = True, is_finished: List[bool] = None, encoder_mask: Optional[mindspore.common.tensor.Tensor] = None, encoder_output: Optional[mindspore.common.tensor.Tensor] = None, target_mask: Optional[mindspore.common.tensor.Tensor] = None, **model_kwargs)"
},
"mindformers.GenerationMixin.forward": {
"signature": "(self, input_ids: [typing.Union[typing.List[int], typing.List[typing.List[int]]]], valid_length_each_example: numpy.ndarray, block_tables: Optional[mindspore.common.tensor.Tensor] = None, slot_mapping: Optional[mindspore.common.tensor.Tensor] = None, prefill: bool = None, use_past: bool = False, encoder_mask: Optional[mindspore.common.tensor.Tensor] = None, encoder_output: Optional[mindspore.common.tensor.Tensor] = None, target_mask: Optional[mindspore.common.tensor.Tensor] = None, key_cache: Optional[List[mindspore.common.tensor.Tensor]] = None, value_cache: Optional[List[mindspore.common.tensor.Tensor]] = None, **model_kwargs)"
},
"mindformers.GenerationMixin.gen_attention_mask": {
"signature": "(self, is_prefill)"
},
"mindformers.GenerationMixin.prepare_inputs_for_generation_mcore": {
"signature": "(self, input_ids: [typing.Union[typing.List[int], typing.List[typing.List[int]]]], valid_length_each_example: numpy.ndarray, block_tables: Optional[mindspore.common.tensor.Tensor] = None, slot_mapping: Optional[mindspore.common.tensor.Tensor] = None, prefill: bool = None, **model_kwargs)"
},
"mindformers.GenerationMixin.forward_mcore": {
"signature": "(self, input_ids: [typing.Union[typing.List[int], typing.List[typing.List[int]]]], valid_length_each_example: numpy.ndarray, block_tables: Optional[mindspore.common.tensor.Tensor] = None, slot_mapping: Optional[mindspore.common.tensor.Tensor] = None, prefill: bool = None, **model_kwargs)"
},
"mindformers.GenerationMixin.infer_mcore": {
"signature": "(self, input_ids: Union[List[List[int]], List[int]], valid_length_each_example: numpy.ndarray, generation_config: mindformers.generation.generation_config.GenerationConfig = None, logits_processor: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, logits_warper: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, block_tables: Optional[mindspore.common.tensor.Tensor] = None, slot_mapping: Optional[mindspore.common.tensor.Tensor] = None, prefill: bool = True, is_finished: List[bool] = None, **model_kwargs)"
},
"mindformers.GenerationMixin.chunk_prefill_infer": {
"signature": "(self, input_ids: [typing.Union[typing.List[int], typing.List[typing.List[int]]]], batch_valid_length: numpy.ndarray, block_tables: numpy.ndarray, slot_mapping: numpy.ndarray, attention_mask: Optional[numpy.ndarray] = None, **model_kwargs)"
},
"mindformers.GenerationMixin.postprocess": {
"signature": "(self, input_ids, is_finished, res, generation_config: mindformers.generation.generation_config.GenerationConfig, valid_length_each_example, current_index: Union[List[List[int]], List[int], NoneType], logits_processor: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, logits_warper: Optional[mindformers.generation.logits_process.LogitsProcessorList] = None, need_gather_logits: bool = True)"
},
"mindformers.GenerationMixin.chat": {
"signature": "(self, tokenizer: mindformers.models.tokenization_utils.PreTrainedTokenizer, query: str, history: Optional[List[Dict[str, str]]] = None, system_role_name: Optional[str] = 'system', user_role_name: Optional[str] = 'user', assistant_role_name: Optional[str] = 'assistant', instruction: Optional[str] = '', max_length: Optional[int] = 512, max_new_tokens: Optional[int] = None, min_length: Optional[int] = 0, min_new_tokens: Optional[int] = None, do_sample: Optional[bool] = True, temperature: Optional[float] = 1.0, top_k: Optional[int] = 50, top_p: Optional[float] = 1.0, repetition_penalty: Optional[float] = 1.0)"
},
"mindformers.GenerationMixin.convert_pin_model_inputs": {
"signature": "(self, model_inputs)"
},
"mindformers.PreTrainedTokenizer": {
"signature": "(**kwargs)"
},
"mindformers.PreTrainedTokenizer.get_added_vocab": {
"signature": "(self) -> Dict[str, int]"
},
"mindformers.PreTrainedTokenizer.num_special_tokens_to_add": {
"signature": "(self, pair: bool = False) -> int"
},
"mindformers.PreTrainedTokenizer.tokenize": {
"signature": "(self, text: str, pair: Optional[str] = None, add_special_tokens: bool = False, **kwargs) -> List[str]"
},
"mindformers.PreTrainedTokenizer.tokenize_atom": {
"signature": "(self, tokens, no_split_token)"
},
"mindformers.PreTrainedTokenizer.convert_tokens_to_ids": {
"signature": "(self, tokens: Union[List[str], str]) -> Union[List[int], int]"
},
"mindformers.PreTrainedTokenizer.prepare_for_tokenization": {
"signature": "(self, text: str, **kwargs) -> Tuple[str, Dict[str, Any]]"
},
"mindformers.PreTrainedTokenizer.get_special_tokens_mask": {
"signature": "(self, token_ids_0: List, token_ids_1: Optional[List] = None, already_has_special_tokens: bool = False) -> List[int]"
},
"mindformers.PreTrainedTokenizer.convert_ids_to_tokens": {
"signature": "(self, ids: Union[List[int], int], skip_special_tokens: bool = False) -> Union[List[str], str]"
},
"mindformers.PreTrainedTokenizer.convert_tokens_to_string": {
"signature": "(self, tokens: List[str]) -> str"
},
"mindformers.PreTrainedTokenizerFast": {
"signature": "(*args, **kwargs)"
},
"mindformers.PreTrainedTokenizerFast.init_atom_1": {
"signature": "(self, *args, **kwargs)"
},
"mindformers.PreTrainedTokenizerFast.init_atom_2": {
"signature": "(self, **kwargs)"
},
"mindformers.PreTrainedTokenizerFast.get_vocab": {
"signature": "(self) -> Dict[str, int]"
},
"mindformers.PreTrainedTokenizerFast.get_added_vocab": {
"signature": "(self) -> Dict[str, int]"
},
"mindformers.PreTrainedTokenizerFast.convert_tokens_to_ids": {
"signature": "(self, tokens: Union[List[str], str]) -> Union[List[int], int]"
},
"mindformers.PreTrainedTokenizerFast.num_special_tokens_to_add": {
"signature": "(self, pair: bool = False) -> int"
},
"mindformers.PreTrainedTokenizerFast.convert_ids_to_tokens": {
"signature": "(self, ids: Union[List[int], int], skip_special_tokens: bool = False) -> Union[List[str], str]"
},
"mindformers.PreTrainedTokenizerFast.tokenize": {
"signature": "(self, text: str, pair: Optional[str] = None, add_special_tokens: bool = False, **kwargs) -> List[str]"
},
"mindformers.PreTrainedTokenizerFast.set_truncation_and_padding": {
"signature": "(self, padding_strategy: mindformers.models.tokenization_utils_base.PaddingStrategy, truncation_strategy: mindformers.models.tokenization_utils_base.TruncationStrategy, max_length: int, stride: int, pad_to_multiple_of: Optional[int])"
},
"mindformers.PreTrainedTokenizerFast.convert_tokens_to_string": {
"signature": "(self, tokens: List[str]) -> str"
},
"mindformers.PreTrainedTokenizerFast.train_new_from_iterator": {
"signature": "(self, text_iterator, vocab_size, length=None, new_special_tokens=None, special_tokens_map=None, **kwargs)"
},
"mindformers.PreTrainedTokenizerFast.save_vocabulary": {
"signature": "(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]"
},
"mindformers.AutoConfig": {
"signature": "()"
},
"mindformers.AutoConfig.invalid_yaml_name": {
"signature": "(yaml_name_or_path)"
},
"mindformers.AutoConfig.for_model": {
"signature": "(model_type: str, *args, **kwargs)"
},
"mindformers.AutoConfig.from_pretrained": {
"signature": "(yaml_name_or_path, **kwargs)"
},
"mindformers.AutoConfig.get_config_origin_mode": {
"signature": "(yaml_name_or_path, **kwargs)"
},
"mindformers.AutoConfig.get_config_experimental_mode": {
"signature": "(*args, **kwargs)"
},
"mindformers.AutoConfig.show_support_list": {
"signature": "()"
},
"mindformers.AutoConfig.get_support_list": {
"signature": "()"
},
"mindformers.AutoConfig.register": {
"signature": "(model_type, config, exist_ok=False)"
},
"mindformers.AutoModel": {
"signature": "(*args, **kwargs)"
},
"mindformers.AutoModel.from_config": {
"signature": "(**kwargs)"
},
"mindformers.AutoModel.from_pretrained": {
"signature": "(*model_args, **kwargs)"
},
"mindformers.AutoModelForCausalLM": {
"signature": "(*args, **kwargs)"
},
"mindformers.AutoModelForCausalLM.from_config": {
"signature": "(**kwargs)"
},
"mindformers.AutoModelForCausalLM.from_pretrained": {
"signature": "(*model_args, **kwargs)"
},
"mindformers.AutoProcessor": {
"signature": "()"
},
"mindformers.AutoProcessor.invalid_yaml_name": {
"signature": "(yaml_name_or_path)"
},
"mindformers.AutoProcessor.from_pretrained": {
"signature": "(yaml_name_or_path, **kwargs)"
},
"mindformers.AutoProcessor.from_pretrained_origin": {
"signature": "(yaml_name_or_path, **kwargs)"
},
"mindformers.AutoProcessor.from_pretrained_experimental": {
"signature": "(*args, **kwargs)"
},
"mindformers.AutoProcessor.register": {
"signature": "(config_class, processor_class, exist_ok=False)"
},
"mindformers.AutoProcessor.show_support_list": {
"signature": "()"
},
"mindformers.AutoProcessor.get_support_list": {
"signature": "()"
},
"mindformers.AutoTokenizer": {
"signature": "()"
},
"mindformers.AutoTokenizer.invalid_yaml_name": {
"signature": "(yaml_name_or_path)"
},
"mindformers.AutoTokenizer.from_pretrained": {
"signature": "(yaml_name_or_path, *args, **kwargs)"
},
"mindformers.AutoTokenizer.get_class_from_origin_mode": {
"signature": "(yaml_name_or_path, **kwargs)"
},
"mindformers.AutoTokenizer.get_class_from_experimental_mode": {
"signature": "(*args, **kwargs)"
},
"mindformers.AutoTokenizer.register": {
"signature": "(config_class, slow_tokenizer_class=None, fast_tokenizer_class=None, exist_ok=False)"
},
"mindformers.AutoTokenizer.show_support_list": {
"signature": "()"
},
"mindformers.AutoTokenizer.get_support_list": {
"signature": "(cls)"
},
"mindformers.ChatGLM2ForConditionalGeneration": {
"signature": "(config: mindformers.models.glm2.glm2_config.ChatGLM2Config, **kwargs)"
},
"mindformers.ChatGLM2ForConditionalGeneration.prepare_inputs_for_predict_layout": {
"signature": "(self, input_ids, **kwargs)"
},
"mindformers.ChatGLM2ForConditionalGeneration.set_dynamic_inputs": {
"signature": "(self, **kwargs)"
},
"mindformers.ChatGLM2ForConditionalGeneration.add_flags_custom": {
"signature": "(self, is_first_iteration)"
},
"mindformers.ChatGLM2ForConditionalGeneration.construct": {
"signature": "(self, input_ids=None, labels=None, input_position=None, position_ids=None, attention_mask=None, input_embeds=None, init_reset=None, batch_valid_length=None, prefix_key_values=None, block_tables=None, slot_mapping=None, batch_index=None, zactivate_len=None, input_mask=None)"
},
"mindformers.ChatGLM2ForConditionalGeneration.convert_name": {
"signature": "(weight_name)"
},
"mindformers.ChatGLM2ForConditionalGeneration.convert_weight_dict": {
"signature": "(source_dict, **kwargs)"
},
"mindformers.ChatGLM2ForConditionalGeneration.convert_map_dict": {
"signature": "(source_dict, **kwargs)"
},
"mindformers.ChatGLM2ForConditionalGeneration.obtain_qkv_ffn_concat_keys": {
"signature": "()"
},
"mindformers.ChatGLM2ForConditionalGeneration.obtain_name_map": {
"signature": "(load_checkpoint_files)"
},
"mindformers.ChatGLM2ForConditionalGeneration.clear_kv_cache": {
"signature": "(self)"
},
"mindformers.ChatGLM2Config": {
"signature": "(batch_size: int = 1, num_layers: int = 28, padded_vocab_size: int = 65024, hidden_size: int = 4096, ffn_hidden_size: int = 13696, kv_channels: int = 128, num_attention_heads: int = 32, seq_length: int = 2048, hidden_dropout: float = 0.0, attention_dropout: float = 0.0, layernorm_epsilon: float = 1e-05, rope_ratio: float = 1, rmsnorm: bool = True, apply_residual_connection_post_layernorm: bool = False, post_layer_norm: bool = True, add_bias_linear: bool = False, add_qkv_bias: bool = True, bias_dropout_fusion: bool = True, multi_query_attention: bool = True, multi_query_group_num: int = 2, apply_query_key_layer_scaling: bool = True, attention_softmax_in_fp32: bool = True, fp32_residual_connection: bool = False, quantization_bit: int = 0, pre_seq_len: int = None, prefix_projection: bool = False, param_init_type: str = 'float16', compute_dtype: str = 'float16', layernorm_compute_type: str = 'float32', residual_dtype: str = 'float32', rotary_dtype: str = None, use_past: bool = False, use_flash_attention: bool = False, enable_high_performance: bool = False, block_size: int = 16, num_blocks: int = 128, is_dynamic: bool = False, eos_token_id: int = 2, pad_token_id: int = 0, gmask_token_id: int = None, bos_token_id: int = None, repetition_penalty: float = 1.0, checkpoint_name_or_path: str = None, parallel_config: Union[dict, mindformers.modules.transformer.transformer.TransformerOpParallelConfig] = <mindformers.modules.transformer.transformer.TransformerOpParallelConfig object>, offset: int = 0, pp_interleave_num: int = 1, mlp_concat: bool = True, qkv_concat: bool = True, use_rearrange_rope: bool = False, mask_generate: str = None, fine_grain_interleave: int = 1, use_ring_attention: bool = False, post_self_attn_layernorm: bool = False, post_mlp_layernorm: bool = False, **kwargs)"
},
"mindformers.ChatGLM3Tokenizer": {
"signature": "(vocab_file, bos_token='<sop>', eos_token='<eop>', end_token='</s>', mask_token='[MASK]', gmask_token='[gMASK]', pad_token='<pad>', unk_token='<unk>', **kwargs)"
},
"mindformers.ChatGLM3Tokenizer.get_command": {
"signature": "(self, token)"
},
"mindformers.ChatGLM3Tokenizer.get_vocab": {
"signature": "(self)"
},
"mindformers.ChatGLM3Tokenizer.build_single_message": {
"signature": "(self, role, metadata, message)"
},
"mindformers.ChatGLM3Tokenizer.build_chat_input": {
"signature": "(self, query, history=None, role='user', return_tensors='np')"
},
"mindformers.ChatGLM3Tokenizer.build_batch_input": {
"signature": "(self, queries, histories=None, roles='user', padding=True, return_tensors='np')"
},
"mindformers.ChatGLM3Tokenizer.tokenize": {
"signature": "(self, text, pair=None, add_special_tokens=True, **kwargs)"
},
"mindformers.ChatGLM3Tokenizer.convert_tokens_to_ids": {
"signature": "(self, tokens: List[str]) -> list"
},
"mindformers.ChatGLM3Tokenizer.convert_tokens_to_string": {
"signature": "(self, tokens: List[str]) -> str"
},
"mindformers.ChatGLM3Tokenizer.save_vocabulary": {
"signature": "(self, save_directory, filename_prefix=None)"
},
"mindformers.ChatGLM3Tokenizer.get_prefix_tokens": {
"signature": "(self)"
},
"mindformers.ChatGLM3Tokenizer.build_inputs_with_special_tokens": {
"signature": "(self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None) -> List[int]"
},
"mindformers.ChatGLM3Tokenizer.apply_chat_template": {
"signature": "(self, conversation, return_tensors=None, **tokenizer_kwargs)"
},
"mindformers.ChatGLM4Tokenizer": {
"signature": "(vocab_file, clean_up_tokenization_spaces=False, encode_special_tokens=False, eos_token='<|endoftext|>', pad_token='<|endoftext|>', **kwargs)"
},
"mindformers.ChatGLM4Tokenizer.get_vocab": {
"signature": "(self)"
},
"mindformers.ChatGLM4Tokenizer.convert_tokens_to_string": {
"signature": "(self, tokens: List[Union[bytes, int, str]]) -> str"
},
"mindformers.ChatGLM4Tokenizer.convert_special_tokens_to_ids": {
"signature": "(self, token)"
},
"mindformers.ChatGLM4Tokenizer.save_vocabulary": {
"signature": "(self, save_directory, filename_prefix=None)"
},
"mindformers.ChatGLM4Tokenizer.get_prefix_tokens": {
"signature": "(self)"
},
"mindformers.ChatGLM4Tokenizer.build_single_message": {
"signature": "(self, role, metadata, message, tokenize=True)"
},
"mindformers.ChatGLM4Tokenizer.build_inputs_with_special_tokens": {
"signature": "(self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None) -> List[int]"
},
"mindformers.LlamaConfig": {
"signature": "(batch_size: int = 1, seq_length: int = 2048, hidden_size: int = 4096, num_layers: int = 32, num_heads: int = 32, n_kv_heads: Optional[int] = None, max_position_embedding: Optional[int] = None, intermediate_size: Optional[int] = None, vocab_size: int = 32000, multiple_of: int = 256, ffn_dim_multiplier: Optional[int] = None, rms_norm_eps: float = 1e-05, bos_token_id: int = 1, eos_token_id: int = 2, pad_token_id: int = 0, ignore_token_id: int = -100, theta: float = 10000.0, compute_dtype: str = 'float16', layernorm_compute_type: str = 'float32', softmax_compute_type: str = 'float32', rotary_dtype: str = 'float32', param_init_type: str = 'float16', residual_dtype: str = None, embedding_init_type=None, qkv_has_bias: bool = False, qkv_concat: bool = False, attn_proj_has_bias: bool = False, parallel_config: Union[dict, mindformers.modules.transformer.transformer.TransformerOpParallelConfig] = <mindformers.modules.transformer.transformer.TransformerOpParallelConfig object>, moe_config: Union[dict, mindformers.modules.transformer.moe.MoEConfig] = <mindformers.modules.transformer.moe.MoEConfig object>, use_past: bool = False, extend_method: str = 'None', scaling_factor: float = 1.0, is_dynamic: bool = False, use_rope_slice: bool = False, use_flash_attention: bool = False, use_ring_attention: bool = False, use_attn_mask_compression: bool = False, use_eod_attn_mask_compression: bool = False, parallel_optimizer: bool = False, fine_grain_interleave: int = 1, pp_interleave_num: int = 1, offset: int = 0, init_method_std: float = 0.01, checkpoint_name_or_path: str = '', repetition_penalty: float = 1.0, max_decode_length: int = 1024, block_size: int = 16, num_blocks: int = 512, top_k: int = 5, top_p: float = 1.0, do_sample: bool = True, quant_config: dict = None, tie_word_embeddings: bool = False, llm_backend: str = '', fused_rms_norm: bool = True, input_sliced_sig: bool = False, rmsnorm_compute_2d: bool = False, chunk_prefill: bool = False, calculate_per_token_loss: bool = False, pipeline_stage: dict = None, return_hidden_states: bool = False, **kwargs)"
},
"mindformers.LlamaForCausalLM": {
"signature": "(config: mindformers.models.llama.llama_config.LlamaConfig = None)"
},
"mindformers.LlamaForCausalLM.to_embeddings": {
"signature": "(self, tokens)"
},
"mindformers.LlamaForCausalLM.prepare_inputs_for_predict_layout": {
"signature": "(self, input_ids, **kwargs)"
},
"mindformers.LlamaForCausalLM.set_dynamic_inputs": {
"signature": "(self, **kwargs)"
},
"mindformers.LlamaForCausalLM.add_flags_custom": {
"signature": "(self, is_first_iteration)"
},
"mindformers.LlamaForCausalLM.pre_gather_func": {
"signature": "(self, pre_gather, output, batch_valid_length, gather_index=None)"
},
"mindformers.LlamaForCausalLM.construct": {
"signature": "(self, input_ids, labels=None, input_position=None, position_ids=None, attention_mask=None, input_embeds=None, init_reset=None, batch_valid_length=None, batch_index=None, zactivate_len=None, block_tables=None, slot_mapping=None, prefix_keys_values=None, llm_boost_inputs=None, q_seq_lens=None, loss_mask=None, gather_index=None, seq_range=None, actual_seq_len=None)"
},
"mindformers.LlamaForCausalLM.kvcache": {
"signature": "(self, layer_idx)"
},
"mindformers.LlamaForCausalLM.convert_name": {
"signature": "(weight_name)"
},
"mindformers.LlamaForCausalLM.convert_weight_dict": {
"signature": "(source_dict, **kwargs)"
},
"mindformers.LlamaForCausalLM.convert_map_dict": {
"signature": "(source_dict, **kwargs)"
},
"mindformers.LlamaForCausalLM.obtain_qkv_ffn_concat_keys": {
"signature": "()"
},
"mindformers.LlamaForCausalLM.obtain_name_map": {
"signature": "(load_checkpoint_files)"
},
"mindformers.LlamaForCausalLM.clear_kv_cache": {
"signature": "(self)"
},
"mindformers.LlamaForCausalLM.get_model_parameters": {
"signature": "(self)"
},
"mindformers.LlamaTokenizer": {
"signature": "(vocab_file, unk_token='<unk>', bos_token='<s>', eos_token='</s>', pad_token='<unk>', sp_model_kwargs: Optional[Dict[str, Any]] = None, add_bos_token=True, add_eos_token=False, clean_up_tokenization_spaces=False, legacy=True, **kwargs)"
},
"mindformers.LlamaTokenizer.get_spm_processor": {
"signature": "(self, from_slow=False)"
},
"mindformers.LlamaTokenizer.get_vocab": {
"signature": "(self)"
},
"mindformers.LlamaTokenizer.tokenize": {
"signature": "(self, text: 'TextInput', pair: Optional[str] = None, add_special_tokens: bool = False, **kwargs) -> List[str]"
},
"mindformers.LlamaTokenizer.convert_tokens_to_string": {
"signature": "(self, tokens)"
},
"mindformers.LlamaTokenizer.save_vocabulary": {
"signature": "(self, save_directory, filename_prefix=None)"
},
"mindformers.LlamaTokenizer.build_inputs_with_special_tokens": {
"signature": "(self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None)"
},
"mindformers.LlamaTokenizer.get_special_tokens_mask": {
"signature": "(self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False) -> List[int]"
},
"mindformers.LlamaTokenizer.create_token_type_ids_from_sequences": {
"signature": "(self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None) -> List[int]"
},
"mindformers.LlamaTokenizerFast": {
"signature": "(vocab_file=None, tokenizer_file=None, clean_up_tokenization_spaces=False, unk_token='<unk>', bos_token='<s>', eos_token='</s>', add_bos_token=True, add_eos_token=False, use_default_system_prompt=False, **kwargs)"
},
"mindformers.LlamaTokenizerFast.slow_tokenizer_class": {
"signature": "(vocab_file, unk_token='<unk>', bos_token='<s>', eos_token='</s>', pad_token='<unk>', sp_model_kwargs: Optional[Dict[str, Any]] = None, add_bos_token=True, add_eos_token=False, clean_up_tokenization_spaces=False, legacy=True, **kwargs)"
},
"mindformers.LlamaTokenizerFast.update_post_processor": {
"signature": "(self)"
},
"mindformers.LlamaTokenizerFast.save_vocabulary": {
"signature": "(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]"
},
"mindformers.LlamaTokenizerFast.build_inputs_with_special_tokens": {
"signature": "(self, token_ids_0, token_ids_1=None)"
},
"mindformers.ModalContentTransformTemplate": {
"signature": "(output_columns: List[str] = None, tokenizer=None, mode='predict', vstack_columns: List[str] = None, modal_content_padding_size=1, max_length=2048, **kwargs)"
},
"mindformers.ModalContentTransformTemplate.process_predict_query": {
"signature": "(self, query_ele_list: List[Dict], result_recorder: mindformers.models.multi_modal.utils.DataRecord)"
},
"mindformers.ModalContentTransformTemplate.process_train_item": {
"signature": "(self, conversation_list: List[List], result_recorder: mindformers.models.multi_modal.utils.DataRecord)"
},
"mindformers.ModalContentTransformTemplate.build_conversation_input_text": {
"signature": "(self, raw_inputs, result_recorder: mindformers.models.multi_modal.utils.DataRecord)"
},
"mindformers.ModalContentTransformTemplate.build_modal_context": {
"signature": "(self, input_ids, result_recorder: mindformers.models.multi_modal.utils.DataRecord, **kwargs)"
},
"mindformers.ModalContentTransformTemplate.build_labels": {
"signature": "(self, text_id_list, result_recorder, **kwargs)"
},
"mindformers.ModalContentTransformTemplate.generate_modal_context_positions": {
"signature": "(self, input_ids, batch_index: int = 0, result_recorder: mindformers.models.multi_modal.utils.DataRecord = None, **kwargs)"
},
"mindformers.ModalContentTransformTemplate.check_modal_builder_tokens": {
"signature": "(self, tokenizer)"
},
"mindformers.ModalContentTransformTemplate.get_need_update_output_items": {
"signature": "(result: mindformers.models.multi_modal.utils.DataRecord) -> Dict[str, Any]"
},
"mindformers.ModalContentTransformTemplate.batch_input_ids": {
"signature": "(self, input_ids_list, max_length)"
},
"mindformers.ModalContentTransformTemplate.stack_data": {
"signature": "(self, data, need_vstack: bool = False)"
},
"mindformers.ModalContentTransformTemplate.try_to_batch": {
"signature": "(self, data_list, column_name)"
},
"mindformers.ModalContentTransformTemplate.batch": {
"signature": "(self, data_list, token_padding_length, **kwargs)"
},
"mindformers.ModalContentTransformTemplate.post_process": {
"signature": "(self, output_ids, **kwargs)"
},
"mindformers.PretrainedConfig": {
"signature": "(**kwargs)"
},
"mindformers.PretrainedConfig.to_dict": {
"signature": "(self) -> Dict[str, Any]"
},
"mindformers.PretrainedConfig.convert_to_transformer_config": {
"signature": "(self, is_mla_model: bool = False)"
},
"mindformers.PretrainedConfig.from_pretrained": {
"signature": "(yaml_name_or_path, **kwargs) -> 'PretrainedConfig'"
},
"mindformers.PretrainedConfig.get_config_experimental_mode": {
"signature": "(*args, **kwargs)"
},
"mindformers.PretrainedConfig.get_config_origin_mode": {
"signature": "(yaml_name_or_path, **kwargs)"
},
"mindformers.PretrainedConfig.save_pretrained": {
"signature": "(self, save_directory=None, save_name='mindspore_model', **kwargs)"
},
"mindformers.PretrainedConfig.save_config_experimental_mode": {
"signature": "(cls, *args, **kwargs)"
},
"mindformers.PretrainedConfig.save_config_origin_mode": {
"signature": "(self, save_directory, save_name)"
},
"mindformers.PretrainedConfig.remove_type": {
"signature": "(self)"
},
"mindformers.PretrainedConfig.inverse_parse_config": {
"signature": "(self)"
},
"mindformers.PretrainedConfig.show_support_list": {
"signature": "()"
},
"mindformers.PretrainedConfig.get_support_list": {
"signature": "()"
},
"mindformers.PretrainedConfig.get_config_dict": {
"signature": "(pretrained_model_name_or_path: Union[os.PathLike, str], **kwargs) -> Tuple[Dict[str, Any], Dict[str, Any]]"
},
"mindformers.PretrainedConfig.from_dict": {
"signature": "(config_dict: Dict[str, Any], **kwargs) -> 'PretrainedConfig'"
},
"mindformers.PretrainedConfig.from_json_file": {
"signature": "(json_file: Union[os.PathLike, str]) -> 'PretrainedConfig'"
},
"mindformers.PretrainedConfig.to_json_file": {
"signature": "(self, json_file_path: Union[os.PathLike, str], use_diff: bool = True)"
},
"mindformers.PretrainedConfig.to_json_string": {
"signature": "(self, use_diff: bool = True) -> str"
},
"mindformers.PretrainedConfig.to_diff_dict": {
"signature": "(self) -> Dict[str, Any]"
},
"mindformers.PretrainedConfig.delete_from_dict": {
"signature": "(self, config_dict)"
},
"mindformers.PretrainedConfig.dict_ms_dtype_to_str": {
"signature": "(self, d: Dict[str, Any]) -> None"
},
"mindformers.PretrainedConfig.register_for_auto_class": {
"signature": "(auto_class='AutoConfig')"
},
"mindformers.PreTrainedModel": {
"signature": "(config: mindformers.models.configuration_utils.PretrainedConfig, *inputs, **kwargs)"
},
"mindformers.PreTrainedModel.post_init": {
"signature": "(self)"
},
"mindformers.PreTrainedModel.check_pipeline_stage": {
"signature": "(self)"
},
"mindformers.PreTrainedModel.can_generate": {
"signature": "() -> bool"
},
"mindformers.PreTrainedModel.save_pretrained": {
"signature": "(self, save_directory: Union[os.PathLike, str], save_name: str = 'mindspore_model', **kwargs)"
},
"mindformers.PreTrainedModel.save_pretrained_experimental_mode": {
"signature": "(self, save_directory: Union[os.PathLike, str], is_main_process: bool = True, state_dict: Optional[dict] = None, push_to_hub: bool = False, max_shard_size: Union[int, str] = '5GB', variant: Optional[str] = None, token: Union[NoneType, bool, str] = None, **kwargs)"
},
"mindformers.PreTrainedModel.save_pretrained_origin_mode": {
"signature": "(self, save_directory: Optional[str] = None, save_name: str = 'mindspore_model')"
},
"mindformers.PreTrainedModel.remove_type": {
"signature": "(self, config)"
},
"mindformers.PreTrainedModel.prepare_inputs_for_predict_layout": {
"signature": "(self, input_ids, **kwargs)"
},
"mindformers.PreTrainedModel.is_experimental_mode": {
"signature": "(pretrained_model_name_or_dir)"
},
"mindformers.PreTrainedModel.from_pretrained": {
"signature": "(pretrained_model_name_or_dir: str, *model_args, **kwargs)"
},
"mindformers.PreTrainedModel.from_pretrained_origin_mode": {
"signature": "(pretrained_model_name_or_dir: str, **kwargs)"
},
"mindformers.PreTrainedModel.from_pretrained_experimental_mode": {
"signature": "(pretrained_model_name_or_path: Union[NoneType, os.PathLike, str], *model_args, config: Union[NoneType, mindformers.models.configuration_utils.PretrainedConfig, os.PathLike, str] = None, cache_dir: Union[NoneType, os.PathLike, str] = None, ignore_mismatched_sizes: bool = False, force_download: bool = False, local_files_only: bool = False, token: Union[NoneType, bool, str] = None, revision: str = 'main', **kwargs)"
},
"mindformers.PreTrainedModel.register_for_auto_class": {
"signature": "(auto_class='AutoModel')"
},
"mindformers.PreTrainedModel.load_checkpoint": {
"signature": "(self, config)"
},
"mindformers.PreTrainedModel.show_support_list": {
"signature": "()"
},
"mindformers.PreTrainedModel.get_support_list": {
"signature": "()"
},
"mindformers.PreTrainedModel.kvcache": {
"signature": "(self, layer_idx)"
},
"mindformers.PreTrainedModel.fuse_weight_from_ckpt": {
"signature": "(self, ckpt_dict)"
},
"mindformers.PreTrainedModel.get_model_parameters": {
"signature": "(self, only_trainable=True)"
},
"mindformers.LoraConfig": {
"signature": "(lora_rank: int = 8, lora_alpha: int = 16, lora_dropout: float = 0.01, lora_a_init: str = 'normal', lora_b_init: str = 'zero', param_init_type: str = None, compute_dtype: str = None, target_modules: str = None, exclude_layers: str = None, freeze_include: List[str] = None, freeze_exclude: List[str] = None, **kwargs)"
},
"mindformers.PetConfig": {
"signature": "(pet_type: str = None, **kwargs)"
},
"mindformers.LoraModel": {
"signature": "(config: mindformers.pet.pet_config.LoraConfig, base_model: mindformers.models.modeling_utils.PreTrainedModel)"
},
"mindformers.LoraModel.add_adapter": {
"signature": "(self, base_model: mindformers.models.modeling_utils.PreTrainedModel)"
},
"mindformers.LoraModel.update_model_kwargs_before_generate": {
"signature": "(self, input_ids, model_kwargs: dict)"
},
"mindformers.LoraModel.prepare_inputs_for_generation": {
"signature": "(self, input_ids, **kwargs)"
},
"mindformers.LoraModel.prepare_inputs_for_predict_layout": {
"signature": "(self, input_ids, **kwargs)"
},
"mindformers.LoraModel.slice_incremental_inputs": {
"signature": "(self, model_inputs: dict, current_index, need_flatten: bool = False)"
},
"mindformers.LoraModel.set_dynamic_inputs": {
"signature": "(self, **kwargs)"
},
"mindformers.LoraModel.save_pet_config": {
"signature": "(self, save_path: str)"
},
"mindformers.LoraModel.to_embeddings": {
"signature": "(self, tokens)"
},
"mindformers.LoraModel.convert_name": {
"signature": "(self, weight_name)"
},
"mindformers.LoraModel.convert_weight_dict": {
"signature": "(self, source_dict, **kwargs)"
},
"mindformers.LoraModel.convert_map_dict": {
"signature": "(self, source_dict, **kwargs)"
},
"mindformers.LoraModel.obtain_name_map": {
"signature": "(self, load_checkpoint_files)"
},
"mindformers.LoraModel.get_gpt_transformer_config": {
"signature": "(self)"
},
"mindformers.LoraModel.construct": {
"signature": "(self, *inputs, **kwargs)"
},
"mindformers.MindFormerConfig": {
"signature": "(*args, **kwargs)"
},
"mindformers.MindFormerConfig.merge_from_dict": {
"signature": "(self, options)"
},
"mindformers.MindFormerConfig.get_value": {
"signature": "(self, levels: Union[list, str], default=None)"
},
"mindformers.MindFormerConfig.set_value": {
"signature": "(self, levels: Union[list, str], value)"
},
"mindformers.MindFormerModuleType": {
"signature": "()"
},
"mindformers.MindFormerRegister": {
"signature": "()"
},
"mindformers.MindFormerRegister.register": {
"signature": "(module_type='tools', alias=None, legacy=True, search_names=None)"
},
"mindformers.MindFormerRegister.register_cls": {
"signature": "(register_class, module_type='tools', alias=None, legacy=True, search_names=None)"
},
"mindformers.MindFormerRegister.is_exist": {
"signature": "(module_type, class_name=None)"
},
"mindformers.MindFormerRegister.get_cls": {
"signature": "(module_type, class_name=None)"
},
"mindformers.MindFormerRegister.get_instance_type_from_cfg": {
"signature": "(cfg, module_type='models')"
},
"mindformers.MindFormerRegister.get_instance_from_cfg": {
"signature": "(cfg, module_type='tools', default_args=None)"
},
"mindformers.MindFormerRegister.get_instance": {
"signature": "(module_type='tools', class_name=None, **kwargs)"
},
"mindformers.MindFormerRegister.auto_register": {
"signature": "(class_reference: str, module_type='tools')"
},
"mindformers.Trainer": {
"signature": "(args: Union[NoneType, mindformers.tools.register.config.MindFormerConfig, mindformers.trainer.training_args.TrainingArguments, str] = None, task: Optional[str] = 'general', model: Union[NoneType, mindformers.models.modeling_utils.PreTrainedModel, str] = None, model_name: Optional[str] = None, tokenizer: Optional[mindformers.models.tokenization_utils_base.PreTrainedTokenizerBase] = None, train_dataset: Union[NoneType, collections.abc.Iterable, mindformers.dataset.base_dataset.BaseDataset, mindspore.dataset.engine.datasets.Dataset, str] = None, eval_dataset: Union[NoneType, collections.abc.Iterable, mindformers.dataset.base_dataset.BaseDataset, mindspore.dataset.engine.datasets.Dataset, str] = None, data_collator: Optional[Callable] = None, optimizers: Optional[mindspore.nn.optim.optimizer.Optimizer] = None, compute_metrics: Union[NoneType, dict, set] = None, callbacks: Union[List[mindspore.train.callback._callback.Callback], NoneType, mindspore.train.callback._callback.Callback] = None, eval_callbacks: Union[List[mindspore.train.callback._callback.Callback], NoneType, mindspore.train.callback._callback.Callback] = None, pet_method: Optional[str] = '', image_processor: Optional[mindformers.models.image_processing_utils.BaseImageProcessor] = None, audio_processor: Optional[mindformers.models.base_processor.BaseAudioProcessor] = None, save_config: bool = False, reset_model: bool = False)"
},
"mindformers.Trainer.train": {
"signature": "(self, train_checkpoint: Union[NoneType, bool, str] = False, resume_from_checkpoint: Union[NoneType, bool, str] = None, resume_training: Union[NoneType, bool, str] = None, ignore_data_skip: Optional[bool] = None, data_skip_steps: Optional[int] = None, auto_trans_ckpt: Optional[bool] = None, src_strategy: Optional[str] = None, transform_process_num: Optional[int] = None, do_eval: Optional[bool] = False)"
},
"mindformers.Trainer.finetune": {
"signature": "(self, finetune_checkpoint: Union[NoneType, bool, str] = False, resume_from_checkpoint: Union[NoneType, bool, str] = None, resume_training: Union[NoneType, bool, str] = None, ignore_data_skip: Optional[bool] = None, data_skip_steps: Optional[int] = None, auto_trans_ckpt: Optional[bool] = None, src_strategy: Optional[str] = None, transform_process_num: Optional[int] = None, do_eval: bool = False)"
},
"mindformers.Trainer.evaluate": {
"signature": "(self, eval_dataset: Union[NoneType, collections.abc.Iterable, mindformers.dataset.base_dataset.BaseDataset, mindspore.dataset.engine.datasets.Dataset, str] = None, eval_checkpoint: Union[NoneType, bool, str] = False, auto_trans_ckpt: Optional[bool] = None, src_strategy: Optional[str] = None, transform_process_num: Optional[int] = None, **kwargs)"
},
"mindformers.Trainer.predict": {
"signature": "(self, predict_checkpoint: Union[NoneType, bool, str] = None, auto_trans_ckpt: Optional[bool] = None, src_strategy: Optional[str] = None, transform_process_num: Optional[int] = None, input_data: Union[NoneType, PIL.Image.Image, list, mindspore.common.tensor.Tensor, mindspore.dataset.engine.datasets_user_defined.GeneratorDataset, numpy.ndarray, str] = None, batch_size: int = None, **kwargs)"
},
"mindformers.Trainer.add_callback": {
"signature": "(self, callback)"
},
"mindformers.Trainer.pop_callback": {
"signature": "(self, callback)"
},
"mindformers.Trainer.remove_callback": {
"signature": "(self, callback)"
},
"mindformers.Trainer.set_parallel_config": {
"signature": "(self, data_parallel=1, model_parallel=1, context_parallel=1, expert_parallel=1, pipeline_stage=1, micro_batch_interleave_num=1, micro_batch_num=1, use_seq_parallel=False, optimizer_shard=False, gradient_aggregation_group=4, vocab_emb_dp=True)"
},
"mindformers.Trainer.set_recompute_config": {
"signature": "(self, recompute=False, parallel_optimizer_comm_recompute=False, select_recompute=False, mp_comm_recompute=True, recompute_slice_activation=False)"
},
"mindformers.Trainer.get_task_config": {
"signature": "(task, model_name)"
},
"mindformers.Trainer.get_train_dataloader": {
"signature": "(self)"
},
"mindformers.Trainer.get_eval_dataloader": {
"signature": "(self)"
},
"mindformers.Trainer.get_last_checkpoint": {
"signature": "(self)"
},
"mindformers.Trainer.get_load_checkpoint": {
"signature": "(checkpoint)"
},
"mindformers.Trainer.init_openmind_repo": {
"signature": "(self)"
},
"mindformers.Trainer.save_model": {
"signature": "(self, output_dir: Optional[str] = None, internal_call: bool = False)"
},
"mindformers.Trainer.push_to_hub": {
"signature": "(self, commit_message: Optional[str] = 'End of training', blocking: bool = True) -> str"
},
"mindformers.TrainingArguments": {
"signature": "(output_dir: str = './output', overwrite_output_dir: bool = False, seed: int = 42, data_seed: Optional[int] = None, only_save_strategy: bool = False, auto_trans_ckpt: bool = False, src_strategy: Optional[str] = None, transform_process_num: int = 1, resume_from_checkpoint: Optional[str] = None, resume_training: Union[NoneType, bool, str] = None, ignore_data_skip: bool = False, data_skip_steps: Optional[int] = None, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, check_for_nan_in_loss_and_grad: bool = False, calculate_per_token_loss: bool = False, remote_save_url: Optional[str] = None, batch_size: Optional[int] = None, num_train_epochs: float = 3.0, sink_mode: bool = True, sink_size: int = 2, gradient_accumulation_steps: int = 1, mode: int = 0, use_cpu: bool = False, device_id: int = 0, device_target: str = 'Ascend', max_call_depth: int = 10000, max_device_memory: str = '1024GB', save_graphs: bool = False, save_graphs_path: str = './graph', use_parallel: bool = False, parallel_mode: int = 1, gradients_mean: bool = False, loss_repeated_mean: bool = False, enable_alltoall: bool = False, full_batch: bool = True, dataset_strategy: Union[str, tuple] = 'full_batch', search_mode: str = 'sharding_propagation', enable_parallel_optimizer: bool = False, gradient_accumulation_shard: bool = False, parallel_optimizer_threshold: int = 64, optimizer_weight_shard_size: int = -1, strategy_ckpt_save_file: str = './ckpt_strategy.ckpt', data_parallel: int = 1, model_parallel: int = 1, expert_parallel: int = 1, pipeline_stage: int = 1, micro_batch_num: int = 1, gradient_aggregation_group: int = 4, micro_batch_interleave_num: int = 1, use_seq_parallel: bool = False, vocab_emb_dp: bool = True, expert_num: int = 1, capacity_factor: float = 1.05, aux_loss_factor: float = 0.05, num_experts_chosen: int = 1, recompute: bool = False, select_recompute: bool = False, parallel_optimizer_comm_recompute: bool = False, mp_comm_recompute: bool = True, recompute_slice_activation: bool = False, optim: Union[mindformers.trainer.utils.OptimizerType, str] = 'AdamW', adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, weight_decay: float = 0.0, layer_scale: bool = False, layer_decay: float = 0.65, lr_scheduler_type: Union[mindformers.trainer.utils.LrSchedulerType, str] = 'cosine', learning_rate: float = 5e-05, lr_end: float = 1e-06, warmup_lr_init: float = 0.0, warmup_epochs: Optional[int] = None, warmup_ratio: Optional[float] = None, warmup_steps: int = 0, total_steps: int = -1, lr_scale: bool = False, lr_scale_factor: int = 256, dataset_task: Optional[str] = None, dataset_type: Optional[str] = None, train_dataset: Optional[str] = None, train_dataset_in_columns: Optional[List[str]] = None, train_dataset_out_columns: Optional[List[str]] = None, eval_dataset: Optional[str] = None, eval_dataset_in_columns: Optional[List[str]] = None, eval_dataset_out_columns: Optional[List[str]] = None, shuffle: bool = True, dataloader_drop_last: bool = True, repeat: int = 1, per_device_train_batch_size: int = 8, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, dataloader_num_workers: int = 8, python_multiprocessing: bool = False, numa_enable: bool = False, prefetch_size: int = 1, wrapper_type: str = 'MFTrainOneStepCell', scale_sense: Union[float, str] = 'DynamicLossScaleUpdateCell', loss_scale_value: int = 65536, loss_scale_factor: int = 2, loss_scale_window: int = 1000, use_clip_grad: bool = True, max_grad_norm: float = 1.0, max_scale_window: int = 1000, min_scale_window: int = 20, metric_type: Union[List[str], NoneType, str] = None, logging_strategy: Union[mindformers.trainer.utils.LoggingIntervalStrategy, str] = 'steps', logging_steps: int = 1, save_prefix: str = 'CKP', save_directory: Optional[str] = None, save_strategy: Union[mindformers.trainer.utils.SaveIntervalStrategy, str] = 'steps', save_steps: int = 500, save_seconds: Optional[int] = None, save_total_limit: Optional[int] = 5, keep_checkpoint_per_n_minutes: int = 0, save_on_each_node: bool = True, integrated_save: bool = None, save_network_params: bool = True, save_trainable_params: bool = False, async_save: bool = False, evaluation_strategy: Union[mindformers.trainer.utils.IntervalStrategy, str] = 'no', eval_steps: Optional[float] = None, eval_epochs: Optional[int] = None, profile: bool = False, profile_start_step: int = 1, profile_end_step: int = 10, init_start_profile: bool = False, profile_communication: bool = False, profile_memory: bool = True, auto_tune: bool = False, filepath_prefix: str = './autotune', autotune_per_step: int = 10, push_to_hub: bool = False, hub_model_id: Optional[str] = None, hub_strategy: Union[mindformers.trainer.utils.HubStrategy, str] = 'every_save', hub_token: Optional[str] = None, hub_private_repo: bool = False, hub_always_push: bool = False) -> None"
},
"mindformers.TrainingArguments.check_step_rules": {
"signature": "(steps, info='steps')"
},
"mindformers.TrainingArguments.get_warmup_steps": {
"signature": "(self, num_training_steps: int)"
},
"mindformers.TrainingArguments.get_recompute_config": {
"signature": "(self)"
},
"mindformers.TrainingArguments.get_parallel_config": {
"signature": "(self)"
},
"mindformers.TrainingArguments.get_moe_config": {
"signature": "(self)"
},
"mindformers.TrainingArguments.to_dict": {
"signature": "(self)"
},
"mindformers.TrainingArguments.to_json_string": {
"signature": "(self)"
},
"mindformers.TrainingArguments.set_training": {
"signature": "(self, learning_rate: float = 5e-05, batch_size: int = 8, weight_decay: float = 0, num_epochs: float = 3.0, gradient_accumulation_steps: int = 1, seed: int = 42, **kwargs)"
},
"mindformers.TrainingArguments.set_evaluate": {
"signature": "(self, strategy: Union[mindformers.trainer.utils.IntervalStrategy, str] = 'no', steps: int = 500, batch_size: int = 8, **kwargs)"
},
"mindformers.TrainingArguments.set_testing": {
"signature": "(self, batch_size: int = 8, loss_only: bool = False, **kwargs)"
},
"mindformers.TrainingArguments.set_save": {
"signature": "(self, strategy: Union[mindformers.trainer.utils.IntervalStrategy, str] = 'steps', steps: int = 500, total_limit: Optional[int] = None, on_each_node: bool = True, **kwargs)"
},
"mindformers.TrainingArguments.set_logging": {
"signature": "(self, strategy: Union[mindformers.trainer.utils.IntervalStrategy, str] = 'steps', steps: int = 500, **kwargs)"
},
"mindformers.TrainingArguments.set_push_to_hub": {
"signature": "(self, model_id: str, strategy: Union[mindformers.trainer.utils.HubStrategy, str] = 'every_save', token: Optional[str] = None, private_repo: bool = False, always_push: bool = False, **kwargs)"
},
"mindformers.TrainingArguments.set_optimizer": {
"signature": "(self, name: Union[mindformers.trainer.utils.OptimizerType, str] = 'AdamW', learning_rate: float = 5e-05, lr_end: float = 1e-06, weight_decay: float = 0, beta1: float = 0.9, beta2: float = 0.999, epsilon: float = 1e-08, **kwargs)"
},
"mindformers.TrainingArguments.set_lr_scheduler": {
"signature": "(self, name: Union[mindformers.trainer.utils.LrSchedulerType, str] = 'linear', num_epochs: float = 3.0, warmup_lr_init: float = 0.0, warmup_epochs: Optional[int] = None, warmup_ratio: Optional[float] = None, warmup_steps: int = 0, total_steps: int = -1, **kwargs)"
},
"mindformers.TrainingArguments.set_dataloader": {
"signature": "(self, train_batch_size: int = 8, eval_batch_size: int = 8, drop_last: bool = False, num_workers: int = 0, ignore_data_skip: bool = False, data_skip_steps: Optional[int] = None, sampler_seed: Optional[int] = None, **kwargs)"
},
"mindformers.TrainingArguments.print_kwargs_unused": {
"signature": "(**kwargs)"
},
"mindformers.TrainingArguments.convert_args_to_mindformers_config": {
"signature": "(self, task_config: mindformers.tools.register.config.MindFormerConfig = None)"
},
"mindformers.MFPipelineWithLossScaleCell": {
"signature": "(network, optimizer, use_clip_grad=True, max_grad_norm=1.0, scale_sense=1.0, micro_batch_num=1, local_norm=False, calculate_per_token_loss=False, global_norm_spike_threshold=1.0, use_skip_data_by_global_norm=False, print_separate_loss=False, **kwargs)"
},
"mindformers.MFPipelineWithLossScaleCell.construct": {
"signature": "(self, *inputs)"
},
"mindformers.MFPipelineWithLossScaleCell.grads_for_legacy": {
"signature": "(self, scaling_sens, *inputs)"
},
"mindformers.MFPipelineWithLossScaleCell.grads_for_mcore": {
"signature": "(self, scaling_sens, *inputs)"
},
"mindformers.MFTrainOneStepCell": {
"signature": "(network, optimizer, use_clip_grad=False, max_grad_norm=1.0, scale_sense=1.0, local_norm=False, calculate_per_token_loss=False, global_norm_spike_threshold=1.0, use_skip_data_by_global_norm=False, print_separate_loss=False, **kwargs)"
},
"mindformers.MFTrainOneStepCell.construct": {
"signature": "(self, *inputs)"
},
"mindformers.MFTrainOneStepCell.grads_for_legacy": {
"signature": "(self, scaling_sens, *inputs)"
},
"mindformers.MFTrainOneStepCell.grads_for_mcore": {
"signature": "(self, scaling_sens, *inputs)"
}
}