tvm.meta_schedule

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

类

`构建器`	抽象构建器接口。
`成本模型`	成本模型。
`数据库`	抽象数据库接口。
`ExtractedTask`(task_name, mod, target, ...)	从高层 IR 中提取的调优任务
`特征提取器`	从测量候选提取特征以用于成本模型的提取器。
`测量回调`	在测量结果可用后应用的规则。
`变异器`	变异器旨在变异 trace 以探索设计空间。
`后处理器`	将后处理器应用于调度的规则。
`性能分析器`()	调优时间性能分析器。
`运行器`	抽象运行器接口
`调度规则`	修改调度中 block 的规则。
`MeasureCandidate`(sch, args_info)	测量候选类。
`搜索策略`	搜索策略是生成测量候选的类。
`空间生成器`	抽象设计空间生成器接口。
`任务调度器`	抽象任务调度器接口。
`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 – 创建的构建器。
返回类型:: 构建器

class tvm.meta_schedule.CostModel

成本模型。

方法

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

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 (List[MeasureCandidate]) – 测量候选。
results (List[RunnerResult]) – 测量候选的运行结果。

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

使用成本模型预测归一化得分。

参数:

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

返回:

result – 预测的归一化得分。

返回类型:

np.ndarray

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

创建一个成本模型。

参数:: kind (Literal["xgb", "mlp", "random", "none"]) – 成本模型的种类。可以是 “xgb”、“mlp”、“random” 或 “none”。
返回:: cost_model – 创建的成本模型。
返回类型:: 成本模型

class tvm.meta_schedule.Database

抽象数据库接口。

方法

`has_workload`(mod)	检查数据库是否具有给定的 workload。
`commit_workload`(mod)	如果缺少 workload，则将其提交到数据库。
`commit_tuning_record`(record)	将调优记录提交到数据库。
`get_top_k`(workload, top_k)	从数据库中获取给定 workload 的前 K 个有效调优记录。
`get_all_tuning_records`()	从数据库中获取所有调优记录。
`query_tuning_record`(mod, target, workload_name)	从数据库中查询给定 workload 的最佳记录。
`query_schedule`(mod, target, workload_name)	从数据库中查询给定 workload 的最佳调度。
`query_ir_module`(mod, target, workload_name)	从数据库中查询给定 workload 的最佳 IRModule。
`dump_pruned`(destination)	将 pruned 数据库转储为 JSONDatabase 格式的文件。
`query`(mod, target, *[, workload_name, kind])	查询数据库以检索给定 workload 的最佳优化结果。
`current`()	获取当前作用域下的数据库。
`create`([kind])	创建一个数据库。

has_workload(mod: IRModule) → bool

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

返回:: result – 数据库是否具有给定的 workload。
返回类型:: bool

commit_workload(mod: IRModule) → Workload

如果缺少 workload，则将其提交到数据库。

参数:: mod (IRModule) – 要搜索或添加的 IRModule。
返回:: workload – 与给定 IRModule 相对应的 workload。
返回类型:: Workload

commit_tuning_record(record: TuningRecord) → None

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

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

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

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

参数:

workload (Workload) – 要搜索的 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

从数据库中查询给定 workload 的最佳记录。

参数:

mod (IRModule) – 要搜索的 IRModule。
target (Target) – 要搜索的目标。
workload_name (str) – 要搜索的 workload 的名称。

返回:

tuning_record – 给定 workload 的最佳记录；如果未找到，则为 None。

返回类型:

Optional[TuningRecord]

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

从数据库中查询给定 workload 的最佳调度。

参数:

mod (IRModule) – 要搜索的 IRModule。
target (Target) – 要搜索的目标。
workload_name (str) – 要搜索的 workload 的名称。

返回:

schedule – 给定 workload 的最佳调度；如果未找到，则为 None。

返回类型:

Optional[tvm.tir.Schedule]

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

从数据库中查询给定 workload 的最佳 IRModule。

参数:

mod (IRModule) – 要搜索的 IRModule。
target (Target) – 要搜索的目标。
workload_name (str) – 要搜索的 workload 的名称。

返回:

ir_module – 给定 workload 的最佳 IRModule；如果未找到，则为 None。

返回类型:

Optional[IRModule]

dump_pruned(destination: Database) → None

将 pruned 数据库转储为 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

查询数据库以检索给定 workload 的最佳优化结果。

参数:

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

返回:

result – 给定 workload 的最佳优化结果。

返回类型:

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] – 要创建的数据库的类型（kind）。支持以下类型：“json”、“memory”、“union”、“ordered_union”以及自定义的 schedule 函数。

返回:

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 (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: List[MeasureCandidate]) → List[NDArray]

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

参数:

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

返回:

features – 提取的特征 tvm ndarray。

返回类型:

List[NDArray]

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

class tvm.meta_schedule.MeasureCallback

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

方法

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

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

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

参数:

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

变异器旨在变异 trace 以探索设计空间。

方法

`apply`(trace)	将 mutator 函数应用于给定的 trace。
`clone`()	克隆 mutator。
`create`(kind)	创建默认 mutator 列表。

apply(trace: Trace) → Trace | None

将 mutator 函数应用于给定的 trace。

参数:: trace (Trace) – 给定的用于变异的 trace。
返回:: trace – 如果 mutator 失败则返回 None，否则返回变异后的 trace。
返回类型:: Optional[Trace]

clone() → Mutator

克隆 mutator。

返回:: mutator – 克隆的 mutator。
返回类型:: 变异器

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

创建默认 mutator 列表。

参数:: kind (Literal["llvm", "cuda", "cuda-tensorcore", "hexagon"]) – mutator 的类型。
返回:: mutators – mutator 列表。
返回类型:: List[Mutator]

class tvm.meta_schedule.Postproc

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

方法

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

apply(sch: Schedule) → bool

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

参数:: sch (tvm.tir.Schedule) – 要进行后处理的 schedule。
返回:: result – 后处理器是否成功应用。
返回类型:: bool

clone() → Postproc

克隆后处理器。

返回:: cloned_postproc – 克隆的后处理器。
返回类型:: 后处理器

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

创建默认后处理器列表。

参数:: kind (Literal["llvm", "cuda", "cuda-tensorcore", "hexagon"]) – 后处理器的类型。
返回:: postprocs – 后处理器列表。
返回类型:: List[Mutator]

class tvm.meta_schedule.Profiler

调优时间性能分析器。

方法

`get`()	以秒为单位获取性能分析结果
`table`()	以表格格式获取性能分析结果
`current`()	获取当前的性能分析器。
`timeit`(name)	对一段代码进行计时

get() → Dict[str, float]: 以秒为单位获取性能分析结果

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

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

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

class tvm.meta_schedule.Runner

抽象运行器接口

方法

`run`(runner_inputs)	运行构建的工件并获取运行器 futures。
`create`([kind])	创建 Runner。

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

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

参数:: runner_inputs (List[RunnerInput]) – Runner 的输入。
返回:: runner_futures – Runner futures。
返回类型:: List[RunnerFuture]

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

class tvm.meta_schedule.ScheduleRule

修改调度中 block 的规则。

方法

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

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

将 schedule rule 应用于给定 schedule 中的特定 block。

参数:

sch (tvm.tir.Schedule) – 要修改的 schedule。
block (BlockRV) – 应用 schedule rule 的特定 block。

返回:

design_spaces – 通过应用 schedule rule 生成的 schedule 列表。

返回类型:

List[tvm.tir.Schedule]

clone() → ScheduleRule

深度克隆 schedule rule。

返回:: cloned_rule – 克隆的 schedule rule。
返回类型:: 调度规则

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

为给定类型创建 schedule rule 列表。

参数:: kind (Literal["llvm", "cuda", "cuda-tensorcore", "hexagon"]) – schedule rule 的类型。
返回:: rules – schedule rule 列表。
返回类型:: List[ScheduleRule]

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

测量候选类。

参数:

sch (tvm.tir.Schedule) – 要测量的 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]) – 调优过程中使用的设计空间。
database (Optional[Database] = None) – 调优过程中使用的数据库。
cost_model (Optional[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]) – 来自 runner 的性能分析结果。

clone() → SearchStrategy

克隆搜索策略。

返回:: cloned – 克隆的搜索策略。
返回类型:: 搜索策略

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 – 生成的设计空间，即 schedule。
返回类型:: List[tvm.tir.Schedule]

clone() → SpaceGenerator

克隆设计空间生成器。

返回:: cloned_sg – 克隆的设计空间生成器。
返回类型:: 空间生成器

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

自动调优。

参数:

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

terminate_task(task_id: int) → None

终止任务

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

touch_task(task_id: int) → None

触发任务并更新其状态

参数:: 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 | 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 (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 (Optional[int]) – 随机数生成器的种子。
module_equality (Optional[str]) – 用于指定模块相等性测试和哈希方法的字符串。
special_space (Optional[Mapping[str, SpaceGenerator.SpaceGeneratorType]]) – 从任务名称到该任务的特殊空间生成器的映射。

返回:

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

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

参数:

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 (Optional[str]) –
用于指定模块相等性测试和哈希方法的字符串。它必须是以下选项之一
- “structural”：使用 StructuralEqual/Hash
- “ignore-ndarray”：与 “structural” 相同，但在相等性测试和哈希期间忽略 ndarray 原始数据。
  测试和哈希。
- “anchor-block”：对从给定模块中提取的锚定块应用相等性测试和哈希。“ignore-ndarray” 变量用于提取的块，或者在未找到锚定块的情况下使用。有关锚定块的定义，请参阅 tir/analysis/analysis.py。
  a given module. The “ignore-ndarray” varint is used for the extracted blocks or in case no anchor block is found. For the definition of the anchor block, see tir/analysis/analysis.py.
post_optimization (Optional[Bool]) – 使用 Droplet Search 生成后优化作为探索空间。

返回:

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 (Optional[IRModule] = None) – 要优化的工作负载。
target (Optional[Target] = None) – 要优化的目标。
space_generator (Union[None, ScheduleFnType, SpaceGenerator] = None) – 设计空间生成器。
search_strategy (Union[None, SearchStrategy] = None) – 搜索策略。如果为 None，则策略留空。
task_name (Optional[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.space_generator.generate_design_space，使用 self.mod

返回:: design_spaces – 生成的设计空间，即 schedule。
返回类型:: 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 (Optional[Database] = None) – 调优过程中使用的数据库。如果为 None，且搜索策略为 EvolutionarySearch，则使用 tvm.meta_schedule.database.MemoryDatabase。
cost_model (Optional[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]) – 来自 runner 的性能分析结果。

clone() → TuneContext

克隆 TuneContext。

返回:: cloned_context – 克隆的 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):
        ...