任务

class Task(private=None, **kwargs)

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

术语“主执行任务”是指当前正在运行实验的 Task 上下文。Python 实验脚本可以创建并且只能创建一个主执行任务。它是可追踪的，并且在脚本运行完毕 ClearML 将 Task 存储在 ClearML Server (后端) 中后，它是可修改、可重现、可由 worker 执行的，并且您可以复制它以进行进一步实验。

Task 类及其方法允许您创建和管理实验，以及执行高级实验功能，例如自动机器学习 (autoML)。

警告

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

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

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

重要

在某些情况下，Task.init 可能会返回一个已存储在 ClearML Server (已初始化) 中的 Task 对象，而不是创建一个新的 Task。有关详细说明，请参阅 Task.init 方法。

手动创建一个新的 Task (不应用自动日志记录) - Task.create
获取当前正在运行的 Task - Task.current_task
获取另一个 (不同的) Task - Task.get_task

信息

ClearML 文档通常将 Task 称为“Task (实验)”。

“Task”指代 ClearML Python Client Package 中的类，您 Python 实验脚本中的对象，以及 ClearML Server 和 ClearML Agent 协同工作的实体。

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

因此，“Task”实际上就是一个“实验”，而“Task (实验)”涵盖了其在整个 ClearML 中的用法。

此 Task 行为的例外情况是子任务 (不可重现的任务)，它们不使用主执行任务。创建子任务总是会创建一个具有新 Task ID 的新 Task。

警告

不要手动构造 Task！请使用 Task.init 或 Task.get_task

参数
- private (Optional [ Any ] ) – (可选)
- kwargs (Any ) – (可选)
返回类型

None

Task.add_requirements

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')

信息

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

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

None

add_tags

add_tags(tags)

向此任务添加标签。旧标签不会被删除。在远程执行 Task (实验) 时，此方法无效。

参数

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

None

artifacts

property artifacts: Dict[str, clearml.binding.artifacts.Artifact]

Task 工件（名称，工件对象）的只读字典。

返回类型

Dict[str, Artifact]
返回

工件。

cache_dir

property cache_dir: pathlib2.Path

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

返回类型

Path

Task.clone

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

创建 Task (实验) 的副本 (克隆)。克隆的 Task 的状态为 Draft 且可修改。

使用此方法管理实验和进行 autoML。

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

新的克隆 Task (实验)。
返回类型

任务

close

close()

关闭当前 Task 并将其状态更改为“Completed”。允许您从打开 Task 的进程中手动关闭 Task。

此方法不会终止 (当前) Python 进程，与 Task.mark_completed 不同。

在调用 Task.close 关闭 Task 后，相应的对象不能再使用，像 Task.connect 或 Task.connect_configuration 这样的方法将抛出 ValueError。要再次获取表示该 Task 的对象，请使用像 Task.get_task 这样的方法。

警告

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

返回类型

None

comment

property comment: str

返回当前 Task 的 (用户定义的) 注释。

返回类型

str

completed

completed(ignore_errors=True)

信息

已弃用，请改用 mark_completed(…)

返回类型

()
参数

ignore_errors (bool ) –

connect

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

连接一个对象到 Task 对象。这会将一个实验组件 (实验的一部分) 连接到实验。例如，实验组件可以是一个包含一些超参数的有效对象，或一个 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 仅支持 dict 和 TaskParameter 对象，其他支持的类型应省略此参数。(可选) 例如，通过设置 name=’General’，连接的字典将位于超参数部分的 General بخش 下。而通过设置 name=’Train’，连接的字典将位于超参数部分的 Train بخش 下。
- ignore_remote_overrides (bool) – 如果为 True，则在远程运行时忽略 UI/后端覆盖。默认为 False，这意味着在 UI/后端中所做的任何更改都将在远程执行中应用。
返回类型

Any
返回

它将返回作为 mutable 参数传递给方法的同一对象，但如果对象类型为 dict 则除外。对于 dict，Task.connect 将返回装饰为 ProxyDictPostWrite 的 dict。这样做是为了允许传播来自连接对象的更新。
抛出

如果传入不受支持的对象，则引发异常。

connect_configuration

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

连接配置字典或配置文件 (pathlib.Path / str) 到 Task 对象。此方法应在读取配置文件之前调用。

例如，本地文件

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)。

参数
- configuration (Union[Mapping, list, Path, str]) – 配置。这通常用于模型训练过程中的配置。
  
  指定以下之一
  - 字典/列表 - 包含配置的字典。ClearML 将配置存储在 ClearML Server (后端) 中，采用可编辑的 HOCON 格式 (类似于 JSON 的格式)。
  - 一个 pathlib2.Path 字符串 - 配置文件的路径。ClearML 存储文件的内容。本地路径必须是相对路径。当在 worker 中远程执行 Task 时，从 ClearML Server (后端) 获取的内容将覆盖文件的内容。
- name (str ) – 配置部分名称。默认值: ‘General’。允许用户存储多个配置字典/文件
- description (str ) – 配置部分描述 (文本)。默认值: None
- ignore_remote_overrides (bool ) – 如果为 True，则在远程运行时忽略 UI/后端覆盖。默认为 False，这意味着在 UI/后端中所做的任何更改都将在远程执行中应用。
返回类型

Union[dict, Path, str]
返回

如果指定了字典，则返回一个字典。如果指定了 pathlib2.Path / 字符串，则返回本地配置文件的路径。配置对象。

connect_label_enumeration

connect_label_enumeration(enumeration, ignore_remote_overrides=False)

将标签枚举字典连接到 Task (实验) 对象。

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

参数
- enumeration (dict ) – 一个从字符串 (标签) 到整数 (值) 对的标签枚举字典。
例如
```
{
     "background": 0,
     "person": 1
}
```
- ignore_remote_overrides (bool) – 如果为 True，则在远程运行时忽略 UI/后端覆盖。默认为 False，这意味着在 UI/后端中所做的任何更改都将在远程执行中应用。
返回类型

Dict[str, int]
返回

标签枚举字典 (JSON)。

Task.create

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, binary=None, module=None, detect_repository=True)

在系统中手动创建并填充新的 Task (实验)。如果代码尚未包含对 Task.init 的调用，则传入 add_task_init_call=True，代码将在远程执行时 (即由 clearml-agent 执行时) 被修补

信息

此方法总是创建一个新的 Task。使用 Task.init 方法为正在运行的进程自动创建并填充任务。要引用现有 Task，请调用 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]) – 添加在设置 Task 环境之前在 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，则不自动检测本地仓库
- binary (Optional[str]) – 用于启动入口点的二进制文件
- module (Optional[str]) – 如果指定，则执行名为 module 的模块，而不是执行脚本。表示 script 参数为空。Module 可以包含多个执行参数，例如：module=”my.module arg1 arg2”
- detect_repository (bool) – 如果为 True，则在未指定仓库时检测仓库。如果为 False，则在任何情况下都不检测仓库。如果指定了 repo 则忽略
返回

新创建的 Task (实验)
返回类型

任务

create_function_task

create_function_task(func, func_name=None, task_name=None, **kwargs)

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

信息

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

远程 Tasks 继承创建 Task 的环境

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

在远程 Task 中，执行流程在到达此函数调用之前与创建 Task 相同

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

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

Optional[Task]

Task.current_task

classmethod current_task()

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

返回

当前正在运行的 Task (实验)。
返回类型

任务

Task.debug_simulate_remote_task

classmethod debug_simulate_remote_task(task_id, reset_task=False)

模拟指定 Task 的远程执行。此调用将模拟 Task 如同由 ClearML-Agent 执行时的行为。这意味着配置将从后端服务器进入代码 (与手动执行相反，手动执行时后端记录代码参数)。请谨慎使用。

参数
- task_id (str) – 要模拟的 Task ID，注意所有配置都将取自指定的 Task，而忽略代码的初始值，就像由 ClearML agent 执行时一样
- reset_task (bool) – 如果为 True，目标 Task 会自动清除/重置。
返回类型

()

delete

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)。如果提供了 callback，则忽略此参数。
- skip_models_used_by_other_tasks (bool) – 如果为 True，则其他任务使用的模型不会被删除 (默认为 True)
- raise_on_error (bool) – 如果为 True，则在遇到错误时将抛出异常。如果为 False，将打印错误但不抛出异常。
- callback (Optional[Callable[[str, str], bool]]) – 一个可选的 callback，接受 uri 类型 (字符串) 和 uri (字符串)，将为每个工件和模型调用。如果提供，则忽略 delete_artifacts_and_models 参数。返回 True 表示应删除工件/模型，否则返回 False。
返回类型

bool
返回

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

delete_artifacts

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

根据工件名称，从 Task 中删除工件列表。

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

bool
返回

如果成功则为 True

delete_parameter

delete_parameter(name, force=False)

根据其完整名称 Section/name 删除参数。

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

bool
返回

如果参数成功删除则为 True

delete_user_properties

delete_user_properties(*iterables)

删除此任务的超参数。

参数

iterables (Iterable[Union[dict, Iterable[str]]]) – 超参数键的可迭代对象。每个都是一个可迭代对象，其可能的值代表要删除的超参数条目，值格式为
- 包含 ‘section’ 和 ‘name’ 字段的字典
- 可迭代对象 (例如 tuple、list 等)，其前两个项表示 ‘section’ 和 ‘name’
返回类型

bool

Task.dequeue

classmethod dequeue(task)

从执行队列中出队列 (移除) Task。

参数

task (Task/str ) – 要出队列的 Task。指定 Task 对象或 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 - 入队列的 Task 数量 (整数或 null)。
字段
- status - 实验状态。
- status_reason - 上次状态更改的原因。
- status_message - 有关状态的信息。
- status_changed - 上次状态更改的日期和时间 (ISO 8601 格式)。
- last_update - Task 创建、更新、更改，或报告此任务事件的最后时间。
changed, or events for this task were reported.
- execution.queue - Task 入队列的队列 ID。null 表示未入队列。
updated - 已更新的 Task 数量 (整数或 null)。

Task.enqueue

classmethod enqueue(task, queue_name=None, queue_id=None, force=False)

通过将其添加到执行队列中，将 Task 入队列以执行。

信息

worker 守护程序必须在队列处监听，以便 worker 获取 Task 并执行它，请参阅 ClearML 文档中的“ClearML Agent”。

参数
- task (Task/str ) – 要入队列的 Task。指定 Task 对象或 Task ID。
- queue_name (str ) – 队列名称。如果未指定，则必须指定 queue_id。
- queue_id (str ) – 队列 ID。如果未指定，则必须指定 queue_name。
- force (bool ) – 如果为 True，则在入队列之前根据需要重置 Task
返回类型

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 - 入队列的 Task 数量 (整数或 null)。
- updated - 已更新的 Task 数量 (整数或 null)。
- 字段
  - status - 实验状态。
  - status_reason - 上次状态更改的原因。
  - status_message - 有关状态的信息。
  - status_changed - 上次状态更改的日期和时间 (ISO 8601 格式)。
  - last_update - 最后 Task 更新时间，包括 Task 创建、更新、更改，或报告此任务事件 (ISO 8601 格式)。
  - execution.queue - Task 入队列的队列 ID。null 表示未入队列。

execute_remotely

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

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

信息

如果任务正在远程运行 (即由 clearml-agent 执行)，此调用将是空操作 (即不执行任何操作)。

参数
- queue_name (Optional[str]) – 用于将任务入队列的队列名称。如果为 None，此调用将退出进程而不将任务入队列。
- clone (bool) – 克隆 Task 并执行新克隆的 Task
  
  值如下
  - True - 将创建此 Task 的克隆副本并将其入队列，而不是此 Task。
  - False - Task 将被入队列。
- exit_process (bool) – 函数调用结束后将退出调用进程。
  - True - 退出进程 (exit(0))。注意：如果 clone==False，则 exit_process 必须为 True。
  - False - 不退出进程。
返回 Task

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

Optional[Task]

export_task

export_task()

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

返回类型

dict
返回

Task 的配置字典。

flush

flush(wait_for_uploads=False)

刷新任何未提交的报告或控制台日志。

参数

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

bool

Task.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

Task.force_store_standalone_script

classmethod force_store_standalone_script(force=True)

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

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

参数

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

None

Task.get_all

classmethod get_all(session=None, log=None, **kwargs)

根据特定投影列出所有 Task。

参数
- session (Session ) – 用于向 API 发送请求的会话对象。
- log (logging.Logger ) – Log 对象。
- 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

get_all_reported_scalars(x_axis='iter')

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

信息

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

参数

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

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

dict: 嵌套标量图：dict[title(str), dict[series(str), dict[axis(str), list(float)]]]

get_archived

get_archived()

返回 Task 的归档状态

返回类型

bool
返回

如果为 True，则 Task 已归档，否则未归档。

get_base_docker

get_base_docker()

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

返回类型

str

Task.get_by_name

classmethod get_by_name(task_name)

信息

此方法已弃用，请改用 Task.get_task。

以 Task 对象的形式返回系统中任意位置具有给定名称的最新任务。

参数

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

~TaskInstance
返回

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

get_configuration_object

get_configuration_object(name)

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

参数

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

Optional[str]
返回

Task 的配置作为文本块 (无限制文本字符串)。如果配置名称无效则返回 None

get_configuration_object_as_dict

get_configuration_object_as_dict(name)

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

参数

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

Union[dict, list, None]
返回

Task 的配置作为解析后的 dict。如果配置名称无效则返回 None

get_configuration_objects

get_configuration_objects()

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

返回类型

Optional[Mapping[str, str]]
返回

Task 的配置作为字典 (配置名称作为键)，文本块作为值 (无限制文本字符串)

get_debug_samples

get_debug_samples(title, series, n_last_iterations=None)

参数
- title (str ) – 调试样本的标题，在 UI 中也称为指标
- 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

get_http_router

get_http_router()

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

示例用法

返回类型

HttpRouter

get_initial_iteration

get_initial_iteration()

返回初始迭代偏移量，默认值为 0。在从先前检查点继续训练时很有用

返回类型

int
返回

初始迭代偏移量。

get_label_num_description

get_label_num_description()

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

返回类型

Dict[int, str]

get_labels_enumeration

get_labels_enumeration()

获取标签枚举字典，从字符串 (标签) 到整数 (值) 对的标签枚举字典。

返回类型

Mapping[str, int]
返回

包含标签枚举的字典。

get_last_iteration

get_last_iteration()

获取最后报告的迭代，这是 Task 报告指标的最后一个迭代。

信息

最后报告的迭代不在本地缓存中。此方法会向 ClearML Server (后端) 发送请求。

返回类型

int
返回

最后报告的迭代号。

get_last_scalar_metrics

get_last_scalar_metrics()

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

例如

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

返回类型

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

最后标量指标。

get_logger

get_logger()

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

返回类型

日志记录器
返回

此 Task (实验) 的 Logger。

get_model_config_dict

get_model_config_dict()

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

返回类型

Dict

get_model_config_text

get_model_config_text()

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

返回类型

str

get_model_design

get_model_design()

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

返回类型

str
返回

模型配置作为文本块。

get_models

get_models()

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

返回类型

Mapping[str, Sequence[Model]]
返回

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

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

Task.get_num_enqueued_tasks

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_num_of_classes()

基于任务标签的类数量

返回类型

int

get_offline_mode_folder

get_offline_mode_folder()

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

返回类型

Optional[pathlib2.Path]

get_output_destination

get_output_destination(extra_path=None, **kwargs)

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

返回类型

str
参数
- extra_path (Optional [ str ] ) –
- kwargs (Any ) – (可选)

get_output_log_web_page

get_output_log_web_page()

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

返回类型

str
返回

http/s URL 链接。

get_parameter

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

获取参数的值。

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

Any
返回

参数值 (如果参数未定义则为默认值)。

get_parameters

get_parameters(backwards_compatibility=True, cast=False)

获取 Task 的参数。此方法返回一组完整的键值对参数，但不支持参数描述 (结果是键值对字典)。注意返回的参数字典是扁平的：即 {'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)

将 Task 参数作为原始嵌套字典获取。

信息

如果 cast 为 False (默认)，则不对值进行解析。它们按原样返回。

参数

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

Dict

get_progress

get_progress()

获取 Task 的进度 (0 - 100)

返回类型

Optional[int]
返回

Task 进度（整数）。如果进度不存在，则返回 None

Task.get_project_id

classmethod get_project_id(project_name, search_hidden=True)

返回项目的唯一 ID (str)。如果多个项目匹配 project_name，则返回最后更新的项目。如果没有项目匹配请求的名称，则返回 None

返回类型

Optional[str]
返回

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

get_project_name

get_project_name()

获取当前 Task 的项目名称。

返回类型

Optional[str]

get_project_object

get_project_object()

将当前 Task 的项目作为 python 对象获取。

返回类型

dict

Task.get_projects

classmethod get_projects(**kwargs)

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

返回类型

List[Project]
返回

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

kwargs (Any ) – (可选)

get_registered_artifacts

get_registered_artifacts()

获取一个字典，其中包含 Task 的注册 (动态同步) 工件 (名称，工件对象)。

信息

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

返回类型

Dict[str, Artifact]
返回

注册 (动态同步) 的工件。

get_reported_console_output

get_reported_console_output(number_of_reports=1)

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

参数

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

Sequence[str]
返回

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

get_reported_plots

get_reported_plots(max_iterations=None)

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

信息

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

示例

[{
  "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]
返回

list: 字典列表，每个代表一个图表

get_reported_scalars

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

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

信息

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

信息

调用此方法将返回可能下采样的标量。返回的最大样本数量为 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’：自 epoch 以来的毫秒时间戳，‘iso_time’：绝对时间
返回类型

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

dict: 嵌套标量图：dict[title(str), dict[series(str), dict[axis(str), list(float)]]]

get_reported_single_value

get_reported_single_value(name)

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

参数

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

Optional[float]
返回

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

get_reported_single_values

get_reported_single_values()

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

返回类型

Dict[str, float]
返回

包含报告值的字典

get_requirements

get_requirements()

获取任务的依赖

返回类型

RequirementsDict
返回

一个 RequirementsDict 对象，包含 pip、conda、orig_pip 依赖。

get_script

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

get_status()

返回任务状态，而不刷新整个 Task 对象 (仅刷新状态属性)

TaskStatusEnum: [“created”, “in_progress”, “stopped”, “closed”, “failed”, “completed”, “queued”, “published”, “publishing”, “unknown”]

返回类型

str
返回

str: Task 状态（字符串）(TaskStatusEnum)

get_status_message

get_status_message()

返回任务状态，而不刷新整个 Task 对象 (仅刷新状态属性)。同时返回与状态更改关联的最后一条消息。

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

返回类型

(typing.Union[str, NoneType], typing.Union[str, NoneType])
返回

(Task 状态（字符串），最后一条消息)

get_tags

get_tags()

获取当前 Task 的所有标签。

返回类型

Sequence[str]

Task.get_task

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

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

例如

以下代码演示了调用 Task.get_task 向另一个 Task 报告标量。来自测试的 Logger.report_scalar 输出与名为 training 的 Task 相关联。这使得训练和测试可以并行运行，因为它们初始化了不同的 Task (有关初始化 Task 的信息，请参阅 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 的项目名称。
- task_name (str ) – 在指定的 project_name (或 project_name 为 None 时所有项目) 中匹配 Task 的全名或部分名称。此方法支持正则表达式进行名称匹配 (如果您希望匹配特殊字符并避免任何正则表达式行为，请使用 re.escape())。(可选) 要匹配确切的任务名称 (即非部分匹配)，请在字符串开头/结尾添加 ^/$，例如：“^exact_task_name_here$”
- tags (list ) – 基于请求的标签列表进行过滤 (字符串)。要排除标签，请在标签前添加“-”前缀。示例：["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://clearml.machinelearning.org.cn/docs/latest/docs/clearml_sdk/task_sdk/#tag-filters。
- allow_archived (bool ) – 仅当不使用特定 task_id 时适用。如果为 True (默认)，允许返回归档的 Task；如果为 False，则过滤掉归档的 Task
- task_filter (bool ) – 仅当不使用特定 task_id 时适用。传递附加查询过滤器，在项目/名称之上。有关详细信息，请参阅 Task.get_tasks。
返回

由 ID 或项目名称/实验名称组合指定的 Task (请参阅参数)。
返回类型

任务

Task.get_task_output_log_web_page

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

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

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

str
返回

http/s URL 链接。

Task.get_tasks

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

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

特定 Task ID 列表。
根据特定字段过滤 Task

项目名称 (包括部分匹配)、任务名称 (包括部分匹配)、标签使用 task_filter 应用额外的进阶过滤

信息

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

参数
- task_ids (list ( str ) ) – 要获取的实验 ID (系统 UUID)。如果指定了 task_ids，则忽略 project_name 和 task_name。
- project_name (str ) – 要获取的 Task 的项目名称。要获取所有项目中的实验，请使用默认值 None。(可选) 可以使用字符串列表表示多个可选项目名称。
- task_name (str ) – 在指定的 project_name (或 project_name 为 None 时所有项目) 中匹配 Task 的全名或部分名称。此方法支持正则表达式进行名称匹配 (如果您希望匹配特殊字符并避免任何正则表达式行为，请使用 re.escape())。(可选) 要匹配确切的任务名称 (即非部分匹配)，请在字符串开头/结尾添加 ^/$，例如：“^exact_task_name_here$”
- tags (list ) – 基于请求的标签列表进行过滤 (字符串)。要排除标签，请在标签前添加“-”前缀。示例：["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://clearml.machinelearning.org.cn/docs/latest/docs/clearml_sdk/task_sdk/#tag-filters。
- allow_archived (bool ) – 如果为 True (默认)，允许返回归档的 Task；如果为 False，则过滤掉归档的 Task
- task_filter (dict ) – 过滤和排序 Task。
  
  有关详细信息，请参阅 backend_api.service.v?.tasks.GetAllRequest；? 需要替换为适当的版本。
  - parent - (str) 按父任务 ID 匹配过滤
  - search_text - (str) 自由文本搜索 (在任务字段 comment/name/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] 基于 Task 的用户所有者过滤，提供有效用户 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'))
返回

由参数组合指定的 Task (请参阅参数)。
返回类型

List[Task]

get_user_properties

get_user_properties(value_only=False)

获取此任务的用户属性。返回将用户属性名称映射到用户属性详情字典的字典。

参数

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

Dict[str, Union[str, dict]]

Task.ignore_requirements

classmethod ignore_requirements(package_name)

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

参数

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

None

Task.import_offline_session

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

上传 Task 的离线会话 (执行)。完整的 Task 执行包括仓库详情、已安装包、工件、日志、指标和调试样本。此函数也可用于使用离线执行的任务继续先前执行的任务。

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

Optional[str]
返回

新创建的任务 ID 或继续任务的 ID (previous_task_id)

Task.import_task

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

从先前导出的 Task 配置导入 (创建) Task (请参阅 Task.export_task)。也可用于编辑/更新现有 Task (通过传入 target_task 和 update=True)。

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

Optional[Task]
返回

如果 Task 已导入/更新则返回 True

Task.init

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)

如果满足以下条件，则创建一个新的 Task (实验)：

Task 从未运行过。ClearML Server 中没有存储具有相同 task_name 和 project_name 的 Task。
Task 以前运行过 (具有相同的 task_name 和 project_name)，并且 (a) 它存储了模型和/或工件，或 (b) 其状态为 Published，或 (c) 它已归档。
通过调用 Task.init 并设置 reuse_last_task_id=False 来强制创建一个新的 Task。

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

信息

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

例如：以下代码首次运行时，将创建一个新的 Task。状态将为 Completed。

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

如果此代码再次运行，它不会创建新的 Task。它没有存储模型或工件，它不是 Published 状态 (其状态为 Completed)，它没有被归档，并且没有强制创建一个新 Task。

如果 Task 处于 Published 或 Archived 状态并再次运行，它将创建一个具有新 Task ID 的新 Task。

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

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

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

参数
- project_name (str ) – 项目名称，实验将在其中创建。如果项目不存在，则创建。如果 project_name 为 None，则使用仓库名称。(可选)
- task_name (str ) – Task (实验) 名称。如果 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
- tags (Optional[Sequence[str]]) – 向创建的 Task 添加标签 (str) 列表。例如：tags=[‘512x512’, ‘yolov3’]
- reuse_last_task_id (bool ) – 强制创建新的 Task (实验)，使用先前使用的 Task ID，
  
  以及相同的项目和 Task 名称。如果先前执行的 Task 包含工件或模型，则不会被重用 (覆盖)，而会创建一个新的 Task。当 Task 被重用时，先前的执行输出会被删除，包括控制台输出和日志。值如下
  - True - 重用最后 Task ID。(默认)
  - False - 强制创建一个新的 Task (实验)。
  - 字符串 - 您还可以指定要重用的 Task ID (字符串)，而不是基于项目/名称组合的缓存 ID。
- continue_last_task (bool ) – 继续执行先前执行的 Task (实验)。继续执行
  
  先前执行的 Task 时，所有先前的工件/模型/日志保持不变。新的日志将根据先前执行的最大迭代值继续迭代/步骤。例如，最后报告的 train/loss 标量迭代为 100，下一次报告将是迭代 101。值如下
  - True - 继续最后 Task ID。由 reuse_last_task_id 显式指定或隐式遵循与 reuse_last_task_id 相同的逻辑
  - False - 覆盖先前 Task 的执行 (默认)。
  - 字符串 - 您还可以指定要继续的 Task ID (字符串)。这等同于 continue_last_task=True 和 reuse_last_task_id=一个 Task ID 字符串。
  - 整数 - 指定初始迭代偏移量 (覆盖自动的 last_iteration_offset)。传入 0 以禁用自动的 last_iteration_offset 或指定不同的初始偏移量。您可以指定要与 reuse_last_task_id='task_id_here' 一起使用的 Task ID
- output_uri (str ) – 输出模型和其他工件的默认位置。如果为 True，将使用默认的
  
  files_server 进行模型存储。在默认位置，ClearML 会为输出创建一个子文件夹。如果设置为 False，本地运行将不会上传输出模型和工件，远程运行将不使用通过 default_output_uri 提供的任何默认值。子文件夹结构如下：<输出目标名称> / <项目名称> / <任务名称>.。请注意，对于云存储，您必须安装适用于您的云存储类型的 ClearML 包，然后配置您的存储凭据。有关详细信息，请参阅 ClearML 文档中的“存储”。以下是支持位置的 output_uri 值示例
  - 共享文件夹：/mnt/share/folder
  - S3：s3://bucket/folder
  - Google Cloud Storage：gs://bucket-name/folder
  - Azure Storage：azure://company.blob.core.windows.net/folder/
  - 默认文件服务器：True
- auto_connect_arg_parser (Union[bool, Mapping[str, bool]]) – 自动将 argparse 对象连接到 Task。支持的参数
  
  解析器包有：argparse, click, python-fire, jsonargparse。值如下
  - True - 自动连接。(默认)
  - False - 不自动连接。
  - 字典 - 除了布尔值外，您还可以使用字典进行精细控制连接参数。
  字典的键是 argparse 变量名，值是布尔值。False 值将指定的参数排除在 Task 的参数部分之外。字典中缺失的键默认为 True，您可以通过添加 \* 键并设置为 False 将其更改为 False。空字典默认为 False。
  
  例如
```
auto_connect_arg_parser={"do_not_include_me": False, }
```
```
auto_connect_arg_parser={"only_include_me": True, "*": False}
```
  信息
  要手动连接 argparse，请使用 Task.connect。
- auto_connect_frameworks (Union[bool, Mapping[str, Union[bool, str, list]]]) – 自动连接框架。这包括修补 MatplotLib、XGBoost、
  
  scikit-learn、Keras 回调和 TensorBoard/X，以便将图表、图形和模型位置序列化到 ClearML Server (后端)，除了原始输出目标外。值如下
  - 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 实例的 kwargs 字典。键可以是：
    - report_start_sec 或 first_report_sec 或 seconds_from_start - 等待标量/图表报告的最长时间（秒），在此之前将回退到基于实验开始时间经过的秒数的机器统计信息报告
    - wait_for_first_iteration_to_start_sec - 设置等待迭代报告的初始时间（秒），用于资源监控的 x 轴；如果超时，则回退到 seconds_from_start
    - max_wait_for_first_iteration_to_start_sec - 设置最大时间（秒），允许资源监控在开始报告 seconds_from_start 后，回退到使用迭代报告作为 x 轴
    - report_mem_used_per_process 或 report_global_mem_used - 兼容性特性，报告整台机器的内存使用情况。默认 (false)，仅报告运行中的进程及其子进程的内存使用情况
- auto_connect_streams (Union[bool, Mapping[str, bool]]) – 控制标准输出 (stdout) 和标准错误 (stderr) 的自动日志记录。
  
  值如下
  - True - 自动连接 (默认)
  - False - 不自动连接
  - 字典 - 除了布尔值之外，您还可以使用字典来精细控制标准输出 (stdout) 和标准错误 (stderr)。字典的键是“stdout”、“stderr”和“logging”，值是布尔值。字典中缺失的键默认为 False，空字典默认为 False。注意，默认行为是记录标准输出/标准错误。logging 模块作为标准错误日志记录的附带产品被记录。
例如
```
auto_connect_streams={'stdout': True, 'stderr': True, 'logging': False}
```
- deferred_init (bool) – （默认：False）等待 Task 完全初始化（常规行为）。
  
  ** BETA 功能！请谨慎使用 **。
  
  如果设置为 True，Task.init 函数立即返回，所有初始化/与 clearml-server 的通信都在后台线程中运行。返回的对象是常规 Task 对象的完整代理，因此一切都将按预期工作。默认行为可以通过设置 CLEARML_DEFERRED_TASK_INIT=1 来控制。注意：
  - 对返回的代理 Task 对象的任何访问实际上会等待 Task.init 完成。例如：print(task.name) 将等待 Task.init 在后台完成，然后返回任务原始对象的 name 属性
  - 在 Task.init 在后台完成之前，自动日志记录（控制台/指标）可能会被遗漏
  - 如果通过 agent 运行，此参数将被忽略，并且 Task init 会同步调用（默认）
返回

主执行 Task (Task context)
返回类型

任务

input_models_id

property input_models_id: Mapping[str, str]

返回当前 Task 的输入模型 ID 字典。

返回类型

Mapping[str, str]

is_current_task

is_current_task()

已弃用: 自 0.13.0 版以来已弃用: 此方法已弃用。请改用 Task.is_main_task。

此 Task 对象是否是主执行 Task（由 Task.init 初始返回的）

返回类型

bool
返回

此 Task 对象是否是主执行 Task
- True - 是主执行 Task。
- False - 不是主执行 Task。

is_main_task

is_main_task()

此 Task 对象是否是主执行 Task（由 Task.init 初始返回的）

信息

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

Task.init() == task

返回类型

bool
返回

此 Task 对象是否是主执行 Task
- True - 是主执行 Task。
- False - 不是主执行 Task。

Task.is_offline

classmethod is_offline()

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

返回类型

bool
返回

布尔型的离线模式状态

labels_stats

property labels_stats: dict

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

返回类型

dict

last_worker

property last_worker: str

处理该 Task 的最后一个 worker 的 ID。

返回类型

str
返回

worker ID。

launch_multi_node

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

将当前 Task 的多个克隆排队到队列中，允许 Task 由多个 worker 并行运行。以这种方式运行的每个 Task 称为一个节点 (node)。每个节点都有一个 rank。初始化其他节点执行的节点称为主节点 (master node)，其 rank 等于 0。

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

total_num_nodes - 节点总数，包括主节点
queue - 节点排队进入的队列

将设置以下环境变量：

MASTER_ADDR - 主节点运行所在机器的地址
MASTER_PORT - 主节点运行所在机器的开放端口
WORLD_SIZE - 节点总数，包括主节点
RANK - 当前节点的 rank（主节点 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。例如，要实现这一点，可以在“附加 ClearML 配置”部分设置以下 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 (int) – 需要排队的节点总数，包括主节点（远程运行时主节点应已排队）
- port (Optional[int]) – 主节点打开的端口。如果设置了环境变量 CLEARML_MULTI_NODE_MASTER_DEF_PORT，此参数的值将设置为 CLEARML_MULTI_NODE_MASTER_DEF_PORT 中定义的值。如果 CLEARML_MULTI_NODE_MASTER_DEF_PORT 不存在，但 MASTER_PORT 存在，则此参数的值将设置为 MASTER_PORT 中定义的值。如果两个环境变量都不存在，将使用传递给参数的值
- queue (Optional[str]) – 节点排队进入的队列。可以与主节点排队进入的队列不同。如果为 None，节点将排队进入与主节点相同的队列
- wait (bool) – 如果为 True，主节点将等待其他节点启动
- addr (Optional[str]) – 主节点 worker 的地址。如果设置了环境变量 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 (Union[int, Sequence[int], None]) – 要使用的设备。这可以是一个正数，表示要使用的设备数量；一个索引序列；或值 -1 表示应使用所有可用设备。
- hide_children – 如果为 True，子 Task 将被隐藏。否则，它们将在 UI 中可见
返回

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

list_external_endpoints

list_external_endpoints(protocol=None)

列出所有已分配的外部端点

参数

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

List[Dict]
返回

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

logger

property logger: clearml.logger.Logger

返回类型

日志记录器
返回

当前 Task (实验) 的 Logger 对象。

mark_completed

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

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

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

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

然而，如果从创建该 Task 的同一进程中调用了 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，Task 状态将更改为 stopped（停止），不论当前 Task 处于何种状态。
- status_message (str ) – 可选，添加状态更改消息到停止请求。此消息将作为 status_message 存储在 Task 的信息面板上
返回类型

()

mark_failed

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

表示此 Task 已停止的信号。

返回类型

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

mark_started

mark_started(force=False)

手动将 Task 标记为已启动（自动发生）

参数

force (bool ) – 如果为 True，Task 状态将更改为 started（已启动），不论当前 Task 处于何种状态。
返回类型

()

mark_stop_request

mark_stop_request(force=False, status_message=None)

请求停止一个 Task。这不会更改 Task 状态，但会标记一个请求，以便 agent 或 SDK 实际停止 Task。这将触发 Task 的中止回调，并在最后将 Task 状态更改为 stopped（已停止）并杀死 Task 的进程

注意：在您自己的 Task 上调用此方法将导致 watchdog 调用 on_abort 回调并杀死进程

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

()

mark_stopped

mark_stopped(force=False, status_message=None)

手动将 Task 标记为已停止（也在 _at_exit 中使用）

参数
- force (bool ) – 如果为 True，Task 状态将更改为 stopped（停止），不论当前 Task 处于何种状态。
- status_message (str ) – 可选，添加状态更改消息到停止请求。此消息将作为 status_message 存储在 Task 的信息面板上
返回类型

()

metrics_manager

property metrics_manager: clearml.backend_interface.metrics.interface.Metrics

用于管理与此 Task 相关指标的指标管理器

返回类型

Metrics

models

property models: Mapping[str, Sequence[clearml.model.Model]]

Task 已加载/存储模型的只读字典。

返回类型

Mapping[str, Sequence[Model]]
返回

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

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

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

move_to_project

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

将此 Task 移动到另一个项目

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

bool
返回

如果移动成功返回 True，否则返回 False

name

property name: str

返回当前 Task 的名称。

返回类型

str

output_models_id

property output_models_id: Mapping[str, str]

返回当前 Task 的输出模型 ID 字典。

返回类型

Mapping[str, str]

output_uri

property output_uri: str

此 Task 的存储/输出 URL。这是输出模型和其他 artifact 的默认位置。

返回类型

str
返回

URL 字符串。

parent

property parent: str

返回当前 Task 的父 Task ID (str)。

返回类型

str

project

property project: str

返回当前 Task 的项目 ID。

返回类型

str

publish

publish(ignore_errors=True)

表示此 Task 将被发布的信号

返回类型

()
参数

ignore_errors (bool ) –

publish_on_completion

publish_on_completion(enable=True)

表示此 Task 将在 Task 完成时自动发布的信号

返回类型

()
参数

enable (bool ) –

Task.query_tasks

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

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

参数
- project_name (str ) – 要获取的 Task 的项目名称。要获取所有项目中的实验，请使用默认值 None。(可选) 可以使用字符串列表表示多个可选项目名称。
- task_name (str ) – 要匹配的 Task 的全名或部分名称，在指定的 project_name 中（如果 project_name 为 None，则在所有项目中）。此方法支持使用正则表达式进行名称匹配（如果您想匹配特殊字符并避免任何正则表达式行为，请使用 re.escape()）。(可选)
- project_name – Task 所属的项目名称 (str)（使用 None 表示所有项目）
- task_name – 所选项目中的 Task 名称 (str)。返回 task_name 的任何部分匹配，也支持正则表达式匹配。如果传递 None，返回项目中的所有 Task
- tags (list ) – 基于请求的标签列表进行过滤 (字符串)。要排除标签，请在标签前添加“-”前缀。示例：["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://clearml.machinelearning.org.cn/docs/latest/docs/clearml_sdk/task_sdk/#tag-filters。
- additional_return_fields (list ) – 可选，如果未提供，返回 Task ID 列表。如果提供，返回每个 Task 的字典，包含附加请求的字段。示例：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 ) – 过滤和排序 Task。
  
  有关详细信息，请参阅 backend_api.service.v?.tasks.GetAllRequest；? 需要替换为适当的版本。
  - parent - (str) 按父任务 ID 匹配过滤
  - search_text - (str) 自由文本搜索 (在任务字段 comment/name/id 中)
  - status - List[str] 有效状态列表。选项有：“created”, “queued”, “in_progress”, “stopped”, “published”, “publishing”, “closed”, “failed”, “completed”, “unknown”
  - type - List[Union[str, TaskTypes]] 有效 Task 类型列表。选项包括：“training”、“testing”、“inference”、“data_processing”、“application”、“monitor”、“controller”、“optimizer”、“service”、“qc”、“custom”
  - user - List[str] 基于 Task 的用户所有者过滤，提供有效用户 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')}
返回类型

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

由参数组合指定的 Task (请参阅参数)。

register_abort_callback

register_abort_callback(callback_function, callback_execution_timeout=30.0)

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

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

注意：Ctrl-C 不被视为外部操作，此处仅包含由后端触发的中止

参数
- callback_function (Optional[Callable]) – 将通过外部线程调用的回调函数（来自主进程）。传递 None 以移除现有回调
- callback_execution_timeout (float) – 回调执行的最长时间（秒），超过此时间后，进程将被终止，即使回调函数尚未返回

register_artifact

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

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

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

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

信息

ClearML 还支持上传的 artifact，后者是静态 artifact 的一次性上传，它们不与 ClearML Server (后端) 动态同步。这些静态 artifact 包含其他对象类型。更多信息请参阅 Task.upload_artifact。

参数
- name (str ) – artifact 的名称。
警告
如果之前注册过同名 artifact，则会覆盖它。
- artifact (object ) – artifact 对象。
- metadata (dict ) – 包含任何元数据的键值对字典。此字典随实验一起显示在 ClearML Web-App (UI) 的 ARTIFACTS 标签页中。
- uniqueness_columns (Union[bool, Sequence[str]]) – 用于 artifact 唯一性比较标准的列序列，或默认值 True。如果为 True，artifact 唯一性比较标准是所有列，这与 artifact.columns 相同。
返回类型

None

reload

reload()

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

返回类型

()

remove_input_models

remove_input_models(models_to_remove)

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

参数

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

()

rename

rename(new_name)

重命名此 Task

参数

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

bool
返回

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

request_external_endpoint

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

reset(set_started_on_success=False, force=False)

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

参数
- set_started_on_success (bool ) – 如果成功，自动将 Task 设置为 started（已启动）
  - True - 如果成功，设置为 started（已启动）。
  - False - 如果成功，不设置为 started（已启动）。(默认)
- force (bool ) – 强制重置 Task，即使在 worker 中远程执行 Task（实验）时
  - True - 强制
  - False - 不强制（默认）
返回类型

None

running_locally

static running_locally()

Task 是否在本地运行（即，不是由 clearml-agent 执行）

返回类型

bool
返回

True，如果 Task 在本地运行。False，如果 Task 不在本地运行。

save_exec_model_design_file

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

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

返回类型

str
参数
- filename (str ) –
- use_cache (bool ) –

set_archived

set_archived(archive)

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

参数

archive (bool) – 如果为 True，归档 Task。如果为 False，确保它已从归档文件夹中移除
返回类型

()

set_artifacts

set_artifacts(artifacts_list=None)

artifacts 列表 (tasks.Artifact) 用于更新 Task

参数

artifacts_list (list ) – artifact 列表 (类型 tasks.Artifact)
返回类型

Optional[List[Artifact]]
返回

当前 Task 的 Artifact 列表，如果出错则为 None。

set_base_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 (Optional[str]) – docker 容器镜像（示例：‘nvidia/cuda:11.1’）
- docker_arguments (Union[Sequence[str], str, None]) – docker 执行参数（示例：‘-e ENV=1’）
- docker_setup_bash_script (Union[Sequence[str], str, None]) – 在 docker 启动 Task 本身之前在 docker 开头运行的 bash 脚本。示例：['apt update', 'apt-get install -y gcc']
返回类型

()

set_comment

set_comment(comment)

为 Task 设置评论/描述。

参数

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

()

set_configuration_object

set_configuration_object(name, config_text=None, description=None, config_type=None, config_dict=None)

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

参数
- name (str ) – 配置部分名称
- config_text (Optional[str]) – 作为文本块的配置（无限制的文本字符串），通常是某种配置文件的内容
- description (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 Server (后端) 主机和凭据。

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

警告

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

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

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

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

None

set_initial_iteration

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)

为 Task 设置新的输入模型。模型必须处于“就绪”状态（状态为 Published）才能用作 Task 的输入模型。

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

()

set_model_config

set_model_config(config_text=None, config_dict=None)

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

返回类型

None
参数
- config_text (Optional [ str ] ) –
- config_dict (Optional [ Mapping ] ) –

set_model_label_enumeration

set_model_label_enumeration(enumeration=None)

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

参数

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

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

()

set_name

set_name(name)

设置 Task 名称。

参数

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

()

Task.set_offline

类方法 set_offline(offline_mode=False)

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

信息

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

set_packages(packages)

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

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

参数

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

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

()

set_parameter

set_parameter(name, value, description=None, value_type=None)

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

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

()

set_parameters

set_parameters(*args, **kwargs)

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

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

()

set_parameters_as_dict

set_parameters_as_dict(dictionary)

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

返回类型

None
参数

dictionary (Dict ) –

set_parent

set_parent(parent)

设置任务的父任务。

参数

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

()

set_progress

set_progress(progress)

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

参数

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

()

set_project

set_project(project_id=None, project_name=None)

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

返回类型

()
参数
- project_id (Optional [ str ] ) –
- project_name (Optional [ str ] ) –

Task.set_random_seed

类方法 set_random_seed(random_seed)

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

参数

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

()

set_repo

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

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

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

()

Task.set_resource_monitor_iteration_timeout

类方法 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）等待报告第一个标量/图表的最大持续时间（秒）。如果在达到超时时尚未报告任何内容，资源监控器将开始基于任务开始时间（而不是基于迭代）报告机器统计信息。注意！应在 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
返回

成功时返回 True

set_script

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

set_tags

set_tags(tags)

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

参数

tags (Sequence ( str ) ) – 要设置的任意标签序列。
返回类型

()

set_task_type

set_task_type(task_type)

设置任务的任务类型。

参数

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

有效的任务类型
- 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

set_user_properties(*iterables, **properties)

设置此任务的用户属性。用户属性可以包含以下字段（所有类型均为字符串）：name / value / description / type

示例

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]]) – 属性可迭代对象，每个可以是

一个字符串键（名称）到字符串值（值）或字典（属性详情）的字典。如果该值

是一个字典，则它必须包含一个“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"
}

一个字典的可迭代对象（每个代表属性详情）。每个字典必须包含一个“name”字段和一个

“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

setup_aws_upload

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 (str) – AWS 存储桶名称
- subdir (Optional[str]) – AWS 存储桶中的子目录
- host (Optional[str]) – 主机名。仅在使用非 AWS S3 解决方案（例如本地 Minio 服务器）时需要）
- key (Optional[str]) – AWS 访问密钥。如果未提供，我们将尝试从配置文件中获取密钥（优先存储桶特定配置，其次全局配置）
- secret (Optional[str]) – AWS 秘密密钥。如果未提供，我们将尝试从配置文件中获取密钥（优先存储桶特定配置，其次全局配置）
- token (Optional[str]) – AWS 2FA 令牌
- region (Optional[str]) – 存储桶区域。如果存储桶不在默认区域 (us-east-1) 中，则需要此参数
- multipart (bool) – 服务器支持分段上传。仅在使用不支持分段上传的非 AWS S3 解决方案时需要。
- secure (bool) – 服务器支持 HTTPS。仅在使用仅支持 HTTPS 的非 AWS S3 解决方案时需要。
- verify (bool) – 是否验证 SSL 证书。
- profile (Optional[str]) – AWS 配置文件。仅在使用仅支持带有自签名证书的 HTTPS 的非 AWS S3 解决方案时需要。
返回类型

None

setup_azure_upload

setup_azure_upload(account_name, account_key, container_name=None)

设置 Azure 上传选项。

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

None

setup_gcp_upload

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

设置 GCP 上传选项。

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

None

started

started(ignore_errors=True, force=False)

标记此任务已启动。

返回类型

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

status

property status: str

任务状态。为了保持任务最新，ClearML 仅在访问此值时重新加载任务状态信息。

return str: TaskStatusEnum status

返回类型

str

stop_request

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

注意：在您自己的 Task 上调用此方法将导致 watchdog 调用 on_abort 回调并杀死进程

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

()

stopped

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

表示此 Task 已停止的信号。

返回类型

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

task_id

property task_id: str

返回当前任务的 ID。

返回类型

str

task_type

property task_type: str

返回当前任务的类型。

有效的任务类型

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

unregister_artifact(name)

取消注册（移除）已注册的制品。这会从 ClearML 用于与 ClearML Server（后端）同步制品的监视列表中移除该制品。

重要

调用此方法不会从任务中移除制品。它只是停止 ClearML 监视该制品。

调用此方法时，ClearML 会立即获取该制品的最后快照。

返回类型

None
参数

name (str ) –

update_model_desc

update_model_desc(new_model_desc_file=None)

更改任务的模型描述。

返回类型

()
参数

new_model_desc_file (Optional [ str ] ) –

update_output_model

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]) – 更新后的模型名称。如果未提供，则名称将是模型权重文件的文件名（不带扩展名）。
- comment (Optional[str]) – 更新后的模型描述。（可选）
- tags (Optional[Sequence[str]]) – 更新后的模型标签。（可选）
- model_name (Optional[str]) – 如果提供，此名称将作为模型在模型制品库中显示。（可选）默认值：Task.name - name
- iteration (Optional[int]) – 当前存储模型的迭代次数（可选）
- auto_delete_file (bool ) – 上传后删除临时文件（可选）
  - True - 删除（默认）
  - False - 不删除
返回类型

str
返回

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

update_parameters

update_parameters(*args, **kwargs)

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

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

()

update_task

update_task(task_data)

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

参数

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

bool
返回

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

upload_artifact

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 文件。
dict - 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）文件并上传。
Any - 如果调用时 auto_pickle=True，对象将被序列化（pickle）并上传。

参数
- name (str ) – 制品名称。
警告
如果之前上传了同名的制品，则会被覆盖。
- 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 文件制品上传（文件扩展名为 .pkl）。如果设置为 None（默认），将使用 sdk.development.artifacts.auto_pickle 配置值。
- preview (object ) – 制品预览
- wait_on_upload (bool ) – 上传是否应同步，强制上传在继续之前完成。
- extension_name (str ) – 文件扩展名，指示制品的存储格式。
  
  根据制品类型，支持以下格式（当 extension_name 为 None 时应用默认值）
  - Any - 如果传入，.pkl 会取代任何其他序列化类型，并且总是对对象进行序列化（pickle）
  - dict - .json, .yaml (默认 .json)
  - pandas.DataFrame - .csv.gz, .parquet, .feather, .pickle (默认 .csv.gz)
  - numpy.ndarray - .npz, .csv.gz (默认 .npz)
  - PIL.Image - PIL 支持的任何扩展名（默认 .png）
  - 如果设置了 serialization_function 参数 - 支持任何扩展名
- serialization_function (Optional[Callable[[Any], Union[bytes, bytearray]]]) – 一个序列化函数，接受任意类型的单个参数（即要序列化的对象）。该函数应返回一个 bytes 或 bytearray 对象，表示序列化后的对象。请注意，对象将立即使用此函数进行序列化，因此不会使用其他序列化方法（例如 pandas.DataFrame.to_csv），即使可能。在使用 Artifact.get 方法获取此制品时，要进行反序列化，请使用其 deserialization_function 参数。
- retries (int ) – 上传制品失败前的重试次数。如果为 0，则不重试上传
返回类型

bool
返回

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

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

wait_for_external_endpoint

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 - 端点使用的协议。如果未指定协议，则返回一个字典列表，其中包含请求并等待的每个协议的上述值。

wait_for_status

wait_for_status(status=(TaskTypes.completed, TaskTypes.stopped, TaskTypes.closed), raise_on_status=(TaskTypes.failed), check_interval_sec=60.0)

等待任务达到指定状态。

参数
- status (Iterable[TaskStatusEnum]) – 要等待的状态。默认为 (‘completed’, ‘stopped’, ‘closed’, )
- raise_on_status (Optional[Iterable[TaskStatusEnum]]) – 如果任务状态匹配其中一个值，则引发 RuntimeError。默认为 (‘failed’)。
- check_interval_sec (float) – 两次检查之间的间隔（秒）。默认为 60 秒。
抛出

如果状态是 {raise_on_status} 中的一个，则引发 RuntimeError。
返回类型

()

class Task(private=None, **kwargs)​

Task.add_requirements​

add_tags​

artifacts​

cache_dir​

Task.clone​

close​

comment​

completed​

connect​

connect_configuration​

connect_label_enumeration​

Task.create​

create_function_task​

Task.current_task​

Task.debug_simulate_remote_task​

delete​

delete_artifacts​

delete_parameter​

delete_user_properties​

Task.dequeue​

Task.enqueue​

execute_remotely​

export_task​

flush​

Task.force_requirements_env_freeze​

Task.force_store_standalone_script​

Task.get_all​

get_all_reported_scalars​

get_archived​

get_base_docker​

Task.get_by_name​

get_configuration_object​

get_configuration_object_as_dict​

get_configuration_objects​

get_debug_samples​

get_executed_queue​

get_http_router​

get_initial_iteration​

get_label_num_description​

get_labels_enumeration​

get_last_iteration​

get_last_scalar_metrics​

get_logger​

get_model_config_dict​

get_model_config_text​

get_model_design​

get_models​

Task.get_num_enqueued_tasks​

get_num_of_classes​

get_offline_mode_folder​

get_output_destination​

get_output_log_web_page​

get_parameter​

get_parameters​

get_parameters_as_dict​

get_progress​

Task.get_project_id​

get_project_name​

get_project_object​

Task.get_projects​

get_registered_artifacts​

get_reported_console_output​

get_reported_plots​

get_reported_scalars​

get_reported_single_value​

get_reported_single_values​

get_requirements​

get_script​

get_status​

get_status_message​

get_tags​

Task.get_task​

Task.get_task_output_log_web_page​

Task.get_tasks​

get_user_properties​

Task.ignore_requirements​

Task.import_offline_session​

Task.import_task​

Task.init​

class Task(private=None, **kwargs)

Task.add_requirements

add_tags

artifacts

cache_dir

Task.clone

close

comment

completed

connect

connect_configuration

connect_label_enumeration

Task.create

create_function_task

Task.current_task

Task.debug_simulate_remote_task

delete

delete_artifacts

delete_parameter

delete_user_properties

Task.dequeue

Task.enqueue

execute_remotely

export_task

flush

Task.force_requirements_env_freeze

Task.force_store_standalone_script

Task.get_all

get_all_reported_scalars

get_archived

get_base_docker

Task.get_by_name

get_configuration_object

get_configuration_object_as_dict

get_configuration_objects

get_debug_samples

get_executed_queue

get_http_router

get_initial_iteration

get_label_num_description

get_labels_enumeration

get_last_iteration

get_last_scalar_metrics

get_logger

get_model_config_dict

get_model_config_text

get_model_design

get_models

Task.get_num_enqueued_tasks

get_num_of_classes

get_offline_mode_folder

get_output_destination

get_output_log_web_page

get_parameter

get_parameters

get_parameters_as_dict

get_progress

Task.get_project_id

get_project_name

get_project_object

Task.get_projects

get_registered_artifacts

get_reported_console_output

get_reported_plots

get_reported_scalars

get_reported_single_value

get_reported_single_values

get_requirements

get_script

get_status

get_status_message

get_tags

Task.get_task

Task.get_task_output_log_web_page

Task.get_tasks

get_user_properties

Task.ignore_requirements

Task.import_offline_session

Task.import_task

Task.init