Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· OpenAIAi2 WildChat-4.8M (AI2)

pls corrct this code : !pip install -q tensorflow-text !pip install datasets !pip…

  1. User

    pls corrct this code : !pip install -q tensorflow-text !pip install datasets !pip install -q -U tensorflow-text !cd /content import requests import tensorflow as tf import tensorflow_text as tf_text import functools

    from datasets import load_dataset

    dataset = load_dataset("Helsinki-NLP/opus_books", "en-fr") data = dataset["train"]

    french_sentences = [example["fr"] for example in data["translation"][:127085]] english_sentences = [example["en"] for example in data["translation"][:127085]] dataset = tf.data.Dataset.from_tensor_slices((french_sentences, english_sentences))

    french_sentences_decoded = [] english_sentences_decoded = []

    for french_sentence, english_sentence in dataset.take(127085): french_sentences_decoded.append(french_sentence.numpy().decode('utf-8')) english_sentences_decoded.append(english_sentence.numpy().decode('utf-8'))

    print("Nombre de phrases en français :", len(french_sentences_decoded)) print("Nombre de phrases en anglais :", len(english_sentences_decoded))

    train_en = data.map(lambda example: example['translation'][0]['en']) train_fr = data.map(lambda example: example['translation'][0]['fr'])

    this is the error message: Map:   0%  0/127085 [00:00<?, ? examples/s]

    KeyError Traceback (most recent call last) in <cell line: 1>() ----> 1 train_en = data.map(lambda example: example['translation'][0]['en']) 2 train_fr = data.map(lambda example: example['translation'][0]['fr'])

    5 frames /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in wrapper(*args, **kwargs) 591 self: "Dataset" = kwargs.pop("self") 592 # apply actual function --> 593 out: Union["Dataset", "DatasetDict"] = func(self, *args, **kwargs) 594 datasets: List["Dataset"] = list(out.values()) if isinstance(out, dict) else [out] 595 for dataset in datasets:

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in wrapper(*args, **kwargs) 556 } 557 # apply actual function --> 558 out: Union["Dataset", "DatasetDict"] = func(self, *args, **kwargs) 559 datasets: List["Dataset"] = list(out.values()) if isinstance(out, dict) else [out] 560 # re-apply format to the output

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in map(self, function, with_indices, with_rank, input_columns, batched, batch_size, drop_last_batch, remove_columns, keep_in_memory, load_from_cache_file, cache_file_name, writer_batch_size, features, disable_nullable, fn_kwargs, num_proc, suffix_template, new_fingerprint, desc) 3103 desc=desc or "Map", 3104 ) as pbar: -> 3105 for rank, done, content in Dataset._map_single(**dataset_kwargs): 3106 if done: 3107 shards_done += 1

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in _map_single(shard, function, with_indices, with_rank, input_columns, batched, batch_size, drop_last_batch, remove_columns, keep_in_memory, cache_file_name, writer_batch_size, features, disable_nullable, fn_kwargs, new_fingerprint, rank, offset) 3456 _time = time.time() 3457 for i, example in shard_iterable: -> 3458 example = apply_function_on_filtered_inputs(example, i, offset=offset) 3459 if update_data: 3460 if i == 0:

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in apply_function_on_filtered_inputs(pa_inputs, indices, check_same_num_examples, offset) 3359 if with_rank: 3360 additional_args += (rank,) -> 3361 processed_inputs = function(*fn_args, *additional_args, **fn_kwargs) 3362 if isinstance(processed_inputs, LazyDict): 3363 processed_inputs = {

    in (example) ----> 1 train_en = data.map(lambda example: example['translation'][0]['en']) 2 train_fr = data.map(lambda example: example['translation'][0]['fr'])

    KeyError: 0

  2. Assistant

    The error you're encountering is arising because you're trying to access data in a way that doesn't align with the structure it has in the datasets object. When you attempt to map over data using example['translation'][0]['en'], it seems like you're expecting example['translation'] to be a list of dictionaries where you can access elements with keys like "0", "en", etc. However, judging by your successful list comprehensions earlier in the code (french_sentences = [example["fr"] for example in data["translation"][:127085]]), example["translation"] is likely already a dictionary with "en" and "fr" as keys at each iteration.

    Given this, you'll want to adjust the lambda function in your .map() method to correctly access the "en" and "fr" fields without indexing [0]. Here's how you can correct that part of the code:

    # Assuming `data` is a dataset or a similar iterable containing dictionaries
    # with a "translation" key, where "translation" itself is a dictionary with "en" and "fr" keys
    train_en = data.map(lambda example: example['translation']['en'])
    train_fr = data.map(lambda example: example['translation']['fr'])
    

    If data indeed represents the dataset in a structure where each item is a dictionary containing another dictionary under the key "translation" and then "en" and "fr" keys inside of that, the corrected code will work. However, since data directly represents the dataset split and map function expects a certain structure, you typically use it with datasets objects to apply transformations.

    Given your code, you might not need to remap data if your goal was to create lists of sentences for training as you've already accomplished that with list comprehensions.

    If you're facing further issues, make sure that:

    1. The dataset is correctly loaded and inspect its structure by printing an example item.
    2. Understand how the map function is intended to be used with datasets – it's generally to apply transformations or processing to each element of the dataset.

    Considering your primary objectives appear to be extracting French and English sentences and you've achieved that, review whether the .map() operations are essential for your next steps or if there's a misunderstanding in what you're trying to achieve with those lines.

  3. User

    i have a probleme the code send me this error message what i will do ? : Map:   0%  0/127085 [00:00<?, ? examples/s]

    TypeError Traceback (most recent call last) in <cell line: 1>() ----> 1 train_en = data.map(lambda example: example['translation']['en']) 2 train_fr = data.map(lambda example: example['translation']['fr'])

    5 frames /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in wrapper(*args, **kwargs) 591 self: "Dataset" = kwargs.pop("self") 592 # apply actual function --> 593 out: Union["Dataset", "DatasetDict"] = func(self, *args, **kwargs) 594 datasets: List["Dataset"] = list(out.values()) if isinstance(out, dict) else [out] 595 for dataset in datasets:

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in wrapper(*args, **kwargs) 556 } 557 # apply actual function --> 558 out: Union["Dataset", "DatasetDict"] = func(self, *args, **kwargs) 559 datasets: List["Dataset"] = list(out.values()) if isinstance(out, dict) else [out] 560 # re-apply format to the output

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in map(self, function, with_indices, with_rank, input_columns, batched, batch_size, drop_last_batch, remove_columns, keep_in_memory, load_from_cache_file, cache_file_name, writer_batch_size, features, disable_nullable, fn_kwargs, num_proc, suffix_template, new_fingerprint, desc) 3103 desc=desc or "Map", 3104 ) as pbar: -> 3105 for rank, done, content in Dataset._map_single(**dataset_kwargs): 3106 if done: 3107 shards_done += 1

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in _map_single(shard, function, with_indices, with_rank, input_columns, batched, batch_size, drop_last_batch, remove_columns, keep_in_memory, cache_file_name, writer_batch_size, features, disable_nullable, fn_kwargs, new_fingerprint, rank, offset) 3456 _time = time.time() 3457 for i, example in shard_iterable: -> 3458 example = apply_function_on_filtered_inputs(example, i, offset=offset) 3459 if update_data: 3460 if i == 0:

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in apply_function_on_filtered_inputs(pa_inputs, indices, check_same_num_examples, offset) 3370 # Check if the function returns updated examples 3371 update_data = isinstance(processed_inputs, (Mapping, pa.Table, pd.DataFrame)) -> 3372 validate_function_output(processed_inputs, indices) 3373 if not update_data: 3374 return None # Nothing to update, let's move on

    /usr/local/lib/python3.10/dist-packages/datasets/arrow_dataset.py in validate_function_output(processed_inputs, indices) 3315 """Validate output of the map function.""" 3316 if processed_inputs is not None and not isinstance(processed_inputs, (Mapping, pa.Table, pd.DataFrame)): -> 3317 raise TypeError( 3318 f"Provided function which is applied to all elements of table returns a variable of type {type(processed_inputs)}. Make sure provided function returns a variable of type dict (or a pyarrow table) to update the dataset or None if you are only interested in side effects." 3319 )

    TypeError: Provided function which is applied to all elements of table returns a variable of type <class 'str'>. Make sure provided function returns a variable of type dict (or a pyarrow table) to update the dataset or None if you are only interested in side effects.

  4. Assistant

    The error message indicates that the lambda function you provided to the map method returns a string (<class 'str'>), while the map method expects either a dict, a PyArrow Table, or a Pandas DataFrame. This is because the map method is used to update or transform the entries in the dataset, and returning a simple string does not provide enough information on how to update the dataset entries.

    The map operation on a Hugging Face datasets.Dataset object is intended to transform each item in the dataset and should return a dictionary where the keys are the column names and the values are the new values for these columns. Since you are only extracting the sentences, the operation does not inherently modify the structure of the dataset. Hence, expecting a direct transformation to strings for both train_en and train_fr variables through map is where the problem lies.

    In your specific case, if you still want to use the map function for some transformations and handle the issue, ensure you return a dictionary from the lambda function that matches the expected structure of your dataset entries. However, if your goal is simply to extract the "en" and "fr" sentences into two separate variables and assuming you've already obtained the french_sentences and english_sentences lists, you might not need to use map here.

    If you still want to proceed with some form of transformation and correct this for future processing steps, here is what you should consider:

    1. Direct Extraction (Already Done): You've already extracted french_sentences and english_sentences successfully.

    2. Using map Properly: If you intend to modify or add new fields to the dataset based on existing columns, you should return a dictionary that reflects these changes. Here's an example structure assuming you want to add a dummy transformation:

    # Adding a suffix "_transformed" to each sentence as a dummy example
    def transform_example(example):
        return {
            'en_transformed': example['translation']['en'] + "_transformed",
            'fr_transformed': example['translation']['fr'] + "_transformed"
        }
    
    transformed_data = data.map(transform_example)
    

    Given your original code and objectives, it seems you may not need to use map for this task since you've already accomplished sentence extraction. If your goal is data manipulation or transformation beyond simple extraction, ensure that transformations return a structured form compatible with the Dataset.map expectations, such as a dictionary reflecting the new or modified dataset schema.

  5. User

    peux tu me récapituler le probléme

  6. Assistant

    Le problème que vous rencontrez est lié à l'utilisation de la méthode .map() de la bibliothèque datasets de Hugging Face avec une fonction lambda qui retourne un type incorrect par rapport à ce qu'attend cette méthode. La méthode .map() attend que la fonction passée en paramètre retourne un dictionnaire, une table PyArrow, ou un DataFrame Pandas représentant les données transformées, où les clés du dictionnaire correspondent aux noms des colonnes dans le dataset.

    Dans votre cas spécifique, vous avez essayé d'utiliser .map() avec une fonction lambda qui accède directement à un champ spécifique ('en' ou 'fr') dans le dictionnaire des données, ce qui retourne une chaîne de caractères (<class 'str'>). Cela n'est pas compatible avec ce que .map() attend, d'où l'erreur TypeError :

    TypeError: Provided `function` which is applied to all elements of table returns a variable of type <class 'str'>. Make sure provided `function` returns a variable of type `dict` (or a pyarrow table) to update the dataset or `None` if you are only interested in side effects.
    

    Cette erreur vous indique que la fonction fournie à .map() retourne une variable de type <class 'str'> alors qu'elle devrait retourner un dict, une table PyArrow, ou un DataFrame Pandas pour mettre à jour le dataset ou None si la fonction est utilisée seulement pour des effets de bord.

    La correction suggérée consistait à repenser l'utilisation de .map() dans votre contexte. Si votre objectif était simplement d'extraire des phrases en anglais et en français dans des listes séparées (ce que vous avez déjà réussi à faire plus tôt dans votre code avec des compréhensions de listes), alors l'utilisation de .map() n'était pas nécessaire pour cet objectif spécifique.

    Pour résumer, l'erreur provient de la manière dont vous avez utilisé la méthode .map() avec une fonction lambda qui ne respecte pas les attentes de la méthode en termes de type de retour. La solution est soit d'ajuster votre usage de .map() pour qu'il effectue les transformations attendues et retourne les données dans le format correct, soit de reconnaître que .map() n'est pas nécessaire pour votre objectif initial d'extraction de phrases.

  7. User

    quescue je peux faire pour le réparer ?

  8. Assistant

    Pour réparer le problème et continuer à utiliser votre code de manière efficace, voici quelques suggestions adaptées à vos objectifs :

    Si le but est d'extraire simplement des phrases :

    Puisque vous avez déjà réussi à extraire les phrases en français et en anglais dans des listes séparées grâce à des compréhensions de listes, vous n'avez pas besoin d'utiliser la méthode .map() pour cet objectif spécifique. Vous avez déjà les listes french_sentences et english_sentences que vous souhaitiez obtenir, donc aucune action supplémentaire n'est nécessaire dans ce cas.

    Pour transformer le dataset avec .map() :

    Si vous souhaitez transformer ou ajuster les données dans votre dataset et vous avez besoin d'utiliser .map(), assurez-vous que la fonction passée à .map() retourne un dictionnaire où chaque clé correspond au nom d'une colonne dans le dataset, et chaque valeur correspond à la nouvelle valeur de cette colonne.

    Par exemple, si vous voulez ajouter une transformation simple (comme mettre en majuscule) aux phrases en anglais et en français dans le dataset, vous feriez quelque chose comme :

    def transformer(example):
        # La fonction prend en entrée un exemple du dataset
        # et retourne un dictionnaire avec les données transformées
        return {
            'en': example['translation']['en'].upper(),  # Met la phrase en anglais en majuscule
            'fr': example['translation']['fr'].upper()   # Met la phrase en français en majuscule
        }
    
    # Appliquer la fonction de transformation à chaque exemple du dataset
    data_transformed = data.map(transformer)
    

    Notez que .map() sera utilisé ici pour appliquer une transformation qui maintient la structure du dataset intacte mais modifie les valeurs des données selon la logique définie dans la fonction transformer.

    Conclusion :

    Choisissez l'approche qui convient le mieux à vos objectifs. Si vous souhaitez juste obtenir des listes de phrases, vous n'avez pas besoin de corriger ou d'utiliser .map(). Si votre objectif est de transformer les données du dataset de manière structurée (par exemple, pour prétraiter des textes avant de les fournir à un modèle de machine learning), utilisez .map() avec une fonction qui retourne un dictionnaire adapté aux attentes de cette méthode.

  9. User

    il y a id et translation comme colone

  10. Assistant

    Si votre dataset contient les colonnes id et translation, et que votre objectif est d'appliquer une transformation ou une opération spécifique tout en conservant ces structures, vous pouvez ajuster votre fonction passée à .map() pour refléter cela. Par exemple, si vous souhaitez transformer les phrases (dans translation), tout en conservant l'id intact, voici comment vous pourriez procéder :

    Transformer les Données en Gardant les Colonnes id et translation

    Supposons que votre dataset data a des entrées qui ressemblent à quelque chose comme ceci : {'id': 123, 'translation': {'en': 'Hello', 'fr': 'Bonjour'}}. Vous souhaitez appliquer une transformation aux phrases dans translation sans altérer l'id.

    Vous pouvez définir une fonction transformer qui sera passée à la méthode .map(). Cette fonction devrait retourner un dictionnaire qui contient à la fois l'id original et les phrases transformées dans translation. Cependant, puisque id ne doit pas être modifié, vous le retournerez tel quel, et vous appliquerez votre transformation spécifique aux parties en et fr de translation.

    Voici un exemple concret où nous appliquons une transformation simple (pour cet exemple, un simple ajout de suffixe pour illustrer) :

    def transformer(example):
        # Exemple d'une transformation simple appliquée aux données de traduction
        new_translation = {
            'en': example['translation']['en'] + "_suffixe",
            'fr': example['translation']['fr'] + "_suffixe"
        }
        # Retourne un dictionnaire contenant l'ID inchangé et la nouvelle traduction
        return {
            'id': example['id'],  # On conserve l'ID original
            'translation': new_translation  # On retourne les phrases transformées
        }
    
    # Appliquer cette transformation à chaque élément du dataset
    data_transformed = data.map(transformer)
    

    Dans cet exemple, pour chaque élément du dataset :

    • L'id est conservé tel quel.
    • Les valeurs des champs en et fr dans translation sont transformées selon la logique définie (ici, simplement en ajoutant "_suffixe" à chaque phrase).

    Ce procédé vous permet de manipuler les données de translation tout en conservant les autres structures du dataset (id dans cet exemple) inchangées. Adaptez la partie de code de la transformation (new_translation) selon les besoins spécifiques de votre projet.

  11. User

    donne moi juste le code

  12. Assistant

    Si vous souhaitez appliquer une transformation spécifique aux données contenues dans les champs translation de votre dataset, tout en conservant le champ id intact, voici le code minimisé pour cette opération :

    def transformer(example):
        # Assurez-vous d'ajuster la transformation ci-dessous selon les besoins réels de votre projet
        transformed_translation = {
            'en': example['translation']['en'] + "_transformed",  # Exemple de transformation pour 'en'
            'fr': example['translation']['fr'] + "_transformed"   # Exemple de transformation pour 'fr'
        }
        return {
            'id': example['id'],  # Conserve l'ID original
            'translation': transformed_translation  # Applique la transformation
        }
    
    # Appliquer la fonction de transformation au dataset
    data_transformed = data.map(transformer)
    

    Ce code définit une fonction transformer qui prend chaque example (ou échantillon) du dataset et retourne un dictionnaire qui contient l'id inchangé et la partie translation transformée selon les besoins de votre traitement.

    Note : Le suffixe "_transformed" est juste un exemple pour illustrer comment vous pourriez modifier les valeurs. Vous devez remplacer cette logique de transformation par celle qui correspond à votre cas d'usage réel.

    Si votre objectif est de transformer réellement les phrases d'une manière spécifique (par exemple, les traduire, les nettoyer, ou appliquer une autre forme de prétraitement), remplacez la partie + "_transformed" par votre logique de transformation réelle.

  13. User

    il faut que je map je fais une ia de traduction

  14. Assistant

    Si vous travaillez sur une IA de traduction et vous souhaitez préparer vos données pour l'entraînement, vous devriez effectivement structurer vos données de manière à séparer les phrases sources et cibles. Habituellement, pour l'entraînement d'un modèle de traduction, vous voudriez avoir deux listes (ou deux ensembles de données) : l'une pour les phrases sources (par exemple, en anglais) et l'autre pour les phrases cibles (par exemple, en français).

    En supposant que le dataset contient des entrées avec id et translation, et que translation contient les champs en pour l'anglais et fr pour le français, vous pouvez utiliser .map() pour préparer ces deux ensembles séparément. Cependant, si votre intention est simplement de séparer les données en deux listes (ou datasets) sans transformation supplémentaire, vous pourriez ne pas avoir besoin de .map() pour cela ; l'extration directe comme vous l'avez fait initialement peut suffire.

    Si vous avez besoin d'effectuer une certaine forme de prétraitement ou de transformation des données (comme le nettoyage du texte, l'ajout d'un token de début/fin, etc.) avant de les passer à votre modèle, alors l'utilisation de .map() avec une fonction de transformation serait appropriée. Voici une structure de base pour effectuer ce genre de prétraitement :

    def preprocess(example):
        # Votre logique de prétraitement ici, par exemple :
        example['translation']['en'] = "<start> " + example['translation']['en'] + " <end>"
        example['translation']['fr'] = "<start> " + example['translation']['fr'] + " <end>"
        return example
    
    # Appliquer la fonction de prétraitement au dataset
    data_preprocessed = data.map(preprocess)
    

    Ensuite, pour séparer les ensembles de données en phrases sources et cibles, vous pouvez procéder comme suit :

    # Après avoir prétraité vos données
    english_sentences = [example['translation']['en'] for example in data_preprocessed]
    french_sentences = [example['translation']['fr'] for example in data_preprocessed]
    

    Ces listes english_sentences et french_sentences peuvent alors être utilisées pour entraîner votre modèle de traduction. Gardez à l'esprit que selon le framework que vous utilisez pour l'entraînement (par exemple, TensorFlow ou PyTorch), il peut y avoir des étapes supplémentaires pour convertir ces listes en formats appropriés (comme des tenseurs ou des dataloaders).

    Rappelez-vous de personnaliser la fonction preprocess avec les opérations spécifiques nécessaires pour votre cas d'usage, telles que le nettoyage de texte, la tokenisation, etc.

  15. User

    les phrases source et cibles sont dans une variables

  16. Assistant

    Si vos phrases source et cible sont contenues dans une seule variable (par exemple, chaque élément de votre variable data contient à la fois les phrases en anglais et en français dans une structure de dictionnaire sous la clé translation), et que votre objectif est de préparer ces données pour un modèle de traduction AI, alors vous aurez besoin d'extraire ces paires de phrases en deux listes (ou deux variables) séparées : une pour les phrases source et une autre pour les phrases cibles.

    En supposant que vous avez déjà accès à votre dataset sous la forme désirée grâce à la bibliothèque datasets et que vous souhaitez simplement extraire et préparer ces phrases pour l'entraînement, voici comment vous pourriez procéder sans utiliser .map() pour la transformation, mais plutôt pour directement extraire les informations :

    from datasets import load_dataset
    
    # Imaginons que vous avez chargé votre dataset ici
    dataset = load_dataset("Helsinki-NLP/opus_books", "en-fr")
    data = dataset["train"]
    
    # Extraction des phrases en utilisant une compréhension de liste
    english_sentences = [example['translation']['en'] for example in data]
    french_sentences = [example['translation']['fr'] for example in data]
    
    # À ce stade, `english_sentences` contiendrait toutes vos phrases source en anglais,
    # et `french_sentences` contiendrait toutes vos phrases cibles en français.
    

    Ces étapes ci-dessus sont suffisantes pour préparer vos données pour un modèle de traduction, en supposant que l'étape principale nécessaire soit la séparation des phrases source et cible.

    Voici quelques suggestions supplémentaires pour préparer vos données avant l'entraînement :

    Tokenisation

    Les modèles de traduction fonctionnent avec des tokens plutôt qu'avec du texte brut. Utilisez un tokeniseur pour convertir vos phrases en séquences de tokens. Les bibliothèques populaires comme transformers de Hugging Face fournissent des tokeniseurs prêts à l'emploi pour de nombreux modèles.

    from transformers import AutoTokenizer
    
    model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
    tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
    
    # Tokenisez les phrases
    tokenized_en = tokenizer(english_sentences, padding=True, truncation=True, return_tensors="pt")
    tokenized_fr = tokenizer(french_sentences, padding=True, truncation=True, return_tensors="pt")
    

    Prétraitement supplémentaire

    Selon les exigences de votre modèle, vous pourriez avoir besoin d'effectuer des étapes de prétraitement supplémentaires, telles que le nettoyage des données, la normalisation, ou l'ajout de tokens spéciaux.

    Division en Ensembles de Données d'Entraînement/Test

    Pour évaluer la performance de votre modèle, il est bon de diviser vos données en ensembles d'entraînement et de test. Utilisez une approche standard pour la division, en veillant à maintenir une distribution représentative dans chaque ensemble.

    from sklearn.model_selection import train_test_split
    
    en_train, en_test, fr_train, fr_test = train_test_split(english_sentences, french_sentences, test_size=0.2)
    

    En suivant ces étapes, vous devriez être bien préparé pour entraîner votre modèle de traduction avec les données préparées et traitées adéquatement.

  17. User

    peux tu optimisez ce code : !pip install -q tensorflow-text !pip install datasets !pip install -q -U tensorflow-text !cd /content import requests import tensorflow as tf import tensorflow_text as tf_text import functools

    from datasets import load_dataset

    dataset = load_dataset("Helsinki-NLP/opus_books", "en-fr") data = dataset["train"]

    french_sentences = [example["fr"] for example in data["translation"][:127085]] english_sentences = [example["en"] for example in data["translation"][:127085]] dataset = tf.data.Dataset.from_tensor_slices((french_sentences, english_sentences))

    french_sentences_decoded = [] english_sentences_decoded = []

    for french_sentence, english_sentence in dataset.take(127085): french_sentences_decoded.append(french_sentence.numpy().decode('utf-8')) english_sentences_decoded.append(english_sentence.numpy().decode('utf-8'))

    print("Nombre de phrases en français :", len(french_sentences_decoded)) print("Nombre de phrases en anglais :", len(english_sentences_decoded))

  18. Assistant

    Pour optimiser votre code actuel, quelques modifications peuvent être apportées :

    1. Réduire les Installations Redondantes : Fusionnez les commandes d'installation pour éviter les installations redondantes de tensorflow-text.

    2. Chargement et Transformation Efficace : Utilisez une approche plus directe et efficace pour charger et transformer le dataset. Plutôt que d'itérer sur le dataset TensorFlow pour décodage, faites-le avant la conversion en tf.data.Dataset.

    3. Utilisation de Compréhensions de Listes : Lorsque possible, utilisez des compréhensions de listes pour des opérations simples, car elles sont généralement plus rapides et plus lisibles que les boucles for standards.

    Voici comment ces suggestions pourraient être appliquées :

    !pip install -q -U tensorflow-text datasets
    
    import tensorflow as tf
    import tensorflow_text as tf_text
    from datasets import load_dataset
    
    # Chargement du dataset
    dataset = load_dataset("Helsinki-NLP/opus_books", "en-fr")
    data = dataset["train"]
    
    # Directement extraire et décoder les données
    french_sentences = [example["fr"] for example in data["translation"][:127085]]
    english_sentences = [example["en"] for example in data["translation"][:127085]]
    
    # Pas besoin de décoder en utf-8 si on ne travaille pas directement avec des données binaires
    # Créer un tf.data.Dataset
    dataset = tf.data.Dataset.from_tensor_slices((french_sentences, english_sentences))
    
    # Calculer les tailles
    print("Nombre de phrases en français :", len(french_sentences))
    print("Nombre de phrases en anglais :", len(english_sentences))
    

    Points Importants :

    • En supprimant la partie du code qui nécessitait le décodage utf-8 après la création du tf.data.Dataset, nous évitons un itération inutile. Cet itération était superflue parce que les chaînes dans french_sentences et english_sentences sont déjà décodées lors du chargement via datasets.load_dataset(). Elles ne sont pas en format binaire; par conséquent, le décodage utf-8 après la création du dataset TensorFlow n'était pas nécessaire.
    • Les commandes d'installation ont été simplifiées et fusionnées afin de réduire la redondance.
    • En utilisant cette approche, le code est simplifié, plus rapide, et toujours fonctionnel pour votre utilisation prévue.

    Soyez conscient que si plus tard vous avez besoin de manipuler des données binaires (par exemple, en travaillant avec des fichiers texte bruts ou d'autres formes de données non structurées), des étapes supplémentaires pour le décodage en UTF-8 peuvent être nécessaires. Cependant, dans ce contexte spécifique, où vous travaillez avec un dataset chargé via datasets.load_dataset(), cette étape supplémentaire n'est pas nécessaire.