pls corrct this code : !pip install -q tensorflow-text !pip install datasets !pip…
- 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
- 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
datasetsobject. When you attempt to map overdatausingexample['translation'][0]['en'], it seems like you're expectingexample['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
dataindeed 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, sincedatadirectly represents the dataset split andmapfunction expects a certain structure, you typically use it with datasets objects to apply transformations.Given your code, you might not need to remap
dataif 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:
- The dataset is correctly loaded and inspect its structure by printing an example item.
- Understand how the
mapfunction is intended to be used withdatasets– 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. - 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
functionwhich is applied to all elements of table returns a variable of type {type(processed_inputs)}. Make sure providedfunctionreturns a variable of typedict(or a pyarrow table) to update the dataset orNoneif you are only interested in side effects." 3319 )TypeError: Provided
functionwhich is applied to all elements of table returns a variable of type <class 'str'>. Make sure providedfunctionreturns a variable of typedict(or a pyarrow table) to update the dataset orNoneif you are only interested in side effects. - Assistant
The error message indicates that the lambda function you provided to the
mapmethod returns a string (<class 'str'>), while themapmethod expects either adict, a PyArrow Table, or a Pandas DataFrame. This is because themapmethod 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
mapoperation on a Hugging Facedatasets.Datasetobject 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 bothtrain_enandtrain_frvariables throughmapis where the problem lies.In your specific case, if you still want to use the
mapfunction 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 thefrench_sentencesandenglish_sentenceslists, you might not need to usemaphere.If you still want to proceed with some form of transformation and correct this for future processing steps, here is what you should consider:
-
Direct Extraction (Already Done): You've already extracted
french_sentencesandenglish_sentencessuccessfully. -
Using
mapProperly: 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
mapfor 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 theDataset.mapexpectations, such as a dictionary reflecting the new or modified dataset schema. -
- User
peux tu me récapituler le probléme
- Assistant
Le problème que vous rencontrez est lié à l'utilisation de la méthode
.map()de la bibliothèquedatasetsde 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'erreurTypeError: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 undict, une table PyArrow, ou un DataFrame Pandas pour mettre à jour le dataset ouNonesi 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. - User
quescue je peux faire pour le réparer ?
- 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 listesfrench_sentencesetenglish_sentencesque 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 fonctiontransformer.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. - User
il y a id et translation comme colone
- Assistant
Si votre dataset contient les colonnes
idettranslation, 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 (danstranslation), tout en conservant l'idintact, voici comment vous pourriez procéder :Transformer les Données en Gardant les Colonnes
idettranslationSupposons que votre dataset
dataa des entrées qui ressemblent à quelque chose comme ceci :{'id': 123, 'translation': {'en': 'Hello', 'fr': 'Bonjour'}}. Vous souhaitez appliquer une transformation aux phrases danstranslationsans altérer l'id.Vous pouvez définir une fonction
transformerqui sera passée à la méthode.map(). Cette fonction devrait retourner un dictionnaire qui contient à la fois l'idoriginal et les phrases transformées danstranslation. Cependant, puisqueidne doit pas être modifié, vous le retournerez tel quel, et vous appliquerez votre transformation spécifique aux partiesenetfrdetranslation.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'
idest conservé tel quel. - Les valeurs des champs
enetfrdanstranslationsont 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
translationtout en conservant les autres structures du dataset (iddans cet exemple) inchangées. Adaptez la partie de code de la transformation (new_translation) selon les besoins spécifiques de votre projet. - L'
- User
donne moi juste le code
- Assistant
Si vous souhaitez appliquer une transformation spécifique aux données contenues dans les champs
translationde votre dataset, tout en conservant le champidintact, 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
transformerqui prend chaqueexample(ou échantillon) dudatasetet retourne un dictionnaire qui contient l'idinchangé et la partietranslationtransformé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. - User
il faut que je map je fais une ia de traduction
- 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
idettranslation, et quetranslationcontient les champsenpour l'anglais etfrpour 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 (oudatasets) 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_sentencesetfrench_sentencespeuvent 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
preprocessavec les opérations spécifiques nécessaires pour votre cas d'usage, telles que le nettoyage de texte, la tokenisation, etc. - User
les phrases source et cibles sont dans une variables
- Assistant
Si vos phrases source et cible sont contenues dans une seule variable (par exemple, chaque élément de votre variable
datacontient à 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
datasetset 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
transformersde 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.
- 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))
- Assistant
Pour optimiser votre code actuel, quelques modifications peuvent être apportées :
-
Réduire les Installations Redondantes : Fusionnez les commandes d'installation pour éviter les installations redondantes de
tensorflow-text. -
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. -
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 dansfrench_sentencesetenglish_sentencessont déjà décodées lors du chargement viadatasets.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. -