Merge pull request #910 from huggingface/bump_release

Bump_release

Author: burtenshaw

.github/workflows/build_documentation.yml

@@ -14,6 +14,6 @@ jobs:
       package: course
       path_to_docs: course/chapters/
       additional_args: --not_python_module
-      languages: ar bn de en es fa fr gj he hi id it ja ko ne pt ru rum th tr vi zh-CN zh-TW
+      languages: ar bn de en es fa fr gj he hi id it ja ko ne pl pt ru rum th tr vi zh-CN zh-TW
     secrets:
       hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}

.github/workflows/build_pr_documentation.yml

@@ -16,4 +16,4 @@ jobs:
       package: course
       path_to_docs: course/chapters/
       additional_args: --not_python_module
-      languages: ar bn de en es fa fr gj he hi id it ja ko ne pt ru rum th tr vi zh-CN zh-TW
+      languages: ar bn de en es fa fr gj he hi id it ja ko ne pl pt ru rum th tr vi zh-CN zh-TW

chapters/en/chapter1/2.mdx

@@ -9,6 +9,8 @@ Before jumping into Transformer models, let's do a quick overview of what natura
 
 ## What is NLP?[[what-is-nlp]]
 
+<Youtube id="iNzlxWUAjd4" />
+
 NLP is a field of linguistics and machine learning focused on understanding everything related to human language. The aim of NLP tasks is not only to understand single words individually, but to be able to understand the context of those words.
 
 The following is a list of common NLP tasks, with some examples of each:

chapters/en/chapter1/5.mdx

@@ -1,5 +1,7 @@
 # How 🤗 Transformers solve tasks
 
+<Youtube id="zsfR7eY9Uho" />
+
 In [Transformers, what can they do?](/course/chapter1/3), you learned about natural language processing (NLP), speech and audio, computer vision tasks, and some important applications of them. This page will look closely at how models solve these tasks and explain what's happening under the hood. There are many ways to solve a given task, some models may implement certain techniques or even approach the task from a new angle, but for Transformer models, the general idea is the same. Owing to its flexible architecture, most models are a variant of an encoder, a decoder, or an encoder-decoder structure. 
 
 <Tip>

chapters/en/chapter1/8.mdx

@@ -5,6 +5,8 @@
     classNames="absolute z-10 right-0 top-0"
 />
 
+<Youtube id="Xp2w1_LKZN4" />
+
 So far, we've explored the transformer architecture in relation to a range of discrete tasks, like text classification or summarization. However, Large Language Models are most used for text generation, and this is what we'll explore in this chapter.
 
 In this page, we'll explore the core concepts behind LLM inference, providing a comprehensive understanding of how these models generate text and the key components involved in the inference process.

chapters/en/chapter3/3.mdx

@@ -58,7 +58,7 @@ model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_label
 
 You will notice that unlike in [Chapter 2](/course/chapter2), you get a warning after instantiating this pretrained model. This is because BERT has not been pretrained on classifying pairs of sentences, so the head of the pretrained model has been discarded and a new head suitable for sequence classification has been added instead. The warnings indicate that some weights were not used (the ones corresponding to the dropped pretraining head) and that some others were randomly initialized (the ones for the new head). It concludes by encouraging you to train the model, which is exactly what we are going to do now.
 
-Once we have our model, we can define a `Trainer` by passing it all the objects constructed up to now — the `model`, the `training_args`, the training and validation datasets, our `data_collator`, and our `tokenizer`:
+Once we have our model, we can define a `Trainer` by passing it all the objects constructed up to now — the `model`, the `training_args`, the training and validation datasets, our `data_collator`, and our `processing_class` (e.g., a tokenizer, feature extractor, or processor):
 
 ```py
 from transformers import Trainer
@@ -69,11 +69,11 @@ trainer = Trainer(
     train_dataset=tokenized_datasets["train"],
     eval_dataset=tokenized_datasets["validation"],
     data_collator=data_collator,
-    tokenizer=tokenizer,
+    processing_class=tokenizer,
 )
 ```
 
-Note that when you pass the `tokenizer` as we did here, the default `data_collator` used by the `Trainer` will be a `DataCollatorWithPadding` as defined previously, so you can skip the line `data_collator=data_collator` in this call. It was still important to show you this part of the processing in section 2!
+Note that when you pass a tokenizer as the `processing_class`, as we did here, the default `data_collator` used by the `Trainer` will be a `DataCollatorWithPadding` if the `processing_class` is a tokenizer or feature extractor, so you can skip the line `data_collator=data_collator` in this call. It was still important to show you this part of the processing in section 2!
 
 To fine-tune the model on our dataset, we just have to call the `train()` method of our `Trainer`:
 
@@ -147,7 +147,7 @@ trainer = Trainer(
     train_dataset=tokenized_datasets["train"],
     eval_dataset=tokenized_datasets["validation"],
     data_collator=data_collator,
-    tokenizer=tokenizer,
+    processing_class=tokenizer,
     compute_metrics=compute_metrics,
 )
 ```

chapters/pl/_toctree.yml

@@ -0,0 +1,4 @@
+- title: 0. Ustawienie
+  sections:
+  - local: chapter0/1
+    title: Wstęp

chapters/pl/chapter0/1.mdx

@@ -0,0 +1,110 @@
+# Wstęp[[introduction]]
+
+Witamy w kursie Hugging Face! Ten wstęp poprowadzi Cię przez konfigurację twojego środowiska. Jeśli jesteś tutaj nowy, polecamy najpierw spojrzeć na [pierwszy rozdział](/course/chapter1) i następnie wrócić tutaj żeby skonfigurować środowisko i korzystać z kodu.
+
+Wszystkie biblioteki jakich będziemy używać w tym kursie są dostępne jako pakiety języka Python, więc w tym miejscu pokażemy Ci jak skonfigurować środowisko do pracy z Pythonem i zainstalować biblioteki których będziesz potrzebować.
+
+Pokażemy Ci dwa sposoby na skonfigurowanie środowiska, jeden korzystając z notatnika Colab lub drugi korzystając z wirtualnego środowiska Pythona. Skorzystaj z tego który Ci najbardziej pasuje. Dla początkujących, zalecamy rozpoczęcie pracy z notatnikiem Colab.
+
+Zwróć uwagę, że nie będziemy korzystać z systemu Windows. Jeśli z niego korzystasz, zalecamy korzystanie z notatnika Colab. Jeśli korzystasz z dystrybucji systemu Linux lub z macOS, możesz korzystać z obu sposobów.
+
+Większość kursu zależy od posiadania konta Hugging Face. Polecamy stworzenie jednego w tym miejscu: [stwórz konto](https://huggingface.co/join).
+
+## Korzystanie z notatnika Google Colab [[using-a-google-colab-notebook]]
+
+Korzystanie z notatnika Colab jest najłatwiejszym możliwym podejściem; odpal notatnik w swojej przeglądarce i zacznij programować!
+
+Jeśli nie korzystałeś nigdy wcześniej z Colaba, zalecamy rozpocząć ze [wstępem](https://colab.research.google.com/notebooks/intro.ipynb). Dzięki Colab możesz korzystać z akceleracji sprzętowej z GPU lub TPU i jest darmowe dla mniejszych obciążeń.
+
+Jak poczujesz się komfortowo z Colabem, stwórz nowy notatnik i skonfiguruj swoje środowisko:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter0/new_colab.png" alt="Pusty notatnik Colab" width="80%"/>
+</div>
+
+Następnym krokiem jest zainstalowanie bibliotek których będziemy używać w kursie. Skorzystamy z `pip` do instalacji, który jest menadżerem pakietów dla języka Python. W notatnikach możesz korzystać z komend systemowych rozpoczynając je od znaku `!`, więc możesz zainstalować bibliotekę 🤗 Transformers następująco:
+
+```
+!pip install transformers
+```
+
+Możesz sprawdzić czy pakiety zainstalowały się poprawnie importując jest wewnątrz notatnika:
+
+```
+import transformers
+```
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter0/install.gif" alt="A gif showing the result of the two commands above: installation and import" width="80%"/>
+</div>
+
+To instaluje bardzo lekką wersję 🤗 Transformers. Ściślej rzecz ujmując, żadna specyficzna biblioteka uczenia maszynowego (jak PyTorch lub TensorFlow) nie jest instalowana. Ponieważ będziemy używać wiele różnych funkcji biblioteki zalecamy zainstalowanie wersji deweloperskiej, która zawiera wszystkie wymagane zależności dla praktycznie każdego zastosowania:
+
+```
+!pip install transformers[sentencepiece]
+```
+
+To zajmie trochę czasu, ale będzie z głowy na resztę kursu!
+
+## Korzystanie z wirtualnego środowiska Pythona[[using-a-python-virtual-environment]]
+
+Jeśli wolisz korzystać z wirtualnego środowiska Pythona, pierwszym krokiem będzie jego zainstalowanie na systemie. Polecamy następujący [poradnik](https://realpython.com/installing-python/) na początek.
+
+Jak Python zostanie zainstalowany, będziesz w stanie uruchomić komendy Pythona w terminualu. Możesz zacząć uruchamiając następującą komendę żeby się upewnić, że został poprawnie zainstalowany przed pójściem dalej: `python --version`. To powinno wypisac wersję Pythona dostępną na twoim systemie.
+
+Uruchamiając komendę Pythona w terminalu, taką jak `python --version`, pomyśl o programie wykonującym twoją komendę jako o "głównym" Pythonie na twoim systemie. Zalecamy trzymanie głównej instalacji Pythona bez żadnych pakietów i korzystanie z niej do tworzenia osobnych środowisk dla każdej aplikacji nad która pracujesz. W ten sposób, każda aplikacja będzie miała swoje własne odosobnione zależności i pakiety, więc nie będzie problemu z potencjalnymi konfliktami między różnymi aplikacjami.
+
+W Pythonie robi się to za pomocą [*wirtualnych środowisk*](https://docs.python.org/3/tutorial/venv.html), które są samozawierającymi się katalogami posiadającymi instalacje Pythona o odpowiedniej wersji wraz z pakietami jakie aplikacja wymaga. Tworzenie takiego wirtualnego środowiska może być wykonane na kilka sposobów, ale my skorzystamy z oficjalnego pakietu Pythona [`venv`](https://docs.python.org/3/library/venv.html#module-venv).
+
+Na początek, stworzymy katalog dla twojej aplikacji - na przykład, możemy stworzyć nowy katalog o nazwie *transformers-course* w twoim katalogu domowym:
+
+```
+mkdir ~/transformers-course
+cd ~/transformers-course
+```
+
+Z wewnątrz tego katalogu, tworzymy wirtualne środowisko korzystając z modułu `venv` Pythona:
+
+```
+python -m venv .env
+```
+
+Teraz powinien powstać katalog o nazwie *.env*: 
+
+```
+ls -a
+```
+
+```out
+.      ..    .env
+```
+
+Możesz aktywować i dezaktywować swoje wirtualne środowiska korzystając ze skryptów `activate` oraz `deactivate`:
+
+```
+# Aktywuj wirtualne środowisko
+source .env/bin/activate
+
+# Dezaktywuj wirtualne środowisko
+deactivate
+```
+
+Możesz się upewnić że środowisko jest aktywne uruchamiając komendę `which python`: jeśli zwraca ścieżkę do twojego wirtualnego środowiska, to udało Ci się je poprawnie aktywować!
+
+```
+which python
+```
+
+```out
+/home/<user>/transformers-course/.env/bin/python
+```
+
+### Instalowanie zależności[[installing-dependencies]]
+
+Tak jak w poprzedniej sekcji o korzystaniu z notatnika Google Colab, musisz teraz zainstalować odpowiednie pakiety żeby kontynuować. Ponownie, możesz zainstalować wersję deweloperską biblioteki 🤗 Transformers korzystając z menadżera pakietów `pip`:
+
+```
+pip install "transformers[sentencepiece]"
+```
+
+Zaczynajmy!