MaxCompute:Présentation de PyODPS

PyODPS est utilisé dans les scénarios suivants :

• Démarrage rapide.

• Lecture des données des tables partitionnées à l'aide de PyODPS.

• Transmission de paramètres dans PyODPS.

• Utilisation de packages tiers avec PyODPS.

• Affichage des partitions de hachage à l'aide de PyODPS.

• Exécution de requêtes conditionnelles à l'aide de PyODPS.

• Utilisation des opérations Sequence et d'exécution dans PyODPS.

PyODPS s'exécute dans les environnements locaux, DataWorks et PAI Notebooks.

• Environnement local : vous pouvez installer et utiliser PyODPS dans votre environnement local. Pour plus d'informations, consultez Utilisation de PyODPS dans un environnement local.

• DataWorks : PyODPS est préinstallé sur les nœuds PyODPS dans DataWorks. Vous pouvez développer et exécuter périodiquement des tâches PyODPS directement sur ces nœuds. Pour plus d'informations, consultez Utilisation de PyODPS dans DataWorks.

• PAI Notebooks : vous pouvez installer et exécuter PyODPS dans l'environnement Python de PAI. PyODPS est préinstallé dans les images PAI intégrées, telles que le composant Python personnalisé de PAI-Designer, et est prêt à l'emploi. L'utilisation de PyODPS dans PAI Notebooks est similaire à son utilisation standard. Pour plus d'informations, consultez Présentation des opérations de base et DataFrame (non recommandé).

PyODPS est un SDK qui s'exécute sur divers clients, notamment les PC, les nœuds PyODPS DataWorks dans Data Studio et les environnements PAI Notebook. PyODPS fournit plusieurs opérations pratiques pour extraire les données vers une machine locale, telles que tunnel download, execute et to_pandas. Par conséquent, de nombreux nouveaux utilisateurs tentent d'extraire les données localement, de les traiter, puis de les charger à nouveau dans MaxCompute. Cependant, cette méthode est souvent très inefficace. L'extraction des données localement vous empêche de tirer parti des capacités de calcul parallèle à grande échelle de MaxCompute.

L'exemple de tokenisation suivant compare le code des deux méthodes.

• Scénario d'exemple

  Vous devez extraire des informations en analysant des chaînes de journaux quotidiens. Vous disposez d'une table contenant une seule colonne de type chaîne. Vous devez utiliser la bibliothèque jieba pour tokeniser le texte chinois, trouver les mots-clés souhaités et stocker ces mots-clés dans une table d'informations.

• Démonstration de code de traitement inefficace

  import jieba
  t = o.get_table('word_split')
  out = []
  with t.open_reader() as reader:
      for r in reader:
          words = list(jieba.cut(r[0]))
          #
          # Processing logic to generate processed_data
          #
          out.append(processed_data)
  out_t = o.get_table('words')
  with out_t.open_writer() as writer:
      writer.write(out)

  Cette approche suit une logique de traitement sur une seule machine : lire les données ligne par ligne, les traiter ligne par ligne, puis les écrire dans la table de destination ligne par ligne. L'ensemble du processus consomme beaucoup de temps pour le téléchargement et le chargement des données. La machine qui exécute le script a également besoin d'une grande quantité de mémoire pour traiter toutes les données. Pour les utilisateurs des nœuds DataWorks, cette approche peut facilement provoquer une erreur OOM en dépassant la mémoire allouée par défaut.

• Démonstration de code de traitement efficace

  from odps.df import output
  out_table = o.get_table('words')
  df = o.get_table('word_split').to_df()
  
  # Assume the following fields and types need to be returned
  out_names = ["word", "count"]
  out_types = ["string", "int"]
  
  @output(out_names, out_types)
  def handle(row):
      import jieba
      words = list(jieba.cut(row[0]))
      #
      # Processing logic to generate processed_data
      #
      yield processed_data
  df.apply(handle, axis=1).persist(out_table.name)

  Utilisez la méthode apply pour une exécution distribuée :

  • La logique complexe est placée dans la fonction handle. Cette fonction est automatiquement sérialisée côté serveur pour être utilisée comme UDF, où elle est appelée et exécutée. Étant donné que la fonction handle traite également les données ligne par ligne lors de l'exécution côté serveur, la logique est identique. La différence réside dans le fait que lorsque ce programme est soumis à MaxCompute pour exécution, plusieurs machines traitent les données simultanément. Cela permet de gagner beaucoup de temps.

  • L'appel de l'interface persist écrit les données générées directement dans une autre table MaxCompute. Toute la génération et la consommation de données ont lieu au sein du cluster MaxCompute. Cela permet d'économiser les ressources réseau et mémoire locales.

  • Cet exemple utilise également un package tiers. MaxCompute prend en charge les packages tiers, tels que jieba dans cet exemple, dans les UDF. Par conséquent, vous n'avez pas à vous soucier du coût des modifications de code. Vous pouvez tirer parti des capacités de calcul à grande échelle de MaxCompute avec presque aucune modification de votre logique principale.