Estandarizar el etiquetado para DLC, DSW y EAS - Platform For AI - Centro de documentación de Alibaba Cloud

Las reglas de etiquetas permiten a los administradores del espacio de trabajo aplicar un etiquetado uniforme en DLC, DSW y EAS. Los administradores definen las claves de etiqueta obligatorias, los valores predefinidos, las descripciones y el alcance de productos aplicable. Cuando una regla está activa, los desarrolladores de ML deben etiquetar los trabajos de DLC, las instancias de DSW y los servicios de EAS al momento de crearlos; las etiquetas se validan automáticamente. Un etiquetado coherente facilita la asignación de costos, el análisis de distribución de trabajos y los reportes de consumo de recursos.

Definir reglas de etiquetas

Nota

Solo los propietarios y administradores del espacio de trabajo pueden editar las reglas de etiquetas.

Vaya a la página de detalles del espacio de trabajo. En la esquina superior derecha, haga clic en Configure Workspace > General Configurations.
Desplácese hasta la sección Tag Configuration y haga clic en Modify Configuration para entrar al modo de edición.
Agregue las reglas de etiquetas según lo requiera y haga clic en Save. Las reglas configuradas entran en vigor para el alcance de productos seleccionado. En las páginas de los subproductos correspondientes, estas etiquetas son obligatorias de forma predeterminada. Si falta una etiqueta o no cumple con la regla, el envío falla. Los desarrolladores de ML también pueden agregar etiquetas personalizadas además de las obligatorias, siempre que cumplan con los requisitos de clave y valor de etiqueta.
- Requisitos de Tag Key: no debe comenzar con aliyun ni con acs:, no puede contener http:// ni https://, y su longitud máxima es de 128 caracteres. Solo se permiten letras, dígitos, guiones (-), caracteres chinos y puntos (.); no se admiten guiones bajos (_).
- Requisitos de valor: no puede contener http:// ni https://, y su longitud máxima es de 256 caracteres. Separe varios valores enumerados con comas.
- Value Constraints: cuando esta opción está habilitada, los usuarios deben elegir entre los valores predefinidos y no pueden introducir valores personalizados. Habilítela para mantener un etiquetado uniforme en todo el equipo.
- Applicable Services: seleccione a qué subproductos (DLC, DSW o EAS) aplica esta regla. Debe seleccionar como mínimo uno.

Aplicar etiquetas

Aplique las etiquetas conforme a las reglas del espacio de trabajo cuando envíe un trabajo de DLC o cree una instancia de DSW o EAS. A continuación se muestra un ejemplo con el envío de un trabajo de DLC:

Vaya a la consola de DLC y haga clic en Create Job.
En la página de configuración del trabajo, ubique la sección Tag y complete los pares clave-valor según las reglas de etiquetas del espacio de trabajo.

También puede agregar etiquetas personalizadas durante la creación del trabajo.
Una vez completadas todas las etiquetas obligatorias, envíe el trabajo.

Importante

Las reglas de etiquetas se validan al enviar el trabajo. Si falta una etiqueta obligatoria o el valor no coincide con la regla, el envío falla y se muestra un mensaje de error.

Filtrar trabajos por etiqueta

Utilice el filtrado por etiquetas en la lista de trabajos de DLC para desglosar la distribución de trabajos y el uso de recursos por escenario, tipo de modelo u otros criterios.

Vaya a la página de la lista de trabajos en la consola de DLC.
En la barra de búsqueda, seleccione Tag como condición de filtro, introduzca la clave y el valor de la etiqueta, y ejecute la búsqueda. La lista mostrará únicamente los trabajos que coincidan con los criterios.

Apéndice

Referencia de API

Para configurar reglas de etiquetas de forma masiva o integrarlas con pipelines de automatización, utilice los siguientes ejemplos de código. Sustituya los valores de región, ID del espacio de trabajo, AccessKey ID y Secret antes de ejecutar el código.

Configurar reglas de etiquetas de forma masiva

La API UpdateConfigs permite configurar de forma masiva reglas de etiquetas predefinidas. Este método resulta adecuado para aplicar la misma configuración de etiquetas en varios espacios de trabajo.

Estructura de ejemplo del cuerpo de la solicitud:

{
  "Configs": [
    {
      "ConfigKey": "predefinedTags",
      "ConfigValue": "[{\"Type\":\"Tag\",\"Key\":\"scenario\",\"Value\":\"{\\\"Products\\\":\\\"DLC,DSW,EAS\\\",\\\"Values\\\":\\\"train,evluate,inference\\\",\\\"ValueFlexible\\\":false,\\\"Description\\\":\\\"select scenario\\\"}\"}]",
      "Labels": [
        {
          "Key": "system.categoryName",
          "Value": "CommonTagConfig"
        }
      ]
    }
  ]
}

Código de ejemplo en Python: configurar reglas de etiquetas de forma masiva

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PAI Workspace - Batch create/update predefined tag rules (CommonTagConfig)
API: PUT /api/v1/workspaces/{WorkspaceId}/configs
Before use, fill in ACCESS_KEY_ID, ACCESS_KEY_SECRET, REGION_ID, and WORKSPACE_ID,
and define tag rules in the TAGS list.
"""

import json, sys, hashlib, hmac, datetime, requests

ACCESS_KEY_ID     = "your-AccessKeyId"
ACCESS_KEY_SECRET = "your-AccessKeySecret"
REGION_ID         = "cn-hangzhou"
WORKSPACE_ID      = "your-workspace-ID"

ENDPOINT = f"aiworkspace.{REGION_ID}.aliyuncs.com"
API_PATH = f"/api/v1/workspaces/{WORKSPACE_ID}/configs"

# Tag definition: key-tag name, products-applicable products, values-allowed values, flexible-whether custom values are allowed, desc-description
TAGS = [
    {"key": "Scene",      "products": "DLC,DSW,EAS", "values": "Training,Evaluation,Inference",         "flexible": False, "desc": "Select the current use scenario"},
    {"key": "ModelType",  "products": "DLC,DSW",     "values": "NLP-Text,CV-Image,Multimodal",          "flexible": False, "desc": "Select the model type"},
    {"key": "ExpDirection","products": "DLC",         "values": "LR-Schedule,DataAugmentation,Distillation", "flexible": True, "desc": "Customize the experiment direction"},
]

def build_config_value(tags):
    arr = []
    for t in tags:
        inner = {"Products": t["products"], "Values": t["values"],
                 "ValueFlexible": t.get("flexible", False), "Description": t.get("desc", "")}
        arr.append({"Type": "Tag", "Key": t["key"], "Value": json.dumps(inner, ensure_ascii=False)})
    return json.dumps(arr, ensure_ascii=False)

def sign_request(method, path, headers, body):
    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    headers.update({"x-acs-date": now, "x-acs-version": "2021-02-04",
                    "x-acs-action": "UpdateConfigs",
                    "x-acs-signature-nonce": hashlib.md5((now + body).encode()).hexdigest()})
    signed_keys = sorted(k for k in headers if k.startswith("x-acs-") or k in ("host", "content-type"))
    canonical_headers = "".join(f"{k}:{headers[k]}\n" for k in signed_keys)
    hashed_body = hashlib.sha256(body.encode("utf-8")).hexdigest()
    canonical_request = f"{method}\n{path}\n\n{canonical_headers}\n{';'.join(signed_keys)}\n{hashed_body}"
    string_to_sign = f"ACS3-HMAC-SHA256\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(ACCESS_KEY_SECRET.encode(), string_to_sign.encode(), hashlib.sha256).hexdigest()
    headers["Authorization"] = (f"ACS3-HMAC-SHA256 Credential={ACCESS_KEY_ID},"
                                 f"SignedHeaders={';'.join(signed_keys)},Signature={signature}")
    return headers

def main():
    config_value = build_config_value(TAGS)
    request_body = json.dumps({"Configs": [{"ConfigKey": "predefinedTags", "ConfigValue": config_value,
                                            "Labels": [{"Key": "system.categoryName", "Value": "CommonTagConfig"}]}]},
                              ensure_ascii=False)
    url = f"https://{ENDPOINT}{API_PATH}"
    headers = sign_request("PUT", API_PATH, {"host": ENDPOINT, "content-type": "application/json"}, request_body)
    resp = requests.put(url, headers=headers, data=request_body.encode("utf-8"), timeout=30)
    print(f"HTTP {resp.status_code}: {resp.text}")
    if resp.status_code != 200:
        sys.exit(1)

if __name__ == "__main__":
    main()

Especificar etiquetas al enviar un trabajo de DLC

Cuando envíe un trabajo de DLC mediante la API CreateJob, especifique las etiquetas en el campo Settings.Tags. Debe completar todas las etiquetas obligatorias. Los valores deben seleccionarse de las opciones predefinidas, excepto en las etiquetas donde ValueFlexible sea true, ya que estas aceptan entradas personalizadas.

Código de ejemplo en Python: especificar etiquetas al enviar un trabajo de DLC

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PAI-DLC Submit training job (with predefined tags)
API: POST /api/v1/jobs (API version 2020-12-03)
Tags are placed in Settings.Tags as a dictionary {"tag-name": "tag-value"}.
"""

import json, sys, hashlib, hmac, datetime, time, requests

ACCESS_KEY_ID     = "your-AccessKeyId"
ACCESS_KEY_SECRET = "your-AccessKeySecret"
REGION_ID         = "cn-hangzhou"
WORKSPACE_ID      = "your-workspace-ID"
RESOURCE_ID       = ""  # Resource quota ID; leave empty to use public resources

DLC_ENDPOINT = f"pai-dlc.{REGION_ID}.aliyuncs.com"
DLC_API_PATH = "/api/v1/jobs"

# Fill in according to the workspace predefined tags; all predefined tags must be provided
TAGS = {
    "Scene":        "Training",
    "ModelType":    "NLP-Text",
    "ExpDirection": "Fine-grained-DataProcessing",
}

def sign_request(method, path, headers, body, action="CreateJob"):
    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    headers.update({"x-acs-date": now, "x-acs-version": "2020-12-03", "x-acs-action": action,
                    "x-acs-signature-nonce": hashlib.md5((now + body).encode()).hexdigest()})
    signed_keys = sorted(k for k in headers if k.startswith("x-acs-") or k in ("host", "content-type"))
    canonical_headers = "".join(f"{k}:{headers[k]}\n" for k in signed_keys)
    hashed_body = hashlib.sha256(body.encode("utf-8")).hexdigest()
    canonical_request = f"{method}\n{path}\n\n{canonical_headers}\n{';'.join(signed_keys)}\n{hashed_body}"
    string_to_sign = f"ACS3-HMAC-SHA256\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(ACCESS_KEY_SECRET.encode(), string_to_sign.encode(), hashlib.sha256).hexdigest()
    headers["Authorization"] = (f"ACS3-HMAC-SHA256 Credential={ACCESS_KEY_ID},"
                                 f"SignedHeaders={';'.join(signed_keys)},Signature={signature}")
    return headers

def main():
    job = {
        "DisplayName": f"my-training-job-{int(time.time())}",
        "JobType": "PyTorchJob",
        "WorkspaceId": WORKSPACE_ID,
        "UserCommand": "echo hello && sleep 5",
        "JobSpecs": [{"Type": "Worker",
                      "Image": "registry.cn-hangzhou.aliyuncs.com/pai-dlc/pytorch-training:1.12-gpu-py39-cu116-ubuntu20.04",
                      "PodCount": 1, "EcsSpec": "ecs.g6.large"}],
        "Settings": {"Tags": TAGS},  # Tags are placed in Settings.Tags
    }
    if RESOURCE_ID:
        job["ResourceId"] = RESOURCE_ID
    request_body = json.dumps(job, ensure_ascii=False)
    url = f"https://{DLC_ENDPOINT}{DLC_API_PATH}"
    headers = sign_request("POST", DLC_API_PATH, {"host": DLC_ENDPOINT, "content-type": "application/json"}, request_body)
    resp = requests.post(url, headers=headers, data=request_body.encode("utf-8"), timeout=30)
    print(f"HTTP {resp.status_code}: {resp.text}")
    if resp.status_code != 200:
        sys.exit(1)

if __name__ == "__main__":
    main()

Filtrar trabajos de DLC por etiqueta

La API ListJobs admite el filtrado por etiquetas mediante el parámetro de consulta Tags (en formato de cadena JSON). Cuando se especifican varias etiquetas, se aplica lógica AND: un trabajo aparecerá en los resultados solo si coincide con todas las etiquetas indicadas.

Código de ejemplo en Python: filtrar trabajos de DLC por etiqueta

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import json
import sys
import hashlib
import hmac
import datetime
import requests
from urllib.parse import urlencode

ACCESS_KEY_ID     = "your-AccessKeyId"
ACCESS_KEY_SECRET = "your-AccessKeySecret"
REGION_ID         = "cn-hangzhou"
WORKSPACE_ID      = "your-workspace-ID"

ENDPOINT = f"pai-dlc.{REGION_ID}.aliyuncs.com"
API_PATH = "/api/v1/jobs"

def build_query_params(workspace_id, filter_tags, page_size=50, page_number=1):
    query_params = {
        "WorkspaceId": workspace_id,
        "PageSize": str(page_size),
        "PageNumber": str(page_number),
        "SortBy": "GmtCreateTime",
        "Order": "desc",
    }

    if filter_tags:
        query_params["Tags"] = json.dumps(
            filter_tags, ensure_ascii=False, separators=(",", ":")
        )

    return query_params

def sign_request(method, path, query_string, headers, body=""):
    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    headers.update({
        "x-acs-date": now,
        "x-acs-version": "2020-12-03",
        "x-acs-action": "ListJobs",
        "x-acs-signature-nonce": hashlib.md5((now + query_string + body).encode()).hexdigest(),
    })

    normalized_headers = {k.lower(): v for k, v in headers.items()}
    signed_keys = sorted(
        k for k in normalized_headers
        if k.startswith("x-acs-") or k in ("host", "content-type")
    )

    canonical_headers = "".join(f"{k}:{normalized_headers[k]}\n" for k in signed_keys)
    hashed_body = hashlib.sha256(body.encode("utf-8")).hexdigest()

    canonical_request = (
        f"{method}\n"
        f"{path}\n"
        f"{query_string}\n"
        f"{canonical_headers}\n"
        f"{';'.join(signed_keys)}\n"
        f"{hashed_body}"
    )

    string_to_sign = f"ACS3-HMAC-SHA256\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(
        ACCESS_KEY_SECRET.encode(),
        string_to_sign.encode(),
        hashlib.sha256
    ).hexdigest()

    headers["Authorization"] = (
        f"ACS3-HMAC-SHA256 Credential={ACCESS_KEY_ID},"
        f"SignedHeaders={';'.join(signed_keys)},"
        f"Signature={signature}"
    )
    return headers

def list_jobs_by_tags(filter_tags, page_size=50, page_number=1):
    query_params = build_query_params(WORKSPACE_ID, filter_tags, page_size, page_number)
    query_string = urlencode(sorted(query_params.items()))
    url = f"https://{ENDPOINT}{API_PATH}?{query_string}"

    headers = {
        "host": ENDPOINT,
        "content-type": "application/json",
    }
    headers = sign_request("GET", API_PATH, query_string, headers, body="")

    resp = requests.get(url, headers=headers, timeout=30)
    print(f"HTTP {resp.status_code}")
    print(resp.text)

    if resp.status_code != 200:
        sys.exit(1)

    return resp.json()

def main():
    filter_tags = {"Scene": "Training"}
    list_jobs_by_tags(filter_tags)

if __name__ == "__main__":
    main()

Consultar el historial de cambios de etiquetas

ActionTrail registra todos los cambios en las reglas de etiquetas, incluido el operador, la marca de tiempo y los elementos modificados.

Inicie sesión en la consola de ActionTrail, vaya a Advanced query, establezca el nombre del servicio en PAI y el nombre del evento en UpdateConfigs. Después, filtre los registros donde ConfigKey sea predefinedTags para consultar el historial de cambios de las reglas de etiquetas.