nllw 0.1.0__tar.gz

nllw-0.1.0/.gitignore

@@ -0,0 +1,72 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+other/*
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+transformers-main/*
+docs_hf/*
+nllb-200-distilled-*-ctranslate2/
+*.pkl
+*.csv
+*.png
+*.gif
+

nllw-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: nllw
+Version: 0.1.0
+Summary: Simultaneous Machine Translation (SimulMT) with NLLB model optimization
+Author: Quentin Fuxa
+License: MIT
+Project-URL: Homepage, https://github.com/QuentinFuxa/NoLanguageLeftWaiting
+Keywords: machine-translation,simultaneous-translation,nllb,streaming,nlp,transformers,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=1.10.0
+Requires-Dist: transformers>=4.30.0
+Provides-Extra: ctranslate2
+Requires-Dist: ctranslate2>=3.16.0; extra == "ctranslate2"
+Provides-Extra: demo
+Requires-Dist: textual>=0.40.0; extra == "demo"
+
+<h1 align="center">NoLanguageLeftWaiting</h1>
+
+<p align="center">
+<img src="demo.gif"width="730">
+</p>
+
+<p align="center">
+<img src="architecture_NLLW.png"width="730">
+</p>
+
+Converts [NoLanguageLeftBehind](https://arxiv.org/abs/2207.04672) translation model to a SimulMT (Simultaneous Machine Translation) model, optimized for live/streaming use cases.
+
+> Based offline models such as NLLB suffer from eos token and punctuation insertion, inconsistent prefix handling and exponentially growing computational overhead as input length increases. This implementation aims at resolving that.
+
+
+- [LocalAgreement policy](https://www.isca-archive.org/interspeech_2020/liu20s_interspeech.pdf)
+- [HuggingFace transformers](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoModelForSeq2SeqLM) implementation only.
+- Built for [WhisperLiveKit](https://github.com/QuentinFuxa/WhisperLiveKit)
+- 200 languages. See [supported_languages.md](supported_languages.md) for the full list.
+
+## Installation
+
+```bash
+pip install nllw
+```
+> The textual frontend is not installed by default.
+
+
+## Quick Start
+
+1. Demo interface :
+```bash
+python textual_interface.py
+```
+
+2. Use it as a package
+```python
+import nllw
+
+model = nllw.load_model(
+    src_langs=["fra_Latn"],
+    nllb_backend="transformers",
+    nllb_size="600M"
+)
+translator = nllw.OnlineTranslation(
+    model,
+    input_languages=["fra_Latn"],
+    output_languages=["eng_Latn"]
+)
+
+translator.insert_tokens(tokens)
+validated, buffer = translator.process()
+
+print(f"Stable: {validated[0].text}")
+print(f"Buffer: {buffer.text}")
+```
+
+
+## Input vs Output length:
+
+Succesfully maintain output length, even if stable prefix tends to take time to grow.
+
+<p align="center">
+<img src="french_to_english.png"width="730">
+</p>

nllw-0.1.0/README.md

@@ -0,0 +1,65 @@
+<h1 align="center">NoLanguageLeftWaiting</h1>
+
+<p align="center">
+<img src="demo.gif"width="730">
+</p>
+
+<p align="center">
+<img src="architecture_NLLW.png"width="730">
+</p>
+
+Converts [NoLanguageLeftBehind](https://arxiv.org/abs/2207.04672) translation model to a SimulMT (Simultaneous Machine Translation) model, optimized for live/streaming use cases.
+
+> Based offline models such as NLLB suffer from eos token and punctuation insertion, inconsistent prefix handling and exponentially growing computational overhead as input length increases. This implementation aims at resolving that.
+
+
+- [LocalAgreement policy](https://www.isca-archive.org/interspeech_2020/liu20s_interspeech.pdf)
+- [HuggingFace transformers](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoModelForSeq2SeqLM) implementation only.
+- Built for [WhisperLiveKit](https://github.com/QuentinFuxa/WhisperLiveKit)
+- 200 languages. See [supported_languages.md](supported_languages.md) for the full list.
+
+## Installation
+
+```bash
+pip install nllw
+```
+> The textual frontend is not installed by default.
+
+
+## Quick Start
+
+1. Demo interface :
+```bash
+python textual_interface.py
+```
+
+2. Use it as a package
+```python
+import nllw
+
+model = nllw.load_model(
+    src_langs=["fra_Latn"],
+    nllb_backend="transformers",
+    nllb_size="600M"
+)
+translator = nllw.OnlineTranslation(
+    model,
+    input_languages=["fra_Latn"],
+    output_languages=["eng_Latn"]
+)
+
+translator.insert_tokens(tokens)
+validated, buffer = translator.process()
+
+print(f"Stable: {validated[0].text}")
+print(f"Buffer: {buffer.text}")
+```
+
+
+## Input vs Output length:
+
+Succesfully maintain output length, even if stable prefix tends to take time to grow.
+
+<p align="center">
+<img src="french_to_english.png"width="730">
+</p>

nllw-0.1.0/compare_translation_approaches.py

@@ -0,0 +1,129 @@
+from translation_backend import TranslationBackend
+import matplotlib.pyplot as plt
+import pandas as pd
+
+src_texts = [
+    "Il s'arrêtait par moments devant une villa",
+    "coquettement nichée dans la verdure, il regardait",
+    "par la grille et voyait au loin des femmes",
+    "élégantes sur les balcons et les terrasses, des",
+    "enfants couraient dans les jardins. Il s'intéressait",
+    "surtout aux fleurs ; c'étaient elles qui attiraient",
+    "particulièrement ses regards. De temps en temps,",
+    "il voyait passer des cavaliers, des amazones et de",
+    "belles voitures ; il les suivait d'un œil curieux et",
+    "les oubliait avant qu'ils eussent disparu. ",
+    "Une fois, il s'arrêta et compta son argent ; il",
+    "lui restait trente kopecks : « vingt au sergent de",
+    "ville, trois à Nastassia pour la lettre, j'en ai donc",
+    "donné hier à Marmeladov quarante-sept ou",
+    "cinquante », se dit-il. Il devait avoir une raison de",
+    "calculer ainsi, mais il l'oublia en tirant l'argent de",
+    "sa poche et ne s'en souvint qu'un peu plus tard en",
+    "passant devant un marchand de comestibles, une",
+    "sorte de gargote plutôt ; il sentit alors qu'il avait",
+    "faim. "
+]
+
+# print("1: direct generation)")
+# translation_backend_1 = TranslationBackend(source_lang='fra_Latn', target_lang="eng_Latn")
+# l_vals_no_cache = []
+
+# for i in range(1, len(src_texts) + 1):
+#     print(f'{i}/{len(src_texts) + 1}')
+#     truncated_text = " ".join(src_texts[:i])
+#     input_tokens = translation_backend_1.tokenizer(truncated_text, return_tensors="pt").to(translation_backend_1.device)
+#     encoder_outputs = translation_backend_1.model.get_encoder()(**input_tokens)
+#     output_tokens = translation_backend_1.model.generate(
+#         encoder_outputs=encoder_outputs,
+#         forced_bos_token_id=translation_backend_1.bos_token_id
+#     )
+#     output_text = translation_backend_1.tokenizer.decode(output_tokens[0], skip_special_tokens=True)
+#     l_vals_no_cache.append({
+#         "input": truncated_text,
+#         "output_text": output_text,
+#         "input_word_count": len(truncated_text.split()),
+#         "output_word_count": len(output_text.split())
+#     })
+
+# print("2: prefix reuse")
+# translation_backend_2 = TranslationBackend(source_lang='fra_Latn', target_lang="eng_Latn")
+# l_vals_with_cache = []
+
+# for i in range(1, len(src_texts) + 1):
+#     print(f'{i}/{len(src_texts) + 1}')
+#     truncated_text = " ".join(src_texts[:i])
+#     stable_translation, buffer = translation_backend_2.translate(truncated_text)
+    
+#     full_output = stable_translation + buffer
+#     l_vals_with_cache.append({
+#         "input": truncated_text,
+#         "stable_translation": stable_translation,
+#         "buffer": buffer,
+#         "full_output": full_output,
+#         "input_word_count": len(truncated_text.split()),
+#         "stable_word_count": len(stable_translation.split()) if stable_translation else 0,
+#         "buffer_word_count": len(buffer.split()) if buffer else 0,
+#         "total_output_word_count": len(full_output.split()) if full_output else 0
+#     })
+
+# df_base = pd.DataFrame(l_vals_no_cache)
+# df_prefix = pd.DataFrame(l_vals_with_cache)
+# df_base.to_csv('output_base_analysis.csv')
+# df_prefix.to_csv('output_prefix_analysis.csv')
+
+df_base = pd.read_csv('output_base_analysis.csv')
+df_prefix = pd.read_csv('output_prefix_analysis.csv')
+
+# df_merged = pd.concat([df_base, df_prefix], axis=1)
+
+# Extract data from dataframe
+iterations = list(range(1, len(df_prefix) + 1))
+input_counts = df_prefix['input_word_count'].tolist()
+output_with_prefix_and_buffer = df_prefix['total_output_word_count'].tolist()
+stable_counts = df_prefix['stable_word_count'].tolist()
+buffer_counts = df_prefix['buffer_word_count'].tolist()
+base_output_wc = df_base['output_word_count'].tolist()
+
+fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10))
+fig, (ax1) = plt.subplots(1, 1, figsize=(5, 5))
+
+
+colors = {
+    "dark_gray_1": "#2E2E2E",   # deep graphite gray
+    "dark_gray_2": "#4B4B4B",   # medium-dark neutral gray
+    "orange": "#FF7F0E",        # modern vivid orange (Matplotlib's default orange)
+    "red": "#D62728",           # elegant deep red
+}
+from matplotlib.ticker import MaxNLocator
+
+
+ax1.plot(iterations, input_counts, label='Input', marker='o', color=colors['dark_gray_1'])
+ax1.plot(iterations, base_output_wc, label='Base output (no prefix, no stability)', marker='^', color=colors['dark_gray_2'])
+ax1.plot(iterations, stable_counts, label='With prefix (Stable part)', marker='^', linewidth=2, color=colors['red'])
+ax1.plot(iterations, output_with_prefix_and_buffer, label='With prefix use output (Stable part + Buffer)', marker='^', color=colors['orange'])
+ax1.set_xlabel('Iteration')
+ax1.set_ylabel('Word count')
+ax1.set_title('SimulMT french to english Word Count')
+ax1.legend(fontsize=10)
+ax1.grid(True, alpha=0.3)
+ax1.xaxis.set_major_locator(MaxNLocator(integer=True))
+
+# # Second plot: Detailed view of cached approach
+# ax2.plot(iterations, input_counts, label='Input', marker='o', linewidth=2)
+# ax2.plot(iterations, stable_counts, label='Stable prefix (cached)', marker='D', linewidth=2)
+# ax2.plot(iterations, buffer_counts, label='Buffer (new)', marker='x', linewidth=2)
+# ax2.plot(iterations, output_with_cache, label='Total output', marker='^', linewidth=2, linestyle='--')
+# ax2.set_xlabel('Iteration', fontsize=12)
+# ax2.set_ylabel('Word count', fontsize=12)
+# ax2.set_title('Detailed view: Stable prefix vs Buffer (with cache)', fontsize=14, fontweight='bold')
+# ax2.legend(fontsize=10)
+# ax2.grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.savefig('translation_comparison.png', dpi=300, bbox_inches='tight')
+plt.show()
+
+# df = pd.DataFrame(l_vals_with_cache)
+# df.to_csv('output_prefix_analysis.csv')
+# print("terminated")

nllw-0.1.0/nllw/__init__.py

@@ -0,0 +1,42 @@
+from .translation import (
+    load_model,
+    OnlineTranslation,
+    TranslationModel,
+    TimedText,
+    MIN_SILENCE_DURATION_DEL_BUFFER,
+)
+
+from .core import TranslationBackend
+
+from .languages import (
+    get_nllb_code,
+    get_language_code_code,
+    get_language_name_by_language_code,
+    get_language_name_by_nllb,
+    get_language_info,
+    list_all_languages,
+    list_all_nllb_codes,
+    list_all_language_code_codes,
+    LANGUAGES,
+)
+
+__all__ = [
+    # Main API
+    "load_model",
+    "OnlineTranslation",
+    "TranslationModel",
+    "TimedText",
+    "MIN_SILENCE_DURATION_DEL_BUFFER",
+    # Backend (advanced)
+    "TranslationBackend",
+    # Language utilities
+    "get_nllb_code",
+    "get_language_code_code",
+    "get_language_name_by_language_code",
+    "get_language_name_by_nllb",
+    "get_language_info",
+    "list_all_languages",
+    "list_all_nllb_codes",
+    "list_all_language_code_codes",
+    "LANGUAGES",
+]

nllw-0.1.0/nllw/core.py

@@ -0,0 +1,252 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from transformers.cache_utils import EncoderDecoderCache, DynamicCache
+from typing import Tuple, Optional
+
+
+class TranslationBackend:
+    def __init__(self, source_lang, target_lang, model_name: str = "facebook/nllb-200-distilled-600M", model=None, tokenizer=None):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        if model is not None:
+            self.model = model
+            if not hasattr(model, 'device') or str(model.device) != self.device:
+                self.model = self.model.to(self.device)
+        else:
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(self.device)
+
+        if tokenizer is not None:
+            self.tokenizer = tokenizer
+        else:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name, src_lang=source_lang)
+        
+        self.source_lang = source_lang
+        self.target_lang = target_lang
+        self.bos_token_id = self.tokenizer.convert_tokens_to_ids(self.target_lang)
+
+        self.sentence_end_token_ids = set()
+
+        # find all tokens that decode to sentence-ending punctuation. For ex: token 81 and 248075 both represent '.')
+        for token_id in range(min(300000, self.tokenizer.vocab_size)):
+            try:
+                decoded = self.tokenizer.decode([token_id])
+                cleaned = decoded.strip().strip("'\"").strip()
+                if cleaned in ['.', '!', '?']:
+                    self.sentence_end_token_ids.add(token_id)
+            except:
+                pass
+
+        self.previous_tokens = None
+        self.stable_prefix = None
+    
+    def simple_translation(self, text):
+        inputs = self.tokenizer(text, return_tensors="pt").to(self.device)
+        encoder_outputs = self.model.get_encoder()(**inputs)
+        output = self.generate(
+                    encoder_outputs=encoder_outputs,
+        )
+        result = self.tokenizer.decode(output[0], skip_special_tokens=True)
+        return output, result
+
+    def generate(
+        self,
+        encoder_outputs: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        max_length: Optional[int] = 200
+        
+    ) -> Tuple[torch.Tensor, Optional[Tuple]]:    
+        with torch.no_grad():
+            generated_tokens = self.model.generate(
+                encoder_outputs=encoder_outputs,
+                attention_mask=attention_mask,
+                forced_bos_token_id=self.bos_token_id,
+                max_length=max_length,
+            )
+        return generated_tokens
+
+    def compute_common_prefix_tokens(
+        self, new_tokens
+    ):
+        common_length = 0
+        for i in range(min(len(self.previous_tokens[0]), len(new_tokens[0]))):
+            if self.previous_tokens[0][i] != new_tokens[0][i]:
+                common_length = i
+                break
+        else:
+            common_length = min(len(self.previous_tokens[0]), len(new_tokens[0]))
+
+        last_sentence_end = -1
+        for i in range(common_length):
+            if new_tokens[0][i].item() in self.sentence_end_token_ids:
+                last_sentence_end = i
+
+        if last_sentence_end >= 0:
+            return new_tokens[:, :last_sentence_end]
+
+        return new_tokens[:, :common_length]
+    
+    def translate(self, text: str) -> str:
+        word_count = len(text.strip().split())
+        
+        if word_count < 3:
+            return "", ""
+    
+        inputs = self.tokenizer(text, return_tensors="pt").to(self.device)            
+        with torch.no_grad():
+            encoder_outputs = self.model.get_encoder()(**inputs)
+        
+        if (self.previous_tokens is not None and self.stable_prefix is not None):
+            translation_tokens = self._continue_generation_with_cache(
+                encoder_hidden_states=encoder_outputs.last_hidden_state,
+            )
+        else:
+            with torch.no_grad():
+                translation_tokens = self.generate(
+                    encoder_outputs=encoder_outputs,
+                    attention_mask=inputs['attention_mask'],
+                )
+        if self.previous_tokens is not None:
+            self.stable_prefix = self.compute_common_prefix_tokens(new_tokens=translation_tokens)
+        self.previous_tokens = translation_tokens
+        
+        buffer = self.tokenizer.decode(
+                translation_tokens[0], 
+                skip_special_tokens=True
+        )        
+        if self.stable_prefix is not None:
+            stable_translation = self.tokenizer.decode(
+                self.stable_prefix[0], 
+                skip_special_tokens=True
+            )
+            return stable_translation, buffer[len(stable_translation):]            
+        else:
+            return "", buffer
+
+    def _continue_generation_with_cache(
+        self,
+        encoder_hidden_states: torch.Tensor,
+        max_new_tokens: int = 200
+    ) -> torch.Tensor:
+        eos_token_id = self.tokenizer.eos_token_id
+
+        with torch.no_grad():
+            past_key_values = EncoderDecoderCache(
+                self_attention_cache=DynamicCache(),
+                cross_attention_cache=DynamicCache()
+            )
+
+            decoder_out = self.model.model.decoder(
+                input_ids=self.stable_prefix,
+                encoder_hidden_states=encoder_hidden_states,
+                past_key_values=past_key_values,
+                use_cache=True,
+                return_dict=True,
+            )
+            past_key_values = decoder_out.past_key_values
+            prefix_logits = self.model.lm_head(decoder_out.last_hidden_state)
+            next_token_id = torch.argmax(prefix_logits[:, -1, :], dim=-1).unsqueeze(-1)
+
+            generated_tokens = self.stable_prefix.clone()
+
+            for _ in range(max_new_tokens):
+                if next_token_id.item() == eos_token_id:
+                    break
+
+                generated_tokens = torch.cat([generated_tokens, next_token_id], dim=-1)
+
+                decoder_out = self.model.model.decoder(
+                    input_ids=next_token_id,
+                    encoder_hidden_states=encoder_hidden_states,
+                    past_key_values=past_key_values,
+                    use_cache=True,
+                    return_dict=True,
+                )
+                past_key_values = decoder_out.past_key_values
+                logits = self.model.lm_head(decoder_out.last_hidden_state)
+                next_token_id = torch.argmax(logits[:, -1, :], dim=-1).unsqueeze(-1)
+
+        return generated_tokens
+
+
+
+if __name__ == '__main__':
+    # src_texts = [
+    #     "Have you noticed how accurate",
+    #     "LLM are now that GPU have became more powerful, ",
+    #     "especially when we think at the difficulties we had in the 2010 era",
+    #     "where online chatbots were not performant",
+    #     "at all, and ofter doing strict rules worked better",
+    #     "do you remember that era?"]
+
+#     src_texts = [
+#         "As-tu remarqué à quel point",
+#         "les LLM sont précis maintenant que les GPU sont devenus plus puissants, ",
+#         "surtout quand on pense aux difficultés qu'on avait dans les années 2010",
+#         "où les chatbots en ligne n'étaient pas performants",
+#         "du tout, et souvent faire des règles strictes fonctionnait mieux.",
+#         "Tu te souviens de cette époque, ",
+#         "c'était bien plus compliqué de travailler"]
+
+    translation_backend = TranslationBackend(source_lang='fra_Latn', target_lang="eng_Latn")
+    
+#     # for i in range(len(src_texts)+1):
+#     #     translation, buffer = translation_backend.translate(" ".join(src_texts[:i]))
+#     #     print(translation, '|', buffer)
+
+#     tokens, text = translation_backend.simple_translation("Ceci est un test de traduction. Nous avons fait tout notre possible. Jusqu'à partir de 0")[1]
+    
+#     # text = "Ceci est un test de traduction. Nous avons fait tout notre possible. Jusqu'à partir de 0, où nous avions pris la route, tout droit, et loin, loin, loin ! tu penses qu'on peut vraiment faire la longeur qu'on veut ?"
+#     print(output_text) 
+    
+
+    src_texts = ["Il s’arrêtait par moments devant une villa",
+    "coquettement nichée dans la verdure, il regardait",
+    "par la grille et voyait au loin des femmes",
+    "élégantes sur les balcons et les terrasses, des",
+    "enfants couraient dans les jardins. Il s’intéressait",
+    "surtout aux fleurs ; c’étaient elles qui attiraient",
+    "particulièrement ses regards. De temps en temps,"
+    "il voyait passer des cavaliers, des amazones et de"
+    "belles voitures ; il les suivait d’un œil curieux et",
+    "les oubliait avant qu’ils eussent disparu. "]
+
+    text = " ".join(src_texts)
+    
+
+    target = """He would stop occasionally in front of a villa
+    nestled charmingly in the greenery, look
+    through the gate, and see elegant women
+    on balconies and terraces in the distance,
+    children running in the gardens. He was particularly interested
+    in the flowers; they were what caught his eye. From time to time, 
+    he would see horsemen, horsewomen, and beautiful carriages passing by; 
+    he would follow them with a curious eye and
+    forget them before they had disappeared.
+    """
+    l_vals = []
+    for i in range(1, len(src_texts)+1):
+        truncated_text = " ".join(src_texts[:i])
+        input_tokens = translation_backend.tokenizer(truncated_text, return_tensors="pt").to(translation_backend.device)
+        encoder_outputs = translation_backend.model.get_encoder()(**input_tokens)
+        output_tokens = translation_backend.model.generate(
+            encoder_outputs=encoder_outputs,
+            forced_bos_token_id=translation_backend.bos_token_id
+        )
+        output_text = translation_backend.tokenizer.decode(output_tokens[0], skip_special_tokens=True)
+        l_vals.append(
+            {
+                "input": truncated_text,
+                "output_tokens_shape": output_tokens.shape[1], 
+                "output_text": output_text,
+            }
+        )
+    # input_tokens = translation_backend.tokenizer(text, return_tensors="pt").to(translation_backend.device)
+    # encoder_outputs = translation_backend.model.get_encoder()(**input_tokens)
+    # output_tokens = translation_backend.model.generate(
+    #     encoder_outputs=encoder_outputs,
+    #     forced_bos_token_id=translation_backend.bos_token_id
+    # )
+    # output_text = translation_backend.tokenizer.decode(output_tokens[0], skip_special_tokens=True)
+
+    
+    print('end')