Todos los productos
Search
Centro de documentos

Platform For AI:Uso de OSS

Última actualización: Sep 04, 2026

Los productos de PAI, como Deep Learning Containers (DLC) y Data Science Workshop (DSW), permiten montar un origen de datos de Object Storage Service (OSS) en una ruta específica dentro de un contenedor mediante ossfs 2.0 o JindoFuse de Alibaba Cloud E-MapReduce. También es posible leer datos de OSS con OSS Connector for AI/ML o el SDK de OSS. Elija el método de acceso a datos que mejor se adapte a su caso de uso.

Contexto

En el desarrollo de IA, los datos de origen suelen almacenarse en OSS y descargarse a un entorno de entrenamiento para el desarrollo y entrenamiento de modelos. Sin embargo, esta práctica común presenta varios desafíos:

  • Los tiempos prolongados de descarga de conjuntos de datos pueden dejar las GPU inactivas.

  • Los datos deben descargarse repetidamente para cada trabajo de entrenamiento.

  • El muestreo aleatorio de datos requiere descargar todo el conjunto de datos en cada nodo de entrenamiento.

Para resolver estos problemas, considere los siguientes métodos para leer datos de OSS:

Método de acceso

Descripción

Casos de uso

JindoFuse

Monta un conjunto de datos de OSS en una ruta especificada del contenedor mediante el componente JindoFuse, lo que permite la lectura y escritura directa de datos.

  • Desea acceder a los datos de OSS como si fueran un conjunto de datos local, o bien su conjunto de datos es lo suficientemente pequeño para beneficiarse del almacenamiento en caché local de JindoFuse.

  • Su framework no es PyTorch.

  • Necesita escribir datos en OSS.

ossfs 2.0

ossfs 2.0 es un cliente para acceso montado de alto rendimiento a OSS. Destaca en operaciones de lectura y escritura secuencial, lo que le permite aprovechar al máximo el ancho de banda elevado de OSS.

ossfs 2.0 is suitable for scenarios that require high-performance storage access, such as AI training, inference, big data processing, autonomous driving, and other compute-intensive workloads. These workloads primarily involve sequential and random reads, sequential (append-only) writes, and do not require full POSIX semantics.

OSS Connector for AI/ML

PAI integra OSS Connector for AI/ML para transmitir archivos desde OSS directamente dentro del código PyTorch, lo que simplifica y acelera el acceso a los datos. Las principales ventajas incluyen:

  • Carga por streaming: elimina la necesidad de descargar previamente los datos al entorno de entrenamiento, ahorra tiempo de inactividad de las GPU y reduce costos.

  • Interfaz amigable para desarrolladores: se alinea con los patrones de uso de Dataset de PyTorch. Ofrece una mejor abstracción que el SDK de OSS y es más fácil de personalizar y extender.

  • Lecturas de alta eficiencia: ofrece un rendimiento de lectura de datos superior al del SDK de OSS para una carga de datos más eficiente.

Utilice este conector para acceso sin montaje y acelerar la lectura de conjuntos de datos en entrenamientos con PyTorch, especialmente cuando se leen millones de archivos pequeños o se requiere un throughput alto.

OSS SDK

Transmite datos desde OSS mediante el SDK de OSS. Ofrece una solución flexible y eficiente que reduce significativamente los tiempos de solicitud de datos y mejora la eficiencia del entrenamiento.

Utilice el SDK de Python para OSS o la API de Python para OSS para obtener acceso temporal sin montaje a los datos de OSS, o cuando la lógica de su aplicación determine cuándo acceder a OSS.

Importante

Cuando utilice JindoFuse u ossfs 2.0 para montar OSS, puede especificar un rol de RAM para el acceso a OSS y lograr un control de permisos más detallado. También puede habilitar OSS Mount Requires RAM Role en la configuración general de un espacio de trabajo. Después de habilitar esta opción:

  • Al crear montajes de OSS en funciones como DSW, DLC y EAS, debe seleccionar un rol de RAM. No se permite el rol de RAM predeterminado.

  • Al crear un conjunto de datos avanzado o lógico que implique un montaje de OSS, también se aplica la obligación del rol de RAM según esta configuración.

  • Al crear una instancia de DSW, un trabajo de DLC o un servicio de EAS, no puede seleccionar el rol predeterminado de PAI como rol de RAM.

JindoFuse

DLC y DSW permiten utilizar el componente JindoFuse para montar un conjunto de datos de OSS o una ruta de OSS en una ruta específica dentro de un contenedor. Esto permite leer y escribir directamente los datos almacenados en OSS durante el proceso de entrenamiento.

Métodos de montaje

DLC

Al crear un trabajo de entrenamiento distribuido (DLC), puede montar datos de OSS. Se admiten los dos tipos de montaje siguientes: Para obtener instrucciones detalladas de configuración, consulte Create a training job.

Tanto en las secciones Datasets como Directly Mount, puede hacer clic en Expand Advanced Configuration para ver más opciones de montaje y usar el interruptor Read-Only para controlar el modo de montaje.

Tipo de montaje

Descripción

Datasets

Seleccione un conjunto de datos del tipo OSS y configure la Mount Path. Para conjuntos de datos públicos, solo se admite el modo de solo lectura.

Directly Mount

Monte directamente una ruta de bucket de OSS.

Si utiliza una cuota de recursos de computación inteligente Lingjun con almacenamiento en caché local habilitado, puede activar el interruptor Use Cache para habilitar la caché.

DSW

Al crear una instancia de DSW, puede montar datos de OSS. Se admiten los dos tipos de montaje siguientes: Para obtener instrucciones detalladas de configuración, consulte Create a DSW instance.

Ambos tipos de montaje proporcionan la opción Expand Advanced Configuration. Los tipos de almacenamiento compatibles con Storage Path Mounting incluyen OSS, NAS de propósito general, NAS extremo, CPFS y CPFS de computación inteligente.

Tipo de montaje

Descripción

Dataset Mounting

Seleccione un conjunto de datos del tipo OSS y configure la Mount Path. Cuando utilice un conjunto de datos público, solo se admite el modo de solo lectura.

Storage Path Mounting

Monte directamente una ruta de bucket de OSS.

Limitaciones de la configuración predeterminada

Si deja vacíos los parámetros de Advanced Configurations, se aplica la configuración predeterminada. Esta configuración tiene las siguientes limitaciones:

  • Para acelerar la lectura de archivos de OSS, los metadatos (listas de directorios y archivos) se almacenan en caché al montar OSS.

    En un entrenamiento distribuido, si varios nodos intentan crear el mismo directorio, la caché de metadatos puede provocar que cada nodo intente realizar la creación. Solo un nodo tendrá éxito y los demás reportarán un error.

  • De forma predeterminada, se utiliza la API MultiPart de OSS para crear archivos. El objeto solo se vuelve visible en OSS después de que finalizan las operaciones de escritura.

  • No se admiten operaciones simultáneas de lectura y escritura en el mismo archivo.

  • No se admiten operaciones de escritura aleatoria en archivos.

Configuraciones comunes de JindoFuse

También puede personalizar los parámetros de JindoFuse en la configuración avanzada según su caso de uso.

Este tema proporciona sugerencias de configuración de JindoFuse para algunos escenarios comunes. Es posible que estos ajustes no ofrezcan un rendimiento óptimo para todas las cargas de trabajo. Para opciones de configuración más flexibles, consulte JindoFuse User Guide .
  • Quick Read/write: garantiza lecturas y escrituras rápidas. Sin embargo, puede haber inconsistencia de datos durante lecturas o escrituras concurrentes. Puede montar datos de entrenamiento y modelos en la ruta de montaje de este modo. Se recomienda no utilizar la ruta de montaje de este modo como directorio de trabajo.

    {
      "fs.oss.download.thread.concurrency": "Twice the number of CPU cores",
      "fs.oss.upload.thread.concurrency": "Twice the number of CPU cores",
      "fs.jindo.args": "-oattr_timeout=3 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink"
    }
    
  • Incremental Read/Write: garantiza la consistencia de los datos durante la escritura incremental. Si se sobrescriben los datos originales, puede producirse inconsistencia de datos. La velocidad de lectura es ligeramente menor. Puede utilizar este modo para guardar los archivos de pesos del modelo correspondientes a los datos de entrenamiento.

    {
      "fs.oss.upload.thread.concurrency": "Twice the number of CPU cores",
      "fs.jindo.args": "-oattr_timeout=3 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink"
    }
    
  • Consistent Read/write: garantiza la consistencia de los datos durante lecturas o escrituras concurrentes y es adecuado para escenarios que requieren alta consistencia de datos pero no necesitan lecturas rápidas. Puede utilizar este modo para guardar el código de sus proyectos.

    {
      "fs.jindo.args": "-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink"
    }
    
  • Read-only: permite únicamente lecturas. Puede utilizar este modo para montar conjuntos de datos públicos.

    {
      "fs.oss.download.thread.concurrency": "Twice the number of CPU cores",
      "fs.jindo.args": "-oro -oattr_timeout=7200 -oentry_timeout=7200 -onegative_timeout=7200 -okernel_cache -ono_symlink"
    }

Otras operaciones de configuración comunes incluyen:

  • Seleccionar una versión diferente de JindoFuse:

    {
      "fs.jindo.fuse.pod.image.tag": "6.7.0"
    }
  • Deshabilitar la caché de metadatos: Al ejecutar un entrenamiento distribuido donde varios nodos intentan escribir en el mismo directorio simultáneamente, la caché podría causar fallos en las operaciones de escritura de algunos nodos. Para resolver este problema, agregue el argumento -oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 a la línea de comandos de JindoFuse.

    {
      "fs.jindo.args": "-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0"
    }
  • Ajustar el número de hilos de carga/descarga: Ajuste el recuento de hilos mediante los siguientes parámetros.

    {
      "fs.oss.upload.thread.concurrency": "32",
      "fs.oss.download.thread.concurrency": "32",
      "fs.oss.read.readahead.buffer.count": "64",
      "fs.oss.read.readahead.buffer.size": "4194304"
    }
  • Usar AppendObject para escrituras: Todos los archivos creados localmente en el punto de montaje se crean como objetos en OSS mediante la llamada a la API AppendObject. El tamaño de un objeto creado con AppendObject no puede superar los 5 GB. Para más límites de uso, consulte AppendObject. A continuación se muestra un ejemplo de configuración:

    {
      "fs.jindo.args": "-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0",
      "fs.oss.append.enable": "true",
      "fs.oss.flush.interval.millisecond": "1000",
      "fs.oss.read.readahead.buffer.size": "4194304",
      "fs.oss.write.buffer.size": "262144"
    }
  • Montar OSS-HDFS: Para obtener información sobre cómo habilitar OSS-HDFS, consulte What is OSS-HDFS service?. En escenarios de entrenamiento distribuido, se recomienda agregar los siguientes parámetros:

    {
      "fs.jindo.args": "-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 -ono_symlink -ono_xattr -ono_flock -odirect_io",
      "fs.oss.flush.interval.millisecond": "10000",
      "fs.oss.randomwrite.sync.interval.millisecond": "10000"
    }
  • Configurar recursos de memoria: Puede establecer el parámetro fs.jindo.fuse.pod.mem.limit para ajustar el límite de memoria. El siguiente código proporciona un ejemplo:

    {
      "fs.jindo.fuse.pod.mem.limit": "10Gi"
    }

Uso del SDK de Python para modificar parámetros de JindoFuse en un conjunto de datos

También puede usar el SDK de Python para modificar los parámetros de JindoFuse.

  1. Complete los siguientes requisitos previos.

    1. Instale el SDK para AI Workspace.

      !pip install alibabacloud-aiworkspace20210204
    2. Configure las variables de entorno. Para más información, consulte Install the Credentials Tool y Configure environment variables on Linux, macOS, and Windows.

  2. Modifique los parámetros de JindoFuse.

    Fast read/write

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def change_config():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
        # Recommended value: twice the number of CPU cores.
        options['fs.oss.download.thread.concurrency'] = 32
        options['fs.oss.upload.thread.concurrency'] = 32
        options['fs.jindo.args'] = '-oattr_timeout=3 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink'
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    change_config()

    Incremental read/write

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def change_config():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
        # Recommended value: twice the number of CPU cores.
        options['fs.oss.upload.thread.concurrency'] = 32
        options['fs.jindo.args'] = '-oattr_timeout=3 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink'
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    change_config()

    Consistent read/write

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def change_config():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
        options['fs.jindo.args'] = '-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink'
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    change_config()

    Read-only

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def change_config():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
        # Recommended value: twice the number of CPU cores.
        options['fs.oss.download.thread.concurrency'] = 32
        options['fs.jindo.args'] = '-oro -oattr_timeout=7200 -oentry_timeout=7200 -onegative_timeout=7200 -okernel_cache -ono_symlink'
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    change_config()

    JindoFuse version

    El siguiente código proporciona un ejemplo:

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def change_version():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
        # Set the JindoFuse version. Supported versions include 6.4.4, 6.7.0, and 6.6.0. For release notes, see https://aliyun.github.io/alibabacloud-jindodata/releases/.
        options['fs.jindo.fuse.pod.image.tag'] = "6.7.0"
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    change_version()

    Metadata cache

    Al ejecutar un entrenamiento distribuido donde varios nodos intentan escribir en el mismo directorio simultáneamente, la caché podría causar fallos en las operaciones de escritura de algunos nodos. Para resolver este problema, agregue el argumento -oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 a la línea de comandos de JindoFuse. El siguiente código proporciona un ejemplo:

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def turnOffMetaCache():
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
        workspace_client = AIWorkspaceClient(
          config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
          )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
    
        options['fs.jindo.args'] = '-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0'
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    turnOffMetaCache()
    

    Upload/download thread count

    Establezca los siguientes parámetros para ajustar el recuento de hilos:

    • fs.oss.upload.thread.concurrency:32

    • fs.oss.download.thread.concurrency:32

    • fs.oss.read.readahead.buffer.count:64

    • fs.oss.read.readahead.buffer.size:4194304

    El siguiente código proporciona un ejemplo:

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def adjustThreadNum():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
    
        options['fs.oss.upload.thread.concurrency'] = 32
        options['fs.oss.download.thread.concurrency'] = 32
        options['fs.oss.read.readahead.buffer.count'] = 64
     
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
     
     
    adjustThreadNum()
    

    AppendObject writes

    Todos los archivos creados localmente en el punto de montaje se crean como objetos en OSS mediante la llamada a la API AppendObject. El tamaño de un objeto creado con AppendObject no puede superar los 5 GB. Para más límites de uso, consulte AppendObject. El siguiente código proporciona un ejemplo:

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def useAppendObject():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
    
        options['fs.jindo.args'] = '-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0'
        options['fs.oss.append.enable'] = "true"
        options['fs.oss.flush.interval.millisecond'] = "1000"
        options['fs.oss.read.buffer.size'] = "262144"
        options['fs.oss.write.buffer.size'] = "262144"
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    useAppendObject()

    OSS-HDFS

    Para obtener información sobre cómo habilitar OSS-HDFS, consulte What is OSS-HDFS service?. El siguiente ejemplo muestra cómo crear un conjunto de datos que utiliza un endpoint de OSS-HDFS:

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import CreateDatasetRequest
    
    def createOssHdfsDataset():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        workspace_id = 'YOUR_WORKSPACE_ID'
    
        oss_bucket = 'YOUR_OSS_BUCKET'
        # Use the OSS-HDFS endpoint.
        oss_endpoint = f'{region_id}.oss-dls.aliyuncs.com'
        # The OSS-HDFS path to mount.
        oss_path = '/'
        # The local mount path.
        mount_path = '/mnt/data/'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
    
        response = workspace_client.create_dataset(CreateDatasetRequest(
            workspace_id=workspace_id,
            name="YOUR_DATASET_NAME",
            data_type='COMMON',
            data_source_type='OSS',
            property='DIRECTORY',
            uri=f'oss://{oss_bucket}.{oss_endpoint}{oss_path}',
            accessibility='PRIVATE',
            source_type='USER',
            options=json.dumps({
                'mountPath': mount_path,
                # In distributed training scenarios, we recommend that you add the following parameters.
                'fs.jindo.args': '-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 -ono_symlink -ono_xattr -ono_flock -odirect_io',
                'fs.oss.flush.interval.millisecond': "10000",
                'fs.oss.randomwrite.sync.interval.millisecond': "10000",
            })
        ))
        print(f'datasetId: {response.body.dataset_id}')
    
    createOssHdfsDataset()
    

    Memory resources

    Puede establecer el parámetro fs.jindo.fuse.pod.mem.limit para ajustar el límite de memoria. El siguiente código proporciona un ejemplo:

    import json
    from alibabacloud_tea_openapi.models import Config
    from alibabacloud_credentials.client import Client as CredClient
    from alibabacloud_aiworkspace20210204.client import Client as AIWorkspaceClient
    from alibabacloud_aiworkspace20210204.models import UpdateDatasetRequest
    
    def adjustResource():
        # Use the region where the DLC job runs. For example, use cn-hangzhou for China (Hangzhou).
        region_id = 'cn-hangzhou'
        # An Alibaba Cloud account AccessKey has permissions to call all APIs. We recommend that you use a RAM user for API calls and daily O&M.
        # We strongly recommend that you do not store the AccessKey ID or AccessKey Secret in your code. Otherwise, your AccessKey may be leaked and put all resources in your account at risk.
        # In this example, the Credentials SDK reads the AccessKey from environment variables by default for authentication. You must install the Credentials tool and configure environment variables first.
        cred = CredClient()
        dataset_id = 'YOUR_DATASET_ID'
    
        workspace_client = AIWorkspaceClient(
            config=Config(
                credential=cred,
                region_id=region_id,
                endpoint="aiworkspace.{}.aliyuncs.com".format(region_id),
            )
        )
        # 1. Get the dataset content.
        get_dataset_resp = workspace_client.get_dataset(dataset_id)
        options = json.loads(get_dataset_resp.body.options)
        # The memory resource to configure.
        options['fs.jindo.fuse.pod.mem.limit'] = "10Gi"
    
        update_request = UpdateDatasetRequest(
            options=json.dumps(options)
        )
        # 2. Update the options.
        workspace_client.update_dataset(dataset_id, update_request)
        print('new options is: {}'.format(update_request.options))
    
    adjustResource()
    

ossfs 2.0

Para montar un origen de datos de OSS mediante ossfs, establezca {"mountType":"ossfs"} en Advanced Configuration.

Métodos de montaje

Montar OSS en DLC

Al crear un trabajo de DLC, puede montar datos de OSS. DLC admite los siguientes dos tipos de montaje. Para obtener más información sobre la configuración, consulte Create a training job.

Tipo de montaje

Descripción

Datasets

Seleccione un conjunto de datos de OSS y configure la Mount Path. Los conjuntos de datos públicos solo admiten el modo de solo lectura.

Directly Mount

Monte directamente una ruta de almacenamiento de bucket de OSS.

Si utiliza una cuota de recursos de Lingjun con caché local habilitada, puede activar Use Cache.

Montar OSS en DSW

Al crear una instancia de DSW, puede montar datos de OSS. DSW admite los siguientes dos tipos de montaje. Para obtener más información sobre la configuración, consulte Create a DSW instance.

Tipo de montaje

Descripción

Dataset Mounting

Seleccione un conjunto de datos de OSS y configure la Mount Path. Los conjuntos de datos públicos solo admiten el modo de solo lectura.

Storage Path Mounting

Monte directamente una ruta de almacenamiento de bucket de OSS.

Configuraciones comunes de ossfs

En Advanced Configuration, puede definir parámetros avanzados mediante fs.ossfs.args. Separe varios parámetros con una coma (,). Para obtener más información sobre estos parámetros avanzados, consulte ossfs 2.0. A continuación se muestran algunos casos de uso comunes:

  • Origen de datos estático durante el trabajo: Para los archivos que no se modifican durante la ejecución del trabajo, configure un tiempo de espera de caché prolongado para reducir las solicitudes de metadatos. Un caso de uso típico es la lectura de un lote de archivos existentes y la generación de un nuevo conjunto de archivos tras el procesamiento.

    {
        "mountType":"ossfs",
        "fs.ossfs.args": "-oattr_timeout=7200" 
    }
  • Lectura y escritura rápidas: Utilice un tiempo de espera de caché de metadatos más corto para equilibrar la eficiencia de la caché y la actualización de los datos.

    {
        "mountType":"ossfs",
        "fs.ossfs.args": "-oattr_timeout=3, -onegative_timeout=0"
    }
  • Lectura y escritura consistentes para trabajos distribuidos: De forma predeterminada, ossfs actualiza los datos de los archivos según la caché de metadatos. Utilice la siguiente configuración para garantizar una vista consistente en varios nodos.

    {   
        "mountType":"ossfs",
        "fs.ossfs.args": "-onegative_timeout=0, -oclose_to_open"
    }
  • Error de memoria insuficiente (OOM) por demasiados archivos abiertos en DLC o DSW: La alta concurrencia de trabajos en DLC y DSW puede abrir muchos archivos simultáneamente, lo que podría causar problemas de memoria insuficiente (OOM). La siguiente configuración ayuda a reducir la presión sobre la memoria.

    {
        "mountType":"ossfs",
        "fs.ossfs.args": "-oreaddirplus=false, -oinode_cache_eviction_threshold=300000"
    }
  • Error al escribir archivos grandes: -oupload_buffer_size establece el tamaño del búfer (en bytes) para cargas multiparte. Este parámetro determina el tamaño máximo de archivo que se puede escribir, calculado como upload_buffer_size * 10000.

    De forma predeterminada, ossfs 2.0 utiliza un tamaño de parte de 8 MiB, lo que limita el tamaño máximo de archivo escribible a 78.125 GiB. Si intenta escribir un archivo que supere este límite, la operación fallará. Para aumentar el tamaño máximo de archivo admitido, configure la opción -oupload_buffer_size e incremente el tamaño de la parte. Por ejemplo, si establece el tamaño de la parte en 32 MiB (33,554,432 bytes), se admitirá un tamaño máximo de archivo de 312.5 GiB. Tenga en cuenta que un valor mayor de -upload_buffer_size consume más memoria. Puede controlar el uso de memoria mediante la configuración de -total_mem_limit. Para obtener más información, consulte Mount options.

    {
        "mountType":"ossfs",
        "fs.ossfs.args": "-oupload_buffer_size=33554432"
    }
    

OSS Connector for AI/ML

OSS Connector for AI/ML es una biblioteca cliente del equipo de Alibaba Cloud OSS diseñada para cargas de trabajo de IA y aprendizaje automático. Simplifica la carga de datos para entrenamientos de PyTorch a gran escala, reduce el tiempo y la complejidad de la transferencia de datos, y acelera el entrenamiento de modelos al eliminar los cuellos de botella en la carga de datos. Para agilizar el acceso a los datos, la plataforma PAI ha integrado OSS Connector for AI/ML, lo que le permite transmitir datos directamente desde OSS dentro de su código PyTorch para lograr una carga eficiente.

Límites

  • Imágenes oficiales: OSS Connector for AI/ML solo está disponible en trabajos de DLC e instancias de DSW que utilizan una imagen oficial de PyTorch 2.0 o posterior.

  • Imágenes personalizadas: Solo se admite PyTorch 2.0 o posterior. Para imágenes personalizadas que utilicen una versión compatible, instale OSS Connector for AI/ML mediante la ejecución del siguiente comando:

    pip install -i http://yum.tbsite.net/aliyun-pypi/simple/ --extra-index-url http://yum.tbsite.net/pypi/simple/ --trusted-host=yum.tbsite.net osstorchconnector
  • Versión de Python: Solo se admiten las versiones de Python 3.8 a 3.12.

Requisitos previos

  1. Configure un archivo de credenciales.

    Puede configurar las credenciales de una de las siguientes maneras:

    • Configure el acceso sin contraseña a OSS para su trabajo de DLC. Para obtener más información, consulte Configure a DLC RAM role. Con este método, el trabajo de DLC obtiene una credencial temporal de STS para acceder de forma segura a OSS y otros recursos en la nube. Esto elimina la necesidad de incluir información de autenticación explícita y reduce el riesgo de filtración de claves de acceso.

    • Configure un archivo de credenciales en su proyecto de código para gestionar la información de autenticación. El siguiente código muestra un ejemplo de configuración:

      Nota

      Almacenar información de claves de acceso en texto plano representa un riesgo de seguridad. Se recomienda utilizar un rol de RAM para configurar automáticamente las credenciales dentro de una instancia de DLC. Para obtener más información, consulte Configure a DLC RAM role.

      Cuando utilice OSS Connector for AI/ML, puede especificar la ruta al archivo de credenciales para recuperar automáticamente la información de autenticación necesaria para firmar las solicitudes de datos de OSS.

      {
        "AccessKeyId": "<Access-key-id>",
        "AccessKeySecret": "<Access-key-secret>",
        "SecurityToken": "<Security-Token>",
        "Expiration": "2024-08-20T00:00:00Z"
      }

      La siguiente tabla describe los campos.

      Parámetro

      Obligatorio

      Descripción

      Ejemplo

      AccessKeyId

      Sí

      El ID de clave de acceso y el secreto de clave de acceso de una cuenta de Alibaba Cloud o un usuario de RAM.

      Nota

      Cuando utilice una credencial temporal de STS para acceder a OSS, establezca estos parámetros con el ID de clave de acceso temporal y el secreto de clave de acceso temporal.

      NTS****

      AccessKeySecret

      Sí

      7NR2****

      SecurityToken

      No

      El token de seguridad de STS. Este parámetro solo es obligatorio cuando se utiliza una credencial temporal de STS para acceder a OSS.

      STS.6MC2****

      Expiration

      No

      La fecha de caducidad de la credencial. Si este campo está vacío, la credencial no caduca. OSS Connector for AI/ML vuelve a leer el archivo de credenciales cuando esta caduca.

      2024-08-20T00:00:00Z

  2. Configure un archivo config.json. El siguiente código muestra un ejemplo de configuración:

    Este archivo se utiliza para gestionar la configuración de su proyecto, como los niveles de concurrencia, los parámetros de precarga y las ubicaciones de los archivos de registro. Al usar OSS Connector for AI/ML, especifique la ruta a este archivo config.json. El conector aplicará automáticamente la configuración definida y escribirá los registros relacionados con las solicitudes de datos de OSS en el archivo de registro especificado.

    {
        "logLevel": 1,
        "logPath": "/var/log/oss-connector/connector.log",
        "auditPath": "/var/log/oss-connector/audit.log",
        "datasetConfig": {
            "prefetchConcurrency": 24,
            "prefetchWorker": 2
        },
        "checkpointConfig": {
            "prefetchConcurrency": 24,
            "prefetchWorker": 4,
            "uploadConcurrency": 64
        }
    }

    La siguiente tabla describe los campos.

    Parámetro

    Obligatorio

    Descripción

    Ejemplo

    logLevel

    Sí

    El nivel de registro. El valor predeterminado es 1 (INFO). Valores válidos:

    • 0: DEBUG

    • 1: INFO

    • 2: WARN

    • 3: ERROR

    1

    logPath

    Sí

    La ruta de registro para el conector. La ruta predeterminada es /var/log/oss-connector/connector.log.

    /var/log/oss-connector/connector.log

    auditPath

    Sí

    El registro de auditoría para las operaciones de E/S del conector registra las solicitudes de lectura y escritura con una latencia superior a 100 milisegundos. La ruta predeterminada es /var/log/oss-connector/audit.log.

    /var/log/oss-connector/audit.log

    DatasetConfig

    prefetchConcurrency

    Sí

    El número de tareas simultáneas para precargar datos desde OSS al utilizar un conjunto de datos. El valor predeterminado es 24.

    24

    prefetchWorker

    Sí

    El número de vCPU disponibles para precargar datos desde OSS al utilizar un conjunto de datos. El valor predeterminado es 2.

    2

    checkpointConfig

    prefetchConcurrency

    Sí

    El número de tareas simultáneas para precargar datos desde OSS durante una lectura de punto de control. El valor predeterminado es 24.

    24

    prefetchWorker

    Sí

    El número de vCPU disponibles para precargar datos desde OSS durante una lectura de punto de control. El valor predeterminado es 4.

    4

    uploadConcurrency

    Sí

    El número de tareas simultáneas para cargar datos durante una escritura de punto de control. El valor predeterminado es 64.

    64

Uso

OSS Connector for AI/ML proporciona dos interfaces de acceso a conjuntos de datos, OssMapDataset y OssIterableDataset, que amplían las interfaces Dataset y IterableDataset de PyTorch, respectivamente. OssIterableDataset está optimizado con precarga para lograr una mayor eficiencia en el entrenamiento. El orden de lectura de datos de OssMapDataset lo determina DataLoader y admite operaciones de mezcla. Puede elegir una interfaz de acceso a conjuntos de datos según las siguientes recomendaciones:

  • Si tiene memoria limitada, un conjunto de datos grande y solo requiere lecturas secuenciales con bajo paralelismo, utilice OssIterableDataset.

  • Si dispone de suficiente memoria, un conjunto de datos más pequeño y requiere acceso aleatorio y procesamiento paralelo, utilice OssMapDataset.

OSS Connector for AI/ML también proporciona la interfaz OssCheckpoint para cargar y guardar modelos. Actualmente, la función OssCheckpoint solo está disponible en entornos de recursos de cómputo de propósito general.

Las siguientes secciones describen cómo utilizar estas tres interfaces.

OssMapDataset

Se admiten los siguientes tres métodos de acceso a conjuntos de datos:

  • Acceso a una carpeta mediante prefijo de ruta de OSS

    Puede especificar únicamente el nombre de la carpeta sin necesidad de configurar un archivo de índice, lo que simplifica el mantenimiento y la escalabilidad. Utilice este método si su carpeta de OSS tiene la siguiente estructura:

    dataset_folder/
        ├── class1/
        │   ├── image1.JPEG
        │   └── ...
        ├── class2/
        │   ├── image2.JPEG
        │   └── ...

    Cuando utilice este método, debe especificar un prefijo de ruta de OSS y definir un método personalizado para analizar sintácticamente el flujo de archivos. El siguiente ejemplo muestra cómo analizar y transformar archivos de imagen:

    def read_and_transform(data):
        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                         std=[0.229, 0.224, 0.225])
        transform = transforms.Compose([
            transforms.RandomResizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            normalize,
        ])
    
        try:
            img = accimage.Image((data.read()))
            val = transform(img)
            label = data.label # File name
        except Exception as e:
            print("read failed", e)
            return None, 0
        return val, label
    dataset = OssMapDataset.from_prefix("{oss_data_folder_uri}", endpoint="{oss_endpoint}", transform=read_and_transform, cred_path=cred_path, config_path=config_path)
  • Acceso a archivos desde un archivo de manifiesto

    Este método le permite acceder a datos de varios buckets de OSS, lo que ofrece una gestión de datos más flexible. Utilice este método si su carpeta de OSS tiene la siguiente estructura y cuenta con un archivo de manifiesto que asigna nombres de archivo a etiquetas.

    dataset_folder/
        ├── class1/
        │   ├── image1.JPEG
        │   └── ...
        ├── class2/
        │   ├── image2.JPEG
        │   └── ...
        └── .manifest

    El archivo de manifiesto tiene el siguiente formato:

    {'data': {'source': 'oss://examplebucket.oss-cn-wulanchabu.aliyuncs.com/dataset_folder/class1/image1.JPEG'}}
    {'data': {'source': ''}}

    Cuando utilice este método, debe definir un método personalizado para analizar sintácticamente el archivo de manifiesto. El siguiente código muestra un ejemplo:

    def transform_oss_path(input_path):
        pattern = r'oss://(.*?)\.(.*?)/(.*)'
        match = re.match(pattern, input_path)
        if match:
            return f'oss://{match.group(1)}/{match.group(3)}'
        else:
            return input_path
    
    def manifest_parser(reader: io.IOBase) -> Iterable[Tuple[str, str, int]]:
        lines = reader.read().decode("utf-8").strip().split("\n")
        data_list = []
        for i, line in enumerate(lines):
            data = json.loads(line)
            yield transform_oss_path(data["data"]["source"]), ""
    dataset = OssMapDataset.from_manifest_file("{manifest_file_path}", manifest_parser, "", endpoint=endpoint, transform=read_and_trans, cred_path=cred_path, config_path=config_path)
  • Acceso a archivos desde una lista de URI de OSS

    Puede acceder a archivos de OSS especificando sus URI de OSS sin necesidad de configurar un archivo de índice. El siguiente código muestra un ejemplo:

    uris =["oss://examplebucket.oss-cn-wulanchabu.aliyuncs.com/dataset_folder/class1/image1.JPEG", "oss://examplebucket.oss-cn-wulanchabu.aliyuncs.com/dataset_folder/class2/image2.JPEG"]
    dataset = OssMapDataset.from_objects(uris, endpoint=endpoint, transform=read_and_trans, cred_path=cred_path, config_path=config_path)

OssIterableDataset

OssIterableDataset admite los mismos tres métodos de acceso a conjuntos de datos que OssMapDataset. Los siguientes ejemplos muestran cómo utilizar estos tres métodos:

  • Acceso a una carpeta mediante prefijo de ruta de OSS

    dataset = OssIterableDataset.from_prefix("{oss_data_folder_uri}", endpoint="{oss_endpoint}", transform=read_and_transform, cred_path=cred_path, config_path=config_path)
  • Acceso a archivos desde un archivo de manifiesto

    dataset = OssIterableDataset.from_manifest_file("{manifest_file_path}", manifest_parser, "", endpoint=endpoint, transform=read_and_trans, cred_path=cred_path, config_path=config_path)
  • Acceso a archivos desde una lista de URI de OSS

    dataset = OssIterableDataset.from_objects(uris, endpoint=endpoint, transform=read_and_trans, cred_path=cred_path, config_path=config_path)

OssCheckpoint

Actualmente, la función OssCheckpoint solo está disponible en entornos de recursos de cómputo de propósito general. Puede utilizar la interfaz OssCheckpoint para acceder a archivos de modelo en OSS y guardarlos. El siguiente código muestra cómo utilizar la interfaz:

checkpoint = OssCheckpoint(endpoint="{oss_endpoint}", cred_path=cred_path, config_path=config_path)

checkpoint_read_uri = "{checkpoint_path}"
checkpoint_write_uri = "{checkpoint_path}"
with checkpoint.reader(checkpoint_read_uri) as reader:
    state_dict = torch.load(reader)
    model.load_state_dict(state_dict)
with checkpoint.writer(checkpoint_write_uri) as writer:
    torch.save(model.state_dict(), writer)

Ejemplo de código

El siguiente código proporciona un ejemplo completo de cómo utilizar OSS Connector for AI/ML para acceder a datos de OSS:

from osstorchconnector import OssMapDataset, OssCheckpoint
import torchvision.transforms as transforms
import accimage
import torchvision.models as models
import torch

# The default credential path after you configure a RAM role for a DLC job or DSW instance.
cred_path = "/mnt/.alibabacloud/credentials"  
config_path = "config.json"
checkpoint = OssCheckpoint(endpoint="{oss_endpoint}", cred_path=cred_path, config_path=config_path)
model = models.__dict__["resnet18"]()

epochs = 100  # Specify the number of epochs.
checkpoint_read_uri = "{checkpoint_path}"
checkpoint_write_uri = "{checkpoint_path}"
with checkpoint.reader(checkpoint_read_uri) as reader:
    state_dict = torch.load(reader)
    model.load_state_dict(state_dict)

def read_and_transform(data):
    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                     std=[0.229, 0.224, 0.225])
    transform = transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        normalize,
    ])

    try:
        img = accimage.Image((data.read()))
        value = transform(img)
    except Exception as e:
        print("read failed", e)
        return None, 0
    return value, 0
dataset = OssMapDataset.from_prefix("{oss_data_folder_uri}", endpoint="{oss_endpoint}", transform=read_and_transform, cred_path=cred_path, config_path=config_path)
data_loader = torch.utils.data.DataLoader(
    dataset, batch_size="{batch_size}",num_workers="{num_workers"}, pin_memory=True)

for epoch in range(args.epochs):
    for step, (images, target) in enumerate(data_loader):
        # batch processing
        # model training
    # save model
    with checkpoint.writer(checkpoint_write_uri) as writer:
        torch.save(model.state_dict(), writer)

Puntos clave en este ejemplo:

  • Construya un conjunto de datos con OssMapDataset directamente desde la URI de OSS proporcionada, siguiendo el patrón estándar DataLoader de PyTorch.

  • Utilice este conjunto de datos para crear un DataLoader estándar de PyTorch y ejecute un ciclo de entrenamiento normal para procesar cada lote, entrenar el modelo y guardar puntos de control.

  • Esto habilita la carga bajo demanda, lo que elimina la necesidad de montar el conjunto de datos en el entorno del contenedor o descargarlo al almacenamiento local previamente.

OSS SDK

OSS Python SDK

Utilice OSS Python SDK para leer datos de OSS y escribir datos en OSS:

  1. Instale OSS Python SDK. Para obtener más información, consulte Installation (Python SDK V1).

  2. Configure las credenciales de acceso para OSS Python SDK. Para obtener más información, consulte Configure access credentials (Python SDK V1).

  3. Lea y escriba datos en OSS.

    # -*- coding: utf-8 -*-
    import oss2
    from oss2.credentials import EnvironmentVariableCredentialsProvider
    
    # Configure access credentials using the RAM user access key from environment variables.
    auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
    bucket = oss2.Bucket(auth, '<Endpoint>', '<your_bucket_name>')
    # Read a complete file.
    result = bucket.get_object('<your_file_path/your_file>')
    print(result.read())
    # Read data by range.
    result = bucket.get_object('<your_file_path/your_file>', byte_range=(0, 99))
    # Write data to OSS.
    bucket.put_object('<your_file_path/your_file>', '<your_object_content>')
    # Append data to an appendable file.
    result = bucket.append_object('<your_file_path/your_file>', 0, '<your_object_content>')
    result = bucket.append_object('<your_file_path/your_file>', result.next_position, '<your_object_content>')
    

    Modifique los siguientes parámetros según sea necesario:

    Parámetro

    Descripción

    <Endpoint>

    El endpoint correspondiente a la región de su bucket. Por ejemplo, para la región China (Hangzhou), establezca el endpoint en https://oss-cn-hangzhou.aliyuncs.com. Para obtener más información sobre cómo obtener un endpoint, consulte Regions and endpoints.

    <your_bucket_name>

    El nombre de su bucket.

    <your_file_path/your_file>

    La ruta del archivo que se va a leer o escribir. Especifique la ruta completa del objeto, pero excluya el nombre del bucket. Por ejemplo, testfolder/exampleobject.txt.

    <your_object_content>

    El contenido que se va a escribir o anexar. Reemplácelo según sea necesario.

OSS Python API

Puede utilizar la OSS Python API para almacenar convenientemente datos de entrenamiento y modelos en OSS. Antes de empezar, asegúrese de haber instalado OSS Python SDK y configurado sus credenciales de acceso. Para obtener más información, consulte Installation (Python SDK V1) y Configure access credentials (Python SDK V1).

  • Cargar datos de entrenamiento

    Puede almacenar sus datos en un bucket de OSS, con las rutas de datos y las etiquetas correspondientes en un archivo de índice dentro del mismo bucket. Al crear un Dataset personalizado, puede utilizar la API DataLoader en PyTorch para leer datos en paralelo en varios procesos. El siguiente código muestra un ejemplo.

    import io
    import oss2
    from oss2.credentials import EnvironmentVariableCredentialsProvider
    import PIL
    import torch
    
    class OSSDataset(torch.utils.data.dataset.Dataset):
        def __init__(self, endpoint, bucket, auth, index_file):
            self._bucket = oss2.Bucket(auth, endpoint, bucket)
            self._indices = self._bucket.get_object(index_file).read().split(',')
    
        def __len__(self):
            return len(self._indices)
    
        def __getitem__(self, index):
            img_path, label = self._indices(index).strip().split(':')
            img_str = self._bucket.get_object(img_path)
            img_buf = io.BytesIO()
            img_buf.write(img_str.read())
            img_buf.seek(0)
            img = Image.open(img_buf).convert('RGB')
            img_buf.close()
            return img, label
    
    # Obtain access credentials from environment variables. Before you run this code sample,
    # make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
    auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
    dataset = OSSDataset(endpoint, bucket, auth, index_file)
    data_loader = torch.utils.data.DataLoader(
        dataset,
        batch_size=batch_size,
        num_workers=num_loaders,
        pin_memory=True)
    

    Esta tabla describe los parámetros clave.

    Parámetro

    Descripción

    endpoint

    El endpoint correspondiente a la región de su bucket. Por ejemplo, para la región China (Hangzhou), establezca el endpoint en https://oss-cn-hangzhou.aliyuncs.com. Para obtener más información sobre cómo obtener un endpoint, consulte Regions and endpoints.

    bucket

    El nombre de su bucket.

    index_file

    La ruta del archivo de índice.

    Nota

    En el ejemplo, el archivo de índice utiliza una coma (,) para separar cada muestra y dos puntos (:) para separar la ruta de la muestra de la etiqueta.

  • Guardar o cargar modelos

    Utilice OSS Python API para guardar o cargar modelos de PyTorch. Para obtener más información sobre cómo guardar y cargar modelos en PyTorch, consulte PyTorch. El siguiente código proporciona ejemplos:

    • Guardar un modelo

      from io import BytesIO
      import torch
      import oss2
      from oss2.credentials import EnvironmentVariableCredentialsProvider
      
      auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
      # bucket_name
      bucket_name = "<your_bucket_name>"
      bucket = oss2.Bucket(auth, endpoint, bucket_name)
      buffer = BytesIO()
      torch.save(model.state_dict(), buffer)
      bucket.put_object("<your_model_path>", buffer.getvalue())
      

      Donde:

      • endpoint es el endpoint correspondiente a la región de su bucket. Por ejemplo, para la región China (Hangzhou), establezca el endpoint en https://oss-cn-hangzhou.aliyuncs.com.

      • <your_bucket_name> es el nombre del bucket de OSS, sin el prefijo oss://.

      • <your_model_path> es la ruta del modelo. Reemplácela según sea necesario.

    • Cargar un modelo

      from io import BytesIO
      import torch
      import oss2
      from oss2.credentials import EnvironmentVariableCredentialsProvider
      
      auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
      bucket_name = "<your_bucket_name>"
      bucket = oss2.Bucket(auth, endpoint, bucket_name)
      buffer = BytesIO(bucket.get_object("<your_model_path>").read())
      model.load_state_dict(torch.load(buffer))

      Donde:

      • endpoint es el endpoint correspondiente a la región de su bucket. Por ejemplo, para la región China (Hangzhou), establezca el endpoint en https://oss-cn-hangzhou.aliyuncs.com.

      • <your_bucket_name> es el nombre del bucket de OSS, sin el prefijo oss://.

      • <your_model_path> es la ruta del modelo. Reemplácela según sea necesario.