Platform For AI:Utiliser OSS

Méthodes de montage

Limitations de la configuration par défaut

Si vous laissez vides les paramètres Advanced Configurations, la configuration par défaut est appliquée. La configuration par défaut présente les limitations suivantes :

• Pour accélérer la lecture des fichiers OSS, les métadonnées (répertoires et listes de fichiers) sont mises en cache lors du montage d'OSS.

  Lors d'un entraînement distribué, si plusieurs nœuds tentent de créer le même répertoire, le cache de métadonnées peut amener chaque nœud à tenter la création. Un seul nœud réussira, tandis que les autres signaleront une erreur.

• Par défaut, l'API OSS MultiPart est utilisée pour créer des fichiers. L'objet devient visible dans OSS uniquement après la fin des opérations d'écriture.

• Les opérations de lecture et d'écriture simultanées sur le même fichier ne sont pas prises en charge.

• Les opérations d'écriture aléatoire sur les fichiers ne sont pas prises en charge.

Configurations courantes de JindoFuse

Vous pouvez également personnaliser les paramètres JindoFuse dans la configuration avancée en fonction de votre cas d'utilisation.

Cette rubrique fournit des suggestions de configuration JindoFuse pour certains scénarios courants. Ces paramètres peuvent ne pas offrir des performances optimales pour toutes les charges de travail. Pour des options de configuration plus flexibles, consultez le Guide d'utilisation de JindoFuse .

• Quick Read/write : garantit des lectures et écritures rapides. Cependant, des incohérences de données peuvent survenir lors de lectures ou d'écritures simultanées. Vous pouvez monter les données d'entraînement et les modèles sur le chemin de montage de ce mode. Nous vous recommandons de ne pas utiliser le chemin de montage de ce mode comme répertoire de travail.

  {
    "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 : garantit la cohérence des données lors de l'écriture incrémentielle. Si les données d'origine sont écrasées, des incohérences de données peuvent survenir. La vitesse de lecture est légèrement plus lente. Vous pouvez utiliser ce mode pour enregistrer les fichiers de poids de modèle pour les données d'entraînement.

  {
    "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 : garantit la cohérence des données lors de lectures ou d'écritures simultanées et convient aux scénarios nécessitant une forte cohérence des données sans besoin de lectures rapides. Vous pouvez utiliser ce mode pour enregistrer le code de vos projets.

  {
    "fs.jindo.args": "-oattr_timeout=0 -oentry_timeout=0 -onegative_timeout=0 -oauto_cache -ono_symlink"
  }
  

• Read-only : autorise uniquement la lecture. Vous pouvez utiliser ce mode pour monter des jeux de données publics.

  {
    "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"
  }

Les autres opérations de configuration courantes incluent :

Méthodes de montage

Configurations ossfs courantes

Dans Advanced Configuration, vous pouvez définir des paramètres avancés à l'aide de fs.ossfs.args. Séparez plusieurs paramètres par une virgule (,). Pour plus d'informations sur ces paramètres avancés, consultez ossfs 2.0. Les exemples suivants illustrent plusieurs cas d'utilisation courants :

• Source de données statique pendant la tâche : pour les fichiers qui ne sont pas modifiés pendant l'exécution de la tâche, configurez un délai d'expiration de cache long afin de réduire les requêtes de métadonnées. Ce scénario est typique lors de la lecture d'un lot de fichiers existants et de la génération d'un nouvel ensemble de fichiers après traitement.

  {
      "mountType":"ossfs",
      "fs.ossfs.args": "-oattr_timeout=7200" 
  }

• Lecture/écriture rapide : utilisez un délai d'expiration de cache de métadonnées plus court pour équilibrer l'efficacité du cache et l'actualité des données.

  {
      "mountType":"ossfs",
      "fs.ossfs.args": "-oattr_timeout=3, -onegative_timeout=0"
  }

• Cohérence en lecture/écriture pour les tâches distribuées : par défaut, ossfs met à jour les données des fichiers en fonction du cache de métadonnées. Utilisez la configuration suivante pour garantir une vue cohérente sur plusieurs nœuds.

  {   
      "mountType":"ossfs",
      "fs.ossfs.args": "-onegative_timeout=0, -oclose_to_open"
  }

• Erreur de mémoire insuffisante (OOM) due à un trop grand nombre de fichiers ouverts dans DLC ou DSW : une forte concurrence des tâches dans DLC et DSW peut entraîner l'ouverture simultanée de nombreux fichiers, provoquant potentiellement des erreurs OOM. La configuration suivante permet de réduire la pression sur la mémoire.

  {
      "mountType":"ossfs",
      "fs.ossfs.args": "-oreaddirplus=false, -oinode_cache_eviction_threshold=300000"
  }

• Échec de l'écriture de fichiers volumineux : -oupload_buffer_size définit la taille du tampon (en octets) pour les téléchargements multiparties. Ce paramètre détermine la taille maximale du fichier pouvant être écrit, calculée comme suit : upload_buffer_size * 10 000.

  Par défaut, ossfs 2.0 utilise une taille de partie de 8 MiB, ce qui limite la taille maximale du fichier écrivable à 78,125 GiB. Si vous tentez d'écrire un fichier dépassant cette limite, l'opération échoue. Pour augmenter la taille de fichier maximale prise en charge, configurez l'option -oupload_buffer_size afin d'augmenter la taille des parties. Par exemple, une taille de partie de 32 MiB (33 554 432 octets) permet de prendre en charge des fichiers jusqu'à 312,5 GiB. Notez qu'une valeur -upload_buffer_size plus élevée consomme davantage de mémoire. Vous pouvez contrôler l'utilisation de la mémoire en configurant -total_mem_limit. Pour plus d'informations, consultez Options de montage.

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

Limites

• Images officielles : OSS Connector for AI/ML est disponible uniquement dans les tâches DLC et les instances DSW utilisant une image officielle de PyTorch 2.0 ou version ultérieure.

• Images personnalisées : Seules les versions PyTorch 2.0 ou ultérieures sont prises en charge. Pour les images personnalisées utilisant une version compatible, installez OSS Connector for AI/ML en exécutant la commande suivante :

  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

• Version Python : Seules les versions Python 3.8 à 3.12 sont prises en charge.

Prérequis

1. Configurez un fichier d'identifiants.

   Vous pouvez configurer les identifiants de l'une des manières suivantes :

   • Configurez l'accès sans mot de passe à OSS pour votre tâche DLC. Pour plus d'informations, consultez Configurer un rôle RAM DLC. Avec cette méthode, la tâche DLC obtient un identifiant temporaire auprès de STS pour accéder de manière sécurisée à OSS et aux autres ressources cloud, éliminant ainsi le besoin d'informations d'authentification explicites et réduisant le risque de fuite de clés d'accès.

   • Configurez un fichier d'identifiants dans votre projet de code pour gérer les informations d'authentification. Le code suivant fournit un exemple de configuration :

     Remarque

     Le stockage des informations de clé d'accès en texte clair présente un risque de sécurité. Nous vous recommandons d'utiliser un rôle RAM pour configurer automatiquement les identifiants au sein d'une instance DLC. Pour plus d'informations, consultez Configurer un rôle RAM DLC.

     Lorsque vous utilisez OSS Connector for AI/ML, vous pouvez spécifier le chemin d'accès au fichier d'identifiants afin de récupérer automatiquement les informations d'authentification nécessaires à la signature des demandes de données OSS.

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

     Le tableau suivant décrit les champs.

     Paramètre	Obligatoire	Description	Exemple
     AccessKeyId	Oui	L'ID de clé d'accès et la clé d'accès secrète d'un compte Alibaba Cloud ou d'un utilisateur RAM. Remarque Lorsque vous utilisez un identifiant temporaire de STS pour accéder à OSS, définissez ces paramètres sur l'ID de clé d'accès temporaire et la clé d'accès secrète temporaire.	NTS****
     AccessKeySecret	Oui		7NR2****
     SecurityToken	Non	Le jeton de sécurité de STS. Ce paramètre est requis uniquement lorsque vous utilisez un identifiant temporaire de STS pour accéder à OSS.	STS.6MC2****
     Expiration	Non	La date d'expiration de l'identifiant. Si ce champ est vide, l'identifiant n'expire pas. OSS Connector for AI/ML relit le fichier d'identifiants lorsque l'identifiant expire.	2024-08-20T00:00:00Z

2. Configurez un fichier config.json. Le code suivant fournit un exemple de configuration :

   Ce fichier sert à gérer les paramètres de votre projet, tels que les niveaux de simultanéité, les paramètres de préchargement et les emplacements des fichiers journaux. Lorsque vous utilisez OSS Connector for AI/ML, spécifiez le chemin d'accès à ce fichier config.json. Le connecteur applique alors automatiquement vos paramètres configurés et écrit les journaux relatifs aux demandes de données OSS dans le fichier journal spécifié.

   {
       "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
       }
   }

   Le tableau suivant décrit les champs.

   Paramètre		Obligatoire	Description	Exemple
   logLevel		Oui	Le niveau de journalisation. La valeur par défaut est 1 (INFO). Valeurs valides : 0 : DEBUG 1 : INFO 2 : WARN 3 : ERROR	1
   logPath		Oui	Le chemin d'accès au journal du connecteur. Le chemin par défaut est /var/log/oss-connector/connector.log.	/var/log/oss-connector/connector.log
   auditPath		Oui	Le journal d'audit pour les enregistrements d'E/S du connecteur consigne les demandes de lecture et d'écriture dont la latence est supérieure à 100 millisecondes. Le chemin par défaut est /var/log/oss-connector/audit.log.	/var/log/oss-connector/audit.log
   DatasetConfig	prefetchConcurrency	Oui	Le nombre de tâches simultanées pour le préchargement des données depuis OSS lors de l'utilisation d'un jeu de données. La valeur par défaut est 24.	24
   	prefetchWorker	Oui	Le nombre de vCPU disponibles pour le préchargement des données depuis OSS lors de l'utilisation d'un jeu de données. La valeur par défaut est 2.	2
   checkpointConfig	prefetchConcurrency	Oui	Le nombre de tâches simultanées pour le préchargement des données depuis OSS lors de la lecture d'un point de contrôle. La valeur par défaut est 24.	24
   	prefetchWorker	Oui	Le nombre de vCPU disponibles pour le préchargement des données depuis OSS lors de la lecture d'un point de contrôle. La valeur par défaut est 4.	4
   	uploadConcurrency	Oui	Le nombre de tâches simultanées pour le téléchargement des données lors de l'écriture d'un point de contrôle. La valeur par défaut est 64.	64

Utilisation

Le connecteur OSS pour l'IA/ML met à disposition deux interfaces d'accès aux jeux de données, OssMapDataset et OssIterableDataset, qui étendent respectivement les interfaces Dataset et IterableDataset de PyTorch. L'interface OssIterableDataset est optimisée grâce au préchargement (prefetching) pour améliorer l'efficacité de l'entraînement. L'ordre de lecture des données avec OssMapDataset est déterminé par le DataLoader et prend en charge les opérations de mélange (shuffle). Choisissez l'interface d'accès aux données adaptée à votre scénario en suivant ces recommandations :

• Si la mémoire disponible est limitée, que le jeu de données est volumineux et que seules des lectures séquentielles avec un faible niveau de parallélisme sont nécessaires, utilisez OssIterableDataset.

• Si la mémoire est suffisante, que le jeu de données est de taille réduite et que vous avez besoin d'un accès aléatoire ainsi que d'un traitement parallèle, utilisez OssMapDataset.

Le connecteur OSS pour l'IA/ML propose également l'interface OssCheckpoint pour le chargement et l'enregistrement des modèles. À ce jour, la fonctionnalité OssCheckpoint n'est disponible que dans les environnements disposant de ressources de calcul polyvalentes.

Les sections suivantes détaillent l'utilisation de ces trois interfaces.

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)

Exemple de code

L'exemple de code complet ci-dessous montre comment utiliser le connecteur OSS pour l'IA/ML afin d'accéder aux données stockées dans 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)

Points clés de cet exemple :

• Créez un jeu de données avec OssMapDataset directement à partir de l'URI OSS fournie, en suivant le modèle standard DataLoader de PyTorch.

• Utilisez ce jeu de données pour créer un DataLoader PyTorch standard, puis exécutez une boucle d'entraînement classique pour traiter chaque lot, entraîner le modèle et enregistrer les points de contrôle.

• Cela permet un chargement à la demande, supprimant ainsi la nécessité de monter le jeu de données dans l'environnement du conteneur ou de le télécharger préalablement sur le stockage local.

SDK Python OSS

Utilisez le SDK Python OSS pour lire et écrire des données dans OSS :

1. Installez le SDK Python OSS. Pour plus d'informations, consultez la rubrique Installation (Python SDK V1).

2. Configurez les identifiants d'accès pour le SDK Python OSS. Pour plus d'informations, consultez la rubrique Configure access credentials (Python SDK V1).

3. Lisez et écrivez des données dans 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>')
   

   Modifiez les paramètres suivants selon vos besoins :

   Paramètre	Description
   <Endpoint>	Endpoint de la région de votre bucket. Par exemple, pour la région Chine (Hangzhou), définissez l'endpoint sur https://oss-cn-hangzhou.aliyuncs.com. Pour savoir comment obtenir un endpoint, consultez la rubrique Regions and endpoints.
   <your_bucket_name>	Nom de votre bucket.
   <your_file_path/your_file>	Chemin du fichier à lire ou à écrire. Indiquez le chemin complet de l'objet, sans inclure le nom du bucket. Exemple : testfolder/exampleobject.txt.
   <your_object_content>	Contenu à écrire ou à ajouter. Adaptez selon vos besoins.

API Python OSS

Vous pouvez utiliser l'API Python OSS pour stocker facilement vos données d'entraînement et vos modèles dans OSS. Avant de commencer, assurez-vous d'avoir installé le SDK Python OSS et configuré vos identifiants d'accès. Pour plus d'informations, consultez les rubriques Installation (Python SDK V1) et Configure access credentials (Python SDK V1).

• Chargement des données d'entraînement

  Stockez vos données dans un bucket OSS, les chemins d'accès aux données et les libellés correspondants étant inscrits dans un fichier d'index situé dans le même bucket. En créant un Dataset personnalisé, vous pouvez utiliser l'API DataLoader de PyTorch pour lire les données en parallèle via plusieurs processus. Voici un exemple de code.

  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)
  

  Ce tableau décrit les principaux paramètres.

  Paramètre	Description
  endpoint	Endpoint de la région de votre bucket. Par exemple, pour la région Chine (Hangzhou), définissez l'endpoint sur https://oss-cn-hangzhou.aliyuncs.com. Pour savoir comment obtenir un endpoint, consultez la rubrique Regions and endpoints.
  bucket	Nom de votre bucket.
  index_file	Chemin du fichier d'index. Remarque Dans l'exemple, le fichier d'index utilise une virgule (,) pour séparer chaque échantillon et deux-points (:) pour séparer le chemin de l'échantillon du libellé.

• Enregistrement ou chargement des modèles

  Utilisez l'API Python OSS pour enregistrer ou charger des modèles PyTorch. Pour plus d'informations sur l'enregistrement et le chargement des modèles dans PyTorch, consultez la documentation PyTorch. Les exemples de code suivants illustrent ces opérations :

  • Enregistrement d'un modèle

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

    Où :

    • endpoint correspond à l'endpoint de la région de votre bucket. Par exemple, pour la région Chine (Hangzhou), définissez l'endpoint sur https://oss-cn-hangzhou.aliyuncs.com.

    • <your_bucket_name> représente le nom du bucket OSS, sans le préfixe oss://.

    • <your_model_path> indique le chemin du modèle. Adaptez selon vos besoins.

  • Chargement d'un modèle

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

    Où :

    • endpoint correspond à l'endpoint de la région de votre bucket. Par exemple, pour la région Chine (Hangzhou), définissez l'endpoint sur https://oss-cn-hangzhou.aliyuncs.com.

    • <your_bucket_name> représente le nom du bucket OSS, sans le préfixe oss://.

    • <your_model_path> indique le chemin du modèle. Adaptez selon vos besoins.