tvm.meta_schedule

tvm.meta_schedule 软件包。元调度基础设施。

类:

Builder	抽象构建器接口。
CostModel	成本模型。
Database	抽象数据库接口。
ExtractedTask(task_name,mod,target,…)	从高级 IR 中提取的调优任务。
FeatureExtractor	从测量候选中提取特征以用于成本模型。
MeasureCallback	测量结果出来后适用的规则可用。
Mutator	Mutator 旨在改变轨迹以探索设计空间。
Postproc	将后处理器应用于调度的规则。
Profiler()	调整时间分析器。
Runner	抽象运行器接口。
ScheduleRule	修改调度中的块的规则。
MeasureCandidate(sch,args_info)	衡量候选类别。
SearchStrategy	搜索策略是生成度量候选的类。
SpaceGenerator	抽象设计空间生成器接口。
TaskScheduler	抽象任务调度程序接口。
TuneContext([mod,target,space_generator,…])	调整上下文类旨在包含调整任务的所有资源。

函数:

tune_tir(mod,target,work_dir,…[,…])	调整 TIR 函数或 TIR 函数的 IRModule。
tune_tasks(*,tasks,task_weights,work_dir,…)	调整任务列表。使用任务调度程序。
derived_object(cls)	用于为 TVM 对象注册派生子类的装饰器。

class tvm.meta_schedule.Builder

抽象构建器接口。

方法：

build(build_inputs)	构建给定的输入。
create([kind])	创建一个构建器。

build(build_inputs:List[BuilderInput]) → List[BuilderResult]

构建给定的输入。

• 参数：build_inputs (List[BuilderInput])：要构建的输入。
• 返回：build_results：构建给定输入的结果。
• 返回类型： List[BuilderResult]。

static create(kind: typing_extensions.Literal[local] = 'local', args*, **kwargs) → Builder

创建一个构建器。

• 参数：kind (Literal["local"])：构建器的类型。目前仅支持「local」。
• 返回：builder：构建器创建。
• 返回类型：Builder。

class tvm.meta_schedule.CostModel

成本模型。

方法：

load(path)	从给定的文件位置加载成本模型。
save(path)	将成本模型保存到给定的文件位置。
update(context, candidates, results)	根据运行结果更新成本模型。
predict(context, candidates)	使用成本模型预测标准化分数。
create(kind, *args, **kwargs)	创建一个 CostModel。

load(path:str) → None

从给定的文件位置加载成本模型。

• 参数：path (str)：文件路径。

save(path:str) → None

将成本模型保存到给定的文件位置。

• 参数：path (str)：文件路径。

update(context:TuneContext, candidates:List[MeasureCandidate], results:List[RunnerResult]) → None

根据运行结果更新成本模型。

• 参数：
  • context ( TuneContext, ) ：调整上下文。
  • candidates（列表[ MeasureCandidate]）：衡量 candidates。
  • results( List[RunnerResult] ) ：度量候选的运行结果。

predict(context:TuneContext, candidates:List[MeasureCandidate]) → ndarray

使用成本模型预测标准化分数。

• 参数：
  • context ( TuneContext, ) ：调整上下文。
  • candidates（列表[ MeasureCandidate]）：衡量 candidates。
• 返回：result：预测的标准分数。
• 返回类型： np.ndarray。

static create(kind: typing_extensions.Literal[xgb, mlp, random, none], args*, **kwargs) → CostModel

创建一个 CostModel。

• 参数： 成本模型的种类。可以是“xgb”、“mlp”、“random”或“none”。
• 返回：cost_model：创建的成本模型。
• 返回类型：CostModel

class tvm.meta_schedule.Database

抽象数据库接口。

方法：

has_workload(mod)	检查数据库是否具有给定的工作负载。
commit_workload(mod)	如果缺失，则将工作负载提交到数据库。
commit_tuning_record(record)	将调整记录提交到数据库。
get_top_k(workload, top_k)	从数据库中获取给定工作负载的前 K 条有效调优记录。
get_all_tuning_records()	从数据库中获取所有调优记录。
query_tuning_record(mod, target, workload_name)	从数据库中查询给定工作量的最佳记录。
query_schedule(mod, target, workload_name)	从数据库中查询给定工作负载的最佳调度。
query_ir_module(mod, target, workload_name)	从数据库中查询给定工作负载的最佳 IRModule。
dump_pruned(destination)	将修剪后的数据库转储为 JSONDatabase 格式的文件。
query(mod, target, *[, workload_name, kind])	查询数据库以检索给定工作负载的最佳优化结果。
current()	获取范围内的当前数据库。
create([kind])	创建数据库。

has_workload(mod:IRModule) → bool

检查数据库是否具有给定的工作负载。:param mod: 要搜索的 IRModule。:type mod: IRModule。

• 返回：result：数据库是否具有给定的工作负载。
• 返回类型：bool。

commit_workload(mod:IRModule) → Workload

如果缺失，则将工作负载提交到数据库。

• 参数：mod (IRModule)：要搜索或添加的 IRModule。
• 返回：workload：与给定 IRModule 对应的工作负载。
• 返回类型：Workload。

commit_tuning_record(record: TuningRecord) → None

将调整记录提交到数据库。

• 参数：record (TuningRecord)：要添加的调整记录。

get_top_k(workload: Workload, top_k:int) → List[TuningRecord]

从数据库中获取给定工作负载的前 K 条有效调优记录。

• 参数：
  • 工作负载（Workload） ：要搜索的工作负载。
  • top_k ( int ) ：要获取的顶级记录的数量。
• 返回：top_k_records：前 K 条记录。
• 返回类型： List[TuningRecord]。

get_all_tuning_records() → List[TuningRecord]

从数据库中获取所有调优记录。

• 返回：tuning_records：来自数据库的所有调整记录。
• 返回类型： List[TuningRecord]。

query_tuning_record(mod:IRModule, target:Target, workload_name:str) → TuningRecord | None

从数据库中查询给定工作量的最佳记录。

• 参数：
  • mod（IRModule） ：要搜索的 IRModule。
  • 目标（Target） ：要搜索的目标。
  • workload_name ( str ) ：要搜索的工作负载的名称。
• 返回：tuning_record：给定工作负载的最佳记录；如果未找到，则返回 None。
• 返回类型： Optional[TuningRecord]。

query_schedule(mod:IRModule, target:Target, workload_name:str) → Schedule | None

从数据库中查询给定工作负载的最佳调度。

• 参数：
  • mod（IRModule） ：要搜索的 IRModule。
  • 目标（Target） ： 要搜索的目标。
  • workload_name ( str ) ：要搜索的工作负载的名称。
• 返回：schedule：给定工作负载的最佳调度；如果未找到，则为 None。
• 返回类型： Optional[tvm.tir.Schedule]。

query_ir_module(mod:IRModule, target:Target, workload_name:str) → IRModule | None

从数据库中查询给定工作负载的最佳 IRModule。

• 参数：
  • mod（IRModule） ：要搜索的 IRModule。
  • 目标（Target） ： 要搜索的目标。
  • workload_name ( str ) ：要搜索的工作负载的名称。
• 返回：ir_module：给定工作负载的最佳 IRModule；如果未找到，则为 None。
• 返回类型： Optional[IRModule]。

dump_pruned(destination:Database) → None

将修剪后的数据库转储为 JSONDatabase 格式的文件。

• 参数：destination (Database)：要转储到的目标数据库。

query(mod:IRModule, target:Target, *, workload_name: str = 'main', kind: typing_extensions.Literal[schedule] | typing_extensions.Literal[record] | typing_extensions.Literal[ir_module] = 'schedule') → Schedule | IRModule | TuningRecord

查询数据库以检索给定工作负载的最佳优化结果。

• 参数：
  • mod（IRModule） ：要搜索的 IRModule。
  • 目标（Target） ： 要搜索的目标。
  • kind（str =“schedule”|“record”|“ir_module”）： 要返回的优化结果的类型。
• 返回：result ： 给定工作负载的最佳优化结果。
• 返回类型： Union[tvm.tir.Schedule, IRModule, TuningRecord]。

static current() → Database | None

获取范围内的当前数据库。

static create(kind: typing_extensions.Literal[json, memory, union, ordered_union] |Callable[[Schedule],bool] = 'json', args*, **kwargs) → Database

创建数据库。

• 参数：
  • kind (str = "json"|"memory"|"union"|"ordered_union"|Callable*[***[tvm.tir.Schedule**],)。
  • bool ：要创建的数据库类型。支持以下类型：“json”、“memory”、“union”、“ordered_union”和自定义调度函数。
• 返回：database：创建的数据库。
• 返回类型：Database。

class tvm.meta_schedule.ExtractedTask(task_name:str, mod:IRModule, target:Target, dispatched:List[IRModule], weight:int)

从高级 IR 中提取的调优任务。

• 参数：
  • task_name ( str ) ：提取的任务名称。
  • mod ( IRModule ) ：高级 IR。
  • 目标（Target） ： 目标信息。
  • dispatched( List[IRModule] ) ：高级 IR 可能分派到的低级 IR 列表。
  • weight（int） ：任务的权重。

class tvm.meta_schedule.FeatureExtractor

从测量候选中提取特征以用于成本模型。

方法：

extract_from(context, candidates)	从给定的测量候选中提取特征。
create(kind, *args, **kwargs)	创建一个 CostModel。

extract_from(context:TuneContext, candidates:List[MeasureCandidate]) → List[NDArray]

从给定的测量候选中提取特征。

• 参数：
  • context（TuneContext）：特征提取的调整上下文。
  • candidates（列表[ MeasureCandidate]）：从中提取特征的测量 candidates。
• 返回：features ： tvm ndarray 提取的特征。
• 返回类型： List[NDArray]。

static create(kind: typing_extensions.Literal[per - store - feature], args*, **kwargs) → FeatureExtractor

创建一个 CostModel。

class tvm.meta_schedule.MeasureCallback

测量结果出来后适用的规则可用。

方法：

apply(task_scheduler, task_id, …)	将测量回调应用于给定的调度。
create(kind)	创建测量回调列表。

apply(task_scheduler:TaskScheduler, task_id:int, measure_candidates:List[MeasureCandidate], builder_results:List[BuilderResult], runner_results:List[RunnerResult]) → None

将测量回调应用于给定的调度。

• 参数：
  • task_scheduler（TaskScheduler） ：任务调度程序。
  • task_id ( int ) ： 任务 ID。
  • measure_candidates ( List[MeasureCandidate] ) ：测量候选对象。
  • builder_results ( List[BuilderResult] ) ： 通过构建度量候选来获得构建器结果。
  • runner_results ( List[RunnerResult] ) ： 通过运行构建的测量候选结果来获得运行器的结果。

static create(kind: typing_extensions.Literal[default]) → List[MeasureCallback]

创建测量回调列表。

class tvm.meta_schedule.Mutator

Mutator 旨在改变轨迹以探索设计空间。

方法：

apply(trace)	将变异函数应用于给定的跟踪。
clone()	克隆变异器。
create(kind)	创建默认变量列表。

apply(trace:Trace) → Trace | None

将变异函数应用于给定的跟踪。

• 参数：trace (Trace)：给定的突变轨迹。
• 返回：trace：如果变异器失败则返回 None，否则返回变异的跟踪。
• 返回类型： Optional[Trace]。

clone() → Mutator

克隆变异器。

• 返回：mutator：–已克隆的 mutator。
• 返回类型：Mutator。

static create(kind: typing_extensions.Literal[llvm, cuda, cuda - tensorcore, hexagon]) → Dict[Mutator, float]

创建默认变量列表。

• 参数：kind (Literal["llvm", "cuda","cuda-tensorcore", "hexagon"])：tensorcore” ，“hexagon”） ： 变量的种类。
• 返回：mutators：修改器列表。
• 返回类型： List[Mutator]。

class tvm.meta_schedule.Postproc

将后处理器应用于调度的规则。

方法：

apply(sch)	将后处理器应用于给定的调度。
clone()	克隆后处理器。
create(kind)	创建默认后处理器列表。

apply(sch:Schedule) → bool

将后处理器应用于给定的调度。

• 参数：sch (tvm.tir.Schedule)： 需要进行后期处理的调度。
• 返回：result：后处理器是否成功应用。
• 返回类型：bool。

clone() → Postproc

克隆后处理器。

• 返回：cloned_postproc：克隆的后处理器。
• 返回类型：Postproc。

static create(kind: typing_extensions.Literal[llvm, cuda, cuda - tensorcore, hexagon]) → List[Postproc]

创建默认后处理器列表。

• 参数：kind (Literal*["llvm", *"cuda","cuda-tensorcore", "hexagon"**])*：tensorcore” ，“hexagon”） ：后处理器的种类。
• 返回：postprocs：后处理器列表。
• 返回类型： List[Mutator]。

class tvm.meta_schedule.Profiler

调整时间分析器。

方法：

get()	几秒钟内即可获得分析结果。
table()	以表格形式获取分析结果。
current()	获取当前分析器。
timeit(name)	Timeit 代码块。

get() → Dict[str, float]

几秒钟内即可获得分析结果。

table() → str

以表格形式获取分析结果。

static current() → Profiler | None

获取当前分析器。

static timeit(name:str)

Timeit 代码块。

class tvm.meta_schedule.Runner

抽象运行器接口。

方法：

run(runner_inputs)	运行构建的工件并获取运行器未来。
create([kind])	创建一个 Runner。

run(runner_inputs:List[RunnerInput]) → List[RunnerFuture]

运行构建的工件并获取运行器未来。

• 参数：runner_inputs (List[RunnerInput])： 运行器的输入。
• 返回：runner_futures：运行器的未来。
• 返回类型： List[RunnerFuture]

static create(kind: typing_extensions.Literal[local, rpc] = 'local', args*, **kwargs) → Runner

创建一个 Runner。

class tvm.meta_schedule.ScheduleRule

修改调度中的块的规则。

方法：

apply(sch, block)	将调度规则应用于给定调度中的特定块。
clone()	深度克隆调度规则。
create(kind)	为给定类型创建调度规则列表。

apply(sch:Schedule, block:BlockRV) → List[Schedule]

将调度规则应用于给定调度中的特定块。

• 参数：
  • sch（tvm.tir.Schedule）：要修改的调度。
  • 块（BlockRV）：应用调度规则的特定块。
• 返回：design_spaces：应用调度规则生成的调度列表。
• 返回类型： List[tvm.tir.Schedule]。

clone() → ScheduleRule

深度克隆调度规则。

• 返回：cloned_rule：克隆的调度规则。
• 返回类型：ScheduleRule。

static create(kind: typing_extensions.Literal[llvm, cuda, cuda - tensorcore, hexagon]) → List[ScheduleRule]

为给定类型创建调度规则列表。

• 参数：kind (Literal*["llvm", *"cuda","cuda-tensorcore", "hexagon"**])：tensorcore"* ,"hexagon"]） ：调度规则的种类。
• 返回：rules：调度规则列表。
• 返回类型： List[ScheduleRule]。

class tvm.meta_schedule.MeasureCandidate(sch:Schedule, args_info:List[ArgInfo])

衡量候选类别。

• 参数：
  • sch（tvm.tir.Schedule）：要测量的调度。
  • args_info ( List[ArgInfo] ) ：参数信息。

class tvm.meta_schedule.SearchStrategy

搜索策略是生成度量候选的类。

方法：

pre_tuning(max_trials, num_trials_per_iter, …)	预先调整搜索策略。
post_tuning()	对搜索策略进行后期调整。
generate_measure_candidates()	从设计空间生成测量候选以进行测量。
notify_runner_results(measure_candidates, …)	使用分析结果更新搜索策略。
clone()	克隆搜索策略。
create([kind])	创建搜索策略。

pre_tuning(max_trials:int, num_trials_per_iter:int, design_spaces:List[Schedule], database:Database|None= None, cost_model:CostModel|None= None) → None

预先调整搜索策略。

• 参数：
  • max_trials ( int ) ：最大试验次数。
  • num_trials_per_iter（int）： 每次迭代的试验次数。
  • design_spaces（List [tvm.tir.Schedule]）：调整过程中使用的设计空间。
  • 数据库（可选*[数据库] = 无） ： 调整过程中使用的数据库。
  • cost_model*（可选*[* CostModel]= None）：调整过程中使用的成本模型。

post_tuning() → None

对搜索策略进行后期调整。

generate_measure_candidates() → List[MeasureCandidate] | None

从设计空间生成测量候选以进行测量。

• 返回：measure_candidates ： 生成的测量候选，如果完成则为 None。
• 返回类型： Optional[List[IRModule]]。

notify_runner_results(measure_candidates:List[MeasureCandidate], results:List[RunnerResult]) → None

使用分析结果更新搜索策略。

• 参数：
  • measure_candidates ( List[MeasureCandidate] ) ：需要更新的测量候选。
  • results ( List[RunnerResult] ) ：来自运行器的分析结果。

clone() → SearchStrategy

克隆搜索策略。

• 返回：cloned：克隆的搜索策略。
• 返回类型：SearchStrategy。

static create(kind: typing_extensions.Literal[evolutionary, replay - trace, replay - func] = 'evolutionary', args*, **kwargs) → SearchStrategy

创建搜索策略。

class tvm.meta_schedule.SpaceGenerator

抽象设计空间生成器接口。

方法：

generate_design_space(mod)	给定一个模块生成设计空间。
clone()	克隆设计空间生成器。
create([kind])	创建一个设计空间生成器。

generate_design_space(mod:IRModule) → List[Schedule]

给定一个模块生成设计空间。

• 参数：mod (IRModule)：用于设计空间生成的模块。
• 返回：design_spaces：生成的设计空间，即调度。
• 返回类型： List[tvm.tir.Schedule]。

clone() → SpaceGenerator

克隆设计空间生成器。

• 返回：cloned_sg ： 克隆的设计空间生成器。
• 返回类型：SpaceGenerator。

static create(kind: typing_extensions.Literal[post - order - apply, union] | ~typing.Callable[[~tvm.tir.schedule.schedule.Schedule], None] | ~typing.Callable[[~tvm.tir.schedule.schedule.Schedule], ~tvm.tir.schedule.schedule.Schedule] | ~typing.Callable[[~tvm.tir.schedule.schedule.Schedule], ~typing.List[~tvm.tir.schedule.schedule.Schedule]] = 'post-order-apply', args*, **kwargs) → SpaceGenerator

创建一个设计空间生成器。

class tvm.meta_schedule.TaskScheduler

抽象任务调度程序接口。

方法：

next_task_id()	获取下一个任务 ID。
join_running_task(task_id)	等待任务完成。
tune(tasks, task_weights, max_trials_global, …)	自动调节。
terminate_task(task_id)	终止任务。
touch_task(task_id)	触摸任务并更新其状态。
print_tuning_statistics()	打印出人类可读的调整统计数据格式。
create([kind])	创建任务调度程序。

next_task_id() → int

获取下一个任务 ID。

• 返回：next_task_id：下一个任务 ID。
• 返回类型：int。

join_running_task(task_id:int) → List[RunnerResult]

等待任务完成。

• 参数：task_id (int)： 要加入的任务 ID。
• 返回：results：结果列表。
• 返回类型： List[RunnerResult]。

tune(tasks:List[TuneContext], task_weights:List[float], max_trials_global:int, max_trials_per_task:int, num_trials_per_iter:int, builder:Builder, runner:Runner, measure_callbacks:List[MeasureCallback], database:Database|None, cost_model:CostModel|None) → None

自动调节。

• 参数：
  • 任务( List [TuneContext]* ) ：作为任务的调整上下文列表。
  • task_weights（List [float]） ：任务权重列表。
  • max_trials_global ( int ) ：全局最大试验次数。
  • max_trials_per_task ( int ) ：每个任务的最大试验次数。
  • num_trials_per_iter（int）：每次迭代的试验次数。
  • builder（Builder）：构建器。
  • runner（Runner） ：运行器。
  • measure_callbacks ( List[MeasureCallback] ) ：测量回调列表。
  • 数据库*（可选*[数据库]） ：数据库。
  • cost_model*（可选*[ CostModel]）：成本模型。

terminate_task(task_id:int) → None

终止任务。

• 参数：task_id (int)*：*要终止的任务 ID。

touch_task(task_id:int) → None

触摸任务并更新其状态。

• 参数：task_id (int)：要检查的任务 ID。

print_tuning_statistics() → Noneprint_tuning_statistics)

打印出人类可读的调整统计数据格式。

static create(kind: typing_extensions.Literal[round - robin, gradient] = 'gradient', args*, **kwargs) → TaskScheduler

创建任务调度程序。

tvm.meta_schedule.tune_tir(mod:IRModule|PrimFunc, target:str|Target, work_dir:str, max_trials_global:int, ***, max_trials_per_task: int | None = None, num_trials_per_iter: int = 64, builder: Builder | typing_extensions.Literal[local] = 'local', runner: Runner | typing_extensions.Literal[local, rpc] = 'local', database: Database | typing_extensions.Literal[json, memory] = 'json', cost_model: CostModel | typing_extensions.Literal[xgb, mlp, random] = 'xgb', measure_callbacks: List[MeasureCallback] | MeasureCallback | typing_extensions.Literal[default] = 'default', task_scheduler: Literal[gradient, round - robin] = 'gradient', space: Literal[post - order - apply, union] = 'post-order-apply', strategy: Literal[replay - func, replay - trace, evolutionary] = 'evolutionary', num_tuning_cores: typing_extensions.Literal[physical, logical] | int = 'physical', seed: int | None = None, module_equality: str = 'structural', special_space: Literal[post - order - apply, union]] | None = None, post_optimization: bool | None = False) → Database

调整 TIR 函数或 TIR 函数的 IRModule。

• 参数：
  • mod ( Union[ir.IRModule,tir.PrimFunc] ) ：要调整的 TIR IRModule。
  • target ( Union[str,Target] ) ：需要调整的目标。
  • work_dir ( str ) ： 工作目录。
  • max_trials_global ( int ) ：全局运行的最大试验次数。
  • max_trials_per_task*（可选*[ int]）：每个任务运行的最大试验次数。
  • num_trials_per_iter ( int ) ： 每次迭代运行的试验次数
  • builder（Builder.BuilderType） ： 构建骑。
  • runner（Runner.RunnerType） ： 运行器。
  • 数据库（Database.DatabaseType） ： 数据库。
  • cost_model（CostModel.CostModelType）：成本模型。
  • measure_callbacks ( MeasureCallback.CallbackListType ) ：测量回调。
  • task_scheduler ( TaskScheduler.TaskSchedulerType ) ： 任务调度程序。
  • 空间（SpaceGenerator.SpaceGeneratorType） ： 空间生成器。
  • 策略（SearchStrategy.SearchStrategyType） ： 搜索策略。
  • num_tuning_cores ( Union[Literal["physical","logical"],int] ) ： 调整期间要使用的 CPU 核心数。
  • seed*（可选*[ int]）： 随机数生成器的种子。
  • module_equality (可选[str] ) ： 用于指定模块相等性测试和散列方法的字符串。
  • special_space (可选[Mapping[str,SpaceGenerator.SpaceGeneratorType]] ) ：从任务名称到该任务的特殊空间生成器的映射。
• 返回：database：包含所有调优记录的数据库。
• 返回类型：Database。

tvm.meta_schedule.tune_tasks(***, tasks: List[TuneContext], task_weights: List[float], work_dir: str, max_trials_global: int, max_trials_per_task: int | None = None, num_trials_per_iter: int = 64, builder: Builder | typing_extensions.Literal[local] = 'local', runner: Runner | typing_extensions.Literal[local, rpc] = 'local', database: Database | typing_extensions.Literal[json, memory] = 'json', cost_model: CostModel | typing_extensions.Literal[xgb, mlp, random] = 'xgb', measure_callbacks: List[MeasureCallback] | MeasureCallback | typing_extensions.Literal[default] = 'default', task_scheduler: Literal[gradient, round - robin] = 'gradient', module_equality: str = 'structural', post_optimization: bool | None = False) → Database

调整任务列表。使用任务调度程序。

• 参数：
• 任务*（列表*[ TuneContext]） ：要调整的任务列表。
• task_weights（List [float]）：每个任务的权重。
• work_dir ( str ) ：工作目录。
• max_trials_global ( int ) ： 全局运行的最大试验次数。
• max_trials_per_task**（可选*[ int]）： 每个任务运行的最大试验次数。
• num_trials_per_iter ( int ) ：每次迭代运行的试验次数
• builder（Builder.BuilderType） ： 构建器。
• runner（Runner.RunnerType） ：运行器。
• 数据库（Database.DatabaseType） ： 数据库。
• cost_model（CostModel.CostModelType）： 成本模型。
• measure_callbacks ( MeasureCallback.CallbackListType ) ： 测量回调。
• task_scheduler ( TaskScheduler.TaskSchedulerType ) ：任务调度程序。
• module_equality（可选[ str]）：用于指定模块相等性测试和哈希方法的字符串。它必须是以下之一：
• 结构化：使用 StructuralEqual/Hash。
• “ignore–ndarray”：与“structural”相同，但在相等时忽略 ndarray 原始数据。

测试和散列。

• “anchor–block”：对从中提取的锚块进行相等性测试和哈希处理

给定模块。“ignore–ndarray”变量用于提取的块或未找到锚块的情况。有关锚块的定义，请参阅 tir/analysis/analysis.py。

• post_optimization（可选[布尔值]）：使用 Droplet Search 作为利用空间生成后优化。
• 返回：database：包含所有调优记录的数据库。
• 返回类型：Database。

class tvm.meta_schedule.TuneContext(mod:IRModule|None= None, *, target: Target | str | None = None, space_generator: SpaceGenerator.SpaceGeneratorType | None = None, search_strategy: SearchStrategy.SearchStrategyType | None = None, task_name: str = 'main', rand_state: int = -1, num_threads: int | typing_extensions.Literal[physical, logical] = 'physical', logger: Logger | None = None)

调整上下文类旨在包含调整任务的所有资源。

• 参数：
  • mod*（可选*[ IRModule]= None） ：要优化的工作负载。
  • 目标*（可选*[目标] = 无） ： 要优化的目标。
  • space_generator ( Union[None,ScheduleFnType,SpaceGenerator]= None ) ： 设计空间生成器。
  • search_strategy ( Union[None,SearchStrategy]= None ) ：搜索策略。如果为 None ，则策略留空。
  • task_name*（可选*[ str]= None）：调整任务的名称。
  • logger（logging.Logger） ： 用于调整任务的记录器。
  • rand_state ( int = –1 ) ：随机状态。需为 [1, 2^31–1] 范围内的整数，–1 表示使用随机数。
  • num_threads（int = None）：要使用的线程数，None 表示使用逻辑 CPU 数量。

方法：

generate_design_space()	给定一个模块生成设计空间。
pre_tuning(max_trials[, …])	在调整之前，SearchStrategy 需要调用的方法来做必要的准备。
post_tuning()	调用 SearchStrategy 进行调整后必要清理的方法。
generate_measure_candidates()	从设计空间中生成一批测量候选对象以供测量。
notify_runner_results(measure_candidates, …)	使用分析结果更新 SearchStrategy 中的状态。
clone()	克隆 TuneContext。

generate_design_space() → List[Schedule]

给定一个模块生成设计空间。

使用 self.mod 委托给 self.space_generator.generate_design_space

• 返回：design_spaces ： 生成的设计空间，即调度。
• 返回类型： List[tvm.tir.Schedule]。

pre_tuning(max_trials:int, num_trials_per_iter:int= 64, design_spaces:List[Schedule] |None= None, database:Database|None= None, cost_model:CostModel|None= None) → None

在调整之前，SearchStrategy 需要调用的方法来做必要的准备。

委托给 self.search_strategy.pre_tuning。

• 参数：
  • max_trials ( int ) ： 要执行的最大试验次数。
  • num_trials_per_iter（int = 64）：每次迭代要执行的试验次数。
  • design_spaces ( Optional[List[tvm.tir.Schedule]] )：调优过程中使用的设计空间。若为 None，则使用self.generate_design_space()的结果。
  • database*（可选*[ Database]= None）：调优过程中使用的数据库。如果为 None 且搜索策略为 EvolutionarySearch，则使用 tvm.meta_schedule.database.MemoryDatabase。
  • cost_model (可选[CostModel]= None ) ：调优过程中使用的成本模型。如果为 None，且搜索策略为 EvolutionarySearch，则使用tvm.meta_schedule.cost_model.RandomModel。

post_tuning() → None

调用 SearchStrategy 进行调整后必要清理的方法。

委托给 self.search_strategy.post_tuning。

generate_measure_candidates() → List[MeasureCandidate] | None

从设计空间中生成一批测量候选对象以供测量。

委托给 self.search_strategy.generate_measure_candidates。

• 返回：measure_candidates：生成的测量候选，如果搜索完成则为 None。
• 返回类型： Optional[List[IRModule]]。

notify_runner_results(measure_candidates:List[MeasureCandidate], results:List[RunnerResult]) → None

使用分析结果更新 SearchStrategy 中的状态。

委托给 self.search_strategy.notify_runner_results。

• 参数：
  • measure_candidates ( List[MeasureCandidate] ) ： 需要更新的测量候选。
  • results ( List[RunnerResult] ) ：来自运行器的分析结果。

clone() → TuneContext

克隆 TuneContext。

• 返回：cloned_context：克隆的 TuneContext。
• 返回类型：TuneContext。

tvm.meta_schedule.derived_object(cls:type) → type

用于为 TVM 对象注册派生子类的装饰器。

• 参数：cls (type)：要注册的派生类。
• 返回：cls：装饰的 TVM 对象。
• 返回类型：type。

示例

@register_object("meta_schedule.PyRunner")
class _PyRunner(meta_schedule.Runner):
    def __init__(self, f_run: Callable = None):
        self.__init_handle_by_constructor__(_ffi_api.RunnerPyRunner, f_run)

class PyRunner:
    _tvm_metadata = {
        "cls": _PyRunner,
        "methods": ["run"]
    }
    def run(self, runner_inputs):
        raise NotImplementedError

@derived_object
class LocalRunner(PyRunner):
    def run(self, runner_inputs):
        ...