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 |
|
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. |
|
|
|
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. |
|
|
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:
|
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. |
|
|
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. |
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=0a 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.limitpara ajustar el límite de memoria. El siguiente código proporciona un ejemplo:{ "fs.jindo.fuse.pod.mem.limit": "10Gi" }
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_sizeestablece 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_sizee 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_sizeconsume 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
-
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:
NotaAlmacenar 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.
NotaCuando 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
-
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 │ └── ... └── .manifestEl 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
OssMapDatasetdirectamente desde la URI de OSS proporcionada, siguiendo el patrón estándarDataLoaderde PyTorch.Utilice este conjunto de datos para crear un
DataLoaderestá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:
Instale OSS Python SDK. Para obtener más información, consulte Installation (Python SDK V1).
Configure las credenciales de acceso para OSS Python SDK. Para obtener más información, consulte Configure access credentials (Python SDK V1).
-
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
DataLoaderen 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.
NotaEn 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.
-