任务

class Task()

Task 类是任务对象的代码模板，它与其连接的实验组件一起，代表当前正在运行的实验。这些连接的组件包括超参数、记录器、配置、标签枚举、模型和其他工件。

术语“主执行任务”指的是当前运行实验的任务上下文。Python实验脚本可以创建一个，且只能创建一个主执行任务。它是可追踪的，脚本运行后，ClearML会将任务存储在ClearML服务器（后端）中，它是可修改的、可复现的、可由工作节点执行的，并且您可以复制它以进行进一步的实验。

Task 类及其方法允许您创建和管理实验，以及执行高级实验功能，例如 autoML。

warning

不要直接构造Task对象。使用下面列出的方法之一来创建实验或引用现有实验。不要定义CLEARML_TASK_*和CLEARML_PROC_*操作系统环境变量，它们用于进程和代理之间的内部记录。

有关创建任务对象的详细信息，请参阅以下方法：

创建一个新的可重复任务 - Task.init

important

在某些情况下，Task.init 可能会返回一个已经存储在 ClearML 服务器中的 Task 对象（已经初始化），而不是创建一个新的 Task。有关这些情况的详细解释，请参阅 Task.init 方法。

手动创建一个新任务（不适用自动记录） - Task.create
获取当前正在运行的任务 - Task.current_task
获取另一个（不同的）任务 - Task.get_task

info

ClearML 文档通常将任务称为“任务（实验）”。

“任务”指的是ClearML Python客户端包中的类，您的Python实验脚本中的对象，以及ClearML服务器和ClearML代理与之工作的实体。

“实验”指的是您的深度学习解决方案，包括其连接的组件、输入和输出，是您可以使用ClearML Web-App（UI）查看、分析、比较、修改、复制和管理的实验。

因此，“任务”实际上是一个“实验”，而“任务（实验）”涵盖了其在ClearML中的使用。

此任务行为的例外是子任务（不可复制的任务），它们不使用主执行任务。创建子任务总是会创建一个带有新任务ID的新任务。

warning

不要手动构建任务！请使用 Task.init 或 Task.get_task

任务.添加需求

classmethod add_requirements(package_name, package_version=None)

强制将包添加到需求列表中。如果package_version为None，则使用已安装的包版本（如果找到）。示例：Task.add_requirements(‘tensorflow’, ‘2.4.0’) 示例：Task.add_requirements(‘tensorflow’, ‘>=2.4’) 示例：Task.add_requirements(‘tensorflow’) -> 使用已安装的tensorflow版本示例：Task.add_requirements(‘tensorflow’, ‘’) -> 无版本限制或者，您可以从文件中添加所有需求。示例：Task.add_requirements(‘/path/to/your/project/requirements.txt’)

info

Task.add_requirements 不会直接修改任务的需求。相反，它提高了捕获任务的 Python 包的准确性。要显式更改任务需求，请使用 Task.set_packages，它会用指定的包覆盖现有的包。

参数
- package_name (str ) – 要添加到任务“已安装包”部分的包名称或需求文件的路径。
- package_version (Optional[str]) – 包的版本要求。如果为 None，则使用已安装的版本。
返回类型

None

添加标签

添加标签(tags)

为此任务添加标签。旧标签不会被删除。当远程执行任务（实验）时，此方法无效。

参数

tags (Union[Sequence[str], str]) – 描述要添加的任务的标签列表。
返回类型

None

工件

属性工件

一个只读的任务工件字典（名称，工件）。

返回类型

Dict[str, Artifact]
返回

制品。

缓存目录

属性 cache_dir

用于存储任务相关文件的缓存目录。

返回类型

Path

任务.clone

classmethod clone(source_task=None, name=None, comment=None, parent=None, project=None)

创建一个任务（实验）的副本（克隆）。克隆任务的初始状态为Draft，并且是可修改的。

使用此方法来管理实验和进行自动机器学习。

参数
- source_task (str ) – 要克隆的任务。指定一个任务对象或任务ID。（可选）
- name (str ) – 新克隆任务的名称。（可选）
- comment (str ) – 新克隆任务的注释/描述。（可选）
- parent (str ) – 新任务的父任务的ID。
  - 如果未指定parent，则parent设置为source_task.parent。
  - 如果未指定parent且source_task.parent不可用，则parent设置为source_task。
- 项目 (str ) – 要在其中创建新任务的项目ID。如果 None，新任务将继承原始任务的项目。（可选）
返回

新克隆的任务（实验）。
返回类型

任务

关闭

close()

关闭当前任务并将其状态更改为“已完成”。允许您从打开任务的进程中手动关闭任务。

此方法不会终止（当前）Python进程，与Task.mark_completed相反。

在Task.close关闭任务后，相应的对象将无法再使用，并且像Task.connect或Task.connect_configuration这样的方法将抛出ValueError。为了再次获得表示任务的对象，请使用像Task.get_task这样的方法。

warning

只有在确定不需要任务时才调用Task.close。

属性注释

返回当前任务的（用户定义的）注释。

返回类型

str

已完成

completed(ignore_errors=True)

info

已弃用，请改用 mark_completed(…)

返回类型

()
参数

ignore_errors (bool ) –

连接

connect(mutable, name=None, ignore_remote_overrides=False)

将一个对象连接到任务对象。这将实验组件（实验的一部分）连接到实验中。例如，实验组件可以是包含一些超参数的有效对象，或者是一个Model。在远程运行时，连接对象的值会被实验的UI/后端中找到的相应值覆盖（除非ignore_remote_overrides为True）。

参数
- mutable (object) – 要连接的实验组件。对象必须是以下类型之一：
  - argparse - 用于参数的argparse对象。
  - dict - 参数的字典。注意：仅支持类型为str的键。
  - TaskParameters - 一个TaskParameters对象。
  - Model - 用于初始模型预热或模型更新/快照上传的模型对象。实际上，模型应该是InputModel或OutputModel。
  - type - 一个类类型，存储所有类属性（不包括以“_”为前缀的属性）。
  - object - 一个类实例，存储所有实例属性（不包括以 '_' 开头的属性）。
- name (str ) – 与连接对象关联的部分名称，如果‘name’为None，则默认为‘General’ 目前，name仅支持字典和TaskParameter对象，对于其他支持的类型应省略。（可选）例如，通过设置name=’General’，连接的字典将位于超参数部分的General部分。而通过设置name=’Train’，连接的字典将位于超参数部分的Train部分。
- ignore_remote_overrides (bool) – 如果为True，在远程运行时忽略UI/后端的覆盖。
返回类型

任何

默认值为False，意味着在UI/后端所做的任何更改将在远程执行中应用。

返回类型

Any
返回

它将返回作为可变参数传递给方法的相同对象，除非对象的类型是字典。对于字典，Task.connect 将返回装饰为 ProxyDictPostWrite 的字典。这样做是为了允许从连接的对象传播更新。
Improvement

If an unsupported object is passed, an exception will be raised.
参数
- 可变的 (任意 ) –
- name (可选 [ str ] ) –
- ignore_remote_overrides (bool ) –

连接配置

connect_configuration(configuration, name=None, description=None, ignore_remote_overrides=False)

将配置字典或配置文件（pathlib.Path / str）连接到任务对象。在读取配置文件之前应调用此方法。

例如，一个本地文件：

config_file = task.connect_configuration(config_file)
my_params = json.load(open(config_file,'rt'))

一个参数字典/列表：

my_params = task.connect_configuration(my_params)

在远程运行时，连接的配置值会被实验的UI/后端中找到的相应值覆盖（除非ignore_remote_overrides为True）。

参数
- 配置 (Union[Mapping, list, Path, str]) – 配置。这通常是用于模型训练过程中的配置。
  
  指定以下之一：
  - 一个字典/列表 - 包含配置的字典。ClearML 将配置存储在
  ClearML 服务器 (后端), 以 HOCON 格式 (类似 JSON 的格式) 可编辑。
  - 一个 pathlib2.Path 字符串 - 配置文件的路径。ClearML 存储文件的内容。
  本地路径必须是相对路径。当在远程工作节点上执行任务时，从ClearML服务器（后端）带来的内容会覆盖文件的内容。
- name (str ) – 配置部分的名称。默认值：'General' 允许用户存储多个配置字典/文件
- 描述 (str ) – 配置部分的描述（文本）。默认值：无
- ignore_remote_overrides (bool ) – 如果为True，在远程运行时忽略UI/后端的覆盖。
返回类型

Union[字典, pathlib2.Path, 字符串]

默认值为False，意味着在UI/后端所做的任何更改将在远程执行中应用。

返回类型

Union[dict, Path, str]
返回

如果指定了字典，则返回一个字典。如果指定了pathlib2.Path / 字符串，则返回本地配置文件的路径。配置对象。
参数
- 配置 (联合 [ 映射 *, * 列表 *, * pathlib2.Path *, * 字符串 ] ) –
- name (可选 [ str ] ) –
- 描述 (可选 [ 字符串 ] ) –
- ignore_remote_overrides (bool ) –

connect_label_enumeration

connect_label_enumeration(enumeration, ignore_remote_overrides=False)

将标签枚举字典连接到任务（实验）对象。

稍后，当创建输出模型时，模型将包含标签枚举字典。

参数
- enumeration (dict ) – A label enumeration dictionary of string (label) to integer (value) pairs.
例如：
```
{
     "background": 0,
     "person": 1
}
```
- ignore_remote_overrides (bool) – If True, ignore UI/backend overrides when running remotely. Default is False, meaning that any changes made in the UI/backend will be applied in remote execution.
返回类型

Dict[str, int]
返回

标签枚举字典（JSON）。

任务创建

classmethod create(project_name=None, task_name=None, task_type=None, repo=None, branch=None, commit=None, script=None, working_directory=None, packages=None, requirements_file=None, docker=None, docker_args=None, docker_bash_setup_script=None, argparse_args=None, base_task_id=None, add_task_init_call=True, force_single_script_file=False)

在系统中手动创建并填充一个新的任务（实验）。如果代码中尚未包含对Task.init的调用，请传递add_task_init_call=True，代码将在远程执行时（即由clearml-agent执行时）进行修补。

info

此方法始终创建一个新的任务。使用 Task.init 方法自动为正在运行的进程创建并填充任务。要引用现有的任务，请调用 Task.get_task 方法。

参数
- project_name (Optional[str]) – 设置任务的名称。如果 base_task_id 为 None，则必须设置。
- task_name (Optional[str]) – 设置远程任务的名称。如果 base_task_id 为 None，则必须设置。
- task_type (Optional[str]) – 可选，要创建的任务类型。支持的值：'training', 'testing', 'inference', 'data_processing', 'application', 'monitor', 'controller', 'optimizer', 'service', 'qc', 'custom'
- repo (Optional[str]) – 要使用的仓库的远程URL，或本地git仓库的路径。示例：'https://github.com/allegroai/clearml.git' 或 '~/project/repo'。如果指定了repo，则还必须指定script参数
- branch (Optional[str]) – 选择特定的仓库分支/标签（意味着从该分支获取最新的提交）
- commit (Optional[str]) – 选择特定的提交ID使用（默认：最新提交，或与本地仓库匹配的本地提交ID）
- script (Optional[str]) – 指定远程执行的入口脚本。当与远程git仓库一起使用时，脚本应该是仓库内的相对路径，例如：'./source/train.py'。当与本地仓库路径一起使用时，它支持直接指向本地仓库内的文件路径，例如：'~/project/source/train.py'
- working_directory (Optional[str]) – 启动脚本的工作目录。默认值：仓库根文件夹。相对于仓库根目录或本地文件夹。
- packages (Union[bool, Sequence[str], None]) – 手动指定所需的包列表。示例：["tqdm>=2.1", "scikit-learn"] 或设置为 True 以根据本地安装的包自动创建需求（仓库必须是本地的）。
- requirements_file (Union[str, Path, None]) – 指定在设置会话时要安装的requirements.txt文件。如果未提供，则将使用存储库中的requirements.txt。
- docker (Optional[str]) – 选择要在远程会话中执行的docker镜像
- docker_args (Optional[str]) – 添加docker参数，传递一个单独的字符串
- docker_bash_setup_script (Optional[str]) – 添加要在设置任务环境之前在docker内部执行的bash脚本
- argparse_args (Optional[Sequence[Tuple[str, str]]]) – 传递给远程执行的参数，字符串对的列表（参数，值）注意，仅在代码库本身使用 argparse.ArgumentParser 时支持。
- base_task_id (Optional[str]) – 使用系统中已存在的任务，而不是本地仓库/脚本。本质上克隆一个现有任务并覆盖参数/要求。
- add_task_init_call (bool) – 如果为True，远程执行时会在脚本入口点添加一个‘Task.init()’调用。
- force_single_script_file (bool) – 如果为True，则不自动检测本地仓库
返回

新创建的任务（实验）
返回类型

任务

create_function_task

**创建函数任务(func, func_name=None, task_name=None, kwargs)

创建一个新任务，并使用指定的kwargs调用func。可以将此调用视为远程分叉，其中新创建的实例是新任务，使用适当的kwargs调用指定的func，并在func终止后退出。请注意，远程执行的函数不能创建另一个子远程执行的函数。

info

必须从主任务中调用，即由Task.init(…)创建的任务

远程任务继承了创建任务的环境

在远程任务中，入口点与创建任务相同

在远程任务中，执行过程相同，直到达到此函数调用

参数
- func (Callable) – 一个在远程执行的函数，作为单个任务。在远程执行的任务中，入口点和环境是从这个调用进程复制的，只有这个函数调用将执行流重定向到被调用的函数，同时传递参数。
- func_name (Optional[str]) – 函数的唯一标识符。默认情况下是函数名，不包括命名空间。例如，Class.foo() 变为 'foo'
- task_name (Optional[str]) – 新创建的Task名称。默认值：调用Task名称 + 函数名称
- kwargs (Optional[Any]) – 目标函数的特定参数名称。这些参数将出现在配置中的“函数”部分。
返回任务

返回新创建的Task，如果在远程运行且执行被跳过，则返回None
返回类型

Optional[Task]

当前任务

classmethod current_task()

获取当前正在运行的任务（实验）。这是作为任务对象返回的主要执行任务（任务上下文）。

返回

当前正在运行的任务（实验）。
返回类型

任务

任务.调试_模拟_远程任务

classmethod debug_simulate_remote_task(task_id, reset_task=False)

模拟远程执行指定的任务。此调用将模拟您的任务的行为，就像由ClearML-Agent执行一样这意味着配置将从后端服务器传递到代码中（与手动执行相反，手动执行时后端会记录代码参数）请谨慎使用。

参数
- task_id (str ) – 要模拟的任务ID，请注意所有配置将从指定的任务中获取，无论代码的初始值如何，就像由ClearML代理执行一样
- reset_task (bool ) – 如果为True，目标Task将自动清除/重置。
返回类型

()

删除

delete(delete_artifacts_and_models=True, skip_models_used_by_other_tasks=True, raise_on_error=False, callback=None)

删除任务及其输出模型和工件。模型和工件将从其存储位置删除，每个都使用其URI。

注意：为了使用URI删除模型和工件，请确保在配置文件中配置了正确的存储凭据（例如，如果工件存储在S3中，请确保sdk.aws.s3.credentials已正确配置，并且您具有相关存储桶的删除权限）。

参数
- delete_artifacts_and_models (bool) – 如果为True，工件和模型也将被删除（默认为True）。如果提供了回调函数，则忽略此参数。
- skip_models_used_by_other_tasks (bool) – 如果为True，其他任务使用的模型将不会被删除（默认为True）
- raise_on_error (bool) – 如果为True，遇到错误时将引发异常。如果为False，将打印错误信息且不会引发异常。
- callback (Optional[Callable[[str, str], bool]]) – 一个可选的回调函数，接受一个uri类型（字符串）和一个uri（字符串），该函数将为每个工件和模型调用。如果提供了此回调函数，则忽略delete_artifacts_and_models。返回True表示应删除工件/模型，否则返回False。
返回类型

bool
返回

如果任务成功删除，则为True。

删除工件

delete_artifacts(artifact_names, raise_on_errors=True, delete_from_storage=True, silent_on_errors=False)

从任务中按工件名称删除一系列工件。

参数
- artifact_names (列表 ) – 工件名称列表
- raise_on_errors (bool ) – 如果为True，则不抑制与连接相关的异常
- delete_from_storage (bool ) – 如果为True，尝试从外部存储（例如S3、GS、Azure、文件服务器等）中删除实际文件。
- silent_on_errors (bool) – 如果为True，则不记录与连接相关的错误
返回类型

bool
返回

如果成功则为真

delete_parameter

delete_parameter(name, force=False)

通过其全名 Section/name 删除一个参数。

参数
- name (str) – 参数的完整名称，即部分/名称。例如，‘Args/batch_size’
- force (bool) – 如果设置为True，则可以删除新任务和正在运行的任务的超参数。否则只能删除新任务的超参数。默认值为False
返回类型

bool
返回

如果参数成功删除，则为True

删除用户属性

*delete_user_properties(iterables)

删除此任务的超参数。

参数

iterables (Iterable [ Union [ dict *, * Iterable [ str *, * str ] ] ] ) – 超参数键的可迭代对象。每个可迭代对象的可能值都代表要删除的超参数条目，值格式为：
- 包含“section”和“name”字段的字典
- 一个可迭代对象（例如元组、列表等），其前两项表示‘部分’和‘名称’
返回类型

布尔

任务出队

classmethod dequeue(task)

从执行队列中出队（移除）一个任务。

参数

任务 (任务/字符串 ) – 要出队的任务。指定一个任务对象或任务ID。
返回类型

Any
返回

一个出队的JSON响应。

{
     "dequeued": 1,
     "updated": 1,
     "fields": {
         "status": "created",
         "status_reason": "",
         "status_message": "",
         "status_changed": "2020-02-24T16:43:43.057320+00:00",
         "last_update": "2020-02-24T16:43:43.057320+00:00",
         "execution.queue": null
         }
 }

dequeued - 出队的任务数量（一个整数或 null）。
fields
- status - 实验的状态。
- status_reason - 上次状态变更的原因。
- status_message - 关于状态的信息。
- status_changed - 最后状态更改的日期和时间，采用ISO 8601格式。
- last_update - 任务最后一次创建或更新的时间，
已更改，或已报告此任务的事件。
- execution.queue - 任务入队的队列ID。null 表示未入队。
updated - 更新的任务数量（一个整数或null）。

任务.入队

classmethod 入队(任务, 队列名称=无, 队列ID=无, 强制=假)

将一个任务加入执行队列以进行执行。

info

工作守护进程必须在队列中监听，以便工作器获取任务并执行它，请参阅ClearML文档中的“ClearML Agent”。

参数
- 任务 (任务/字符串 ) – 要排队的任务。指定一个任务对象或任务ID。
- queue_name (str ) – 队列的名称。如果未指定，则必须指定 queue_id。
- queue_id (str ) – 队列的ID。如果未指定，则必须指定queue_name。
- force (bool ) – 如果为True，则在将任务加入队列之前，如有必要，重置任务
返回类型

Any
返回

一个入队JSON响应。
```
{
     "queued": 1,
     "updated": 1,
     "fields": {
         "status": "queued",
         "status_reason": "",
         "status_message": "",
         "status_changed": "2020-02-24T15:05:35.426770+00:00",
         "last_update": "2020-02-24T15:05:35.426770+00:00",
         "execution.queue": "2bd96ab2d9e54b578cc2fb195e52c7cf"
         }
 }
```
- queued - 已排队的任务数量（一个整数或null）。
- updated - 更新的任务数量（一个整数或null）。
- fields
  - status - 实验的状态。
  - status_reason - 上次状态变更的原因。
  - status_message - 关于状态的信息。
  - status_changed - 最后状态更改的日期和时间（ISO 8601格式）。
  - last_update - 任务的最后更新时间，包括任务的创建、更新、更改或此任务的事件（ISO 8601格式）。
  - execution.queue - 任务入队的队列ID。null 表示未入队。

远程执行

execute_remotely(queue_name=None, clone=False, exit_process=True)

如果任务在本地运行（即不是由clearml-agent运行），则克隆任务并将其排队以进行远程执行；或者，停止当前任务的执行，重置其状态，并将其排队。如果exit==True，退出此进程。

info

如果任务正在远程运行（即clearml-agent正在执行它），此调用将无效（即不执行任何操作）。

参数
- queue_name (Optional[str]) – 用于将任务加入队列的队列名称。如果为None，此调用将退出进程而不将任务加入队列。
- clone (bool) – 克隆任务并执行新克隆的任务
  
  值为：
  - True - 将创建并排队一个任务的克隆副本，而不是这个任务。
  - False - 任务将被加入队列。
- exit_process (bool) – 函数调用将在结束时离开调用进程。
  - True - 退出进程（exit(0)）。注意：如果 clone==False，那么 exit_process 必须为 True。
  - False - 不退出进程。
返回任务

返回新生成的远程执行任务的任务对象
返回类型

Optional[Task]

导出任务

export_task()

将任务的配置导出为字典（用于序列化目的）。可以通过调用Task.import_task()来复制/修改任务。注意：导出任务不包括任务的输出，例如结果（标量/图表等）或任务工件/模型

返回类型

dict
返回

任务配置的字典。

刷新

flush(wait_for_uploads=False)

刷新任何未完成的报告或控制台日志。

参数

wait_for_uploads (bool ) – 等待所有未完成的上传完成
- True - 等待
- False - 不等待（默认）
返回类型

bool

任务.force_requirements_env_freeze

classmethod force_requirements_env_freeze(force=True, requirements_file=None)

强制使用pip freeze或conda list来捕获活动环境中的需求（而不是静态分析运行代码并直接列出导入的包）。注意：必须在Task.init之前调用！

参数
- force (bool) – 如果为 True（默认值），强制使用 pip freeze 或 conda list 来捕获依赖项。如果为 False，ClearML 会通过统计分析代码来获取依赖项。
- requirements_file (Union[str, Path, None]) – （可选）传递一个requirements.txt文件来指定所需的包（而不是使用pip freeze或自动分析）。这将覆盖任何现有的需求列表。
返回类型

None

任务.强制存储独立脚本

classmethod force_store_standalone_script(force=True)

强制将主要的Python文件存储为单个独立的脚本，而不是与本地git仓库/提交ID链接。

注意：必须在 Task.init 之前调用！

参数

force (bool) – 设置强制将主python文件存储为单个独立脚本
返回类型

None

任务.获取全部

**类方法 get_all(session=None, log=None, kwargs)

列出基于特定投影的所有任务。

参数
- session (Session ) – 用于向API发送请求的会话对象。
- log (logging.Logger ) – 日志对象。
- kwargs (dict ) – 传递给GetAllRequest的关键字参数 (详情请参见 backend_api.service.v?.tasks.GetAllRequest；?需要替换为适当的版本。)
例如：
```
status='completed', 'search_text'='specific_word', 'user'='user_id', 'project'='project_id'
```
返回类型

Any
返回

API响应。

获取所有报告的标量

get_all_reported_scalars(x_axis='iter')

返回一个包含所有注册样本的嵌套字典，用于所有标量图，其中第一个键是图标题，第二个是系列名称。值是一个包含'x': 值和'y': 值的字典。要获取下采样标量值，请参阅Task.get_reported_scalars。

info

此调用不会被缓存，任何调用都将从后端检索所有标量报告。如果任务报告了许多标量，调用可能需要很长时间才能返回。

参数

x_axis (str ) – 标量x轴，可能的取值： ‘iter’: 迭代次数（默认），‘timestamp’: 自纪元以来的时间戳（毫秒），‘iso_time’: 绝对时间
返回类型

Mapping[str, Mapping[str, Mapping[str, Sequence[float]]]]
返回

字典：嵌套标量图：dict[标题(str), dict[系列(str), dict[轴(str), 列表(float)]]]

获取已归档

get_archived()

返回任务的归档状态

返回类型

bool
返回

如果为True，则任务被归档，否则不被归档。

获取基础Docker

get_base_docker()

获取为此实验设置的基础Docker命令（镜像）。

返回类型

str

任务.按名称获取

classmethod get_by_name(task_name)

info

此方法已弃用，请使用 Task.get_task 代替。

返回系统中任何位置具有给定名称的最新任务作为Task对象。

参数

task_name (str ) – 要搜索的任务名称。
返回类型

~任务实例
返回

具有该名称的最新任务的任务对象。

获取配置对象

get_configuration_object(name)

获取任务的配置对象部分作为文本块仅用于自动化（外部），否则使用 Task.connect_configuration。

参数

name (str ) – 配置部分名称
返回类型

Optional[str]
返回

任务的配置作为一个文本块（无约束的文本字符串）如果配置名称无效，则返回 None

获取配置对象为字典

get_configuration_object_as_dict(name)

获取任务的配置对象部分作为解析后的字典解析支持JSON和HOCON，否则使用get_configuration_object()手动解析仅用于自动化（外部），否则使用Task.connect_configuration。

参数

name (str ) – 配置部分名称
返回类型

Union[dict, list, None]
返回

任务的配置作为一个解析后的字典。如果配置名称无效，则返回 None

获取配置对象

get_configuration_objects()

获取任务的配置对象部分作为文本块仅用于自动化（外部），否则使用Task.connect_configuration。

返回类型

Optional[Mapping[str, str]]
返回

任务的配置作为一个字典（配置名称作为键）和文本块作为值（无约束的文本字符串）

获取调试样本

get_debug_samples(title, series, n_last_iterations=None)

参数
- title (str ) – 调试样本的标题，在用户界面中也称为指标
- series (str ) – 调试样本的系列，对应于UI中调试样本的文件名，也称为变体
- n_last_iterations (int ) – 按时间倒序获取多少调试样本迭代。留空以获取所有调试样本。
提高

如果n_last_iterations被明确设置为除正整数以外的任何值，则抛出TypeError
返回类型

List[dict]
返回

一个包含`dict`的列表，每个字典包含调试样本的URL和其他元数据。这些URL可以传递给StorageManager.get_local_copy以获取调试样本的本地副本。

get_executed_queue

get_executed_queue(return_name=False)

获取任务执行的队列。

参数

return_name (bool) – 如果为True，返回队列的名称。否则，返回其ID
返回类型

Optional[str]
返回

返回任务执行的队列的ID或名称。如果未找到队列，则返回None

获取HTTP路由器

get_http_router()

检索HttpRouter的实例以管理外部HTTP端点并拦截流量。 HttpRouter充当流量管理器，支持创建和配置本地和外部路由，以重定向、监控或操作HTTP请求和响应。它旨在通过代理设置处理路由需求，该代理设置处理需要HTTP端点管理的应用程序的请求/响应拦截和遥测报告。

示例用法：

返回类型

HttpRouter

获取初始迭代

get_initial_iteration()

返回初始迭代偏移量，默认为0 在从之前的检查点继续训练时非常有用

返回类型

int
返回

初始迭代偏移量。

获取标签数量描述

get_label_num_description()

获取一个标签编号到字符串对的字典，表示与模型标签上此编号关联的所有标签。

获取标签枚举

get_labels_enumeration()

获取标签枚举字典，即字符串（标签）到整数（值）对的标签枚举字典。

返回类型

Mapping[str, int]
返回

包含标签枚举的字典。

获取最后一次迭代

get_last_iteration()

获取最后报告的迭代，即任务报告度量的最后一次迭代。

info

报告的最大迭代次数不在本地缓存中。此方法向ClearML服务器（后端）发送请求。

返回类型

int
返回

最后报告的迭代次数。

获取最后的标量指标

get_last_scalar_metrics()

获取任务报告的最新标量指标。这是一个嵌套字典，按标题和系列排序。

例如：

{
 "title": {
     "series": {
         "last": 0.5,
         "min": 0.1,
         "max": 0.9
         }
     }
 }

返回类型

Dict[str, Dict[str, Dict[str, float]]]
返回

最后的标量指标。

获取日志记录器

get_logger()

获取一个用于报告的Logger对象，针对此任务上下文。您可以在ClearML Web-App (UI)中查看与此方法调用的任务相关的所有Logger报告输出，包括指标、图表、文本、表格和图像。

返回类型

Logger
返回

任务的日志记录器（实验）。

获取模型配置字典

get_model_config_dict()

已弃用： 自版本0.14.1起已弃用：请改用Task.connect_configuration。

返回类型

Dict

获取模型配置文本

get_model_config_text()

已弃用： 自版本0.14.1起已弃用：请改用Task.connect_configuration。

返回类型

str

获取模型设计

get_model_design()

获取模型配置作为文本块。

返回类型

str
返回

模型配置作为文本块。

获取模型

get_models()

返回一个包含{'input': [], 'output': []}的字典，其中加载/存储了当前任务的模型输入模型是任务中加载的文件，无论是手动加载还是自动记录的输出模型是任务中存储的文件，无论是手动存储还是自动记录的。自动记录的框架例如：TensorFlow, Keras, PyTorch, ScikitLearn(joblib) 等。

返回类型

Mapping[str, Sequence[Model]]
返回

一个类似字典的对象，具有“input”/“output”键和输入/输出属性，指向包含模型对象的类似列表的对象。每个类似列表的对象也充当字典，将模型名称映射到适当的模型实例。

示例：
```
{'input': [clearml.Model()], 'output': [clearml.Model()]}
```

任务.获取排队任务数量

classmethod get_num_enqueued_tasks(queue_name=None, queue_id=None)

获取给定队列中排队的任务数量。

参数
- queue_name (Optional[str]) – 队列的名称。如果未指定，则必须指定 queue_id
- queue_id (Optional[str]) – 队列的ID。如果未指定，则必须指定queue_name
返回类型

int
返回

给定队列中排队的任务数量

获取班级数量

get_num_of_classes()

基于任务标签的类别数量

获取离线模式文件夹

get_offline_mode_folder()

返回离线会话中所有任务输出和日志存储的文件夹。 :rtype: Optional[Path] :return: Path对象，本地文件夹，稍后将与report_offline_session()一起使用

返回类型

可选[pathlib2.Path]

获取输出目的地

**get_output_destination(extra_path=None, kwargs)

获取任务的输出目的地，带有可选的后缀

获取输出日志网页

get_output_log_web_page()

返回任务结果和输出网页地址。例如：https://demoapp.demo.clear.ml/projects/216431/experiments/60763e04/output/log

返回类型

str
返回

http/s URL 链接。

获取参数

get_parameter(name, default=None, cast=False)

获取参数的值。

参数
- name (str) – 参数名称
- 默认值 (Optional[Any]) – 默认值
- cast (bool) – 如果找到值，则转换为原始类型。如果为False，则返回字符串。
返回类型

Any
返回

参数值（如果未定义参数，则为默认值）。

获取参数

get_parameters(backwards_compatibility=True, cast=False)

获取任务的参数。此方法返回一组完整的键值参数对，但不支持参数描述（结果是一个键值对的字典）。注意返回的参数字典是扁平的：即 {'Args/param': 'value'} 是来自“Args”部分的参数“param”

参数
- backwards_compatibility (bool) – 如果为True（默认值），没有部分名称的参数 (API版本 <2.9, clearml-server <0.16) 将位于字典的根级别。如果为False，没有部分名称的参数将嵌套在“Args/”键下。
- cast (bool) – 如果为True，将参数转换为原始类型。默认为False，值以字符串形式返回
返回类型

Optional[dict]
返回

任务参数的字典，全部展平为键/值。带有键前缀“section/”的不同部分

get_parameters_as_dict

get_parameters_as_dict(cast=False)

获取任务参数作为原始嵌套字典。

info

如果 cast 为 False（默认值），则不会解析这些值。它们将按原样返回。

参数

cast (bool) – 如果为True，将参数转换为原始类型。默认为False，值以字符串形式返回
返回类型

Dict

获取进度

get_progress()

获取任务的进度（0 - 100）

返回类型

Optional[int]
返回

任务的进度为一个整数。如果进度不存在，将返回None

任务.获取项目ID

classmethod get_project_id(project_name, search_hidden=True)

返回项目的唯一ID（字符串）。如果多个项目匹配project_name，则返回最后更新的项目如果没有项目匹配请求的名称，则返回None

返回类型

Optional[str]
返回

项目唯一ID（str），如果未找到项目则为None。
参数
- project_name (str ) –
- search_hidden (bool ) –

获取项目名称

get_project_name()

获取当前任务的项目名称。

返回类型

Optional[str]

获取项目对象

get_project_object()

获取当前任务的项目作为Python对象。

返回类型

dict

任务.获取项目

**类方法 get_projects(kwargs)

返回系统中项目的列表，按最后更新时间排序

返回类型

List[ForwardRef]
返回

系统中所有项目的列表。每个条目都是一个services.projects.Project对象。
参数

kwargs (任意 ) –

获取已注册的工件

get_registered_artifacts()

获取一个包含任务注册（动态同步）工件（名称，工件对象）的字典。

info

调用get_registered_artifacts后，您仍然可以修改已注册的工件。

返回类型

Dict[str, Artifact]
返回

已注册（动态同步）的工件。

获取报告的控制台输出

get_reported_console_output(number_of_reports=1)

返回由任务报告的控制台输出列表。检索到的输出是最新的控制台输出。

参数

number_of_reports (int ) – 要返回的报告数量。默认值为 1，表示最后（最新）的控制台输出
返回类型

Sequence[str]
返回

一个字符串列表，每个条目对应一个报告。

获取报告的图表

get_reported_plots(max_iterations=None)

返回为此任务报告的所有图表的列表，注意图表数据与plotly兼容。

info

此调用不会被缓存，任何调用都将从后端检索所有绘图报告。如果任务报告了许多绘图，调用可能需要很长时间才能返回。

示例：

[{
  "timestamp": 1636921296370,
  "type": "plot",
  "task": "0ce5e89bbe484f428e43e767f1e2bb11",
  "iter": 0,
  "metric": "Manual Reporting",
  "variant": "Just a plot",
  "plot_str": "{'data': [{'type': 'scatter', 'mode': 'markers', 'name': null,
                          'x': [0.2620246750155817], 'y': [0.2620246750155817]}]}",
  "@timestamp": "2021-11-14T20:21:42.387Z",
  "worker": "machine-ml",
  "plot_len": 6135,
},]

参数

max_iterations (int ) – 返回的最大历史绘图数量（从末尾开始的迭代次数）。
返回类型

List[dict]
返回

列表：字典列表，每个字典代表一个单独的图表

获取报告的标量

get_reported_scalars(max_samples=0, x_axis='iter')

返回一个用于标量图的嵌套字典，其中第一个键是图表的标题，第二个是系列名称。值是一个包含‘x’: 值和‘y’: 值的字典

info

此调用不会被缓存，任何调用都将从后端检索所有标量报告。如果任务报告了许多标量，调用可能需要很长时间才能返回。

info

调用此方法将返回可能经过下采样的标量。返回的样本最大数量为5000。即使将max_samples设置为大于5000的值，它也将被限制为最多5000个样本。要获取所有标量值，请参阅Task.get_all_reported_scalars。

示例：

{"title": {"series": {
            "x": [0, 1 ,2],
            "y": [10, 11 ,12]
}}}

参数
- max_samples (int ) – 每个系列返回的最大样本数。默认值为0，返回最多5000个样本。在样本限制下，采样窗口内的平均标量值。
- x_axis (str ) – 标量x轴，可能的取值： ‘iter’: 迭代次数（默认），‘timestamp’: 自纪元以来的时间戳（毫秒），‘iso_time’: 绝对时间
返回类型

Mapping[str, Mapping[str, Mapping[str, Sequence[float]]]]
返回

字典：嵌套标量图：dict[标题(str), dict[系列(str), dict[轴(str), 列表(float)]]]

获取报告的单值

get_reported_single_value(name)

获取一个由其名称标识的报告值。请注意，此函数调用 Task.get_reported_single_values。

参数

name (str) – 报告值的名称
返回类型

Optional[float]
返回

如果找到报告值的实际值。否则，返回None

获取报告的单值

get_reported_single_values()

获取所有报告的单值作为字典，其中键是值的名称，字典的值是实际报告的值。

返回类型

Dict[str, float]
返回

包含报告值的字典

获取需求

get_requirements()

获取任务的要求

返回类型

RequirementsDict
返回

一个包含pip、conda、orig_pip需求的RequirementsDict对象。

获取脚本

get_script()

获取任务的脚本详情。

返回包含脚本详细信息的字典。

返回类型

Mapping[str, Optional[str]]
返回

带有脚本属性的字典，例如。

{
     'working_dir': 'examples/reporting',
     'entry_point': 'artifacts.py',
     'branch': 'master',
     'repository': 'https://github.com/allegroai/clearml.git'
}

获取状态

get_status()

返回任务状态而不刷新整个任务对象（仅状态属性）

任务状态枚举: [“created”, “in_progress”, “stopped”, “closed”, “failed”, “completed”, “queued”, “published”, “publishing”, “unknown”]

返回类型

str
返回

str: 任务状态为字符串 (TaskStatusEnum)

获取状态信息

get_status_message()

返回任务状态而不刷新整个任务对象（仅状态属性）同时返回与状态更改相关的最后一条消息

任务状态选项：[“created”, “in_progress”, “stopped”, “closed”, “failed”, “completed”, “queued”, “published”, “publishing”, “unknown”] 消息：是一个字符串

返回类型

(可选[str], 可选[str])
返回

（任务状态为字符串，最后一条消息）

获取标签

get_tags()

获取当前任务的所有标签。

返回类型

Sequence[str]

任务.获取任务

classmethod get_task(task_id=None, project_name=None, task_name=None, tags=None, allow_archived=True, task_filter=None)

通过ID或项目名称/任务名称组合获取任务。

例如：

以下代码演示了调用Task.get_task向另一个任务报告标量。测试中的Logger.report_scalar输出与名为training的任务相关联。它允许训练和测试同时运行，因为它们初始化了不同的任务（有关初始化任务的信息，请参见Task.init）。

训练脚本：

# initialize the training Task
task = Task.init('myProject', 'training')

# do some training

测试脚本：

# initialize the testing Task
task = Task.init('myProject', 'testing')

# get the training Task
train_task = Task.get_task(project_name='myProject', task_name='training')

# report metrics in the training Task
for x in range(10):
    train_task.get_logger().report_scalar('title', 'series', value=x * 2, iteration=x)

参数
- task_id (str ) – 要获取的实验的ID（系统UUID）。如果指定了，project_name 和 task_name 将被忽略。
- project_name (str ) – 要获取的任务的项目名称。
- task_name (str ) – 要获取的project_name中的任务名称。
- 标签 (列表 ) – 根据请求的标签列表（字符串）进行过滤。要排除一个标签，请在标签前添加“-”前缀。示例：["best", "-debug"]。默认行为是使用逻辑“OR”运算符连接所有标签。要使用逻辑“AND”运算符连接所有标签，请使用“__$all”作为第一个字符串，例如：
```
["__$all", "best", "experiment", "ever"]
```
要使用AND连接所有标签，但排除某个标签，请在排除的标签前使用“__$not”，例如：
```
["__$all", "best", "experiment", "ever", "__$not", "internal", "__$not", "test"]
```
“OR”和“AND”运算符适用于其后所有标签，直到指定另一个运算符为止。 NOT运算符仅适用于紧随其后的标签。例如：
```
["__$all", "a", "b", "c", "__$or", "d", "__$not", "e", "__$and", "__$or" "f", "g"]
```
这个示例表示 (“a” AND “b” AND “c” AND (“d” OR NOT “e”) AND (“f” OR “g”))。更多信息请参见 https://clear.ml/docs/latest/docs/clearml_sdk/task_sdk/#tag-filters。
- allow_archived (bool ) – 仅在不使用特定task_id时适用，如果为True（默认），允许返回已归档的任务，如果为False则过滤掉已归档的任务
- task_filter (bool ) – 仅在不使用特定 task_id 时适用，在项目/名称的基础上传递额外的查询过滤器。详情请参见 Task.get_tasks。
返回

由ID指定的任务，或项目名称/实验名称组合。
返回类型

任务

任务获取任务输出日志网页

classmethod get_task_output_log_web_page(task_id, project_id=None, app_server_host=None)

返回任务结果和输出网页地址。例如：https://demoapp.demo.clear.ml/projects/216431/experiments/60763e04/output/log

参数
- task_id (str ) – 任务ID。
- project_id (str ) – 此任务的项目ID。
- app_server_host (str ) – ClearML 应用程序服务器主机名。如果未提供，将使用当前会话解析主机名。
返回类型

str
返回

http/s URL 链接。

任务.获取任务

classmethod get_tasks(task_ids=None, project_name=None, task_name=None, tags=None, allow_archived=True, task_filter=None)

获取与查询/过滤器匹配的任务对象列表

特定任务ID的列表。
根据特定字段筛选任务：

项目名称（包括部分匹配），任务名称（包括部分匹配），标签使用task_filter应用额外的高级过滤

info

此函数返回最近的500个任务。如果您希望检索更早的任务，请使用Task.query_tasks()

参数
- task_ids (list ( str ) ) – 要获取的实验的ID（系统UUID）。如果指定了task_ids，则忽略project_name和task_name。
- project_name (str ) – 要获取的任务的项目名称。要获取所有项目中的实验，请使用默认值 None。（可选）对于多个可选项目名称，请使用字符串列表。
- task_name (str ) – 在指定的project_name（如果project_name为None，则为所有项目）中匹配任务的全名或部分名称。此方法支持使用正则表达式进行名称匹配（如果您希望匹配特殊字符并避免任何正则表达式行为，请使用re.escape()）。（可选）要匹配确切的任务名称（即不进行部分匹配），请在字符串的开头/结尾添加^/$，例如：“^exact_task_name_here$”
- 标签 (列表 ) – 根据请求的标签列表（字符串）进行过滤。要排除一个标签，请在标签前添加“-”前缀。示例：["best", "-debug"]。默认行为是使用逻辑“OR”运算符连接所有标签。要使用逻辑“AND”运算符连接所有标签，请使用“__$all”作为第一个字符串，例如：
```
["__$all", "best", "experiment", "ever"]
```
要使用AND连接所有标签，但排除某个标签，请在排除的标签前使用“__$not”，例如：
```
["__$all", "best", "experiment", "ever", "__$not", "internal", "__$not", "test"]
```
“OR”和“AND”运算符适用于其后所有标签，直到指定另一个运算符为止。 NOT运算符仅适用于紧随其后的标签。例如：
```
["__$all", "a", "b", "c", "__$or", "d", "__$not", "e", "__$and", "__$or" "f", "g"]
```
这个示例表示 (“a” AND “b” AND “c” AND (“d” OR NOT “e”) AND (“f” OR “g”))。更多信息请参见 https://clear.ml/docs/latest/docs/clearml_sdk/task_sdk/#tag-filters。
- allow_archived (bool ) – 如果为True（默认），允许返回已归档的任务，如果为False则过滤掉已归档的任务
- task_filter (dict ) – 过滤和排序任务。
  
  详情请参见backend_api.service.v?.tasks.GetAllRequest；?需要替换为适当的版本。
  - parent - (str) 按父任务ID匹配过滤
  - search_text - (str) 自由文本搜索（在任务字段的评论/名称/ID中）
  - status - List[str] 有效状态的列表。选项有：“created”（已创建）、“queued”（已排队）、“in_progress”（进行中）、“stopped”（已停止）、“published”（已发布）、“publishing”（发布中）、“closed”（已关闭）、“failed”（失败）、“completed”（已完成）、“unknown”（未知）
  - type - List[str] 有效任务类型的列表。选项包括：'training', 'testing', 'inference', 'data_processing', 'application', 'monitor', 'controller', 'optimizer', 'service', 'qc', 'custom'
  - user - List[str] 根据任务的所有者用户进行过滤，提供有效的用户ID列表。
  - order_by - List[str] 用于排序的字段名称列表。当使用search_text时。使用‘-’前缀指定降序排列。可选，建议在使用分页时使用。示例：order_by=['-last_update']
  - _all_ - dict(fields=[], pattern=’’) 匹配出现在所有字段中的字符串模式（正则表达式）。示例：dict(fields=[‘script.repository’], pattern=’github.com/user’)
  - _any_ - dict(fields=[], pattern=’’) 匹配出现在任何字段中的字符串模式（正则表达式）。示例：dict(fields=[‘comment’, ‘name’], pattern=’my comment’)
  - 示例 - {'status': ['stopped'], 'order_by': ["-last_update"]} , {'order_by'=['-last_update'], '_all_'=dict(fields=['script.repository'], pattern='github.com/user'))
返回

由参数组合指定的任务（请参阅参数）。
返回类型

任务列表

获取用户属性

get_user_properties(value_only=False)

获取此任务的用户属性。返回一个字典，将用户属性名称映射到用户属性详细信息字典。

参数

value_only (bool) – 如果为True，返回的用户属性详细信息将是一个表示属性值的字符串。
返回类型

Dict[str, Union[str, dict]]

任务.忽略需求

classmethod ignore_requirements(package_name)

在自动生成需求列表时忽略特定的包。示例：Task.ignore_requirements(‘pywin32’)

参数

package_name (str ) – 要从任务的“已安装包”部分移除/忽略的包名称。
返回类型

None

任务.导入离线会话

classmethod import_offline_session(session_folder_zip, previous_task_id=None, iteration_offset=0)

上传任务的离线会话（执行）。完整的任务执行包括仓库详情、安装的包、工件、日志、指标和调试样本。此函数也可用于继续之前执行的任务，该任务是在离线状态下执行的。

参数
- session_folder_zip (str) – 包含会话的文件夹路径，或会话文件夹的压缩文件。
- previous_task_id (Optional[str]) – 您希望在此离线会话中继续的任务的任务ID。
- iteration_offset (Optional[int]) – 离线会话的报告将根据此参数指定的数字进行偏移。有助于避免覆盖指标。
返回类型

Optional[str]
返回

新创建的任务ID或继续任务（previous_task_id）的ID

任务.导入任务

classmethod import_task(task_data, target_task=None, update=False)

从之前导出的任务配置中导入（创建）任务（参见Task.export_task）也可以用于编辑/更新现有任务（通过传递target_task和update=True）。

参数
- task_data (dict) – 任务配置的字典
- target_task (Union[str, Task, None]) – 将task_data导入到现有的Task中。可以是task_id（str）或Task对象。
- 更新 (bool) – 如果为True，将task_data与当前任务配置合并。
返回类型

Optional[Task]
返回

如果任务被导入/更新，则返回 True

任务初始化

classmethod init(project_name=None, task_name=None, task_type=TaskTypes.training, tags=None, reuse_last_task_id=True, continue_last_task=False, output_uri=None, auto_connect_arg_parser=True, auto_connect_frameworks=True, auto_resource_monitoring=True, auto_connect_streams=True, deferred_init=False)

如果满足以下条件，则创建一个新的任务（实验）：

任务之前从未运行过。在ClearML服务器中没有存储具有相同task_name和project_name的任务。
任务之前已经运行过（相同的task_name和project_name），并且（a）它存储了模型和/或工件，或（b）其状态为已发布，或（c）它已归档。
通过调用Task.init并设置reuse_last_task_id=False来强制创建一个新任务。

否则，返回相同task_name和project_name的已初始化的Task对象，或者，当在clearml-agent上远程执行时，返回的任务是来自后端的现有任务。

info

要引用另一个任务，而不是多次初始化相同的任务，请调用 Task.get_task。例如，要在多个脚本中“共享”相同的实验，请调用Task.get_task。有关示例，请参见Task.get_task方法。

例如：第一次运行以下代码时，它将创建一个新的任务。状态将为已完成。

from clearml import Task
task = Task.init('myProject', 'myTask')

如果此代码再次运行，它将不会创建新的任务。它不存储模型或工件，它没有被发布（其状态为已完成），它没有被归档，并且不会强制创建新的任务。

如果任务已发布或已归档，并再次运行，它将创建一个具有新任务ID的新任务。

以下代码每次运行时都会创建一个新的任务，因为它存储了一个工件。

task = Task.init('myProject', 'myOtherTask')

d = {'a': '1'}
task.upload_artifact('myArtifact', d)

参数
- project_name (str ) – 将在其中创建实验的项目的名称。如果项目不存在，则会创建该项目。如果 project_name 是 None，则使用仓库名称。（可选）
- task_name (str ) – 任务的名称（实验）。如果 task_name 是 None，则使用 Python 实验脚本的文件名。（可选）
- task_type (TaskTypes ) – 任务类型。有效的任务类型：
  - TaskTypes.training (默认)
  - TaskTypes.testing
  - TaskTypes.inference
  - TaskTypes.data_processing
  - TaskTypes.application
  - TaskTypes.monitor
  - TaskTypes.controller
  - TaskTypes.optimizer
  - TaskTypes.service
  - TaskTypes.qc
  - TaskTypes.custom
- 标签 (Optional[Sequence[str]]) – 向创建的任务添加一个标签列表（字符串）。例如：tags=[‘512x512’, ‘yolov3’]
- reuse_last_task_id (bool ) – 强制使用之前使用过的任务ID创建一个新的任务（实验），
  
  以及相同的项目和任务名称。如果之前执行的任务有工件或模型，它们将不会被重用（覆盖），并且将创建一个新的任务。当任务被重用时，之前的执行输出将被删除，包括控制台输出和日志。这些值为：
  - True - 重用最后一个任务ID。（默认）
  - False - 强制创建一个新任务（实验）。
  - 一个字符串 - 您还可以指定要重用的任务ID（字符串），而不是基于项目/名称组合的缓存ID。
- continue_last_task (bool) – 继续执行之前执行的任务（实验）。当
  
  继续执行之前执行的任务，所有之前的工件/模型/日志保持完整。新的日志将继续基于之前执行的最大迭代值进行迭代/步骤。例如，最后报告的训练/损失标量是迭代100，下一个报告将是迭代101。值为：
  - True - 继续上一个任务ID。通过reuse_last_task_id显式指定，或隐式使用与reuse_last_task_id相同的逻辑
  - False - 覆盖之前任务的执行（默认）。
  - 一个字符串 - 您还可以指定一个任务ID（字符串）以继续。这相当于continue_last_task=True和reuse_last_task_id=a_task_id_string。
  - 一个整数 - 指定初始迭代偏移量（覆盖自动的last_iteration_offset）。传递0以禁用自动的last_iteration_offset，或指定一个不同的初始偏移量。您可以指定一个任务ID与reuse_last_task_id='task_id_here'一起使用。
- output_uri (str ) – 输出模型和其他工件的默认位置。如果为True，则为默认值
  
  files_server 将用于模型存储。在默认位置，ClearML 会为输出创建一个子文件夹。如果设置为 False，本地运行将不会上传输出模型和工件，远程运行将不会使用通过 default_output_uri 提供的任何默认值。子文件夹结构如下：<输出目标名称> / <项目名称> / <任务名称>.<任务 ID>。请注意，对于云存储，您必须为您的云存储类型安装 ClearML 包，然后配置您的存储凭据。有关详细信息，请参阅 ClearML 文档中的“存储”部分。以下是支持的存储位置的 output_uri 值示例：
  - 一个共享文件夹：/mnt/share/folder
  - S3: s3://bucket/folder
  - Google 云存储: gs://bucket-name/folder
  - Azure 存储: azure://company.blob.core.windows.net/folder/
  - 默认文件服务器: True
- auto_connect_arg_parser (Union[bool, Mapping[str, bool]]) – 自动将argparse对象连接到任务。支持的参数
  
  解析器包包括：argparse, click, python-fire, jsonargparse。它们的值为：
  - True - 自动连接。（默认）
  - False - 不要自动连接。
  - 字典 - 除了布尔值外，您还可以使用字典来对连接进行细粒度的控制
  参数。字典的键是argparse变量名称，值是布尔值。 False值将指定的参数从任务的参数部分排除。字典中缺失的键默认为True，你可以通过将\*键设置为False来将其更改为False。空字典默认为False。
  
  例如：
```
auto_connect_arg_parser={"do_not_include_me": False, }
```
```
auto_connect_arg_parser={"only_include_me": True, "*": False}
```
  info
  要手动连接一个argparse，请使用Task.connect。
- auto_connect_frameworks (Union[bool, Mapping[str, Union[bool, str, list]]]) – 自动连接框架这包括修补 MatplotLib, XGBoost,
  
  scikit-learn、Keras回调函数和TensorBoard/X将图表、图形和模型位置序列化到ClearML服务器（后端），除了原始的输出目的地。这些值是：
  - True - 自动连接（默认）
  - False - 不自动连接
  - 字典 - 除了布尔值，你还可以使用字典来对连接进行细粒度的控制
  框架。字典的键是框架，值是布尔值，其他字典用于更精细的控制或通配符字符串。在通配符字符串的情况下，模型文件的本地路径必须至少匹配一个通配符才能被ClearML保存/加载。示例：{'pytorch' : '\*.pt', 'tensorflow': ['\*.h5', '\*']} 字典中缺少的键默认为True，空字典默认为False。支持的更精细控制键：{'tensorboard': {'report_hparams': bool}} # 是否报告TensorBoard超参数
  
  例如：
```
auto_connect_frameworks={
    'matplotlib': True, 'tensorflow': ['*.hdf5, 'something_else*], 'tensorboard': True,
    'pytorch': ['*.pt'], 'xgboost': True, 'scikit': True, 'fastai': True,
    'lightgbm': True, 'hydra': True, 'detect_repository': True, 'tfdefines': True,
    'joblib': True, 'megengine': True, 'catboost': True, 'gradio': True
}
```
```
auto_connect_frameworks={'tensorboard': {'report_hparams': False}}
```
- auto_resource_monitoring (bool ) – 自动创建机器资源监控图表
  
  这些图表出现在ClearML Web-App (UI)的RESULTS标签页中的SCALARS子标签页，标题为:resource monitor:。显示的值为：
  - True - 自动创建资源监控图。（默认）
  - False - 不自动创建。
  - 类类型 - 创建指定类类型的ResourceMonitor对象。
  - dict - 传递给ResourceMonitor实例的关键字参数字典。
  键可以是：
  - report_start_sec 或 first_report_sec 或 seconds_from_start - 在默认情况下，基于实验开始时间的秒数，等待标量/绘图报告的最大秒数，然后转为机器统计报告
  - wait_for_first_iteration_to_start_sec - Set the initial time (seconds) to wait for iteration
  报告将用作资源监控的x轴，如果超时超过，则恢复到seconds_from_start
  - max_wait_for_first_iteration_to_start_sec - Set the maximum time (seconds) to allow the resource
  监控在开始报告seconds_from_start后恢复到迭代报告的x轴
  - report_mem_used_per_process OR report_global_mem_used - Compatibility feature,
  报告整个机器的内存使用情况默认情况下（false），仅报告正在运行的进程及其子进程
- auto_connect_streams (Union[bool, Mapping[str, bool]]) – 控制标准输出和标准错误的自动记录。
  
  值为：
  - True - 自动连接（默认）
  - False - 不自动连接
  - 字典 - 除了布尔值外，您还可以使用字典来对标准输出进行细粒度的控制。
  stderr。字典的键是‘stdout’、‘stderr’和‘logging’，值是布尔值。字典中缺失的键默认为False，空字典默认为False。注意，默认行为是记录stdout/stderr。日志模块作为stderr日志的副产品被记录。
  
  例如：
```
auto_connect_streams={'stdout': True, 'stderr': True, 'logging': False}
```
- deferred_init (bool) – (默认值: False) 等待任务完全初始化（常规行为）。
  
  ** BETA 功能！请谨慎使用 **。
  
  如果设置为True，Task.init函数会立即返回，所有初始化/与clearml-server的通信将在后台线程中运行。返回的对象是常规Task对象的完整代理，因此一切将按预期工作。默认行为可以通过以下方式控制：CLEARML_DEFERRED_TASK_INIT=1。注意事项：
  - Any access to the returned proxy Task object will essentially wait for the Task.init to be completed.
  例如：print(task.name) 将在后台等待 Task.init 完成，然后返回任务原始对象的 name 属性
  - 在后台完成Task.init之前，自动日志记录（控制台/指标）可能会被遗漏
  - 如果通过代理运行，则忽略此参数，并同步调用任务初始化（默认）
返回

主要执行任务（任务上下文）
返回类型

任务

输入模型ID

属性 input_models_id

返回当前任务的输入模型ID作为字典。

返回类型

Mapping[str, str]

is_current_task

is_current_task()

已弃用：自版本0.13.0起已弃用：此方法已弃用。请改用Task.is_main_task。

这个任务对象是主要的执行任务吗（最初由Task.init返回）

返回类型

bool
返回

这个任务对象是主要的执行任务吗
- True - 是主要的执行任务。
- False - 不是主要的执行任务。

is_main_task

is_main_task()

这个任务对象是主要的执行任务吗（最初由Task.init返回）

info

如果从未调用过Task.init，此方法将不会创建它，使得此测试比以下更高效：

Task.init() == 任务

返回类型

bool
返回

这个任务对象是主要的执行任务吗
- True - 是主要的执行任务。
- False - 不是主要的执行任务。

Task.is_offline

classmethod is_offline()

返回离线模式状态，如果处于离线模式，则不启用与后端的通信。

返回类型

bool
返回

布尔离线模式状态

标签统计

属性 labels_stats

获取当前/上一帧迭代的累积标签统计信息

返回类型

dict

last_worker

属性 last_worker

处理任务的最后一个工作者的ID。

返回类型

str
返回

工作者的ID。

启动多节点

launch_multi_node(total_num_nodes, port=29500, queue=None, wait=False, addr=None, devices=None, hide_children=False)

将当前任务的多个克隆排入队列，允许任务由多个工作器并行运行。以这种方式运行的每个任务称为一个节点。每个节点都有一个等级。初始化其他节点执行的节点称为主节点，其等级为0。

一个名为 multi_node_instance 的字典将被连接到任务。可以使用此字典在远程运行时修改此函数的行为。此字典的内容对应于该函数的参数，它们是：

total_num_nodes - 节点总数，包括主节点
queue - 将节点加入的队列

以下环境变量将被设置：

MASTER_ADDR - 主节点运行的机器的地址
MASTER_PORT - 主节点运行的机器的开放端口
WORLD_SIZE - 节点总数，包括主节点
RANK - 当前节点的排名（主节点的排名为0）

可以将此函数与PyTorch的分布式通信包结合使用。请注意，应在调用torch.distributed.init_process_group之前调用Task.launch_multi_node。例如：

from clearml import Task
import torch
import torch.distributed as dist

def run(rank, size):
    print('World size is ', size)
    tensor = torch.zeros(1)
    if rank == 0:
        for i in range(1, size):
            tensor += 1
            dist.send(tensor=tensor, dst=i)
            print('Sending from rank ', rank, ' to rank ', i, ' data: ', tensor[0])
    else:
        dist.recv(tensor=tensor, src=0)
        print('Rank ', rank, ' received data: ', tensor[0])

if __name__ == '__main__':
    task = Task.init('some_name', 'some_name')
    task.execute_remotely(queue_name='queue')
    config = task.launch_multi_node(4)
    dist.init_process_group('gloo')
    run(config.get('node_rank'), config.get('total_num_nodes'))

使用ClearML云自动扩展应用程序时，需要确保节点之间可以相互访问。机器需要位于同一个安全组中，MASTER_PORT需要暴露，并且 MASTER_ADDR需要是主节点运行的实例的正确私有IP。例如，为了实现这一点，可以在Additional ClearML Configuration部分设置以下Docker参数：

agent.extra_docker_arguments=["--ipc=host", "--network=host", "-p", "29500:29500", "--env", "CLEARML_MULTI_NODE_MASTER_DEF_ADDR=`hostname -I | awk '{print $1}'`"]`

参数
- total_num_nodes – 要入队的节点总数，包括主节点，在远程运行时主节点应该已经入队。
- port – 主节点打开的端口。如果设置了环境变量 CLEARML_MULTI_NODE_MASTER_DEF_PORT，则此参数的值将设置为 CLEARML_MULTI_NODE_MASTER_DEF_PORT 中定义的值。如果 CLEARML_MULTI_NODE_MASTER_DEF_PORT 不存在，但 MASTER_PORT 存在，则此参数的值将设置为 MASTER_PORT 中定义的值。如果两个环境变量都不存在，则将使用传递给参数的值。
- queue – 要入队节点的队列。可以与主节点入队的队列不同。如果为None，节点将被入队到与主节点相同的队列。
- wait – 如果为True，主节点将等待其他节点启动
- addr – 主节点工作者的地址。如果环境变量 CLEARML_MULTI_NODE_MASTER_DEF_ADDR 已设置，则此参数的值将设置为 CLEARML_MULTI_NODE_MASTER_DEF_ADDR 中定义的值。如果 CLEARML_MULTI_NODE_MASTER_DEF_ADDR 不存在，但 MASTER_ADDR 存在，则此参数的值将设置为 MASTER_ADDR 中定义的值。如果这两个环境变量都不存在，则将使用传递给参数的值。如果此值为 None（默认值），则将使用主节点所在机器的私有 IP 地址。
- devices – 要使用的设备。这可以是一个正数，表示要使用的设备数量，一个索引序列或值 -1 表示应使用所有可用设备。
- hide_children – 如果为True，子任务将被隐藏。否则，它们将在UI中可见。
返回

一个包含有关多节点运行的相关信息的字典。该字典具有以下条目：
- master_addr - 主节点运行的机器的地址
- master_port - 主节点运行的机器的开放端口
- total_num_nodes - 节点的总数，包括主节点
- 队列 - 节点被加入的队列，不包括主节点
- node_rank - 当前节点的排名（主节点的排名为0）
- wait - 如果为True，主节点将等待其他节点启动

列出外部端点

list_external_endpoints(protocol=None)

列出所有分配的外部端点

参数

protocol (Optional[str]) – 如果为None，列出所有外部端点。否则，仅列出使用此协议的端点
返回类型

List[Dict]
返回

字典列表。每个字典包含以下值：
- endpoint - 原始端点。可能需要认证才能使用此端点
  - browser_endpoint - 在浏览器中使用的端点。认证将通过浏览器处理
    - port - 应用程序暴露的端口
      - protocol - 端点使用的协议

日志记录器

属性 logger

返回类型

Logger
返回

当前任务（实验）的Logger对象。

标记完成

mark_completed(ignore_errors=True, status_message=None, force=False)

使用此方法关闭并更改（远程！）执行任务的状态。

此方法关闭它所属的任务，将其状态更改为“已完成”，并终止创建该任务的Python进程。这与Task.close形成对比，后者执行前两个步骤，但不终止任何Python进程。

假设进程A创建了任务，而进程B拥有该任务的句柄，例如使用Task.get_task。然后，如果我们调用Task.mark_completed，进程A将被终止，但进程B不会。

然而，如果Task.mark_completed是从创建任务的同一进程中调用的，那么实际上，进程会自行终止。例如，在

task = Task.init(...)
task.mark_completed()
from time import sleep
sleep(30)
print('This text will not be printed!')

文本将不会被打印，因为Python进程立即终止。

参数
- ignore_errors (bool ) – 如果为True（默认），忽略任何引发的错误
- force (bool ) – 如果为True，无论当前任务状态如何，任务状态都将更改为停止。
- status_message (str ) – 可选，向停止请求添加状态更改消息。此消息将作为 status_message 存储在任务的信息面板上
返回类型

()

标记失败

mark_failed(ignore_errors=True, status_reason=None, status_message=None, force=False)

此任务停止的信号。

返回类型

()
参数
- ignore_errors (布尔值 ) –
- status_reason (可选 [ 字符串 ] ) –
- status_message (可选 [ 字符串 ] ) –
- force (布尔值 ) –

mark_started

mark_started(force=False)

手动将任务标记为已开始（自动发生）

参数

force (bool ) – 如果为True，无论当前任务状态如何，任务状态都将更改为已启动。
返回类型

()

mark_stop_request

mark_stop_request(force=False, status_message=None)

请求停止一个任务。这不会改变任务状态，但会标记一个请求，让代理或SDK实际停止任务。这将触发任务的中止回调，最终将任务状态更改为已停止并终止任务的进程。

注意：在您自己的任务上调用此操作，将导致看门狗调用on_abort回调并终止进程

参数
- force (bool ) – 如果不是True，当任务状态不是‘in_progress’时，调用将失败
- status_message (str ) – 可选，向停止请求添加状态更改消息。此消息将作为 status_message 存储在任务的信息面板上
返回类型

()

mark_stopped

mark_stopped(force=False, status_message=None)

手动将任务标记为已停止（也用于_at_exit）

参数
- force (bool ) – 如果为True，无论当前任务状态如何，任务状态都将更改为停止。
- status_message (str ) – 可选，向停止请求添加状态更改消息。此消息将作为 status_message 存储在任务的信息面板上
返回类型

()

指标管理器

属性 metrics_manager

用于管理与该任务相关的指标的指标管理器

返回类型

Metrics

模型

属性模型

任务的加载/存储模型的只读字典。

返回类型

Mapping[str, Sequence[Model]]
返回

一个类似字典的对象，具有“input”/“output”键和输入/输出属性，指向包含模型对象的类似列表的对象。每个类似列表的对象也充当字典，将模型名称映射到适当的模型实例。

获取输入/输出模型：
```
task.models.input
task.models["input"]

task.models.output
task.models["output"]
```
获取最后的输出模型：
```
task.models.output[-1]
```
按名称获取模型：
```
task.models.output["model name"]
```

移动到项目

move_to_project(new_project_id=None, new_project_name=None, system_tags=None)

将此任务移动到另一个项目

参数
- new_project_id (Optional[str]) – 任务应移动到的项目的ID。如果传递了new_project_name，则不需要。
- new_project_name (Optional[str]) – 任务应移动到的新项目的名称。如果传递了new_project_id，则不需要。
- system_tags (Optional[Sequence[str]]) – 任务应移动到的项目的系统标签。
返回类型

bool
返回

如果移动成功则为True，否则为False

名称

属性名称

返回当前任务的名称。

返回类型

str

output_models_id

属性 output_models_id

返回当前任务的输出模型ID作为字典。

返回类型

Mapping[str, str]

output_uri

属性 output_uri

此任务的存储/输出URL。这是输出模型和其他工件的默认位置。

返回类型

str
返回

URL字符串。

父级

属性 parent

返回当前任务的父任务ID（str）。

返回类型

str

项目

属性项目

返回当前任务的项目ID。

返回类型

str

发布

publish(ignore_errors=True)

此任务将发布的信号

返回类型

()
参数

ignore_errors (bool ) –

完成时发布

publish_on_completion(enable=True)

此任务将在任务完成时自动发布的信号

返回类型

()
参数

enable (bool ) –

任务查询任务

classmethod query_tasks(project_name=None, task_name=None, tags=None, additional_return_fields=None, task_filter=None)

获取与特定查询/过滤器匹配的任务ID列表。注意，如果指定了additional_return_fields，则返回包含请求字段的字典列表（每个任务一个字典）

参数
- project_name (str ) – 要获取的任务的项目名称。要获取所有项目中的实验，请使用默认值 None。（可选）对于多个可选项目名称，请使用字符串列表。
- task_name (str ) – 任务的全名或部分名称，用于在指定的project_name（如果project_name为None，则匹配所有项目）中匹配任务。此方法支持使用正则表达式进行名称匹配（如果您希望匹配特殊字符并避免任何正则表达式行为，请使用re.escape()）。（可选）
- project_name – 项目名称 (str) 任务所属的项目（使用 None 表示所有项目）
- task_name – 所选项目中的任务名称（str）返回与task_name部分匹配的任何内容，也支持正则表达式匹配。如果传入None，则返回项目中的所有任务
- 标签 (列表 ) – 根据请求的标签列表（字符串）进行过滤。要排除一个标签，请在标签前添加“-”前缀。示例：["best", "-debug"]。默认行为是使用逻辑“OR”运算符连接所有标签。要使用逻辑“AND”运算符连接所有标签，请使用“__$all”作为第一个字符串，例如：
```
["__$all", "best", "experiment", "ever"]
```
要使用AND连接所有标签，但排除某个标签，请在排除的标签前使用“__$not”，例如：
```
["__$all", "best", "experiment", "ever", "__$not", "internal", "__$not", "test"]
```
“OR”和“AND”运算符适用于其后所有标签，直到指定另一个运算符为止。 NOT运算符仅适用于紧随其后的标签。例如：
```
["__$all", "a", "b", "c", "__$or", "d", "__$not", "e", "__$and", "__$or" "f", "g"]
```
这个示例表示 (“a” AND “b” AND “c” AND (“d” OR NOT “e”) AND (“f” OR “g”))。更多信息请参见 https://clear.ml/docs/latest/docs/clearml_sdk/task_sdk/#tag-filters。
- additional_return_fields (列表 ) – 可选，如果未提供则返回任务ID列表。如果提供，则返回每个任务的字典，包含额外请求的字段。示例：returned_fields=['last_updated', 'user', 'script.repository'] 将返回一个字典列表： [{'id': 'task_id', 'last_update': datetime.datetime(), 'user': 'user_id', 'script.repository': 'https://github.com/user/'}, ]
- task_filter (dict ) – 过滤和排序任务。
  
  详情请参见backend_api.service.v?.tasks.GetAllRequest；?需要替换为适当的版本。
  - parent - (str) 按父任务ID匹配过滤
  - search_text - (str) 自由文本搜索（在任务字段的评论/名称/ID中）
  - status - List[str] 有效状态的列表。选项有：“created”（已创建）、“queued”（已排队）、“in_progress”（进行中）、“stopped”（已停止）、“published”（已发布）、“publishing”（发布中）、“closed”（已关闭）、“failed”（失败）、“completed”（已完成）、“unknown”（未知）
  - type - List[Union[str, TaskTypes]] 有效任务类型的列表。选项包括：'training', 'testing', 'inference', 'data_processing', 'application', 'monitor', 'controller', 'optimizer', 'service', 'qc', 'custom'
  - user - List[str] 根据任务的所有者用户进行过滤，提供有效的用户ID列表。
  - order_by - List[str] 按字段名称排序的列表。当使用search_text时。使用‘-’前缀指定降序。可选，建议在使用分页时使用。示例：order_by=['-last_update']
  - _all_ - dict(fields=[], pattern=’’) 匹配出现在所有字段中的字符串pattern（正则表达式）。dict(fields=['script.repository'], pattern='github.com/user')
  - _any_ - dict(fields=[], pattern=’’) 匹配出现在任何字段中的字符串模式（正则表达式）。dict(fields=[‘comment’, ‘name’], pattern=’my comment’)
  - 示例：{'status': ['stopped'], 'order_by': ["-last_update"]}, {'order_by'=['-last_update'], '_all_'=dict(fields=['script.repository'], pattern='github.com/user')}
返回类型

Union[List[str], List[Dict[str, str]]]
返回

由参数组合指定的任务（请参阅参数）。

注册中止回调

register_abort_callback(callback_function, callback_execution_timeout=30.0)

注册一个任务中止回调（仅支持单个回调函数）。传递一个函数，当任务被外部中止时，该函数将从后台线程调用。用户必须为回调函数的执行指定一个超时时间（默认为30秒），如果回调执行函数超过超时时间，任务进程将被终止。

仅从主进程调用此注册函数。

注意：Ctrl-C 不被视为外部中断，这里仅涵盖后端引发的终止

参数
- callback_function – 通过外部线程（来自主进程）调用的回调函数。传递 None 以移除现有的回调。
- callback_execution_timeout – 回调执行的最大时间（以秒为单位），超过此时间后，即使回调未返回，进程也将被终止

register_artifact

register_artifact(name, artifact, metadata=None, uniqueness_columns=True)

为当前任务注册（添加）一个工件。注册的工件会与ClearML Server（后端）动态同步。如果注册的工件被更新，更新将存储在ClearML Server（后端）中。注册的工件主要用于数据审计。

当前支持的注册工件对象类型是 pandas.DataFrame。

另请参阅 Task.unregister_artifact 和 Task.get_registered_artifacts。

info

ClearML 还支持上传的工件，这些工件是一次性上传的静态工件，不会与 ClearML 服务器（后端）动态同步。这些静态工件包括额外的对象类型。有关更多信息，请参阅 Task.upload_artifact。

参数
- name (str ) – 工件的名称。
警告
如果之前注册了同名的工件，它将被覆盖。
- artifact (对象 ) – 工件对象。
- metadata (dict ) – 一个包含任意元数据的键值对字典。该字典会出现在ClearML Web-App (UI)的ARTIFACTS标签页中。
- uniqueness_columns (Union [ bool *, * Sequence [ str ] ] ) – 用于工件唯一性比较标准的列序列，或默认值True。如果为True，则工件唯一性比较标准为所有列，与artifact.columns相同。
返回类型

无

重新加载

reload()

从clearml-server重新加载当前任务的状态。刷新所有任务的字段，包括工件/模型/参数等。

返回类型

()

remove_input_models

remove_input_models(models_to_remove)

从当前任务中移除输入模型。请注意，模型本身不会被删除，而是任务对模型的引用被移除。要删除模型本身，请参阅 Models.remove

参数

models_to_remove (Sequence [ Union [ str *, * BaseModel ] ] ) – 要从任务中移除的模型。可以是ID列表，或者是BaseModel（包括其子类：Model和InputModel）
返回类型

()

重命名

重命名(new_name)

重命名此任务

参数

new_name (str) – 此任务的新名称
返回类型

bool
返回

如果重命名成功则为True，否则为False

请求外部端点

request_external_endpoint(port, protocol='http', wait=False, wait_interval_seconds=3.0, wait_timeout_seconds=90.0)

为应用程序请求外部端点

参数
- port (int) – 应用程序正在监听的端口
- protocol (str) – http 或 tcp
- wait (bool) – 如果为True，等待端点被分配
- wait_interval_seconds (float) – 等待端点时的轮询频率
- wait_timeout_seconds (float) – 如果在等待端点时超过此超时时间，该方法将不再等待并返回 None
返回类型

Optional[Dict]
返回

如果 wait 为 False，此方法将返回 None。如果在等待时找不到端点，此方法返回 None。否则，它返回一个包含以下值的字典：
- endpoint - 原始端点。可能需要认证才能使用此端点
  - browser_endpoint - 在浏览器中使用的端点。认证将通过浏览器处理
    - port - 应用程序暴露的端口
      - protocol - 端点使用的协议

重置

reset(set_started_on_success=False, force=False)

重置任务。ClearML 在成功重置后重新加载任务。当工作程序远程执行任务时，除非将 force 参数设置为 True（这可以避免意外清除日志和指标），否则任务不会重置。

参数
- set_started_on_success (bool ) – 如果成功，自动将任务设置为已开始
  - True - 如果成功，设置为已启动。
  - False - 如果成功，不要设置为已启动。（默认）
- force (bool ) – 强制重置任务，即使任务（实验）在远程工作者中执行
  - True - 强制
  - False - 不强制（默认）
返回类型

None

本地运行

static running_locally()

任务是否在本地运行（即clearml-agent没有执行它）

返回类型

bool
返回

如果任务在本地运行，则为True。如果任务不在本地运行，则为False。

保存执行模型设计文件

save_exec_model_design_file(filename='model_design.txt', use_cache=False)

将执行模型设计保存到文件

set_archived

set_archived(archive)

归档任务或将其从归档文件夹中移除。

参数

archive (bool ) – 如果为True，则归档任务。如果为False，则确保将其从归档文件夹中移除
返回类型

()

设置工件

set_artifacts(artifacts_list=None)

更新任务所需的工件列表（tasks.Artifact）

参数

artifacts_list (list ) – 工件列表（类型为 tasks.Artifact）
返回类型

Optional[List[Artifact]]
返回

当前任务的工件列表，如果出错则为None。

设置基础Docker

set_base_docker(docker_cmd=None, docker_image=None, docker_arguments=None, docker_setup_bash_script=None)

设置此实验的基础Docker镜像如果提供，clearml-agent将使用此值在提供的Docker镜像中执行此实验。在远程运行时，调用将被忽略

参数
- docker_cmd (Optional [ str ] ) – 已弃用！复合docker容器镜像 + 参数（例如：'nvidia/cuda:11.1 -e test=1'）已弃用，请使用特定参数。
- docker_image (可选 [ str ] ) – docker 容器镜像（例如：'nvidia/cuda:11.1'）
- docker_arguments (可选 [ 联合 [ str *, * 序列 [ str ] ] ] ) – docker 执行参数（例如：‘-e ENV=1’）
- docker_setup_bash_script (可选 [ 联合 [ 字符串 *, * 序列 [ 字符串 ] ] ] ) – 在启动任务本身之前在docker开始时运行的bash脚本。示例：[‘apt update’, ‘apt-get install -y gcc’]
返回类型

()

设置评论

设置评论(comment)

为任务设置评论/描述。

参数

comment (str ) – 任务的评论/描述。
返回类型

()

设置配置对象

set_configuration_object(名称, 配置文本=无, 描述=无, 配置类型=无, 配置字典=无)

将任务的配置对象设置为文本块或自动编码的字典/列表。仅用于自动化（外部），否则使用 Task.connect_configuration。

参数
- name (str ) – 配置部分名称
- config_text (Optional[str]) – 配置作为文本块（无约束的文本字符串）通常是某种配置文件的内容
- 描述 (str ) – 配置部分的描述
- config_type (str ) – 可选的配置格式类型
- config_dict (dict ) – 使用HOCON（类似于json）编码的配置字典/列表，以存储为文本注意，您可以传递config_text或config_dict，但不能同时传递两者
返回类型

None

Task.set_credentials

classmethod set_credentials(api_host=None, web_host=None, files_host=None, key=None, secret=None, store_conf_file=False)

设置新的默认ClearML服务器（后端）主机和凭据。

这些凭证将被操作系统环境变量或ClearML配置文件clearml.conf覆盖。

warning

在初始化Task对象之前必须设置凭据。

例如，要为远程计算机设置凭据：

Task.set_credentials(
    api_host='http://localhost:8008', web_host='http://localhost:8080', files_host='http://localhost:8081',
    key='optional_credentials',  secret='optional_credentials'
)
task = Task.init('project name', 'experiment name')

参数
- api_host (str ) – API服务器URL。例如，host='http://localhost:8008'
- web_host (str ) – Web服务器URL。例如，host='http://localhost:8080'
- files_host (str ) – 文件服务器URL。例如，host='http://localhost:8081'
- key (str ) – 用户密钥（在密钥/密钥对中）。例如，key='thisisakey123'
- secret (str ) – 用户密钥（在密钥/密钥对中）。例如，secret='thisisseceret123'
- store_conf_file (bool ) – 如果为True，将当前配置存储到~/clearml.conf文件中。如果配置文件已存在，则不会进行任何更改（输出警告）。在远程运行时（即clearml-agent）不适用。
返回类型

None

设置初始迭代

set_initial_iteration(offset=0)

设置初始迭代，而不是从零开始。在从之前的检查点继续训练时非常有用。

参数

offset (int ) – 初始迭代（在起点处）
返回类型

int
返回

新设置的初始偏移量。

set_input_model

set_input_model(model_id=None, model_name=None, update_task_design=True, update_task_labels=True, name=None)

为任务设置一个新的输入模型。该模型必须“准备就绪”（状态为Published）才能用作任务的输入模型。

参数
- model_id (str ) – 模型在ClearML Server（后端）上的ID。如果未指定model_name，则必须指定model_id。
- model_name (可选 [ str ] ) – 在 artifactory 中的模型名称。model_name 用于在 ClearML Server（后端）中定位现有模型。如果未指定 model_id，则必须指定 model_name。
- update_task_design (bool) – 更新任务的设计
  - True - ClearML 从输入模型中复制任务模型设计。
  - False - ClearML 不会从输入模型中复制任务模型设计。
- update_task_labels (bool ) – 更新任务的标签枚举
  - True - ClearML 从输入模型中复制任务的标签枚举。
  - False - ClearML 不会从输入模型中复制任务的标签枚举。
- name (可选 [ str ] ) – 要存储在任务上的模型部分名称（与模型对象名称本身无关）默认值：使用模型权重文件名（不包括文件扩展名）
返回类型

()

设置模型配置

set_model_config(config_text=None, config_dict=None)

已弃用： 自版本0.14.1起已弃用：请改用Task.connect_configuration。

返回类型

None
参数
- config_text (可选 [ str ] ) –
- config_dict (可选 [ 映射 ] ) –

设置模型标签枚举

set_model_label_enumeration(enumeration=None)

在创建输出模型之前，为Task对象设置标签枚举。之后，在创建输出模型时，模型将继承这些属性。

参数

枚举 (字典 ) – 一个字符串（标签）到整数（值）对的标签枚举字典。

例如：
```
{
     "background": 0,
     "person": 1
}
```
返回类型

()

设置名称

set_name(name)

设置任务名称。

参数

name (str ) – 任务的名称。
返回类型

()

任务.设置离线

classmethod set_offline(offline_mode=False)

设置离线模式，所有数据和日志将存储在本地文件夹中，以便稍后传输

info

Task.set_offline 不能将同一个任务从离线状态移动到在线状态，也不能在 Task.create 之前应用。以下是一个错误使用 Task.set_offline 的示例：

from clearml import Task

Task.set_offline(True)
task = Task.create(project_name=’DEBUG’, task_name=”offline”)
# ^^^ an error or warning is raised, saying that Task.set_offline(True)
#     is supported only for Task.init
Task.set_offline(False)
# ^^^ an error or warning is raised, saying that running Task.set_offline(False)
#     while the current task is not closed is not supported

data = task.export_task()

imported_task = Task.import_task(task_data=data)

正确使用 Task.set_offline 的方法可以在以下示例中看到：

from clearml import Task

Task.set_offline(True)
task = Task.init(project_name=’DEBUG’, task_name=”offline”)
task.upload_artifact(“large_artifact”, “test_string”)
task.close()
Task.set_offline(False)

imported_task = Task.import_offline_session(task.get_offline_mode_folder())

参数

offline_mode (bool) – 如果为True，则开启离线模式，并且不启用与后端的通信。
返回类型

None
返回

设置包

set_packages(packages)

手动指定所需的包列表或本地的requirements.txt文件。请注意，这将覆盖所有现有的包。

远程运行时，此调用将被忽略

参数

packages (Union [ str *, * Path *, * Sequence [ str ] ] ) – 包列表或requirements.txt文件的路径。

示例：["tqdm>=2.1", "scikit-learn"] 或 "./requirements.txt" 或 "" 使用空字符串（packages=””）来清除需求部分（如果文件存在，远程执行将使用git仓库中的requirements.txt）
返回类型

()

设置参数

set_parameter(名称, 值, 描述=None, 值类型=None)

设置单个任务参数。这将覆盖此参数的任何先前值。

参数
- name (str ) – 参数名称。
- value (str ) – 参数值。
- 描述 (可选 [ str ] ) – 参数描述。
- value_type (可选 [ 任意 ] ) – 参数的类型（转换为字符串并存储）
返回类型

()

设置参数

**设置参数(*args, kwargs)

设置任务的参数。此方法设置一组完整的键值参数对，但不支持参数描述（输入是一个键值对的字典）。请注意参数字典是扁平的：即 {'Args/param': 'value'} 将在“Args”部分设置参数“param”为“value”

参数
- args (dict ) – 位置参数，可以是一个或多个字典或（键，值）可迭代对象。它们会被合并成一个单一的键值对字典。
- kwargs (Any ) – 键值对，合并到从 args 创建的参数字典中。
返回类型

()

set_parameters_as_dict

set_parameters_as_dict(dictionary)

从字典中设置Task对象的参数。字典可以是嵌套的。这不会将字典链接到Task对象。它执行一次性更新。这与Task.connect方法的行为相同。

返回类型

None
参数

字典 (Dict ) –

设置父级

设置父级(parent)

设置任务的父任务。

参数

parent (str * 或 * Task ) – 任务的父任务ID（或父任务对象）。设置为None表示没有父任务。
返回类型

()

设置进度

set_progress(progress)

设置任务的进度（0 - 100）进度是由用户计算和报告的字段。

参数

progress (int ) – 数值 (0 - 100)
返回类型

()

设置项目

set_project(project_id=None, project_name=None)

通过指定项目名称或ID来设置当前任务的项目

返回类型

()
参数
- project_id (可选 [ str ] ) –
- project_name (可选 [ str ] ) –

Task.set_random_seed

classmethod set_random_seed(random_seed)

为任何新初始化的任务设置默认的随机种子

参数

random_seed (可选 [ int ] ) – 如果为 None 或 False，则禁用随机种子初始化。如果为 True，则使用默认的随机种子，否则在初始化新任务时使用提供的整数值进行随机种子初始化。
返回类型

()

设置仓库

set_repo(repo=None, branch=None, commit=None)

指定一个要附加到函数的仓库。允许用户在指定的仓库内执行任务，使他们能够从仓库加载模块/脚本。注意，执行工作目录将是仓库的根文件夹。支持git仓库的URL链接，以及本地仓库路径（自动转换为远程git/提交，如当前检出的那样）。示例远程URL：“https://github.com/user/repo.git”。示例本地仓库副本：“./repo” - 将自动存储远程仓库URL和基于本地克隆副本的提交ID。在远程执行时，此调用不会覆盖仓库数据（它被忽略）

参数
- repo (可选 [ str ] ) – 可选，用于指定远程仓库的URL，或者本地git仓库的路径。使用空字符串来清除仓库。示例: “https://github.com/allegroai/clearml.git” 或 “~/project/repo” 或 “”
- branch (可选 [ str ] ) – 可选，指定远程仓库分支（如果使用本地仓库路径，则忽略）。使用空字符串来清除分支。
- commit (可选 [ str ] ) – 可选，指定仓库的提交ID（如果使用本地仓库路径，则忽略）。使用空字符串来清除提交。
返回类型

()

Task.set_resource_monitor_iteration_timeout

classmethod set_resource_monitor_iteration_timeout(seconds_from_start=30.0, wait_for_first_iteration_to_start_sec=180.0, max_wait_for_first_iteration_to_start_sec=1800.0)

设置ResourceMonitor等待首次报告标量/图的最大持续时间（以秒为单位）。如果在达到超时时间之前没有任何报告，ResourceMonitor将根据任务开始时间（而不是基于迭代）开始报告机器统计信息。注意！应在Task.init之前调用。

参数
- seconds_from_start (float) – 在默认情况下，基于实验开始时间的秒数，等待标量/绘图报告的最大秒数，然后切换到机器统计报告。
- wait_for_first_iteration_to_start_sec (float) – 设置初始等待时间（秒），用于迭代报告作为资源监控的x轴，如果超时则恢复到seconds_from_start
- max_wait_for_first_iteration_to_start_sec (float) – 设置允许资源监控在开始报告seconds_from_start后恢复到迭代报告x轴的最大时间（秒）
返回类型

bool
返回

如果成功则为真

设置脚本

set_script(repository=None, branch=None, commit=None, diff=None, working_dir=None, entry_point=None)

设置任务的脚本。

示例：

task.set_script(
    repository='https://github.com/allegroai/clearml.git,
    branch='main',
    working_dir='examples/reporting',
    entry_point='artifacts.py'
)

参数
- repository (Optional[str]) – 可选的，远程仓库的URL。使用空字符串（“”）来清除仓库条目。
- branch (Optional[str]) – 可选，选择特定的仓库分支/标签。使用空字符串（“”）清除分支条目。
- commit (Optional[str]) – 可选，设置特定的git提交ID。使用空字符串（“”）清除提交ID条目。
- diff (Optional[str]) – 可选，设置“git diff”部分。使用空字符串（“”）清除git-diff条目。
- working_dir (Optional[str]) – 可选，启动脚本的工作目录。
- entry_point (Optional[str]) – 可选项，仓库内执行的路径。
返回类型

None

设置标签

设置标签(tags)

设置当前任务的标签。请注意，这将覆盖已经存在的任何内容。

参数

标签 (序列 ( 字符串 ) ) – 要设置的任何标签序列。
返回类型

()

设置任务类型

set_task_type(task_type)

设置任务的task_type。

参数

task_type (str * 或 * TaskTypes ) – 任务的 task_type。

有效的任务类型：
- TaskTypes.training
- TaskTypes.testing
- TaskTypes.inference
- TaskTypes.data_processing
- TaskTypes.application
- TaskTypes.monitor
- TaskTypes.controller
- TaskTypes.optimizer
- TaskTypes.service
- TaskTypes.qc
- TaskTypes.custom
返回类型

()

设置用户属性

**set_user_properties(*iterables, properties)

为此任务设置用户属性。用户属性可以包含以下字段（所有字段均为字符串类型）：名称 / 值 / 描述 / 类型

示例：

task.set_user_properties(backbone='great', stable=True)
task.set_user_properties(backbone={"type": int, "description": "network type", "value": "great"}, )
task.set_user_properties(
    {"name": "backbone", "description": "network type", "value": "great"},
    {"name": "stable", "description": "is stable", "value": True},
)

参数

iterables (Union[Mapping[str, Union[str, dict, None]], Iterable[dict]]) – 可迭代的属性，每个可以是：

A dictionary of string key (name) to either a string value (value) a dict (property details). If the value

是一个字典，它必须包含一个“value”字段。例如：

{
    "property_name": {"description": "This is a user property", "value": "property value"},
    "another_property_name": {"description": "This is user property", "value": "another value"},
    "yet_another_property_name": "some value"
}

An iterable of dicts (each representing property details). Each dict must contain a “name” field and a

“value”字段。例如：

[
    {
        "name": "property_name",
        "description": "This is a user property",
        "value": "property value"
    },
    {
        "name": "another_property_name",
        "description": "This is another user property",
        "value": "another value"
    }
]

properties (Union[str, dict, int, float, None]) – 额外的属性关键字参数。键是属性名称，值可以是一个字符串（属性值）或一个字典（属性详情）。如果值是一个字典，它必须包含一个“value” 字段。例如：

{
    "property_name": "string as property value",
    "another_property_name": {
        "type": "string",
        "description": "This is user property",
        "value": "another value"
    }
}

返回类型

bool

设置AWS上传

setup_aws_upload(bucket, subdir=None, host=None, key=None, secret=None, token=None, region=None, multipart=True, secure=True, verify=True, profile=None)

设置S3上传选项。

参数
- bucket – AWS 存储桶名称
- subdir – AWS 存储桶中的子目录
- host – 主机名。仅在需要使用非AWS S3解决方案（如本地Minio服务器）时必需）
- key – AWS访问密钥。如果未提供，我们将尝试从配置文件中获取密钥（特定于存储桶，然后是全局）
- secret – AWS 密钥。如果未提供，我们将尝试从配置文件中获取密钥（特定于存储桶，然后是全局）
- token – AWS 双因素认证令牌
- region – Bucket 区域。如果 Bucket 不在默认区域（us-east-1）中，则必须提供。
- multipart – 服务器支持多部分。仅在使用不支持多部分的非AWS S3解决方案时需要。
- secure – 服务器支持HTTPS。仅在使用仅支持HTTPS的非AWS S3解决方案时需要。
- verify – 是否验证SSL证书。
- profile – AWS配置文件仅在使用仅支持带有自签名证书的HTTPS的非AWS S3解决方案时需要。
返回类型

None

设置 Azure 上传

setup_azure_upload(account_name, account_key, container_name=None)

设置Azure上传选项。

参数
- account_name (str) – 账户名称
- account_key (str) – 用于验证账户的密钥
- container_name (Optional[str]) – 要上传到的blob容器的名称
返回类型

None

设置GCP上传

setup_gcp_upload(bucket, subdir='', project=None, credentials_json=None, pool_connections=None, pool_maxsize=None)

设置GCP上传选项。

参数
- bucket (str) – 要上传到的存储桶
- subdir (str) – 要上传到的存储桶中的子目录
- 项目 (Optional[str]) – 存储桶所属的项目
- credentials_json (Optional[str]) – 包含凭证的JSON文件的路径
- pool_connections (Optional[int]) – 缓存的urllib3连接池数量
- pool_maxsize (Optional[int]) – 池中保存的最大连接数
返回类型

None

开始

started(ignore_errors=True, force=False)

此任务开始的信号。

返回类型

()
参数
- ignore_errors (bool ) –
- force (bool ) –

状态

属性状态

任务的状态。为了保持任务的更新。只有当访问此值时，ClearML才会重新加载任务状态信息。

返回字符串：TaskStatusEnum 状态

返回类型

str

停止请求

stop_request(ignore_errors=True, force=False, status_message=None)

注意：在您自己的任务上调用此操作，将导致看门狗调用on_abort回调并终止进程

参数
- force (bool ) – 如果不是True，当任务状态不是‘in_progress’时，调用将失败
- ignore_errors (bool ) – 如果为False，则在出错时引发异常
- status_message (str ) – 可选，向停止请求添加状态更改消息。此消息将作为 status_message 存储在任务的信息面板上
返回类型

()

已停止

stopped(ignore_errors=True, force=False, status_reason=None, status_message=None)

此任务停止的信号。

返回类型

()
参数
- ignore_errors (bool ) –
- force (bool ) –
- status_reason (可选 [ str ] ) –
- status_message (可选 [ str ] ) –

任务ID

属性 task_id

返回当前任务的ID。

返回类型

str

任务类型

属性 task_type

返回当前任务的类型。

有效的任务类型：

TaskTypes.training (默认)

TaskTypes.testing

TaskTypes.inference

TaskTypes.data_processing

TaskTypes.application

TaskTypes.monitor

TaskTypes.controller

TaskTypes.optimizer

TaskTypes.service

TaskTypes.qc

TaskTypes.custom

返回类型

str

取消注册工件

unregister_artifact(name)

取消注册（移除）一个已注册的工件。这将从ClearML用于与ClearML Server（后端）同步工件的监视列表中移除该工件。

important

调用此方法不会从任务中删除工件。它只是停止ClearML监控该工件。

当调用此方法时，ClearML 会立即获取工件的最后快照。

返回类型

None
参数

name (str ) –

更新模型描述

update_model_desc(new_model_desc_file=None)

更改任务的模型描述。

返回类型

()
参数

new_model_desc_file (可选 [ str ] ) –

更新输出模型

update_output_model(model_path, name=None, comment=None, tags=None, model_name=None, iteration=None, auto_delete_file=True)

更新任务的输出模型权重文件。首先，ClearML 将文件上传到预配置的输出目标（请参阅任务的 output.destination 属性或调用 setup_upload 方法），然后 ClearML 更新与任务关联的模型对象。API 调用使用上传文件的 URI 和其他参数提供的值。

注意：本地模型文件将被上传到任务的output_uri目的地，如果未指定output_uri，将使用默认的文件服务器来存储模型文件。

参数
- model_path (str) – 要上传的本地权重文件或文件夹。如果提供了远程URI（例如 http:// 或 s3:// 等），则URI将按原样存储，无需上传。
- name (Optional[str]) – 更新后的模型名称。如果未提供，名称将是模型权重文件的文件名，不带扩展名。
- 评论 (Optional[str]) – 更新后的模型描述。（可选）
- 标签 (Optional[Sequence[str]]) – 更新后的模型标签。（可选）
- model_name (Optional[str]) – 如果提供了模型名称，它将出现在模型仓库中。（可选）默认值：Task.name - name
- 迭代 (Optional[int]) – 当前存储模型的迭代次数（可选）
- auto_delete_file (bool ) – 上传后删除临时文件（可选）
  - True - 删除（默认）
  - False - 不删除
返回类型

str
返回

上传的权重文件的URI。注意：上传是在后台线程中完成的，而函数调用会立即返回

更新参数

**update_parameters(*args, kwargs)

更新任务的参数。此方法更新一组完整的键值参数对，但不支持参数描述（输入是一个键值对的字典）。请注意参数字典是扁平的：即 {'Args/param': 'value'} 会将“Args”部分中的参数“param”设置为“value”

参数
- args (dict ) – 位置参数，可以是一个或多个字典或（键，值）可迭代对象。它们会被合并成一个单一的键值对字典。
- kwargs (Any ) – 键值对，合并到从 args 创建的参数字典中。
返回类型

()

更新任务

update_task(task_data)

使用task_data字典中的配置更新当前任务。另请参阅export_task()以检索任务配置。

参数

task_data (dict) – 包含完整任务配置的字典
返回类型

bool
返回

如果任务更新成功，则返回 True

上传工件

upload_artifact(name, artifact_object, metadata=None, delete_after_upload=False, auto_pickle=None, preview=None, wait_on_upload=False, extension_name=None, serialization_function=None, retries=0)

上传（添加）一个静态工件到任务对象。工件在后台上传。

当前支持的上传（静态）工件类型包括：

string / pathlib2.Path - 指向工件文件的路径。如果指定了通配符或文件夹，则ClearML会创建并上传一个ZIP文件。
字典 - ClearML 将字典存储为 .json（或参见 extension_name）文件并上传它。
pandas.DataFrame - ClearML 将 pandas.DataFrame 存储为 .csv.gz（压缩的 CSV）（或参见 extension_name）文件并上传它。
numpy.ndarray - ClearML 将 numpy.ndarray 存储为 .npz（或参见 extension_name）文件并上传。
PIL.Image - ClearML 将 PIL.Image 存储为 .png（或参见 extension_name）文件并上传。
任何 - 如果使用 auto_pickle=True 调用，对象将被序列化并上传。

参数
- name (str ) – The artifact name.
warning
如果之前上传了同名的工件，则会被覆盖。
- artifact_object (object ) – 工件对象。
- metadata (dict ) – 一个包含任意元数据的键值对字典。该字典会出现在ClearML Web-App (UI)的ARTIFACTS标签页中。
- delete_after_upload (bool ) – 上传后，删除本地的工件副本
  - True - 删除工件的本地副本。
  - False - 不删除。（默认）
- auto_pickle (bool ) – 如果为True且artifact_object不是以下类型之一： pathlib2.Path, dict, pandas.DataFrame, numpy.ndarray, PIL.Image, url (string), local_file (string), 则artifact_object将被pickle并作为pickle文件artifact上传（文件扩展名为.pkl）。如果设置为None（默认值），将使用sdk.development.artifacts.auto_pickle配置值。
- 预览 (任意 ) – 工件预览
- wait_on_upload (bool) – 是否应同步上传，强制上传完成后再继续。
- extension_name (str ) – 文件扩展名，指示工件应存储的格式。
  
  以下是支持的，取决于工件类型（当extension_name为None时，默认值适用）：
  - 任何 - .pkl 如果传递，将取代任何其他序列化类型，并且始终将对象进行pickle处理
  - 字典 - .json, .yaml (默认 .json)
  - pandas.DataFrame - .csv.gz, .parquet, .feather, .pickle (默认 .csv.gz)
  - numpy.ndarray - .npz, .csv.gz (默认 .npz)
  - PIL.Image - 无论PIL支持什么扩展名（默认.png）
  - 如果设置了serialization_function参数 - 则支持任何扩展
- Union [ bytes **, ** bytearray ] **] ** serialization_function (Callable [ Any , ) – 一个序列化函数，它接受一个任意类型的参数，该参数是要序列化的对象。该函数应返回一个表示序列化对象的bytes或bytearray对象。请注意，对象将立即使用此函数进行序列化，因此即使可能，也不会使用其他序列化方法（例如pandas.DataFrame.to_csv）。在使用Artifact.get方法获取此工件时，要反序列化此工件，请使用其deserialization_function参数。
- retries (int ) – 上传工件失败前的重试次数。如果为0，则不会重试上传
- serialization_function (可选 [ Callable [ [ Any ] *, * Union [ bytes *, * bytearray ] ] ] ) –
返回类型

布尔
返回

上传的状态。
- True - 上传成功。
- False - 上传失败。
Improvement

如果工件对象类型不受支持，则引发ValueError。

等待外部端点

wait_for_external_endpoint(wait_interval_seconds=3.0, wait_timeout_seconds=90.0, protocol='http')

等待分配外部端点

参数
- wait_interval_seconds (float) – 等待端点时的轮询频率
- wait_timeout_seconds (float) – 如果在等待端点时超过此超时时间，该方法将不再等待
- protocol (Optional[str]) – http 或 tcp。根据协议等待分配一个端点。如果为 None，则等待所有支持的协议
返回类型

Union[Dict, None, List[Optional[Dict]]]
返回

如果在等待时没有找到任何端点，此方法返回 None。如果已指定协议，则返回包含以下值的字典：
- endpoint - 原始端点。可能需要认证才能使用此端点
  - browser_endpoint - 用于浏览器的端点。认证将通过浏览器处理
    - port - 应用程序暴露的端口
      - protocol - 端点使用的协议如果未指定协议，则返回包含上述值的字典列表，针对每个请求并等待的协议

等待状态

等待状态(status=(TaskTypes.completed, TaskTypes.stopped, TaskTypes.closed), raise_on_status=(TaskTypes.failed), check_interval_sec=60.0)

等待任务达到定义的状态。

参数
- status (Iterable [ Task.TaskStatusEnum ] ) – 等待的状态。默认为 ('completed', 'stopped', 'closed')
- raise_on_status (可选 [ 可迭代 [ Task.TaskStatusEnum ] ] ) – 如果任务的状态与这些值之一匹配，则引发 RuntimeError。默认值为 (‘failed’)。
- check_interval_sec (float ) – 两次检查之间的间隔时间，单位为秒。默认为60秒。
提高

如果状态是{raise_on_status}之一，则抛出RuntimeError。
返回类型

()

class Task()​

任务.添加需求​

添加标签​

工件​

缓存目录​

任务.clone​

关闭​

评论​

已完成​

连接​

连接配置​

connect_label_enumeration​

任务创建​

create_function_task​

当前任务​

任务.调试_模拟_远程任务​

删除​

删除工件​

delete_parameter​

删除用户属性​

任务出队​

任务.入队​

远程执行​

导出任务​

刷新​

任务.force_requirements_env_freeze​

任务.强制存储独立脚本​

任务.获取全部​

获取所有报告的标量​

获取已归档​

获取基础Docker​

任务.按名称获取​

获取配置对象​

获取配置对象为字典​

获取配置对象​

获取调试样本​

get_executed_queue​

获取HTTP路由器​

获取初始迭代​

获取标签数量描述​

获取标签枚举​

获取最后一次迭代​

获取最后的标量指标​

获取日志记录器​

获取模型配置字典​

获取模型配置文本​

获取模型设计​

获取模型​

任务.获取排队任务数量​

获取班级数量​

获取离线模式文件夹​

获取输出目的地​

获取输出日志网页​

获取参数​

获取参数​

get_parameters_as_dict​

获取进度​

任务.获取项目ID​

获取项目名称​

获取项目对象​

任务.获取项目​

获取已注册的工件​

获取报告的控制台输出​

获取报告的图表​

获取报告的标量​

获取报告的单值​

获取报告的单值​

获取需求​

获取脚本​

获取状态​

获取状态信息​

获取标签​

任务.获取任务​

任务获取任务输出日志网页​

任务.获取任务​

获取用户属性​

任务.忽略需求​

任务.导入离线会话​

任务.导入任务​

任务初始化​

class Task()

任务.添加需求

添加标签

工件

缓存目录

任务.clone

关闭

评论

已完成

连接

连接配置

connect_label_enumeration

任务创建

create_function_task

当前任务

任务.调试_模拟_远程任务

删除

删除工件

delete_parameter

删除用户属性

任务出队

任务.入队

远程执行

导出任务

刷新

任务.force_requirements_env_freeze

任务.强制存储独立脚本

任务.获取全部

获取所有报告的标量

获取已归档

获取基础Docker

任务.按名称获取

获取配置对象

获取配置对象为字典

获取配置对象

获取调试样本

get_executed_queue

获取HTTP路由器

获取初始迭代

获取标签数量描述

获取标签枚举

获取最后一次迭代

获取最后的标量指标

获取日志记录器

获取模型配置字典

获取模型配置文本

获取模型设计

获取模型

任务.获取排队任务数量

获取班级数量

获取离线模式文件夹

获取输出目的地

获取输出日志网页

获取参数

获取参数

get_parameters_as_dict

获取进度

任务.获取项目ID

获取项目名称

获取项目对象

任务.获取项目

获取已注册的工件

获取报告的控制台输出

获取报告的图表

获取报告的标量

获取报告的单值

获取报告的单值

获取需求

获取脚本

获取状态

获取状态信息

获取标签

任务.获取任务

任务获取任务输出日志网页

任务.获取任务

获取用户属性

任务.忽略需求

任务.导入离线会话

任务.导入任务

任务初始化