tvm.meta_schedule

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

类：

`Builder`	抽象的构建器接口。
`CostModel`	成本模型。
`数据库`	抽象数据库接口。
`ExtractedTask`(task_name, mod, target, ...)	从高级IR中提取的调优任务
`FeatureExtractor`	从候选测量中提取特征，用于成本模型。
`MeasureCallback`	在测量结果可用后应用的规则。
`Mutator`	Mutator 旨在通过变异跟踪来探索设计空间。
`Postproc`	将后处理器应用于调度表的规则。
`性能分析器`()	调优时间分析器。
`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`(*, 任务列表, 任务权重, 工作目录, ...)	调优任务列表。
`derived_object`(cls)	一个装饰器，用于为TVM对象注册派生子类。

class tvm.meta_schedule.Builder

抽象的构建器接口。

方法：

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

build(build_inputs: 列表[BuilderInput]) → 列表[BuilderResult]

构建给定的输入。

Parameters:: build_inputs (List[BuilderInput]) – 需要构建的输入项。
Returns:: build_results – 构建给定输入的结果。
Return type:: 列表[构建结果]

static create(kind: typing_extensions.Literal[local] = 'local', *args, **kwargs) → 构建器

创建一个构建器。

Parameters:: kind (Literal["local"]) – 构建器的类型。目前仅支持"local"。
Returns:: builder – 创建的构建器。
Return type:: Builder

class tvm.meta_schedule.CostModel

成本模型。

方法：

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

load(path: str) → None

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

Parameters:: path (str) – 文件路径。

save(path: str) → None

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

Parameters:: path (str) – 文件路径。

update(context: TuneContext, candidates: 列表[MeasureCandidate], results: 列表[RunnerResult]) → None

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

Parameters:

context (TuneContext,) – 调优上下文。
candidates (List[MeasureCandidate]) – 测量候选列表。
results (List[RunnerResult]) – 测量候选者的运行结果。

predict(context: TuneContext, candidates: 列表[MeasureCandidate]) → ndarray

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

Parameters:

context (TuneContext,) – 调优上下文。
candidates (List[MeasureCandidate]) – 测量候选列表。

Returns:

result – 预测的归一化分数。

Return type:

np.ndarray

static create(kind: typing_extensions.Literal[xgb, mlp, random, none], *args, **kwargs) → 成本模型

创建一个成本模型。

Parameters:: kind (Literal["xgb", "mlp", "random", "none"]) – 成本模型的类型。可以是 "xgb"、"mlp"、"random" 或 "none"。
Returns:: cost_model – 创建的成本模型。
Return type:: 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

Returns:: result – 数据库是否包含给定的工作负载。
Return type:: bool

commit_workload(mod: IRModule) → Workload

如果缺失，向数据库提交工作负载。

Parameters:: mod (IRModule) – 要搜索或添加的IRModule。
Returns:: workload – 对应给定IRModule的工作负载。
Return type:: Workload

commit_tuning_record(record: TuningRecord) → None

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

Parameters:: record (TuningRecord) – 要添加的调优记录。

get_top_k(workload: Workload, top_k: int) → 列表[TuningRecord]

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

Parameters:

workload (Workload) – 要搜索的工作负载。
top_k (int) – 要获取的顶部记录数量。

Returns:

top_k_records – 前K条记录。

Return type:

列表[调优记录]

get_all_tuning_records() → 列表[TuningRecord]

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

Returns:: tuning_records – 数据库中的所有调优记录。
Return type:: 列表[调优记录]

query_tuning_record(mod: IRModule, target: 目标, workload_name: str) → TuningRecord | None

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

Parameters:

mod (IRModule) – 要搜索的IRModule。
target (Target) – 要搜索的目标。
workload_name (str) – 要搜索的工作负载名称。

Returns:

tuning_record – 给定工作负载的最佳记录；如果未找到则为None。

Return type:

可选[调优记录]

query_schedule(mod: IRModule, target: 目标, workload_name: str) → 调度 | None

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

Parameters:

mod (IRModule) – 要搜索的IRModule。
target (Target) – 要搜索的目标对象。
workload_name (str) - 要搜索的工作负载名称。

Returns:

schedule – 给定工作负载的最佳调度；如果未找到则为None。

Return type:

可选[tvm.tir.Schedule]

query_ir_module(mod: IRModule, target: 目标, workload_name: str) → IRModule | None

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

Parameters:

mod (IRModule) – 要搜索的IRModule。
target (Target) – 要搜索的目标对象。
workload_name (str) – 要搜索的工作负载名称。

Returns:

ir_module – 给定工作负载的最佳IRModule；如果未找到则为None。

Return type:

可选[IRModule]

dump_pruned(destination: 数据库) → None

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

Parameters:: destination (Database) – 要转储到的目标数据库。

query(mod: IRModule, target: 目标, *, workload_name: str = 'main', kind: typing_extensions.Literal[schedule] | typing_extensions.Literal[record] | typing_extensions.Literal[ir_module] = 'schedule') → 日程安排 | IRModule | TuningRecord

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

Parameters:

mod (IRModule) – 要搜索的IRModule。
target (Target) – 要搜索的目标。
kind (str = "schedule" | "record" | "ir_module") - 指定要返回的优化结果类型。

Returns:

result – 给定工作负载的最佳优化结果。

Return type:

联合[tvm.tir.Schedule, IRModule, TuningRecord]

static current() → 数据库 | None: 获取当前作用域下的数据库。

static create(kind: typing_extensions.Literal[json, memory, union, ordered_union] | 可调用[[调度], bool] = 'json', *args, **kwargs) → 数据库

创建一个数据库。

Parameters:

kind (str = "json" | "memory" | "union" | "ordered_union" | Callable[[tvm.tir.Schedule],)
bool] – 要创建的数据库类型。支持以下类型： "json"、"memory"、"union"、"ordered_union"以及自定义调度函数。

Returns:

database – 创建的数据库。

Return type:

Database

class tvm.meta_schedule.ExtractedTask(task_name: str, mod: IRModule, target: 目标, dispatched: 列表[IRModule], weight: int)

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

Parameters:

task_name (str) – 提取的任务名称
mod (IRModule) – 高级IR
target (Target) – 目标信息
dispatched (List[IRModule]) – 高层级IR可能调度到的低层级IR列表
weight (int) – 任务的权重

class tvm.meta_schedule.FeatureExtractor

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

方法：

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

extract_from(context: TuneContext, candidates: 列表[MeasureCandidate]) → 列表[NDArray]

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

Parameters:

context (TuneContext) – 用于特征提取的调优上下文。
candidates (List[MeasureCandidate]) – 用于提取特征的测量候选对象列表。

Returns:

features – 由tvm ndarray提取的特征。

Return type:

列表[NDArray]

static create(kind: typing_extensions.Literal[per - store - feature], *args, **kwargs) → FeatureExtractor: 创建一个成本模型。

class tvm.meta_schedule.MeasureCallback

在测量结果可用后应用的规则。

方法：

`apply`(task_scheduler, task_id, ...)	对给定的时间表应用一个测量回调。
`create`(kind)	创建一个测量回调列表。

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

对给定的调度应用一个测量回调。

Parameters:

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]) → 列表[MeasureCallback]: 创建一个测量回调列表。

class tvm.meta_schedule.Mutator

Mutator 旨在通过变异跟踪来探索设计空间。

方法：

`apply`(trace)	对给定的轨迹应用变异函数。
`clone`()	克隆变异器。
`create`(kind)	创建一个默认变异器列表。

apply(trace: 追踪) → 追踪 | None

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

Parameters:: trace (Trace) – 用于变异的给定追踪记录。
Returns:: trace – 如果变异器失败则为None，否则返回变异后的trace。
Return type:: 可选[Trace]

clone() → 变异器

克隆变异器。

Returns:: mutator – 克隆的变异器。
Return type:: Mutator

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

创建一个默认变异器列表。

Parameters:: kind (Literal["llvm", "cuda", "cuda-tensorcore", "hexagon"]) – 变异器的类型。
Returns:: mutators - 变异器列表。
Return type:: 列表[Mutator]

class tvm.meta_schedule.Postproc

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

方法：

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

apply(sch: 日程安排) → bool

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

Parameters:: sch (tvm.tir.Schedule) – 需要进行后处理的调度表。
Returns:: result – 后处理器是否成功应用。
Return type:: bool

clone() → 后处理

克隆后处理器。

Returns:: cloned_postproc – 克隆的后处理器。
Return type:: Postproc

static create(kind: typing_extensions.Literal[llvm, cuda, cuda - tensorcore, hexagon]) → 列表[后处理]

创建默认后处理器的列表。

Parameters:: kind (Literal["llvm", "cuda", "cuda-tensorcore", "hexagon"]) – 后处理器的类型。
Returns:: postprocs – 后处理器列表。
Return type:: 列表[Mutator]

class tvm.meta_schedule.Profiler

调优时间分析器。

方法：

`get`()	在几秒钟内获取性能分析结果
`table`()	以表格格式获取性能分析结果
`current`()	获取当前的分析器。
`timeit`(name)	对代码块进行计时

get() → Dict[str, 浮点数]: 在几秒钟内获取性能分析结果

table() → str: 以表格格式获取性能分析结果

static current() → 性能分析器 | None: 获取当前分析器。

static timeit(name: str): 对代码块进行计时

class tvm.meta_schedule.Runner

抽象运行器接口

方法：

`run`(runner_inputs)	运行构建产物并获取运行器未来对象。
`create`([kind])	创建一个运行器。

run(runner_inputs: 列表[RunnerInput]) → 列表[RunnerFuture]

运行构建产物并获取运行器未来对象。

Parameters:: runner_inputs (List[RunnerInput]) – runner的输入参数。
Returns:: runner_futures – 运行器期货。
Return type:: List[RunnerFuture]

static create(kind: typing_extensions.Literal[local, rpc] = 'local', *args, **kwargs) → Runner: 创建一个运行器。

class tvm.meta_schedule.ScheduleRule

修改调度中区块的规则。

方法：

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

apply(sch: 日程安排, block: BlockRV) → 列表[日程安排]

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

Parameters:

sch (tvm.tir.Schedule) – 需要被修改的调度计划。
block (BlockRV) - 应用调度规则的具体块。

Returns:

design_spaces – 应用调度规则生成的调度列表。

Return type:

列表[tvm.tir.Schedule]

clone() → ScheduleRule

深度克隆调度规则。

Returns:: cloned_rule – 克隆的调度规则。
Return type:: ScheduleRule

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

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

Parameters:: kind (Literal["llvm", "cuda", "cuda-tensorcore", "hexagon"]) – 调度规则的类型。
Returns:: rules – 调度规则列表。
Return type:: 列表[ScheduleRule]

class tvm.meta_schedule.MeasureCandidate(sch: 日程安排, args_info: 列表[ArgInfo])

测量候选类。

Parameters:

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: 列表[日程安排], database: 数据库 | None = None, cost_model: 成本模型 | None = None) → None

搜索策略的预调优。

Parameters:

max_trials (int) – 最大试验次数。
num_trials_per_iter (int) – 每次迭代的试验次数。
design_spaces (List[tvm.tir.Schedule]) – 调优过程中使用的设计空间。
database (可选[Database] = None) – 调优过程中使用的数据库。
cost_model (Optional[CostModel] = None) – 调优过程中使用的成本模型。

post_tuning() → None: 搜索策略的后调优。

generate_measure_candidates() → 列表[MeasureCandidate] | None

从设计空间生成测量候选方案用于测量。

Returns:: measure_candidates – 生成的测量候选方案，如果已完成则为None。
Return type:: 可选[List[IRModule]]

notify_runner_results(measure_candidates: 列表[MeasureCandidate], results: 列表[RunnerResult]) → None

根据性能分析结果更新搜索策略。

Parameters:

measure_candidates (List[MeasureCandidate]) – 待更新的测量候选列表。
results (List[RunnerResult]) – 来自运行器的性能分析结果。

clone() → SearchStrategy

克隆搜索策略。

Returns:: cloned – 克隆的搜索策略。
Return type:: 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) → 列表[日程安排]

根据给定模块生成设计空间。

Parameters:: mod (IRModule) – 用于设计空间生成的模块。
Returns:: design_spaces – 生成的设计空间，即调度方案。
Return type:: 列表[tvm.tir.Schedule]

clone() → SpaceGenerator

克隆设计空间生成器。

Returns:: cloned_sg – 克隆的设计空间生成器。
Return type:: 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。

Returns:: next_task_id – 下一个任务ID。
Return type:: int

join_running_task(task_id: int) → 列表[RunnerResult]

等待任务完成。

Parameters:: task_id (int) – 要加入的任务ID。
Returns:: results – 结果列表。
Return type:: 运行结果列表

tune(tasks: 列表[TuneContext], task_weights: 列表[浮点数], max_trials_global: int, max_trials_per_task: int, num_trials_per_iter: int, builder: 构建器, runner: Runner, measure_callbacks: 列表[MeasureCallback], database: 数据库 | None, cost_model: 成本模型 | None) → None

自动调优。

Parameters:

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]) – 数据库。
cost_model (可选[CostModel]) – 成本模型。

terminate_task(task_id: int) → None

终止任务

Parameters:: task_id (int) – 要终止的任务ID。

touch_task(task_id: int) → None

点击任务并更新其状态

Parameters:: task_id (int) – 需要检查的任务ID。

print_tuning_statistics() → None: 以人类可读的格式打印出调优统计信息。

static create(kind: typing_extensions.Literal[round - robin, gradient] = 'gradient', *args, **kwargs) → TaskScheduler: 创建一个任务调度器。

tvm.meta_schedule.tune_tir(mod: IRModule | PrimFunc, target: str | 目标, work_dir: str, max_trials_global: int, *, max_trials_per_task: int | None = None, num_trials_per_iter: int = 64, builder: 构建器 | typing_extensions.Literal[local] = 'local', runner: Runner | typing_extensions.Literal[local, rpc] = 'local', database: 数据库 | typing_extensions.Literal[json, memory] = 'json', cost_model: 成本模型 | typing_extensions.Literal[xgb, mlp, random] = 'xgb', measure_callbacks: 列表[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) → 数据库

调优一个TIR函数或TIR函数的IRModule。

Parameters:

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

Returns:

database – 包含所有调优记录的数据库

Return type:

Database

tvm.meta_schedule.tune_tasks(*, tasks: 列表[TuneContext], task_weights: 列表[浮点数], work_dir: str, max_trials_global: int, max_trials_per_task: int | None = None, num_trials_per_iter: int = 64, builder: 构建器 | typing_extensions.Literal[local] = 'local', runner: Runner | typing_extensions.Literal[local, rpc] = 'local', database: 数据库 | typing_extensions.Literal[json, memory] = 'json', cost_model: 成本模型 | typing_extensions.Literal[xgb, mlp, random] = 'xgb', measure_callbacks: 列表[MeasureCallback] | MeasureCallback | typing_extensions.Literal[default] = 'default', task_scheduler: Literal[gradient, round - robin] = 'gradient', module_equality: str = 'structural', post_optimization: bool | None = False) → 数据库

调优任务列表。使用任务调度器。

Parameters:

tasks (List[TuneContext]) – 需要调优的任务列表。
task_weights (List[float]) – 每个任务的权重。
work_dir (str) – 工作目录。
max_trials_global (int) – 全局运行的最大试验次数。
max_trials_per_task (Optional[int]) – 每个任务运行的最大试验次数。
num_trials_per_iter (int) – 每次迭代运行的试验次数
builder (Builder.BuilderType) – 构建器。
runner (Runner.RunnerType) – 运行器。
database (Database.DatabaseType) – 数据库。
cost_model (CostModel.CostModelType) – 成本模型。
measure_callbacks (MeasureCallback.CallbackListType) – 测量回调函数。
task_scheduler (TaskScheduler.TaskSchedulerType) – 任务调度器。
module_equality (可选[str]) –
用于指定模块相等性测试和哈希方法的字符串。必须是以下选项之一：
- "structural"：使用 StructuralEqual/Hash
- "ignore-ndarray"：与"structural"相同，但在相等性测试和哈希计算时忽略ndarray原始数据
- "anchor-block"：对从给定模块提取的锚块应用相等性测试和哈希计算。
  对于提取的块或在找不到锚块的情况下，使用"ignore-ndarray"变体。关于锚块的定义，请参见tir/analysis/analysis.py。
post_optimization (可选[布尔值]) – 使用Droplet Search作为探索空间生成后优化。

Returns:

database – 包含所有调优记录的数据库

Return type:

Database

class tvm.meta_schedule.TuneContext(mod: IRModule | None = None, *, 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)

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

Parameters:

mod (可选[IRModule] = None) – 待优化的工作负载。
target (可选[Target] = 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() → 列表[日程安排]

根据给定模块生成设计空间。

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

Returns:: design_spaces – 生成的设计空间，即调度方案。
Return type:: 列表[tvm.tir.Schedule]

pre_tuning(max_trials: int, num_trials_per_iter: int = 64, design_spaces: 列表[日程安排] | None = None, database: 数据库 | None = None, cost_model: 成本模型 | None = None) → None

SearchStrategy在调优前需要调用此方法进行必要的准备工作。

委托给self.search_strategy.pre_tuning。

Parameters:

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() → 列表[MeasureCandidate] | None

从设计空间生成一批测量候选方案用于测量。

委托给self.search_strategy.generate_measure_candidates。

Returns:: measure_candidates – 生成的测量候选方案，如果搜索已完成则为None。
Return type:: 可选[List[IRModule]]

notify_runner_results(measure_candidates: 列表[MeasureCandidate], results: 列表[RunnerResult]) → None

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

委托给 self.search_strategy.notify_runner_results。

Parameters:

measure_candidates (List[MeasureCandidate]) – 待更新的测量候选列表。
results (List[RunnerResult]) – 来自运行器的性能分析结果。

clone() → TuneContext

克隆TuneContext。

Returns:: cloned_context – 克隆的TuneContext。
Return type:: TuneContext

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

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

Parameters:: cls (type) – 要注册的派生类。
Returns:: cls – 被装饰的TVM对象。
Return type:: 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):
        ...