diff --git a/chapters/kn/_toctree.yml b/chapters/kn/_toctree.yml new file mode 100644 index 000000000..2349d4148 --- /dev/null +++ b/chapters/kn/_toctree.yml @@ -0,0 +1,53 @@ +- title: 0. ಸೆಟಪ್ + sections: + - local: chapter0/1 + title: ಪರಿಚಯ + + +- title: 1. ಟ್ರಾನ್ಸ್ಫಾರ್ಮರ್ ಮಾದರಿಗಳು + sections: + # - local: chapter1/1 + # title: Introduction + - local: chapter1/2 + title: ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಮತ್ತು ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿ + # - local: chapter1/3 + # title: Transformers, what can they do? + # - local: chapter1/4 + # title: How do Transformers work? + # - local: chapter1/5 + # title: How 🤗 Transformers solve tasks + # - local: chapter1/6 + # title: Transformer Architectures + # - local: chapter1/7 + # title: Quick quiz + # - local: chapter1/8 + # title: Inference with LLMs + - local: chapter1/9 + title: ಪಕ್ಷಪಾತ ಮತ್ತು ಮಿತಿಗಳು + - local: chapter1/10 + title: ಸಾರಾಂಶ + - local: chapter1/11 + title: ಪರೀಕ್ಷೆಯ ಸಮಯ! + quiz: 1 + +- title: 2. ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳನ್ನು 🤗 ಬಳಸುವುದು + sections: + - local: chapter2/1 + title: ಪರಿಚಯ + - local: chapter2/2 + title: ಪೈಪ್ಲೈನ್ ​​ಹಿಂದೆ + # - local: chapter2/3 + # title: Models + # - local: chapter2/4 + # title: Tokenizers + # - local: chapter2/5 + # title: Handling multiple sequences + # - local: chapter2/6 + # title: Putting it all together + - local: chapter2/7 + title: ಮೂಲ ಬಳಕೆ ಪೂರ್ಣಗೊಂಡಿದೆ! + # - local: chapter2/8 + # title: Optimized Inference Deployment + # - local: chapter2/9 + # title: End-of-chapter quiz + # quiz: 2 diff --git a/chapters/kn/chapter0/1.mdx b/chapters/kn/chapter0/1.mdx new file mode 100644 index 000000000..331a2da18 --- /dev/null +++ b/chapters/kn/chapter0/1.mdx @@ -0,0 +1,110 @@ +# ಪರಿಚಯ[[ಪರಿಚಯ]] + +ಹಗ್ಗಿಂಗ್ ಫೇಸ್ ಕೋರ್ಸ್‌ಗೆ ಸುಸ್ವಾಗತ! .ಈ ಪರಿಚಯವು ಕೆಲಸದ ವಾತಾವರಣವನ್ನು ಹೊಂದಿಸುವ ಬಗ್ಗೆ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ. ನೀವು ಕೋರ್ಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದರೆ, ಮೊದಲು [ಅಧ್ಯಾಯ 1](/course/chapter1) ಅನ್ನು ನೋಡಿ, ನಂತರ ಹಿಂತಿರುಗಿ ಮತ್ತು ನಿಮ್ಮ ಪರಿಸರವನ್ನು ಹೊಂದಿಸಿ ಇದರಿಂದ ನೀವು ಕೋಡ್ ಅನ್ನು ನೀವೇ ಪ್ರಯತ್ನಿಸಬಹುದು ಎಂದು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. + +ಈ ಕೋರ್ಸ್‌ನಲ್ಲಿ ನಾವು ಬಳಸಲಿರುವ ಎಲ್ಲಾ ಲೈಬ್ರರಿಗಳು ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್‌ಗಳಾಗಿ ಲಭ್ಯವಿದೆ, ಆದ್ದರಿಂದ ಪೈಥಾನ್ ಪರಿಸರವನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು ಮತ್ತು ನಿಮಗೆ ಅಗತ್ಯವಿರುವ ನಿರ್ದಿಷ್ಟ ಲೈಬ್ರರಿಗಳನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸುವುದು ಎಂಬುದನ್ನು ಇಲ್ಲಿ ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ. + +ಕೊಲಾಬ್ ನೋಟ್‌ಬುಕ್ ಅಥವಾ ಪೈಥಾನ್ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಕೆಲಸದ ವಾತಾವರಣವನ್ನು ಹೊಂದಿಸುವ ಎರಡು ವಿಧಾನಗಳನ್ನು ನಾವು ಒಳಗೊಳ್ಳುತ್ತೇವೆ. ನಿಮಗೆ ಹೆಚ್ಚು ಇಷ್ಟವಾಗುವದನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಹಿಂಜರಿಯಬೇಡಿ. ಆರಂಭಿಕರಿಗಾಗಿ, ಕೊಲಾಬ್ ನೋಟ್‌ಬುಕ್ ಬಳಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಲು ನಾವು ಬಲವಾಗಿ ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. + +ನಾವು ವಿಂಡೋಸ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಒಳಗೊಳ್ಳುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನೀವು ವಿಂಡೋಸ್‌ನಲ್ಲಿ ಓಡುತ್ತಿದ್ದರೆ, ಕೊಲಾಬ್ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ಬಳಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ನೀವು ಲಿನಕ್ಸ್ ವಿತರಣೆ ಅಥವಾ ಮ್ಯಾಕ್ಓಎಸ್ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಇಲ್ಲಿ ವಿವರಿಸಿದ ಯಾವುದೇ ವಿಧಾನವನ್ನು ನೀವು ಬಳಸಬಹುದು. + +ಹೆಚ್ಚಿನ ಕೋರ್ಸ್ ನೀವು ಹಗ್ಗಿಂಗ್ ಫೇಸ್ ಖಾತೆಯನ್ನು ಹೊಂದಿರುವುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಈಗಲೇ ಒಂದನ್ನು ರಚಿಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ: [ಖಾತೆಯನ್ನು ರಚಿಸಿ](https://huggingface.co/join). + +## ಗೂಗಲ್ ಕೊಲಾಬ್ ನೋಟ್‌ಬುಕ್ ಬಳಸುವುದು[[ಗೂಗಲ್ ಕೊಲಾಬ್ ನೋಟ್‌ಬುಕ್ ಬಳಸುವುದು]] + +ಕೊಲಾಬ್ ನೋಟ್‌ಬುಕ್ ಬಳಸುವುದು ಸಾಧ್ಯವಾದಷ್ಟು ಸರಳವಾದ ಸೆಟಪ್ ಆಗಿದೆ; ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ಬೂಟ್ ಮಾಡಿ ಮತ್ತು ನೇರವಾಗಿ ಕೋಡಿಂಗ್‌ಗೆ ಹೋಗಿ! + +ನಿಮಗೆ ಕೊಲಾಬ್ ಪರಿಚಯವಿಲ್ಲದಿದ್ದರೆ, [ಪರಿಚಯವನ್ನು](https://colab.research.google.com/notebooks/intro.ipynb) ಅನುಸರಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಕೊಲಾಬ್ ನಿಮಗೆ GPU ಗಳು ಅಥವಾ TPU ಗಳಂತಹ ಕೆಲವು ವೇಗವರ್ಧಕ ಹಾರ್ಡ್‌ವೇರ್ ಅನ್ನು ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಇದು ಸಣ್ಣ ಕೆಲಸದ ಹೊರೆಗಳಿಗೆ ಉಚಿತವಾಗಿದೆ. + +ಕೊಲಾಬ್‌ನಲ್ಲಿ ನೀವು ಆರಾಮದಾಯಕವಾಗಿ ಓಡಾಡಲು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ಹೊಸ ನೋಟ್‌ಬುಕ್ ರಚಿಸಿ ಮತ್ತು ಸೆಟಪ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ: + +
+An empty colab notebook +
+ +ಮುಂದಿನ ಹಂತವೆಂದರೆ ಈ ಕೋರ್ಸ್‌ನಲ್ಲಿ ನಾವು ಬಳಸಲಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು. ನಾವು ಅನುಸ್ಥಾಪನೆಗೆ ಪಿಪ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಪೈಥಾನ್‌ನ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಆಗಿದೆ. ನೋಟ್‌ಬುಕ್‌ಗಳಲ್ಲಿ, ನೀವು ಸಿಸ್ಟಮ್ ಆಜ್ಞೆಗಳನ್ನು ! ಅಕ್ಷರದೊಂದಿಗೆ ಮೊದಲು ಚಲಾಯಿಸಬಹುದು, ಆದ್ದರಿಂದ ನೀವು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ಸ್ ಲೈಬ್ರರಿಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಸ್ಥಾಪಿಸಬಹುದು + +``` +!pip install transformers +``` + +ನಿಮ್ಮ ಪೈಥಾನ್ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಅದನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸರಿಯಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು: + +``` +import transformers +``` + +
+A gif showing the result of the two commands above: installation and import +
+ +ಇದು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಅತ್ಯಂತ ಹಗುರವಾದ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಯಂತ್ರ ಕಲಿಕೆ ಚೌಕಟ್ಟುಗಳನ್ನು (ಪೈಟಾರ್ಚ್ ಅಥವಾ ಟೆನ್ಸರ್‌ಫ್ಲೋ ನಂತಹ) ಸ್ಥಾಪಿಸಲಾಗಿಲ್ಲ. ನಾವು ಲೈಬ್ರರಿಯ ಹಲವಾರು ವಿಭಿನ್ನ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ಅಭಿವೃದ್ಧಿ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ, ಇದು ಯಾವುದೇ ಕಲ್ಪಿಸಬಹುದಾದ ಬಳಕೆಯ ಸಂದರ್ಭಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಬರುತ್ತದೆ: + +``` +!pip install transformers[sentencepiece] +``` + +ಇದು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ನಂತರ ನೀವು ಉಳಿದ ಕೋರ್ಸ್ ಕಲಿಯಲು ಸಿದ್ಧರಾಗಿರುತ್ತೀರಿ! + +## ಪೈಥಾನ್ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಬಳಸುವುದು[[ಪೈಥಾನ್ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಬಳಸುವುದು]] + +ನೀವು ಪೈಥಾನ್ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ಮೊದಲ ಹಂತವೆಂದರೆ ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು. ಪ್ರಾರಂಭಿಸಲು ಈ [ಮಾರ್ಗದರ್ಶಿಯನ್ನು](https://realpython.com/installing-python/) ಅನುಸರಿಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. + +ನೀವು ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಪೈಥಾನ್ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಮುಂದಿನ ಹಂತಗಳಿಗೆ ಮುಂದುವರಿಯುವ ಮೊದಲು ಅದನ್ನು ಸರಿಯಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಬಹುದು: python --version. ಇದು ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಈಗ ಲಭ್ಯವಿರುವ ಪೈಥಾನ್ ಆವೃತ್ತಿಯನ್ನು ಮುದ್ರಿಸಬೇಕು + +ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಪೈಥಾನ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವಾಗ, ಉದಾಹರಣೆಗೆ python --version, ನಿಮ್ಮ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ "ಮುಖ್ಯ" ಪೈಥಾನ್ ಎಂದು ನೀವು ಭಾವಿಸಬೇಕು. ಈ ಮುಖ್ಯ ಅನುಸ್ಥಾಪನೆಯನ್ನು ಯಾವುದೇ ಪ್ಯಾಕೇಜ್‌ಗಳಿಂದ ಮುಕ್ತವಾಗಿಡಲು ಮತ್ತು ನೀವು ಕೆಲಸ ಮಾಡುವ ಪ್ರತಿಯೊಂದು ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪ್ರತ್ಯೇಕ ಪರಿಸರಗಳನ್ನು ರಚಿಸಲು ಇದನ್ನು ಬಳಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ - ಈ ರೀತಿಯಾಗಿ, ಪ್ರತಿಯೊಂದು ಅಪ್ಲಿಕೇಶನ್ ತನ್ನದೇ ಆದ ಅವಲಂಬನೆಗಳು ಮತ್ತು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಸಂಭಾವ್ಯ ಹೊಂದಾಣಿಕೆ ಸಮಸ್ಯೆಗಳ ಬಗ್ಗೆ ನೀವು ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ. + +ಪೈಥಾನ್‌ನಲ್ಲಿ ಇದನ್ನು [*ವರ್ಚುವಲ್ ಪರಿಸರಗಳೊಂದಿಗೆ*](https://docs.python.org/3/tutorial/venv.html) ಮಾಡಲಾಗುತ್ತದೆ, ಅವುಗಳು ಸ್ವಯಂ-ಒಳಗೊಂಡಿರುವ ಡೈರೆಕ್ಟರಿ ಮರಗಳಾಗಿವೆ, ಪ್ರತಿಯೊಂದೂ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಪ್ಯಾಕೇಜ್‌ಗಳ ಜೊತೆಗೆ ನಿರ್ದಿಷ್ಟ ಪೈಥಾನ್ ಆವೃತ್ತಿಯೊಂದಿಗೆ ಪೈಥಾನ್ ಸ್ಥಾಪನೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅಂತಹ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸುವುದನ್ನು ಹಲವಾರು ವಿಭಿನ್ನ ಪರಿಕರಗಳೊಂದಿಗೆ ಮಾಡಬಹುದು, ಆದರೆ ನಾವು ಆ ಉದ್ದೇಶಕ್ಕಾಗಿ ಅಧಿಕೃತ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದನ್ನು [`venv`](https://docs.python.org/3/library/venv.html#module-venv) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ + +ಮೊದಲು, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಾಸಿಸಲು ನೀವು ಬಯಸುವ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿ - ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯ ಮೂಲದಲ್ಲಿ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ಸ್-ಕೋರ್ಸ್ ಎಂಬ ಹೊಸ ಡೈರೆಕ್ಟರಿಯನ್ನು ನೀವು ಮಾಡಲು ಬಯಸಬಹುದು: + +``` +mkdir ~/transformers-course +cd ~/transformers-course +``` + +ಈ ಡೈರೆಕ್ಟರಿಯ ಒಳಗಿನಿಂದ, ಪೈಥಾನ್ venv ಮಾಡ್ಯೂಲ್ ಬಳಸಿ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಿ: + +``` +python -m venv .env +``` + +ಈಗ ನಿಮ್ಮ ಖಾಲಿ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ .env ಎಂಬ ಡೈರೆಕ್ಟರಿ ಇರಬೇಕು: + +``` +ls -a +``` + +```out +. .. .env +``` + +ಸಕ್ರಿಯಗೊಳಿಸುವ ಮತ್ತು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳೊಂದಿಗೆ ನೀವು ನಿಮ್ಮ ವರ್ಚುವಲ್ ಪರಿಸರದ ಒಳಗೆ ಮತ್ತು ಹೊರಗೆ ಜಿಗಿಯಬಹುದು: + +``` +# Activate the virtual environment +source .env/bin/activate + +# Deactivate the virtual environment +deactivate +``` + +ಯಾವ ಪೈಥಾನ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ಪರಿಸರವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆಯೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು: ಅದು ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಸೂಚಿಸಿದರೆ, ನೀವು ಅದನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಿದ್ದೀರಿ ಎಂದರ್ಥ! + +``` +which python +``` + +```out +/home//transformers-course/.env/bin/python +``` + +### ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು[[ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು]] + +Google Colab ನಿದರ್ಶನಗಳನ್ನು ಬಳಸುವ ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿದ್ದಂತೆ, ಈಗ ನೀವು ಮುಂದುವರಿಯಲು ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ. ಮತ್ತೊಮ್ಮೆ, ನೀವು ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಬಳಸಿ 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಅಭಿವೃದ್ಧಿ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸಬಹುದು: + +``` +pip install "transformers[sentencepiece]" +``` + +ನೀವು ಈಗ ಸಿದ್ಧರಾಗಿದ್ದೀರಿ ಮತ್ತು ಹೋಗಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ! \ No newline at end of file diff --git a/chapters/kn/chapter1/10.mdx b/chapters/kn/chapter1/10.mdx new file mode 100644 index 000000000..852b0dfb4 --- /dev/null +++ b/chapters/kn/chapter1/10.mdx @@ -0,0 +1,67 @@ +# ಸಾರಾಂಶ[[ಸಾರಾಂಶ]] + + + +ಈ ಅಧ್ಯಾಯದಲ್ಲಿ, ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳು, ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು (LLM ಗಳು) ನ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಮತ್ತು ಅವು AI ಮತ್ತು ಅದಕ್ಕೂ ಮೀರಿ ಹೇಗೆ ಕ್ರಾಂತಿಕಾರಕವಾಗಿವೆ ಎಂಬುದನ್ನು ನಿಮಗೆ ಪರಿಚಯಿಸಲಾಗಿದೆ. + +## ಒಳಗೊಂಡಿರುವ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು + +### ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಮತ್ತು ಎಲ್‌ಎಲ್‌ಎಂಗಳು + +NLP ಎಂದರೇನು ಮತ್ತು ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು ಈ ಕ್ಷೇತ್ರವನ್ನು ಹೇಗೆ ಪರಿವರ್ತಿಸಿವೆ ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ನೀವು ಕಲಿತದ್ದು: +- NLP ವರ್ಗೀಕರಣದಿಂದ ಪೀಳಿಗೆಯವರೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ +- LLM ಗಳು ಬೃಹತ್ ಪ್ರಮಾಣದ ಪಠ್ಯ ದತ್ತಾಂಶದ ಮೇಲೆ ತರಬೇತಿ ಪಡೆದ ಶಕ್ತಿಶಾಲಿ ಮಾದರಿಗಳಾಗಿವೆ +- ಈ ಮಾದರಿಗಳು ಒಂದೇ ವಾಸ್ತುಶಿಲ್ಪದೊಳಗೆ ಬಹು ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು +- ಅವುಗಳ ಸಾಮರ್ಥ್ಯಗಳ ಹೊರತಾಗಿಯೂ, LLM ಗಳು ಭ್ರಮೆಗಳು ಮತ್ತು ಪಕ್ಷಪಾತ ಸೇರಿದಂತೆ ಮಿತಿಗಳನ್ನು ಹೊಂದಿವೆ. + +### ಟ್ರಾನ್ಸ್ಫಾರ್ಮರ್ ಸಾಮರ್ಥ್ಯಗಳು + +ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ `ಪೈಪ್‌ಲೈನ್()` ಕಾರ್ಯವು 🤗 ವಿವಿಧ ಕಾರ್ಯಗಳಿಗೆ ಪೂರ್ವ ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಗಳನ್ನು ಬಳಸಲು ಹೇಗೆ ಸುಲಭಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡಿದ್ದೀರಿ: +- ಪಠ್ಯ ವರ್ಗೀಕರಣ, ಟೋಕನ್ ವರ್ಗೀಕರಣ ಮತ್ತು ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುವುದು +- ಪಠ್ಯ ರಚನೆ ಮತ್ತು ಸಾರಾಂಶ +- ಅನುವಾದ ಮತ್ತು ಇತರ ಅನುಕ್ರಮ-ಅನುಕ್ರಮ ಕಾರ್ಯಗಳು +- ಭಾಷಣ ಗುರುತಿಸುವಿಕೆ ಮತ್ತು ಚಿತ್ರ ವರ್ಗೀಕರಣ + +### ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ + +ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ಚರ್ಚಿಸಿದ್ದೇವೆ, ಅವುಗಳೆಂದರೆ: +- ಗಮನ ಕಾರ್ಯವಿಧಾನದ ಪ್ರಾಮುಖ್ಯತೆ +- ವರ್ಗಾವಣೆ ಕಲಿಕೆಯು ಮಾದರಿಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳಲು ಹೇಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ +- ಮೂರು ಪ್ರಮುಖ ವಾಸ್ತುಶಿಲ್ಪದ ರೂಪಾಂತರಗಳು: ಎನ್‌ಕೋಡರ್-ಮಾತ್ರ, ಡಿಕೋಡರ್-ಮಾತ್ರ ಮತ್ತು ಎನ್‌ಕೋಡರ್-ಡಿಕೋಡರ್ + +### ಮಾದರಿ ವಾಸ್ತುಶಿಲ್ಪಗಳು ಮತ್ತು ಅವುಗಳ ಅನ್ವಯಗಳು +ಈ ಅಧ್ಯಾಯದ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ವಿಭಿನ್ನ ಕಾರ್ಯಗಳಿಗೆ ಯಾವ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಬಳಸಬೇಕೆಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: + +| ಮಾದರಿ | ಉದಾಹರಣೆಗಳು | ಕಾರ್ಯಗಳು | +|-----------------|--------------------------------------------|----------------------------------------------------------------------------------| +| Encoder-only | BERT, DistilBERT, ModernBERT | ವಾಕ್ಯ ವರ್ಗೀಕರಣ, ಹೆಸರಿಸಲಾದ ಅಸ್ತಿತ್ವ ಗುರುತಿಸುವಿಕೆ, ಹೊರತೆಗೆಯುವ ಪ್ರಶ್ನೆ ಉತ್ತರ | +| Decoder-only | GPT, LLaMA, Gemma, SmolLM | ಪಠ್ಯ ರಚನೆ, ಸಂವಾದಾತ್ಮಕ AI, ಸೃಜನಾತ್ಮಕ ಬರವಣಿಗೆ | +| Encoder-decoder | BART, T5, Marian, mBART | ಸಾರಾಂಶ, ಅನುವಾದ, ಉತ್ಪಾದಕ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರ | + +### ಆಧುನಿಕ LLM ಬೆಳವಣಿಗೆಗಳು +ಈ ಕ್ಷೇತ್ರದಲ್ಲಿನ ಇತ್ತೀಚಿನ ಬೆಳವಣಿಗೆಗಳ ಬಗ್ಗೆಯೂ ನೀವು ಕಲಿತಿದ್ದೀರಿ: +- LLM ಗಳು ಕಾಲಾನಂತರದಲ್ಲಿ ಗಾತ್ರ ಮತ್ತು ಸಾಮರ್ಥ್ಯದಲ್ಲಿ ಹೇಗೆ ಬೆಳೆದಿವೆ +- ಸ್ಕೇಲಿಂಗ್ ಕಾನೂನುಗಳ ಪರಿಕಲ್ಪನೆ ಮತ್ತು ಅವು ಮಾದರಿ ಅಭಿವೃದ್ಧಿಯನ್ನು ಹೇಗೆ ಮಾರ್ಗದರ್ಶನ ಮಾಡುತ್ತವೆ +- ಮಾದರಿಗಳು ದೀರ್ಘ ಅನುಕ್ರಮಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುವ ವಿಶೇಷ ಗಮನ ಕಾರ್ಯವಿಧಾನಗಳು +- ಪೂರ್ವ ತರಬೇತಿ ಮತ್ತು ಸೂಚನಾ ಶ್ರುತಿಯ ಎರಡು-ಹಂತದ ತರಬೇತಿ ವಿಧಾನ + + +### ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಿಕೆಗಳು +ಅಧ್ಯಾಯದ ಉದ್ದಕ್ಕೂ, ಈ ಮಾದರಿಗಳನ್ನು ನೈಜ-ಪ್ರಪಂಚದ ಸಮಸ್ಯೆಗಳಿಗೆ ಹೇಗೆ ಅನ್ವಯಿಸಬಹುದು ಎಂಬುದನ್ನು ನೀವು ನೋಡಿದ್ದೀರಿ: +- ಪೂರ್ವ-ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಗಳನ್ನು ಹುಡುಕಲು ಮತ್ತು ಬಳಸಲು ಹಗ್ಗಿಂಗ್ ಫೇಸ್ ಹಬ್ ಅನ್ನು ಬಳಸುವುದು +- ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಮಾದರಿಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಇನ್ಫರೆನ್ಸ್ API ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದು +- ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಿಗೆ ಯಾವ ಮಾದರಿಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು + +## ಎದುರುನೋಡಲು + +ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳು ಯಾವುವು ಮತ್ತು ಅವು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು ಈಗ ನಿಮಗೆ ಉತ್ತಮ ತಿಳುವಳಿಕೆ ಸಿಕ್ಕಿರುವುದರಿಂದ, ಅವುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ಆಳವಾಗಿ ಅಧ್ಯಯನ ಮಾಡಲು ನೀವು ಸಿದ್ಧರಿದ್ದೀರಿ. ಮುಂದಿನ ಅಧ್ಯಾಯಗಳಲ್ಲಿ, ನೀವು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ಕಲಿಯುವಿರಿ: + +- ಮಾದರಿಗಳನ್ನು ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಉತ್ತಮಗೊಳಿಸಲು ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿ +- ಮಾದರಿ ಇನ್‌ಪುಟ್‌ಗಾಗಿ ವಿವಿಧ ರೀತಿಯ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ +- ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಿಗೆ ಪೂರ್ವ-ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ +- ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಿಕೆಗಳಿಗಾಗಿ ಮಾದರಿಗಳನ್ನು ನಿಯೋಜಿಸಿ + +ಮುಂದಿನ ವಿಭಾಗಗಳಲ್ಲಿ ನೀವು ಹೆಚ್ಚು ಸುಧಾರಿತ ವಿಷಯಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸುವಾಗ ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ನೀವು ನಿರ್ಮಿಸಿರುವ ಅಡಿಪಾಯವು ನಿಮಗೆ ಉತ್ತಮವಾಗಿ ಸೇವೆ ಸಲ್ಲಿಸುತ್ತದೆ. diff --git a/chapters/kn/chapter1/11.mdx b/chapters/kn/chapter1/11.mdx new file mode 100644 index 000000000..405a00d4b --- /dev/null +++ b/chapters/kn/chapter1/11.mdx @@ -0,0 +1,21 @@ +# ಪರೀಕ್ಷೆಯ ಸಮಯ! + +ನಿಮ್ಮ ಜ್ಞಾನವನ್ನು ಪರೀಕ್ಷಿಸುವ ಸಮಯ ಇದು! ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಪರಿಕಲ್ಪನೆಗಳ ಬಗ್ಗೆ ನಿಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ನಾವು ನಿಮಗಾಗಿ ಒಂದು ಸಣ್ಣ ರಸಪ್ರಶ್ನೆಯನ್ನು ಸಿದ್ಧಪಡಿಸಿದ್ದೇವೆ. + +ರಸಪ್ರಶ್ನೆಯಲ್ಲಿ ಭಾಗವಹಿಸಲು, ನೀವು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಬೇಕು: + +1. ನಿಮ್ಮ ಹಗ್ಗಿಂಗ್ ಫೇಸ್ ಖಾತೆಗೆ ಸೈನ್ ಇನ್ ಮಾಡಿ. +2. ರಸಪ್ರಶ್ನೆಯಲ್ಲಿರುವ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಿ. +3. ನಿಮ್ಮ ಉತ್ತರಗಳನ್ನು ಸಲ್ಲಿಸಿ. + + +## ಬಹು ಆಯ್ಕೆ ಪ್ರಶ್ನೆ + +ಈ ರಸಪ್ರಶ್ನೆಯಲ್ಲಿ, ಆಯ್ಕೆಗಳ ಪಟ್ಟಿಯಿಂದ ಸರಿಯಾದ ಉತ್ತರವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ. ಮೇಲ್ವಿಚಾರಣೆಯ ಫೈನ್‌ಟ್ಯೂನಿಂಗ್‌ನ ಮೂಲಭೂತ ಅಂಶಗಳ ಕುರಿತು ನಾವು ನಿಮ್ಮನ್ನು ಪರೀಕ್ಷಿಸುತ್ತೇವೆ. + + diff --git a/chapters/kn/chapter1/2.mdx b/chapters/kn/chapter1/2.mdx new file mode 100644 index 000000000..bfd473c6d --- /dev/null +++ b/chapters/kn/chapter1/2.mdx @@ -0,0 +1,51 @@ +## ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಮತ್ತು ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿ[[ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಮತ್ತು ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿ]] + + + +ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳಿಗೆ ಹಾರಿಹೋಗುವ ಮೊದಲು, ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಎಂದರೇನು, ಭಾಷಾ ಮಾದರಿಗಳು ಕ್ಷೇತ್ರವನ್ನು ಎಷ್ಟು ದೊಡ್ಡದಾಗಿ ಪರಿವರ್ತಿಸಿವೆ ಮತ್ತು ನಾವು ಅದರ ಬಗ್ಗೆ ಏಕೆ ಕಾಳಜಿ ವಹಿಸುತ್ತೇವೆ ಎಂಬುದರ ಕುರಿತು ಒಂದು ತ್ವರಿತ ಅವಲೋಕನವನ್ನು ಮಾಡೋಣ. + +## NLP ಎಂದರೇನು?[[NLP ಎಂದರೇನು]] + +NLP ಎನ್ನುವುದು ಭಾಷಾಶಾಸ್ತ್ರ ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆಯ ಕ್ಷೇತ್ರವಾಗಿದ್ದು, ಮಾನವ ಭಾಷೆಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲವನ್ನೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದೆ. NLP ಕಾರ್ಯಗಳ ಗುರಿ ಒಂದೇ ಪದಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮಾತ್ರವಲ್ಲ, ಆ ಪದಗಳ ಸಂದರ್ಭವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. + +ಕೆಳಗಿನವು ಸಾಮಾನ್ಯ NLP ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯಾಗಿದ್ದು, ಪ್ರತಿಯೊಂದಕ್ಕೂ ಕೆಲವು ಉದಾಹರಣೆಗಳಿವೆ: + +- **ಸಂಪೂರ್ಣ ವಾಕ್ಯಗಳನ್ನು ವರ್ಗೀಕರಿಸುವುದು**: ವಿಮರ್ಶೆಯ ಭಾವನೆಯನ್ನು ಪಡೆಯುವುದು, ಇಮೇಲ್ ಸ್ಪ್ಯಾಮ್ ಆಗಿದೆಯೇ ಎಂದು ಪತ್ತೆಹಚ್ಚುವುದು, ವಾಕ್ಯವು ವ್ಯಾಕರಣಬದ್ಧವಾಗಿ ಸರಿಯಾಗಿದೆಯೇ ಅಥವಾ ಎರಡು ವಾಕ್ಯಗಳು ತಾರ್ಕಿಕವಾಗಿ ಸಂಬಂಧಿಸಿವೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುವುದು +- **ಒಂದು ವಾಕ್ಯದಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಪದವನ್ನು ವರ್ಗೀಕರಿಸುವುದು**: ವಾಕ್ಯದ ವ್ಯಾಕರಣ ಘಟಕಗಳನ್ನು (ನಾಮಪದ, ಕ್ರಿಯಾಪದ, ವಿಶೇಷಣ) ಅಥವಾ ಹೆಸರಿಸಲಾದ ಘಟಕಗಳನ್ನು (ವ್ಯಕ್ತಿ, ಸ್ಥಳ, ಸಂಸ್ಥೆ) ಗುರುತಿಸುವುದು +- **ಪಠ್ಯ ವಿಷಯವನ್ನು ರಚಿಸುವುದು**: ಸ್ವಯಂ-ರಚಿಸಿದ ಪಠ್ಯದೊಂದಿಗೆ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದು, ಮುಖವಾಡದ ಪದಗಳೊಂದಿಗೆ ಪಠ್ಯದಲ್ಲಿನ ಖಾಲಿ ಜಾಗಗಳನ್ನು ಭರ್ತಿ ಮಾಡುವುದು +- **ಪಠ್ಯದಿಂದ ಉತ್ತರವನ್ನು ಹೊರತೆಗೆಯುವುದು**: ಒಂದು ಪ್ರಶ್ನೆ ಮತ್ತು ಸಂದರ್ಭವನ್ನು ನೀಡಿದರೆ, ಸನ್ನಿವೇಶದಲ್ಲಿ ಒದಗಿಸಲಾದ ಮಾಹಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರವನ್ನು ಹೊರತೆಗೆಯುವುದು +- **ಇನ್‌ಪುಟ್ ಪಠ್ಯದಿಂದ ಹೊಸ ವಾಕ್ಯವನ್ನು ರಚಿಸುವುದು**: ಪಠ್ಯವನ್ನು ಮತ್ತೊಂದು ಭಾಷೆಗೆ ಅನುವಾದಿಸುವುದು, ಪಠ್ಯವನ್ನು ಸಂಕ್ಷೇಪಿಸುವುದು + +ಆದಾಗ್ಯೂ, NLP ಕೇವಲ ಲಿಖಿತ ಪಠ್ಯಕ್ಕೆ ಸೀಮಿತವಾಗಿಲ್ಲ. ಇದು ಭಾಷಣ ಗುರುತಿಸುವಿಕೆ ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ದೃಷ್ಟಿಯಲ್ಲಿನ ಸಂಕೀರ್ಣ ಸವಾಲುಗಳನ್ನು ಸಹ ನಿಭಾಯಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಆಡಿಯೊ ಮಾದರಿಯ ಪ್ರತಿಲೇಖನ ಅಥವಾ ಚಿತ್ರದ ವಿವರಣೆಯನ್ನು ರಚಿಸುವುದು. + +## ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳ ಉದಯ (LLMs)[[ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳ ಉದಯ]] + +ಇತ್ತೀಚಿನ ವರ್ಷಗಳಲ್ಲಿ, NLP ಕ್ಷೇತ್ರದಲ್ಲಿ ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು (LLM ಗಳು) ಕ್ರಾಂತಿಯನ್ನುಂಟುಮಾಡಿವೆ. GPT (ಜನರೇಟಿವ್ ಪ್ರಿ-ಟ್ರೈನ್ಡ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್) ಮತ್ತು [ಲಾಮಾದಂತಹ](https://huggingface.co/meta-llama) ವಾಸ್ತುಶಿಲ್ಪಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಈ ಮಾದರಿಗಳು ಭಾಷಾ ಸಂಸ್ಕರಣೆಯಲ್ಲಿ ಸಾಧ್ಯವಾದದ್ದನ್ನು ಪರಿವರ್ತಿಸಿವೆ. + +> [!TIP] +> ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿ (LLM) ಎನ್ನುವುದು ಮಾನವನಂತಹ ಪಠ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಉತ್ಪಾದಿಸಲು, ಭಾಷೆಯಲ್ಲಿನ ಮಾದರಿಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಕಾರ್ಯ-ನಿರ್ದಿಷ್ಟ ತರಬೇತಿಯಿಲ್ಲದೆ ವಿವಿಧ ರೀತಿಯ ಭಾಷಾ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಬೃಹತ್ ಪ್ರಮಾಣದ ಪಠ್ಯ ದತ್ತಾಂಶದ ಮೇಲೆ ತರಬೇತಿ ಪಡೆದ AI ಮಾದರಿಯಾಗಿದೆ. ಅವು ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ (NLP) ಕ್ಷೇತ್ರದಲ್ಲಿ ಗಮನಾರ್ಹ ಪ್ರಗತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. + +LLM ಗಳು ಇವುಗಳಿಂದ ನಿರೂಪಿಸಲ್ಪಟ್ಟಿವೆ: +- **ಪ್ರಮಾಣ**: ಅವು ಲಕ್ಷಾಂತರ, ಶತಕೋಟಿ ಅಥವಾ ನೂರಾರು ಶತಕೋಟಿ ನಿಯತಾಂಕಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ +- **ಸಾಮಾನ್ಯ ಸಾಮರ್ಥ್ಯಗಳು**: ಕಾರ್ಯ-ನಿರ್ದಿಷ್ಟ ತರಬೇತಿಯಿಲ್ಲದೆ ಅವು ಬಹು ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು +- **ಸಂದರ್ಭದಲ್ಲಿ ಕಲಿಕೆ**: ಪ್ರಾಂಪ್ಟ್‌ನಲ್ಲಿ ಒದಗಿಸಲಾದ ಉದಾಹರಣೆಗಳಿಂದ ಅವರು ಕಲಿಯಬಹುದು +- **ಹೊರಹೊಮ್ಮುವ ಸಾಮರ್ಥ್ಯಗಳು**: ಈ ಮಾದರಿಗಳು ಗಾತ್ರದಲ್ಲಿ ಬೆಳೆದಂತೆ, ಅವು ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರೋಗ್ರಾಮ್ ಮಾಡದ ಅಥವಾ ನಿರೀಕ್ಷಿಸದ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ. + +LLM ಗಳ ಆಗಮನವು ನಿರ್ದಿಷ್ಟ NLP ಕಾರ್ಯಗಳಿಗಾಗಿ ವಿಶೇಷ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ಮಾದರಿಯನ್ನು, ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಭಾಷಾ ಕಾರ್ಯಗಳನ್ನು ಪರಿಹರಿಸಲು ಪ್ರೇರೇಪಿಸಬಹುದಾದ ಅಥವಾ ಉತ್ತಮಗೊಳಿಸಬಹುದಾದ ಒಂದೇ, ದೊಡ್ಡ ಮಾದರಿಯನ್ನು ಬಳಸುವತ್ತ ಬದಲಾಯಿಸಿದೆ. ಇದು ಅತ್ಯಾಧುನಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆಯನ್ನು ಹೆಚ್ಚು ಪ್ರವೇಶಿಸುವಂತೆ ಮಾಡಿದೆ ಮತ್ತು ದಕ್ಷತೆ, ನೀತಿಶಾಸ್ತ್ರ ಮತ್ತು ನಿಯೋಜನೆಯಂತಹ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಹೊಸ ಸವಾಲುಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತಿದೆ. + +ಆದಾಗ್ಯೂ, LLM ಗಳು ಪ್ರಮುಖ ಮಿತಿಗಳನ್ನು ಸಹ ಹೊಂದಿವೆ: + +- **ಭ್ರಮೆಗಳು**: ಅವು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ತಪ್ಪು ಮಾಹಿತಿಯನ್ನು ಸೃಷ್ಟಿಸಬಹುದು. +- **ನಿಜವಾದ ತಿಳುವಳಿಕೆಯ ಕೊರತೆ**: ಅವರಿಗೆ ಪ್ರಪಂಚದ ನಿಜವಾದ ತಿಳುವಳಿಕೆಯ ಕೊರತೆಯಿದೆ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಸಂಖ್ಯಾಶಾಸ್ತ್ರೀಯ ಮಾದರಿಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. +- **ಪಕ್ಷಪಾತ**: ಅವರು ತಮ್ಮ ತರಬೇತಿ ಡೇಟಾ ಅಥವಾ ಇನ್‌ಪುಟ್‌ಗಳಲ್ಲಿ ಇರುವ ಪಕ್ಷಪಾತಗಳನ್ನು ಪುನರುತ್ಪಾದಿಸಬಹುದು. +- **ಸಂದರ್ಭ ವಿಂಡೋಗಳು**: ಅವರಿಗೆ ಸೀಮಿತ ಸಂದರ್ಭ ವಿಂಡೋಗಳಿವೆ (ಇದು ಸುಧಾರಿಸುತ್ತಿದ್ದರೂ) +- **ಕಂಪ್ಯೂಟೇಶನಲ್ ಸಂಪನ್ಮೂಲಗಳು**: ಅವರಿಗೆ ಗಮನಾರ್ಹವಾದ ಕಂಪ್ಯೂಟೇಶನಲ್ ಸಂಪನ್ಮೂಲಗಳು ಬೇಕಾಗುತ್ತವೆ + +## ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಏಕೆ ಸವಾಲಿನದ್ದಾಗಿದೆ?[[ಭಾಷಾ ಸಂಸ್ಕರಣೆ ಏಕೆ ಸವಾಲಿನದ್ದಾಗಿದೆ?]] + +ಕಂಪ್ಯೂಟರ್‌ಗಳು ಮಾನವರಂತೆಯೇ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ನಾವು "ನನಗೆ ಹಸಿವಾಗಿದೆ" ಎಂಬ ವಾಕ್ಯವನ್ನು ಓದಿದಾಗ, ಅದರ ಅರ್ಥವನ್ನು ನಾವು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು. ಅದೇ ರೀತಿ, "ನನಗೆ ಹಸಿವಾಗಿದೆ" ಮತ್ತು "ನನಗೆ ದುಃಖವಾಗಿದೆ" ಎಂಬ ಎರಡು ವಾಕ್ಯಗಳನ್ನು ನೀಡಿದರೆ, ಅವು ಎಷ್ಟು ಹೋಲುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ಸುಲಭವಾಗಿ ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಯಂತ್ರ ಕಲಿಕೆ (ML) ಮಾದರಿಗಳಿಗೆ, ಅಂತಹ ಕಾರ್ಯಗಳು ಹೆಚ್ಚು ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ. ಮಾದರಿಯು ಅದರಿಂದ ಕಲಿಯಲು ಅನುವು ಮಾಡಿಕೊಡುವ ರೀತಿಯಲ್ಲಿ ಪಠ್ಯವನ್ನು ಸಂಸ್ಕರಿಸಬೇಕಾಗುತ್ತದೆ. ಮತ್ತು ಭಾಷೆ ಸಂಕೀರ್ಣವಾಗಿರುವುದರಿಂದ, ಈ ಸಂಸ್ಕರಣೆಯನ್ನು ಹೇಗೆ ಮಾಡಬೇಕು ಎಂಬುದರ ಕುರಿತು ನಾವು ಎಚ್ಚರಿಕೆಯಿಂದ ಯೋಚಿಸಬೇಕಾಗಿದೆ. ಪಠ್ಯವನ್ನು ಹೇಗೆ ಪ್ರತಿನಿಧಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಸಾಕಷ್ಟು ಸಂಶೋಧನೆಗಳು ನಡೆದಿವೆ ಮತ್ತು ಮುಂದಿನ ಅಧ್ಯಾಯದಲ್ಲಿ ನಾವು ಕೆಲವು ವಿಧಾನಗಳನ್ನು ನೋಡುತ್ತೇವೆ. + +LLM ಗಳಲ್ಲಿನ ಪ್ರಗತಿಯೊಂದಿಗೆ ಸಹ, ಅನೇಕ ಮೂಲಭೂತ ಸವಾಲುಗಳು ಉಳಿದಿವೆ. ಇವುಗಳಲ್ಲಿ ಅಸ್ಪಷ್ಟತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು, ಸಾಂಸ್ಕೃತಿಕ ಸಂದರ್ಭ, ವ್ಯಂಗ್ಯ ಮತ್ತು ಹಾಸ್ಯ ಸೇರಿವೆ. LLM ಗಳು ವೈವಿಧ್ಯಮಯ ಡೇಟಾಸೆಟ್‌ಗಳ ಕುರಿತು ಬೃಹತ್ ತರಬೇತಿಯ ಮೂಲಕ ಈ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸುತ್ತವೆ, ಆದರೆ ಇನ್ನೂ ಅನೇಕ ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಮಾನವ ಮಟ್ಟದ ತಿಳುವಳಿಕೆಯನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತವೆ. \ No newline at end of file diff --git a/chapters/kn/chapter1/9.mdx b/chapters/kn/chapter1/9.mdx new file mode 100644 index 000000000..22bf3a9f7 --- /dev/null +++ b/chapters/kn/chapter1/9.mdx @@ -0,0 +1,31 @@ +# ಪಕ್ಷಪಾತ ಮತ್ತು ಮಿತಿಗಳು[[ಪಕ್ಷಪಾತ ಮತ್ತು ಮಿತಿಗಳು]] + + + +ನೀವು ಪೂರ್ವ ತರಬೇತಿ ಪಡೆದ ಮಾದರಿ ಅಥವಾ ಉತ್ತಮಗೊಳಿಸಿದ ಆವೃತ್ತಿಯನ್ನು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಬಳಸಬೇಕೆಂದಿದ್ದರೆ, ದಯವಿಟ್ಟು ತಿಳಿದಿರಲಿ, ಈ ಮಾದರಿಗಳು ಶಕ್ತಿಶಾಲಿ ಸಾಧನಗಳಾಗಿದ್ದರೂ, ಅವು ಮಿತಿಗಳೊಂದಿಗೆ ಬರುತ್ತವೆ. ಇವುಗಳಲ್ಲಿ ದೊಡ್ಡದಾದ ಅಂಶವೆಂದರೆ, ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾದ ಮೇಲೆ ಪೂರ್ವ ತರಬೇತಿಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ಸಂಶೋಧಕರು ಸಾಮಾನ್ಯವಾಗಿ ಅವರು ಕಂಡುಕೊಳ್ಳಬಹುದಾದ ಎಲ್ಲಾ ವಿಷಯವನ್ನು ಸ್ಕ್ರ್ಯಾಪ್ ಮಾಡುತ್ತಾರೆ, ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಅತ್ಯುತ್ತಮ ಮತ್ತು ಕೆಟ್ಟದ್ದನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತಾರೆ. + +ಒಂದು ಸಣ್ಣ ವಿವರಣೆಯನ್ನು ನೀಡಲು, BERT ಮಾದರಿಯೊಂದಿಗೆ ಫಿಲ್-ಮಾಸ್ಕ್ ಪೈಪ್‌ಲೈನ್‌ನ ಉದಾಹರಣೆಗೆ ಹಿಂತಿರುಗಿ ನೋಡೋಣ: + +```python +from transformers import pipeline + +unmasker = pipeline("fill-mask", model="bert-base-uncased") +result = unmasker("This man works as a [MASK].") +print([r["token_str"] for r in result]) + +result = unmasker("This woman works as a [MASK].") +print([r["token_str"] for r in result]) +``` + +```python out +['lawyer', 'carpenter', 'doctor', 'waiter', 'mechanic'] +['nurse', 'waitress', 'teacher', 'maid', 'prostitute'] +``` +ಈ ಎರಡು ವಾಕ್ಯಗಳಲ್ಲಿ ಕಾಣೆಯಾದ ಪದವನ್ನು ಭರ್ತಿ ಮಾಡಲು ಕೇಳಿದಾಗ, ಮಾದರಿಯು ಲಿಂಗ-ಮುಕ್ತ ಒಂದೇ ಒಂದು ಉತ್ತರವನ್ನು ನೀಡುತ್ತದೆ (ಮಾಣಿ/ಪರಿಚಾರಿಕೆ). ಉಳಿದವುಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಲಿಂಗದೊಂದಿಗೆ ಸಂಬಂಧ ಹೊಂದಿರುವ ಕೆಲಸದ ವೃತ್ತಿಗಳಾಗಿವೆ - ಮತ್ತು ಹೌದು, ವೇಶ್ಯೆಯು ಮಾದರಿಯು "ಮಹಿಳೆ" ಮತ್ತು "ಕೆಲಸ" ದೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಟಾಪ್ 5 ಸಾಧ್ಯತೆಗಳಲ್ಲಿ ಕೊನೆಗೊಂಡಿತು. BERT ಇಂಟರ್ನೆಟ್‌ನಾದ್ಯಂತ ಡೇಟಾವನ್ನು ಸ್ಕ್ರ್ಯಾಪ್ ಮಾಡುವ ಮೂಲಕ ನಿರ್ಮಿಸದ ಅಪರೂಪದ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳಲ್ಲಿ ಒಂದಾಗಿದ್ದರೂ, ಬದಲಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ತಟಸ್ಥ ಡೇಟಾವನ್ನು ಬಳಸುತ್ತಿದ್ದರೂ ಸಹ ಇದು ಸಂಭವಿಸುತ್ತದೆ (ಇದು ಇಂಗ್ಲಿಷ್ [ವಿಕಿಪೀಡಿಯಾ](https://huggingface.co/datasets/wikipedia) ಮತ್ತು [ಬುಕ್‌ಕಾರ್ಪಸ್](https://huggingface.co/datasets/bookcorpus) ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ತರಬೇತಿ ಪಡೆದಿದೆ). + +ನೀವು ಈ ಪರಿಕರಗಳನ್ನು ಬಳಸುವಾಗ, ನೀವು ಬಳಸುತ್ತಿರುವ ಮೂಲ ಮಾದರಿಯು ಲೈಂಗಿಕತೆ, ಜನಾಂಗೀಯತೆ ಅಥವಾ ಹೋಮೋಫೋಬಿಕ್ ವಿಷಯವನ್ನು ಬಹಳ ಸುಲಭವಾಗಿ ಉತ್ಪಾದಿಸಬಹುದು ಎಂಬುದನ್ನು ನೀವು ಮನಸ್ಸಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕು. ನಿಮ್ಮ ಡೇಟಾದಲ್ಲಿ ಮಾದರಿಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದರಿಂದ ಈ ಆಂತರಿಕ ಪಕ್ಷಪಾತವು ಕಣ್ಮರೆಯಾಗುವುದಿಲ್ಲ. \ No newline at end of file diff --git a/chapters/kn/chapter2/1.mdx b/chapters/kn/chapter2/1.mdx new file mode 100644 index 000000000..6737d0e1f --- /dev/null +++ b/chapters/kn/chapter2/1.mdx @@ -0,0 +1,23 @@ +# ಪರಿಚಯ[[ಪರಿಚಯ]] + + + +ನೀವು [ಅಧ್ಯಾಯ 1](/course/chapter1) ರಲ್ಲಿ ನೋಡಿದಂತೆ, ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಬಹಳ ದೊಡ್ಡದಾಗಿರುತ್ತವೆ. ಲಕ್ಷಾಂತರದಿಂದ ಹತ್ತಾರು ಶತಕೋಟಿ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ, ಈ ಮಾದರಿಗಳಿಗೆ ತರಬೇತಿ ನೀಡುವುದು ಮತ್ತು ನಿಯೋಜಿಸುವುದು ಒಂದು ಸಂಕೀರ್ಣ ಕಾರ್ಯವಾಗಿದೆ. ಇದಲ್ಲದೆ, ಹೊಸ ಮಾದರಿಗಳು ಬಹುತೇಕ ಪ್ರತಿದಿನ ಬಿಡುಗಡೆಯಾಗುವುದರಿಂದ ಮತ್ತು ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಅನುಷ್ಠಾನವನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ಅವೆಲ್ಲವನ್ನೂ ಪ್ರಯತ್ನಿಸುವುದು ಸುಲಭದ ಕೆಲಸವಲ್ಲ. + +ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಗ್ರಂಥಾಲಯವನ್ನು ರಚಿಸಲಾಗಿದೆ. ಯಾವುದೇ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಯನ್ನು ಲೋಡ್ ಮಾಡಲು, ತರಬೇತಿ ನೀಡಲು ಮತ್ತು ಉಳಿಸಲು ಒಂದೇ API ಅನ್ನು ಒದಗಿಸುವುದು ಇದರ ಗುರಿಯಾಗಿದೆ. ಗ್ರಂಥಾಲಯದ ಮುಖ್ಯ ವೈಶಿಷ್ಟ್ಯಗಳು: + +- **ಬಳಕೆಯ ಸುಲಭತೆ**: ನಿರ್ಣಯಕ್ಕಾಗಿ ಅತ್ಯಾಧುನಿಕ NLP ಮಾದರಿಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು, ಲೋಡ್ ಮಾಡುವುದು ಮತ್ತು ಬಳಸುವುದು ಕೇವಲ ಎರಡು ಸಾಲುಗಳ ಕೋಡ್‌ನಲ್ಲಿ ಮಾಡಬಹುದು. +- **ನಮ್ಯತೆ**: ಅವುಗಳ ಮೂಲದಲ್ಲಿ, ಎಲ್ಲಾ ಮಾದರಿಗಳು ಸರಳವಾದ PyTorch nn.Module ತರಗತಿಗಳಾಗಿವೆ ಮತ್ತು ಅವುಗಳ ಸಂಬಂಧಿತ ಯಂತ್ರ ಕಲಿಕೆ (ML) ಚೌಕಟ್ಟುಗಳಲ್ಲಿ ಯಾವುದೇ ಇತರ ಮಾದರಿಗಳಂತೆ ನಿರ್ವಹಿಸಬಹುದು. +- **ಸರಳತೆ**: ಗ್ರಂಥಾಲಯದಾದ್ಯಂತ ಯಾವುದೇ ಅಮೂರ್ತತೆಗಳನ್ನು ಮಾಡಲಾಗುವುದಿಲ್ಲ. "ಆಲ್ ಇನ್ ಒನ್ ಫೈಲ್" ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ: ಒಂದು ಮಾದರಿಯ ಫಾರ್ವರ್ಡ್ ಪಾಸ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದೇ ಫೈಲ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಇದರಿಂದಾಗಿ ಕೋಡ್ ಸ್ವತಃ ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ ಮತ್ತು ಹ್ಯಾಕ್ ಮಾಡಬಹುದಾಗಿದೆ. + +ಈ ಕೊನೆಯ ವೈಶಿಷ್ಟ್ಯವು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳನ್ನು ಇತರ ML ಲೈಬ್ರರಿಗಳಿಗಿಂತ ಸಾಕಷ್ಟು ಭಿನ್ನವಾಗಿಸುತ್ತದೆ. ಮಾದರಿಗಳನ್ನು ಫೈಲ್‌ಗಳಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಲಾದ ಮಾಡ್ಯೂಲ್‌ಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿಲ್ಲ; ಬದಲಾಗಿ, ಪ್ರತಿಯೊಂದು ಮಾದರಿಯು ತನ್ನದೇ ಆದ ಪದರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಮಾದರಿಗಳನ್ನು ಹೆಚ್ಚು ಸುಲಭವಾಗಿ ಮತ್ತು ಅರ್ಥವಾಗುವಂತೆ ಮಾಡುವುದರ ಜೊತೆಗೆ, ಇದು ಇತರರ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದೆ ಒಂದು ಮಾದರಿಯಲ್ಲಿ ಸುಲಭವಾಗಿ ಪ್ರಯೋಗಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. + +ಈ ಅಧ್ಯಾಯವು [ಅಧ್ಯಾಯ 1](/course/chapter1) ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ `ಪೈಪ್‌ಲೈನ್()` ಕಾರ್ಯವನ್ನು ಪುನರಾವರ್ತಿಸಲು ನಾವು ಮಾದರಿ ಮತ್ತು ಟೋಕನೈಜರ್ ಅನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸುವ ಎಂಡ್-ಟು-ಎಂಡ್ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಮುಂದೆ, ನಾವು ಮಾದರಿ API ಅನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ: ನಾವು ಮಾದರಿ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ತರಗತಿಗಳಿಗೆ ಧುಮುಕುತ್ತೇವೆ ಮತ್ತು ಮಾದರಿಯನ್ನು ಹೇಗೆ ಲೋಡ್ ಮಾಡುವುದು ಮತ್ತು ಅದು ಸಂಖ್ಯಾತ್ಮಕ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಭವಿಷ್ಯವಾಣಿಗಳಿಗೆ ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ. + +ನಂತರ ನಾವು ಟೋಕನೈಜರ್ API ಅನ್ನು ನೋಡೋಣ, ಇದು `ಪೈಪ್‌ಲೈನ್()` ಕಾರ್ಯದ ಇನ್ನೊಂದು ಮುಖ್ಯ ಅಂಶವಾಗಿದೆ. ಟೋಕನೈಜರ್‌ಗಳು ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಸಂಸ್ಕರಣಾ ಹಂತಗಳನ್ನು ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ, ನರಮಂಡಲಕ್ಕಾಗಿ ಪಠ್ಯದಿಂದ ಸಂಖ್ಯಾತ್ಮಕ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ ಪರಿವರ್ತನೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಾರೆ ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ಪಠ್ಯಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತಾರೆ. ಅಂತಿಮವಾಗಿ, ಸಿದ್ಧಪಡಿಸಿದ ಬ್ಯಾಚ್‌ನಲ್ಲಿ ಮಾದರಿಯ ಮೂಲಕ ಬಹು ವಾಕ್ಯಗಳನ್ನು ಕಳುಹಿಸುವುದನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂದು ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ, ನಂತರ ಉನ್ನತ ಮಟ್ಟದ `ಟೋಕನೈಜರ್()` ಕಾರ್ಯವನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡುವ ಮೂಲಕ ಎಲ್ಲವನ್ನೂ ಮುಗಿಸುತ್ತೇವೆ. + +> [!TIP] +> ⚠️ ಮಾಡೆಲ್ ಹಬ್ ಮತ್ತು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳೊಂದಿಗೆ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಲು,ಖಾತೆಯನ್ನು ರಚಿಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. \ No newline at end of file diff --git a/chapters/kn/chapter2/2.mdx b/chapters/kn/chapter2/2.mdx new file mode 100644 index 000000000..edf054d02 --- /dev/null +++ b/chapters/kn/chapter2/2.mdx @@ -0,0 +1,226 @@ + + +# ಪೈಪ್ಲೈನ್ ​​ಹಿಂದೆ[[ಪೈಪ್ಲೈನ್ ​​ಹಿಂದೆ]] + + + + + +[ಅಧ್ಯಾಯ 1](/course/chapter1) ರಲ್ಲಿ ನಾವು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ ತೆರೆಮರೆಯಲ್ಲಿ ಏನಾಯಿತು ಎಂಬುದನ್ನು ನೋಡೋಣ, ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ: +```python +from transformers import pipeline + +classifier = pipeline("sentiment-analysis") +classifier( + [ + "I've been waiting for a HuggingFace course my whole life.", + "I hate this so much!", + ] +) +``` +ಮತ್ತು ಪಡೆಯಲಾಗಿದೆ: + +```python out +[{'label': 'POSITIVE', 'score': 0.9598047137260437}, + {'label': 'NEGATIVE', 'score': 0.9994558095932007}] +``` +ನಾವು (ಅಧ್ಯಾಯ 1](/course/chapter1) ರಲ್ಲಿ ನೋಡಿದಂತೆ, ಈ ಪೈಪ್‌ಲೈನ್ ಮೂರು ಹಂತಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ: ಪೂರ್ವ-ಸಂಸ್ಕರಣೆ, ಮಾದರಿಯ ಮೂಲಕ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ರವಾನಿಸುವುದು ಮತ್ತು ನಂತರದ ಸಂಸ್ಕರಣೆ: + +
+The full NLP pipeline: tokenization of text, conversion to IDs, and inference through the Transformer model and the model head. + +
+ +ಇವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡೋಣ. + +## ಟೋಕನೈಸರ್ ಬಳಸಿ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು[[ಟೋಕನೈಸರ್ ಬಳಸಿ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು]] + +ಇತರ ನರಮಂಡಲ ಜಾಲಗಳಂತೆ, ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳು ಕಚ್ಚಾ ಪಠ್ಯವನ್ನು ನೇರವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಮ್ಮ ಪೈಪ್‌ಲೈನ್‌ನ ಮೊದಲ ಹಂತವೆಂದರೆ ಪಠ್ಯ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಮಾದರಿಯು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದಾದ ಸಂಖ್ಯೆಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು. ಇದನ್ನು ಮಾಡಲು ನಾವು ಟೋಕನೈಜರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದು ಇದಕ್ಕೆ ಕಾರಣವಾಗಿದೆ: + +- ಇನ್‌ಪುಟ್ ಅನ್ನು ಪದಗಳು, ಉಪಪದಗಳು ಅಥವಾ ಚಿಹ್ನೆಗಳಾಗಿ (ವಿರಾಮಚಿಹ್ನೆಗಳಂತೆ) ವಿಭಜಿಸುವುದು, ಇವುಗಳನ್ನು ಟೋಕನ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. +- ಪ್ರತಿ ಟೋಕನ್ ಅನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಮ್ಯಾಪಿಂಗ್ ಮಾಡುವುದು +- ಮಾದರಿಗೆ ಉಪಯುಕ್ತವಾಗಬಹುದಾದ ಹೆಚ್ಚುವರಿ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು. + +ಈ ಎಲ್ಲಾ ಪೂರ್ವ-ಸಂಸ್ಕರಣೆಯನ್ನು ಮಾದರಿಯನ್ನು ಪೂರ್ವ-ತರಬೇತಿಗೊಳಿಸಿದ ರೀತಿಯಲ್ಲಿಯೇ ಮಾಡಬೇಕಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಮೊದಲು ಆ ಮಾಹಿತಿಯನ್ನು [ಮಾಡೆಲ್ ಹಬ್‌ನಿಂದ](https://huggingface.co/models) ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ನಾವು `ಆಟೋಟೋಕನೈಜರ್` ವರ್ಗ ಮತ್ತು ಅದರ `from_pretrained`() ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ. ನಮ್ಮ ಮಾದರಿಯ ಚೆಕ್‌ಪಾಯಿಂಟ್ ಹೆಸರನ್ನು ಬಳಸಿಕೊಂಡು, ಅದು ಮಾದರಿಯ ಟೋಕನೈಜರ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಆದ್ದರಿಂದ ನೀವು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಮೊದಲ ಬಾರಿಗೆ ಚಲಾಯಿಸಿದಾಗ ಮಾತ್ರ ಅದನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ). + +`ಸೆಂಟಿಮೆಂಟ್-ಅನಾಲಿಸಿಸ್` ಪೈಪ್‌ಲೈನ್‌ನ ಡೀಫಾಲ್ಟ್ ಚೆಕ್‌ಪಾಯಿಂಟ್ `distilbert-base-uncased-finetuned-sst-2-english` ಆಗಿರುವುದರಿಂದ (ನೀವು ಅದರ ಮಾದರಿ ಕಾರ್ಡ್ ಅನ್ನು [ಇಲ್ಲಿ](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english) ನೋಡಬಹುದು), ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ರನ್ ಮಾಡುತ್ತೇವೆ: + +```python +from transformers import AutoTokenizer + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +``` +ಒಮ್ಮೆ ನಾವು ಟೋಕನೈಸರ್ ಅನ್ನು ಪಡೆದುಕೊಂಡ ನಂತರ, ನಾವು ನಮ್ಮ ವಾಕ್ಯಗಳನ್ನು ನೇರವಾಗಿ ಅದಕ್ಕೆ ರವಾನಿಸಬಹುದು ಮತ್ತು ನಮ್ಮ ಮಾದರಿಗೆ ಫೀಡ್ ಮಾಡಲು ಸಿದ್ಧವಾಗಿರುವ ನಿಘಂಟನ್ನು ನಾವು ಮರಳಿ ಪಡೆಯುತ್ತೇವೆ! ಇನ್‌ಪುಟ್ ಐಡಿಗಳ ಪಟ್ಟಿಯನ್ನು ಟೆನ್ಸರ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಮಾತ್ರ ಉಳಿದಿರುವ ಕೆಲಸ. + +ಯಾವ ML ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬ್ಯಾಕೆಂಡ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಚಿಂತಿಸದೆ ನೀವು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು; ಕೆಲವು ಮಾದರಿಗಳಿಗೆ ಇದು PyTorch ಅಥವಾ Flax ಆಗಿರಬಹುದು. ಆದಾಗ್ಯೂ, ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಗಳು ಟೆನ್ಸರ್‌ಗಳನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ಮಾತ್ರ ಸ್ವೀಕರಿಸುತ್ತವೆ. ಟೆನ್ಸರ್‌ಗಳ ಬಗ್ಗೆ ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಕೇಳುತ್ತಿದ್ದರೆ, ನೀವು ಅವುಗಳನ್ನು NumPy ಅರೇಗಳ ಬದಲಿಗೆ ಯೋಚಿಸಬಹುದು. NumPy ಅರೇ ಸ್ಕೇಲಾರ್ (0D), ವೆಕ್ಟರ್ (1D), ಮ್ಯಾಟ್ರಿಕ್ಸ್ (2D) ಅಥವಾ ಹೆಚ್ಚಿನ ಆಯಾಮಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಇದು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಟೆನ್ಸರ್ ಆಗಿದೆ; ಇತರ ML ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳ ಟೆನ್ಸರ್‌ಗಳು ಇದೇ ರೀತಿ ವರ್ತಿಸುತ್ತವೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ NumPy ಅರೇಗಳಂತೆ ನಿದರ್ಶನ ಮಾಡಲು ಸರಳವಾಗಿದೆ. + +ನಾವು ಮರಳಿ ಪಡೆಯಲು ಬಯಸುವ ಟೆನ್ಸರ್‌ಗಳ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು (ಪೈಟಾರ್ಚ್ ಅಥವಾ ಸರಳ ನಂಬೈ), ನಾವು `ರಿಟರ್ನ್_ಟೆನ್ಸರ್‌ಗಳು` ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ: + +```python +raw_inputs = [ + "I've been waiting for a HuggingFace course my whole life.", + "I hate this so much!", +] +inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt") +print(inputs) +``` + +ಪ್ಯಾಡಿಂಗ್ ಮತ್ತು ಮೊಟಕುಗೊಳಿಸುವಿಕೆಯ ಬಗ್ಗೆ ಇನ್ನೂ ಚಿಂತಿಸಬೇಡಿ; ನಾವು ಅವುಗಳನ್ನು ನಂತರ ವಿವರಿಸುತ್ತೇವೆ. ಇಲ್ಲಿ ನೆನಪಿಡಬೇಕಾದ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ನೀವು ಒಂದು ವಾಕ್ಯ ಅಥವಾ ವಾಕ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ರವಾನಿಸಬಹುದು, ಜೊತೆಗೆ ನೀವು ಮರಳಿ ಪಡೆಯಲು ಬಯಸುವ ಟೆನ್ಸರ್‌ಗಳ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು (ಯಾವುದೇ ಪ್ರಕಾರವನ್ನು ರವಾನಿಸದಿದ್ದರೆ, ನೀವು ಪರಿಣಾಮವಾಗಿ ಪಟ್ಟಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯುತ್ತೀರಿ). + +ಪೈಟಾರ್ಚ್ ಟೆನ್ಸರ್‌ಗಳಂತೆ ಫಲಿತಾಂಶಗಳು ಹೇಗೆ ಕಾಣುತ್ತವೆ ಎಂಬುದು ಇಲ್ಲಿದೆ: + +```python out +{ + 'input_ids': tensor([ + [ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102], + [ 101, 1045, 5223, 2023, 2061, 2172, 999, 102, 0, 0, 0, 0, 0, 0, 0, 0] + ]), + 'attention_mask': tensor([ + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] + ]) +} +``` + +ಔಟ್‌ಪುಟ್ ಸ್ವತಃ ಎರಡು ಕೀಲಿಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ನಿಘಂಟಾಗಿದೆ, input_ids ಮತ್ತು attention_mask. input_ids ಎರಡು ಸಾಲುಗಳ ಪೂರ್ಣಾಂಕಗಳನ್ನು (ಪ್ರತಿ ವಾಕ್ಯಕ್ಕೆ ಒಂದು) ಹೊಂದಿರುತ್ತದೆ, ಅವು ಪ್ರತಿ ವಾಕ್ಯದಲ್ಲಿನ ಟೋಕನ್‌ಗಳ ವಿಶಿಷ್ಟ ಗುರುತಿಸುವಿಕೆಗಳಾಗಿವೆ. ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ಗಮನ_ಮಾಸ್ಕ್ ಏನೆಂದು ನಾವು ನಂತರ ವಿವರಿಸುತ್ತೇವೆ. + +## ಮಾದರಿಯ ಬಗ್ಗೆ[[ಮಾದರಿಯ ಬಗ್ಗೆ]] + +ನಮ್ಮ ಟೋಕನೈಸರ್‌ನೊಂದಿಗೆ ನಾವು ಮಾಡಿದ ರೀತಿಯಲ್ಲಿಯೇ ನಮ್ಮ ಪೂರ್ವತರಬೇತಿ ಪಡೆದ ಮಾದರಿಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು. 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳು `ಆಟೋಮಾಡೆಲ್` ವರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಅದು `from_pretrained()` ವಿಧಾನವನ್ನು ಸಹ ಹೊಂದಿದೆ: + +```python +from transformers import AutoModel + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +model = AutoModel.from_pretrained(checkpoint) +``` + +ಈ ಕೋಡ್ ತುಣುಕಿನಲ್ಲಿ, ನಾವು ನಮ್ಮ ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಬಳಸಿದ ಅದೇ ಚೆಕ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ (ವಾಸ್ತವವಾಗಿ ಅದನ್ನು ಈಗಾಗಲೇ ಕ್ಯಾಶ್ ಮಾಡಿರಬೇಕು) ಮತ್ತು ಅದರೊಂದಿಗೆ ಒಂದು ಮಾದರಿಯನ್ನು ಇನ್‌ಸ್ಟಾಂಟಿಯೇಟ್ ಮಾಡಿದ್ದೇವೆ. + +ಈ ಆರ್ಕಿಟೆಕ್ಚರ್ ಮೂಲ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ: ಕೆಲವು ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ನೀಡಿದರೆ, ಅದು ನಾವು *ಗುಪ್ತ ಸ್ಥಿತಿಗಳು* ಎಂದು ಕರೆಯುವದನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ, ಇದನ್ನು *ವೈಶಿಷ್ಟ್ಯಗಳು* ಎಂದೂ ಕರೆಯುತ್ತಾರೆ. ಪ್ರತಿ ಮಾದರಿ ಇನ್‌ಪುಟ್‌ಗೆ, ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಯಿಂದ **ಆ ಇನ್‌ಪುಟ್‌ನ ಸಂದರ್ಭೋಚಿತ ತಿಳುವಳಿಕೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ** ಹೈ-ಡೈಮೆನ್ಷನಲ್ ವೆಕ್ಟರ್ ಅನ್ನು ನಾವು ಹಿಂಪಡೆಯುತ್ತೇವೆ. + +ಇದು ಅರ್ಥಪೂರ್ಣವಾಗಿಲ್ಲದಿದ್ದರೆ, ಅದರ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ. ನಾವು ಎಲ್ಲವನ್ನೂ ನಂತರ ವಿವರಿಸುತ್ತೇವೆ. + +ಈ ಗುಪ್ತ ಸ್ಥಿತಿಗಳು ತಮ್ಮದೇ ಆದ ಮೇಲೆ ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಅವು ಸಾಮಾನ್ಯವಾಗಿ ಮಾದರಿಯ ಇನ್ನೊಂದು ಭಾಗಕ್ಕೆ ಇನ್‌ಪುಟ್‌ಗಳಾಗಿವೆ, ಇದನ್ನು *ಹೆಡ್* ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. [ಅಧ್ಯಾಯ 1](/course/chapter1) ರಲ್ಲಿ, ವಿಭಿನ್ನ ಕಾರ್ಯಗಳನ್ನು ಒಂದೇ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನೊಂದಿಗೆ ನಿರ್ವಹಿಸಬಹುದಿತ್ತು, ಆದರೆ ಈ ಪ್ರತಿಯೊಂದು ಕಾರ್ಯಗಳು ಅದರೊಂದಿಗೆ ವಿಭಿನ್ನ ತಲೆಯನ್ನು ಹೊಂದಿರುತ್ತವೆ. + +### ಉನ್ನತ ಆಯಾಮದ ವೆಕ್ಟರ್?[[ಉನ್ನತ ಆಯಾಮದ ವೆಕ್ಟರ್]] + +ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾಡ್ಯೂಲ್‌ನಿಂದ ವೆಕ್ಟರ್ ಔಟ್‌ಪುಟ್ ಸಾಮಾನ್ಯವಾಗಿ ದೊಡ್ಡದಾಗಿರುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಮೂರು ಆಯಾಮಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ: + +- **ಬ್ಯಾಚ್ ಗಾತ್ರ**: ಒಂದು ಸಮಯದಲ್ಲಿ ಸಂಸ್ಕರಿಸಿದ ಅನುಕ್ರಮಗಳ ಸಂಖ್ಯೆ (ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ 2). +- **ಅನುಕ್ರಮದ ಉದ್ದ**: ಅನುಕ್ರಮದ ಸಂಖ್ಯಾತ್ಮಕ ಪ್ರಾತಿನಿಧ್ಯದ ಉದ್ದ (ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ 16). +- **ಗುಪ್ತ ಗಾತ್ರ**: ಪ್ರತಿ ಮಾದರಿ ಇನ್‌ಪುಟ್‌ನ ವೆಕ್ಟರ್ ಆಯಾಮ. + +ಕೊನೆಯ ಮೌಲ್ಯದ ಕಾರಣದಿಂದಾಗಿ ಇದನ್ನು "ಹೆಚ್ಚಿನ ಆಯಾಮ" ಎಂದು ಹೇಳಲಾಗುತ್ತದೆ. ಗುಪ್ತ ಗಾತ್ರವು ತುಂಬಾ ದೊಡ್ಡದಾಗಿರಬಹುದು (ಸಣ್ಣ ಮಾದರಿಗಳಿಗೆ 768 ಸಾಮಾನ್ಯವಾಗಿದೆ ಮತ್ತು ದೊಡ್ಡ ಮಾದರಿಗಳಲ್ಲಿ ಇದು 3072 ಅಥವಾ ಹೆಚ್ಚಿನದನ್ನು ತಲುಪಬಹುದು). + +ನಾವು ಪೂರ್ವ-ಸಂಸ್ಕರಿಸಿದ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ನಮ್ಮ ಮಾದರಿಗೆ ಫೀಡ್ ಮಾಡಿದರೆ ನಾವು ಇದನ್ನು ನೋಡಬಹುದು: + +```python +outputs = model(**inputs) +print(outputs.last_hidden_state.shape) +``` + +```python out +torch.Size([2, 16, 768]) +``` + +🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಮಾದರಿಗಳ ಔಟ್‌ಪುಟ್‌ಗಳು `namedtuples` ಅಥವಾ ನಿಘಂಟುಗಳಂತೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನೀವು ಅಂಶಗಳನ್ನು ಗುಣಲಕ್ಷಣಗಳ ಮೂಲಕ (ನಾವು ಮಾಡಿದಂತೆ) ಅಥವಾ ಕೀಲಿಯ ಮೂಲಕ (`ಔಟ್‌ಪುಟ್‌ಗಳು["last_hidden_state"]`), ಅಥವಾ ನೀವು ಹುಡುಕುತ್ತಿರುವ ವಿಷಯ ಎಲ್ಲಿದೆ ಎಂದು ನಿಖರವಾಗಿ ತಿಳಿದಿದ್ದರೆ (`ಔಟ್‌ಪುಟ್‌ಗಳು[0]`) ಸೂಚ್ಯಂಕದ ಮೂಲಕವೂ ಪ್ರವೇಶಿಸಬಹುದು. + +### ಮಾದರಿ ತಲೆಗಳು: ಸಂಖ್ಯೆಗಳಿಂದ ಅರ್ಥವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು[[ಮಾದರಿ ತಲೆಗಳು: ಸಂಖ್ಯೆಗಳಿಂದ ಅರ್ಥವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು]] + +ಮಾದರಿ ಹೆಡ್‌ಗಳು ಗುಪ್ತ ಸ್ಥಿತಿಗಳ ಉನ್ನತ ಆಯಾಮದ ವೆಕ್ಟರ್ ಅನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಂಡು ಅವುಗಳನ್ನು ಬೇರೆ ಆಯಾಮಕ್ಕೆ ಪ್ರಕ್ಷೇಪಿಸುತ್ತವೆ. ಅವು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಅಥವಾ ಕೆಲವು ರೇಖೀಯ ಪದರಗಳಿಂದ ಕೂಡಿರುತ್ತವೆ: + +
+A Transformer network alongside its head. + +
+ +ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮಾದರಿ ಹೆಡ್‌ಗೆ ನೇರವಾಗಿ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. + +ಈ ರೇಖಾಚಿತ್ರದಲ್ಲಿ, ಮಾದರಿಯನ್ನು ಅದರ ಎಂಬೆಡಿಂಗ್ ಲೇಯರ್ ಮತ್ತು ನಂತರದ ಲೇಯರ್‌ಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಎಂಬೆಡಿಂಗ್ ಲೇಯರ್ ಟೋಕನೈಸ್ ಮಾಡಿದ ಇನ್‌ಪುಟ್‌ನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಇನ್‌ಪುಟ್ ಐಡಿಯನ್ನು ಸಂಬಂಧಿತ ಟೋಕನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ವೆಕ್ಟರ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ನಂತರದ ಲೇಯರ್‌ಗಳು ವಾಕ್ಯಗಳ ಅಂತಿಮ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಉತ್ಪಾದಿಸಲು ಗಮನ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಆ ವೆಕ್ಟರ್‌ಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುತ್ತವೆ. + +🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳಲ್ಲಿ ಹಲವು ವಿಭಿನ್ನ ವಾಸ್ತುಶಿಲ್ಪಗಳು ಲಭ್ಯವಿದೆ, ಪ್ರತಿಯೊಂದೂ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಿಭಾಯಿಸುವ ಸುತ್ತಲೂ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇಲ್ಲಿದೆ ಸಮಗ್ರವಲ್ಲದ ಪಟ್ಟಿ: + +- `*Model` (retrieve the hidden states) +- `*ForCausalLM` +- `*ForMaskedLM` +- `*ForMultipleChoice` +- `*ForQuestionAnswering` +- `*ForSequenceClassification` +- `*ForTokenClassification` +- and others 🤗 + +ನಮ್ಮ ಉದಾಹರಣೆಗಾಗಿ, ನಮಗೆ ಅನುಕ್ರಮ ವರ್ಗೀಕರಣ ತಲೆಯನ್ನು ಹೊಂದಿರುವ ಮಾದರಿಯ ಅಗತ್ಯವಿದೆ (ವಾಕ್ಯಗಳನ್ನು ಧನಾತ್ಮಕ ಅಥವಾ ಋಣಾತ್ಮಕ ಎಂದು ವರ್ಗೀಕರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ). ಆದ್ದರಿಂದ, ನಾವು ವಾಸ್ತವವಾಗಿ `ಆಟೋಮಾಡೆಲ್` ವರ್ಗವನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಆದರೆ `ಆಟೋಮಾಡೆಲ್‌ಫೋರ್‌ಸೀಕ್ವೆನ್ಸ್‌ಕ್ಲಾಸಿಫಿಕೇಶನ್` ಅನ್ನು ಬಳಸುತ್ತೇವೆ: + +```python +from transformers import AutoModelForSequenceClassification + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) +outputs = model(**inputs) +``` + +ಈಗ ನಾವು ನಮ್ಮ ಔಟ್‌ಪುಟ್‌ಗಳ ಆಕಾರವನ್ನು ನೋಡಿದರೆ, ಆಯಾಮವು ತುಂಬಾ ಕಡಿಮೆ ಇರುತ್ತದೆ: ಮಾದರಿ ಹೆಡ್ ನಾವು ಮೊದಲು ನೋಡಿದ ಹೆಚ್ಚಿನ ಆಯಾಮದ ವೆಕ್ಟರ್‌ಗಳನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ವೆಕ್ಟರ್‌ಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ (ಪ್ರತಿ ಲೇಬಲ್‌ಗೆ ಒಂದು): + +```python +print(outputs.logits.shape) +``` + +```python out +torch.Size([2, 2]) +``` + +ನಮಗೆ ಕೇವಲ ಎರಡು ವಾಕ್ಯಗಳು ಮತ್ತು ಎರಡು ಲೇಬಲ್‌ಗಳು ಇರುವುದರಿಂದ, ನಮ್ಮ ಮಾದರಿಯಿಂದ ನಮಗೆ ಸಿಗುವ ಫಲಿತಾಂಶವು 2 x 2 ಆಕಾರದಲ್ಲಿದೆ. + +## ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪೋಸ್ಟ್‌ಪ್ರೊಸೆಸ್ ಮಾಡುವುದು[[ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪೋಸ್ಟ್‌ಪ್ರೊಸೆಸ್ ಮಾಡುವುದು]] + +ನಮ್ಮ ಮಾದರಿಯಿಂದ ನಾವು ಪಡೆಯುವ ಮೌಲ್ಯಗಳು ಸ್ವತಃ ಅರ್ಥಪೂರ್ಣವಾಗಿರುವುದಿಲ್ಲ. ನೋಡೋಣ: + +```python +print(outputs.logits) +``` + +```python out +tensor([[-1.5607, 1.6123], + [ 4.1692, -3.3464]], grad_fn=) +``` +ನಮ್ಮ ಮಾದರಿಯು ಮೊದಲ ವಾಕ್ಯಕ್ಕೆ `[-1.5607, 1.6123]` ಮತ್ತು ಎರಡನೆಯದಕ್ಕೆ `[4.1692, -3.3464]` ಎಂದು ಊಹಿಸಲಾಗಿದೆ. ಅವು ಸಂಭವನೀಯತೆಗಳಲ್ಲ ಆದರೆ `ಲಾಜಿಟ್‌ಗಳು`, ಮಾದರಿಯ ಕೊನೆಯ ಪದರದಿಂದ ಔಟ್‌ಪುಟ್ ಮಾಡಲಾದ ಕಚ್ಚಾ, ಅಸಮಂಜಸ ಸ್ಕೋರ್‌ಗಳು. ಸಂಭವನೀಯತೆಗಳಾಗಿ ಪರಿವರ್ತಿಸಲು, ಅವು [ಸಾಫ್ಟ್‌ಮ್ಯಾಕ್ಸ್](https://en.wikipedia.org/wiki/Softmax_function) ಪದರದ ಮೂಲಕ ಹೋಗಬೇಕಾಗುತ್ತದೆ (ಎಲ್ಲಾ 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಮಾದರಿಗಳು ಲಾಜಿಟ್‌ಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತವೆ, ಏಕೆಂದರೆ ತರಬೇತಿಗಾಗಿ ನಷ್ಟ ಕಾರ್ಯವು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಫ್ಟ್‌ಮ್ಯಾಕ್ಸ್‌ನಂತಹ ಕೊನೆಯ ಸಕ್ರಿಯಗೊಳಿಸುವ ಕಾರ್ಯವನ್ನು ಕ್ರಾಸ್ ಎಂಟ್ರೊಪಿಯಂತಹ ನಿಜವಾದ ನಷ್ಟ ಕಾರ್ಯದೊಂದಿಗೆ ಬೆಸೆಯುತ್ತದೆ): + +```py +import torch + +predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) +print(predictions) +``` + +```python out +tensor([[4.0195e-02, 9.5980e-01], + [9.9946e-01, 5.4418e-04]], grad_fn=) +``` +ಈಗ ನಾವು ಮಾದರಿಯು ಮೊದಲ ವಾಕ್ಯಕ್ಕೆ `[0.0402, 0.9598]` ಮತ್ತು ಎರಡನೆಯದಕ್ಕೆ `[0.9995, 0.0005]` ಎಂದು ಊಹಿಸಿರುವುದನ್ನು ನೋಡಬಹುದು. ಇವು ಗುರುತಿಸಬಹುದಾದ ಸಂಭವನೀಯತೆಯ ಅಂಕಗಳಾಗಿವೆ. + +ಪ್ರತಿಯೊಂದು ಸ್ಥಾನಕ್ಕೆ ಅನುಗುಣವಾದ ಲೇಬಲ್‌ಗಳನ್ನು ಪಡೆಯಲು, ನಾವು ಮಾದರಿ ಸಂರಚನೆಯ `id2label` ಗುಣಲಕ್ಷಣವನ್ನು ಪರಿಶೀಲಿಸಬಹುದು (ಇದರ ಕುರಿತು ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಇನ್ನಷ್ಟು): + +```python +model.config.id2label +``` + +```python out +{0: 'NEGATIVE', 1: 'POSITIVE'} +``` + +ಈಗ ನಾವು ಮಾದರಿಯು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಊಹಿಸಿದೆ ಎಂದು ತೀರ್ಮಾನಿಸಬಹುದು: + +- ಮೊದಲ ವಾಕ್ಯ: ನಕಾರಾತ್ಮಕ: 0.0402, ಸಕಾರಾತ್ಮಕ: 0.9598 +- ಎರಡನೇ ವಾಕ್ಯ: ನಕಾರಾತ್ಮಕ: 0.9995, ಸಕಾರಾತ್ಮಕ: 0.0005 + +ನಾವು ಪೈಪ್‌ಲೈನ್‌ನ ಮೂರು ಹಂತಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪುನರುತ್ಪಾದಿಸಿದ್ದೇವೆ: ಟೋಕನೈಜರ್‌ಗಳೊಂದಿಗೆ ಪೂರ್ವ-ಸಂಸ್ಕರಣೆ, ಮಾದರಿಯ ಮೂಲಕ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ರವಾನಿಸುವುದು ಮತ್ತು ನಂತರದ ಸಂಸ್ಕರಣೆ! ಈಗ ಆ ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸಲು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳೋಣ. + +> [!TIP] +> ✏️ **ಇದನ್ನು ಪ್ರಯತ್ನಿಸಿ ನೋಡಿ! **ನಿಮ್ಮದೇ ಆದ ಎರಡು (ಅಥವಾ ಹೆಚ್ಚಿನ) ಪಠ್ಯಗಳನ್ನು ಆರಿಸಿ ಮತ್ತು ಅವುಗಳನ್ನು *ಭಾವನೆ-ವಿಶ್ಲೇಷಣಾ* ಪೈಪ್‌ಲೈನ್ ಮೂಲಕ ಚಲಾಯಿಸಿ. ನಂತರ ನೀವು ಇಲ್ಲಿ ನೋಡಿದ ಹಂತಗಳನ್ನು ನೀವೇ ಪುನರಾವರ್ತಿಸಿ ಮತ್ತು ನೀವು ಅದೇ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯುತ್ತೀರೋ ಇಲ್ಲವೋ ಎಂದು ಪರಿಶೀಲಿಸಿ! \ No newline at end of file diff --git a/chapters/kn/chapter2/7.mdx b/chapters/kn/chapter2/7.mdx new file mode 100644 index 000000000..63c106754 --- /dev/null +++ b/chapters/kn/chapter2/7.mdx @@ -0,0 +1,18 @@ +# ಮೂಲ ಬಳಕೆ ಪೂರ್ಣಗೊಂಡಿದೆ![[ಮೂಲ ಬಳಕೆ ಪೂರ್ಣಗೊಂಡಿದೆ]] + + + +ಇಲ್ಲಿಯವರೆಗೆ ಕೋರ್ಸ್ ಅನ್ನು ಚೆನ್ನಾಗಿ ಮಾಡಿದ್ದೀರಿ! ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ನೀವು: + +- ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಯ ಮೂಲ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಕಲಿತಿದ್ದೀರಿ. +- ಟೋಕನೈಸೇಶನ್ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ರೂಪಿಸುವುದನ್ನು ಕಲಿತಿದ್ದೀರಿ. +- ಪ್ರಾಯೋಗಿಕವಾಗಿ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಮಾದರಿಯನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ನೋಡಿದೆ. +- ಮಾದರಿಯಿಂದ ಅರ್ಥವಾಗುವಂತಹ ಟೆನ್ಸರ್‌ಗಳಾಗಿ ಪಠ್ಯವನ್ನು ಪರಿವರ್ತಿಸಲು ಟೋಕನೈಜರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳುವುದು ಎಂದು ಕಲಿತಿದ್ದೀರಿ. +- ಪಠ್ಯದಿಂದ ಭವಿಷ್ಯವಾಣಿಗಳಿಗೆ ಹೋಗಲು ಟೋಕನೈಜರ್ ಮತ್ತು ಮಾದರಿಯನ್ನು ಒಟ್ಟಿಗೆ ಹೊಂದಿಸಿ. +- ಇನ್‌ಪುಟ್ ಐಡಿಗಳ ಮಿತಿಗಳನ್ನು ಕಲಿತಿದ್ದೀರಿ ಮತ್ತು ಗಮನ ಮುಖವಾಡಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ. +- ಬಹುಮುಖ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ ಟೋಕನೈಜರ್ ವಿಧಾನಗಳೊಂದಿಗೆ ಆಟವಾಡಿದೆ. + +ಇಂದಿನಿಂದ, ನೀವು 🤗 ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳ ಡಾಕ್ಸ್ ಅನ್ನು ಮುಕ್ತವಾಗಿ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ: ಶಬ್ದಕೋಶವು ಪರಿಚಿತವಾಗಿ ಧ್ವನಿಸುತ್ತದೆ ಮತ್ತು ನೀವು ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು ಬಳಸುವ ವಿಧಾನಗಳನ್ನು ನೀವು ಈಗಾಗಲೇ ನೋಡಿದ್ದೀರಿ. \ No newline at end of file diff --git a/chapters/my/chapter10/3.mdx b/chapters/my/chapter10/3.mdx index 56953c0f0..edea9c8fc 100644 --- a/chapters/my/chapter10/3.mdx +++ b/chapters/my/chapter10/3.mdx @@ -58,7 +58,9 @@ settings = rg.Settings( fields=[rg.TextField(name="text")], questions=[ rg.LabelQuestion( - name="label", title="စာသားကို အမျိုးအစားခွဲပါ:", labels=data.unique("label_text") + name="label", + title="စာသားကို အမျိုးအစားခွဲပါ:", + labels=data.unique("label_text"), ), rg.SpanQuestion( name="entities", diff --git a/chapters/my/chapter9/5.mdx b/chapters/my/chapter9/5.mdx index c3b17c295..e7ef3ffa2 100644 --- a/chapters/my/chapter9/5.mdx +++ b/chapters/my/chapter9/5.mdx @@ -53,7 +53,9 @@ Hub ဒါမှမဟုတ် Spaces ကနေ demos တွေကို load ```py gr.Interface.load( - "spaces/abidlabs/remove-bg", inputs="webcam", title="သင့် webcam နောက်ခံကို ဖယ်ရှားပါ!" + "spaces/abidlabs/remove-bg", + inputs="webcam", + title="သင့် webcam နောက်ခံကို ဖယ်ရှားပါ!", ).launch() ```