diff --git a/chapters/th/_toctree.yml b/chapters/th/_toctree.yml index 7638d0516..39b7a199d 100644 --- a/chapters/th/_toctree.yml +++ b/chapters/th/_toctree.yml @@ -11,4 +11,20 @@ - title: 3. การ fine-tune โมเดลที่ผ่านการเทรนมาแล้ว (pretrained model) sections: - local: chapter3/1 - title: บทนำ \ No newline at end of file + title: บทนำ + +- title: 4. การแบ่งปันโมเดลและ tokenizers + sections: + - local: chapter4/1 + title: The Hugging Face Hub + - local: chapter4/2 + title: การใช้งานโมเดลที่ผ่านการเทรนมาแล้ว (pretrained models) + - local: chapter4/3 + title: การแบ่งปันโมเดลที่ผ่านการเทรนมาแล้ว (pretrained models) + - local: chapter4/4 + title: การสร้างการ์ดโมเดล (model card) + - local: chapter4/5 + title: จบพาร์ทที่ 1! + - local: chapter4/6 + title: คำถามท้ายบท + quiz: 4 \ No newline at end of file diff --git a/chapters/th/chapter4/1.mdx b/chapters/th/chapter4/1.mdx new file mode 100644 index 000000000..c4a18cd1e --- /dev/null +++ b/chapters/th/chapter4/1.mdx @@ -0,0 +1,17 @@ +# The Hugging Face Hub + +[Hugging Face Hub](https://huggingface.co/) –- เว็บไซต์หลักของเรา –- เป็นแพลตฟอร์มกลางที่ทุกคนสามารถค้นหาโมเดลและชุดข้อมูลที่ล้ำสมัยที่สุด (state-of-the-art) และสามารถนำไปใช้งาน รวมถึงมีส่วนร่วมได้ เรามีโมเดลที่เปิดให้ใช้ได้อย่างเป็นสาธารณะที่หลากหลายมากกว่า 10,000 โมเดลให้เลือกใช้ ซึ่งในบทนี้เราจะมาเจาะลึกลงในเรื่องของโมเดล และเราจะพูดถึงชุดข้อมูลในบทที่ 5 + +โมเดลใน hub ของเราไม่ได้มีแค่ 🤗 Transformers หรือ NLP เท่านั้น ยังมีโมเดลจาก [Flair](https://github.com/flairNLP/flair) และ [AllenNLP](https://github.com/allenai/allennlp) สำหรับงาน NLP, [Asteroid](https://github.com/asteroid-team/asteroid) และ [pyannote](https://github.com/pyannote/pyannote-audio) สำหรับงานเสียง และ [timm](https://github.com/rwightman/pytorch-image-models) สำหรับงานภาพ และอื่นๆอีกมากมาย + +โมเดลเหล่านี้ถูกเก็บไว้ในรูปแบบของ Git repository ซึ่งนั่นสามารถทำให้เกิดการกำหนดเวอร์ชั่น (versioning) และการทำซ้ำได้ (reproducibility) การแบ่งปันโมเดลบน hub นั้นหมายถึงการปล่อยโมเดลสู่ชุมชน และทำให้ผู้คนสามารถเข้าถึงโมเดลได้อย่างง่ายดาย รวมถึงช่วยกำจัดความจำเป็นในการเทรนโมเดลด้วยตัวเอง และทำให้สามารถแบ่งปันและใช้งานได้ง่ายอีกด้วย + +มากไปกว่านั้นการแบ่งปันโมเดลบน hub ยังเป็นการปล่อย (deploy) API สำหรับใช้โมเดลนั้นในการทำนายผลด้วย ซึ่งทุกคนสามารถนำไปทดสอบใช้งานกับข้อมูลอินพุตที่กำหนดได้เอง (custom inputs) และใช้คู่กับเครื่องมือที่เหมาะสมได้โดยตรงจากหน้าเว็บไซต์ของโมเดลนั้นโดยไม่มีค่าใช้จ่าย + +ส่วนที่ดีที่สุดคือ การแบ่งปันและใช้โมเดลสาธารณะบน hub นั้นไม่มีค่าใช้จ่ายโดยสิ้นเชิง! ซึ่งเรามี [แผนแบบจ่าย](https://huggingface.co/pricing) ถ้าหากคุณต้องการจะแบ่งปันโมเดลอย่างเป็นส่วนตัว + +วีดีโอข้างล่างนี้แสดงวิธีการนำทางไปหน้าต่างๆใน hub + + + +ในส่วนนี้คุณจำเป็นที่จะต้องมีบัญชี huggingface.co เพื่อที่จะทำตาม เพราะเราจะมีการสร้างและจัดการ repositories บน Hugging Face Hub: [สร้างบัญชี](https://huggingface.co/join) diff --git a/chapters/th/chapter4/2.mdx b/chapters/th/chapter4/2.mdx new file mode 100644 index 000000000..22972bd41 --- /dev/null +++ b/chapters/th/chapter4/2.mdx @@ -0,0 +1,96 @@ + + +# การใช้งานโมเดลที่ผ่านการเทรนมาแล้ว (pretrained models) + +{#if fw === 'pt'} + + + +{:else} + + + +{/if} + +Model Hub ทำให้การเลือกใช้โมเดลที่เหมาะสมเป็นเรื่องง่ายขนาดที่ว่า การใช้งานมันคู่กับ library ปลายน้ำสามารถเสร็จได้ในการใช้โค้ดเพียงไม่กี่บรรทัดเท่านั้น มาดูวิธีใช้โมเดลพวกนี้และการให้ความช่วยเหลือกับชุมชนกันดีกว่า + +สมมุติว่าเรากำลังมองหาโมเดลภาษาฝรั่งเศสที่สามารถเติมคำที่หายไปได้ (mask filling) + +
+Selecting the Camembert model. +
+ +เราเลือก `camembert-base` checkpoint มาลองใช้ ตัวระบุ `camembert-base` คือทั้งหมดที่เราต้องการในการเริ่มใช้งาน! อย่างที่คุณได้เห็นไปแล้วในบทก่อนหน้านี้ เราสามารถเรียกใช้งานมันได้ด้วยคำสั่ง `pipeline()`: + +```py +from transformers import pipeline + +camembert_fill_mask = pipeline("fill-mask", model="camembert-base") +results = camembert_fill_mask("Le camembert est :)") +``` + +```python out +[ + {'sequence': 'Le camembert est délicieux :)', 'score': 0.49091005325317383, 'token': 7200, 'token_str': 'délicieux'}, + {'sequence': 'Le camembert est excellent :)', 'score': 0.1055697426199913, 'token': 2183, 'token_str': 'excellent'}, + {'sequence': 'Le camembert est succulent :)', 'score': 0.03453313186764717, 'token': 26202, 'token_str': 'succulent'}, + {'sequence': 'Le camembert est meilleur :)', 'score': 0.0330314114689827, 'token': 528, 'token_str': 'meilleur'}, + {'sequence': 'Le camembert est parfait :)', 'score': 0.03007650189101696, 'token': 1654, 'token_str': 'parfait'} +] +``` + +อย่างที่คุณเห็น การโหลดโมเดลใน pipeline นั้นง่ายมากๆ สิ่งเดียวที่ควรระวังคือ checkpoint ที่คุณเลือกนั้นควรเหมาะสมกับประเภทของงานที่คุณจะทำ อย่างเช่น ในงานนี้เราโหลด `camembert-base` checkpoint ใน `fill-mask` pipeline ซึ่งเหมาะกับงานที่เราจะใช้อย่างแน่นอน แต่ถ้าเราโหลด checkpoint นี้ใน `text-classification` pipeline ผลลัพธ์จะไม่สมเหตุสมผล เพราะหัวข้อของ `camembert-base` ไม่เหมาะสมกับงานประเภทนี้! เราแนะนำให้ใช้ตัวเลือกประเภทงาน (task selector) ในอินเตอร์เฟซของ Hugging Face Hub เพื่อเลือก checkpoints ที่เหมาะสม + +
+The task selector on the web interface. +
+ +คุณสามารถเรียกใช้ checkpoint โดยการใช้สถาปัตยกรรมโมเดล (model architecture) ได้โดยตรงด้วย: + +{#if fw === 'pt'} +```py +from transformers import CamembertTokenizer, CamembertForMaskedLM + +tokenizer = CamembertTokenizer.from_pretrained("camembert-base") +model = CamembertForMaskedLM.from_pretrained("camembert-base") +``` + +อย่างไรก็ตาม เราแนะนำให้ใช้ [คลาส `Auto*`](https://huggingface.co/transformers/model_doc/auto.html?highlight=auto#auto-classes) แทน เพราะว่ามันเป็นคลาสที่สามารถใช้ได้กับสถาปัตยกรรมหลายประเภท (design architecture-agnostic) ในขณะที่โค้ดก่อนหน้านี้จำกัดผู้ใช้อยู่กับ checkpoints ที่สามารถโหลดได้เฉพาะกับสถาปัตยกรรมแบบ CamemBERT การใช้คลาส `Auto*` นั้นทำให้การเปลี่ยน checkpoints เป็นเรื่องง่าย: + +```py +from transformers import AutoTokenizer, AutoModelForMaskedLM + +tokenizer = AutoTokenizer.from_pretrained("camembert-base") +model = AutoModelForMaskedLM.from_pretrained("camembert-base") +``` +{:else} +```py +from transformers import CamembertTokenizer, TFCamembertForMaskedLM + +tokenizer = CamembertTokenizer.from_pretrained("camembert-base") +model = TFCamembertForMaskedLM.from_pretrained("camembert-base") +``` + +อย่างไรก็ตาม เราแนะนำให้ใช้ [คลาส `TFAuto*`](https://huggingface.co/transformers/model_doc/auto.html?highlight=auto#auto-classes) แทน เพราะว่ามันเป็นคลาสที่สามารถใช้ได้กับสถาปัตยกรรมหลายประเภท (design architecture-agnostic) ในขณะที่โค้ดก่อนหน้านี้จำกัดผู้ใช้อยู่กับ checkpoints ที่สามารถโหลดได้เฉพาะกับสถาปัตยกรรมแบบ CamemBERT การใช้คลาส `TFAuto*` นั้นทำให้การเปลี่ยน checkpoints เป็นเรื่องง่าย: + +```py +from transformers import AutoTokenizer, TFAutoModelForMaskedLM + +tokenizer = AutoTokenizer.from_pretrained("camembert-base") +model = TFAutoModelForMaskedLM.from_pretrained("camembert-base") +``` +{/if} + + +เมื่อมีการใช้งานโมเดลที่ผ่านการเทรนมาแล้ว (pretrained model) คุณควรตรวจสอบให้มั่นใจว่ามันถูกเทรนมาอย่างไร กับชุดข้อมูลไหน ขีดจำกัด (limits) และความลำเอียง (biases) คืออะไร ซึ่งข้อมูลทั้งหมดนี้ควรถูกระบุอยู่ในการ์ดโมเดล (model card) + diff --git a/chapters/th/chapter4/3.mdx b/chapters/th/chapter4/3.mdx new file mode 100644 index 000000000..b63c6e6c4 --- /dev/null +++ b/chapters/th/chapter4/3.mdx @@ -0,0 +1,641 @@ + + +# การแบ่งปันโมเดลที่ผ่านการเทรนมาแล้ว (pretrained models) + +{#if fw === 'pt'} + + + +{:else} + + + +{/if} + +ในขั้นตอนข้างล่างต่อไปนี้ เราจะมาดูวิธีที่ง่ายที่สุดในการแบ่งปันโมเดลที่ผ่านการเทรนมาแล้วบน 🤗 Hub มีเครื่องมือและสิ่งอำนวยความสะดวกมากมายที่ทำให้การแบ่งปันและอัพเดตโมเดลโดยตรงบน Hub เป็นเรื่องง่าย ซึ่งนั่นคือสิ่งที่เราจะมาสำรวจกันต่อจากนี้ + + + +เราส่งเสริมให้ผู้ใช้ทุกคนที่เทรนโมเดลช่วยมีส่วนร่วมโดยการแบ่งปันโมเดลเหล่านั้นให้กับชุมชน การแบ่งปันโมเดลนั้นสามารถช่วยเหลือผู้อื่นได้ ช่วยลดเวลาและทรัพยากรในการประมวลผล และช่วยให้เข้าถึงไฟล์ผลลัพธ์จากการเทรน (artifacts) ที่เป็นประโยชน์ได้ แม้ว่าจะเป็นโมเดลที่ถูกเทรนมากับชุดข้อมูลที่เฉพาะเจาะจงมากก็ตาม ในทางเดียวกันนั้นคุณก็ได้รับประโยชน์จากงานที่คนอื่นได้ทำเช่นกัน! + +มี 3 วิธีที่สามารถใช้สร้าง model repositories ใหม่ได้: + +- ใช้ `push_to_hub` API +- ใช้ `huggingface_hub` Python library +- ใช้ web interface + +เมื่อคุณได้สร้าง repository แล้ว คุณสามารถอัพโหลดไฟล์ต่างๆเข้าไปได้ผ่าน git และ git-lfs ในส่วนถัดไปเราจะพาคุณมาดูขั้นตอนการสร้าง model repositories และการอัพโหลดไฟล์ต่างๆเข้าไป + + +## ใช้ `push_to_hub` API + +{#if fw === 'pt'} + + + +{:else} + + + +{/if} + +วิธีที่ง่ายที่สุดในการอัพโหลดไฟล์ขึ้นไปสู่ Hub คือการใช้ `push_to_hub` API + +ก่อนจะไปกันต่อ คุณจะต้องสร้างโทเค็นสำหรับรับรองความน่าเชื่อถือ (authentication token) เพื่อให้ `huggingface_hub` API รู้ว่าคุณคือใครและคุณมีสิทธิ์ในการเขียน (write access) ใน namespaces อะไรบ้าง ในตอนนี้ให้คุณทำให้มั่นใจว่าคุณอยู่ใน environment ที่คุณได้ทำการติดตั้ง `transformers` เอาไว้แล้ว (ดู [ติดตั้งโปรแกรม](/course/chapter0)) ถ้าคุณกำลังอยู่ใน notebook คุณสามารถใช้งานคำสั่งต่อไปนี้ในการเข้าสู่ระบบได้เลย: + +```python +from huggingface_hub import notebook_login + +notebook_login() +``` + +สำหรับใน terminal คนสามารถรัน: + +```bash +huggingface-cli login +``` + +ในทั้งสองกรณี คุณควรจะถูกให้กรอก username และ password ซึ่งเป็นชุดเดียวกันกับที่คุณใช้ในการ login เข้าสู่ Hub ถ้าหากคุณยังไม่มีโปรไฟล์ Hub คุณสามารถสร้างได้ [ที่นี่](https://huggingface.co/join) + +เยี่ยม! ตอนนี้คุณมี authentication token เก็บเอาไว้ใน cache folder ของคุณแล้ว มาเริ่มสร้าง repositories กันเถอะ! + +{#if fw === 'pt'} + +ถ้าคุณเคยได้ลองใช้งาน `Trainer` API ในการเทรนโมเดลมาบ้างแล้ว วิธีที่ง่ายที่สุดที่จะอัพโหลดขึ้นไปสู่ Hub คือการตั้ง `push_to_hub=True` ตอนที่คุณกำหนด `TrainingArguments`: + +```py +from transformers import TrainingArguments + +training_args = TrainingArguments( + "bert-finetuned-mrpc", save_strategy="epoch", push_to_hub=True +) +``` + +เมื่อคุณเรียกใช้ `trainer.train()` ตัว `Trainer` จะทำการอัพโหลดโมเดลของคุณขึ้นสู่ Hub ในทุกๆครั้งที่มันถูกบันทึก (ในที่นี้คือ ทุกๆรอบการเทรน (epoch)) ใน repository และ namespace ของคุณ repository นั้นจะถูกตั้งชื่อให้เหมือนกับโฟลเดอร์ output ที่คุณเลือก (ในที่นี้คือ `bert-finetuned-mrpc`) แต่คุณสามารถเลือกชื่ออื่นได้โดยการใช้ `hub_model_id = "ชื่ออื่น"` + +สำหรับการอัพโหลดโมเดลของคุณเข้าสู่องค์กรที่คุณเป็นสมาชิกนั้น คุณสามารถทำได้โดย เพียงแค่ผ่านตัวแปล `hub_model_id = "องค์กร_ของคุณ/ชื่อ_repo_ของคุณ"` เข้าไป + +เมื่อการเทรนของคุณเสร็จสิ้น คุณควรที่จะใช้ `trainer.push_to_hub()` อีกครั้งเป็นครั้งสุดท้าย เพื่ออัพโหลดโมเดลเวอร์ชั่นล่าสุดของคุณ มันจะสร้างการ์ดโมเดล (model card) ที่มีข้อมูลเมตา (metadata) ที่เกี่ยวข้อง เช่น รายงาน hyperparameters ที่ใช้ และผลลัพธ์ของการประเมินผล (evaluation result) ให้คุณด้วย! ต่อไปนี้เป็นตัวอย่างของเนื้อหาที่คุณเจอได้ในการ์ดโมเดล: + +
+ An example of an auto-generated model card. +
+ +{:else} + +ถ้าคุณใช้ Keras ในเทรนโมเดล วิธีที่ง่ายที่สุดที่จะอัพโหลดมันขึ้นสู่ Hub คือการผ่านค่าตัวแปร `PushToHubCallback` เข้าไป เมื่อคุณเรียกใช้ `model.fit()`: + +```py +from transformers import PushToHubCallback + +callback = PushToHubCallback( + "bert-finetuned-mrpc", save_strategy="epoch", tokenizer=tokenizer +) +``` + +ต่อจากนั้นคุณควรเพิ่ม `callbacks=[callback]` ไปในตอนที่คุณเรียก `model.fit()` ตัว callback นี้จะทำการอัพโหลดโมเดลของคุณขึ้นสู่ Hub ในทุกๆครั้งที่มันถูกบันทึก (ในที่นี้คือ ทุกๆรอบการเทรน (epoch)) ใน repository และ namespace ของคุณ repository นั้นจะถูกตั้งชื่อให้เหมือนกับโฟลเดอร์ output ที่คุณเลือก (ในที่นี้คือ `bert-finetuned-mrpc`) แต่คุณสามารถเลือกชื่ออื่นได้โดยการใช้ `hub_model_id = "ชื่ออื่น"` + +สำหรับการอัพโหลดโมเดลของคุณเข้าสู่องค์กรที่คุณเป็นสมาชิกนั้น คุณสามารถทำได้โดย เพียงแค่ผ่านตัวแปล `hub_model_id = "องค์กร_ของคุณ/ชื่อ_repo_ของคุณ"` เข้าไป + +{/if} + +ในระดับล่างลงไปนั้น การเข้าถึง Model Hub สามารถทำได้โดยตรงจาก objects ประเภท models, tokenizers และconfiguration ผ่านคำสั่ง `push_to_hub()` คำสั่งนี้จะจัดการทั้งการสร้าง repository และการดันไฟล์โมเดลและ tokenizer ขึ้นสู่ repository โดยตรง ไม่มีความจำเป็นที่จะต้องทำอะไรด้วยตนเองเลย ไม่เหมือนกับ API ที่เราจะได้เห็นข้างล่างนี้ + +เพื่อให้เห็นภาพมากขึ้นว่ามันทำงานอย่างไร เรามาเริ่มสร้างโมเดลและ tokenizer ตัวแรกกันเถอะ: + +{#if fw === 'pt'} +```py +from transformers import AutoModelForMaskedLM, AutoTokenizer + +checkpoint = "camembert-base" + +model = AutoModelForMaskedLM.from_pretrained(checkpoint) +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +``` +{:else} +```py +from transformers import TFAutoModelForMaskedLM, AutoTokenizer + +checkpoint = "camembert-base" + +model = TFAutoModelForMaskedLM.from_pretrained(checkpoint) +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +``` +{/if} + +ถึงจุดนี้คุณสามารถทำอะไรก็ได้กับมันตามที่คุณต้องการ ไม่ว่าจะเป็นการเพิ่ม tokens ไปใน tokenizer, การเทรนโมเดล, การ fine-tune โมเดล หลังจากที่คุณพอใจกับผลลัพธ์ของโมเดล, weights และ tokenizer แล้ว คุณสามารถเรียกใช้คำสั่ง `push_to_hub()` ที่มีอยู่ในตัว `model` object ได้โดยตรง + +```py +model.push_to_hub("dummy-model") +``` + +ขั้นตอนนี้จะสร้าง repository ใหม่ชื่อ `dummy-model` ในโปรไฟล์ของคุณ และเติมมันด้วยไฟล์โมเดลต่างๆของคุณ +ทำแบบเดียวกันนี้กับ tokenizer นั่นจะทำให้ไฟล์ทั้งหมดอยู่บน repository นี้: + +```py +tokenizer.push_to_hub("dummy-model") +``` + +ถ้าคุณสังกัดองค์กร คุณสามารถระบุชื่อขององค์กรใน `organization` argument เพื่ออัพโหลดเข้าไปใน namespace ขององค์กร: + +```py +tokenizer.push_to_hub("dummy-model", organization="huggingface") +``` + +ถ้าคุณต้องการที่จะใช้งานโทเค็นของ Hugging Face โดยเฉพาะเจาะจง คุณสามารถระบุมันไปในคำสั่ง `push_to_hub()` ได้เช่นกัน: + +```py +tokenizer.push_to_hub("dummy-model", organization="huggingface", use_auth_token="") +``` + +ในตอนนี้ให้คุณมุ่งหน้าไปที่ Model Hub เพื่อหาโมเดลที่คุณเพิ่งได้อัพโหลดไป: *https://huggingface.co/ชื่อ-user-หรือ-organization/dummy-model* + +คลิกไปที่แท็บ "Files and versions" และคุณควรจะเห็นไฟล์แบบในภาพข้างล่างนี้: + +{#if fw === 'pt'} +
+Dummy model containing both the tokenizer and model files. +
+{:else} +
+Dummy model containing both the tokenizer and model files. +
+{/if} + + + +✏️ **ทดลองใช้ได้เลย!** นำโมเดลและ tokenizer ที่เกี่ยวข้องกับ `bert-base-cased` checkpoint และอัพโหลดขึ้นไปบน repo ใน namespace ของคุณด้วยคำสั่ง `push_to_hub()` จากนั้นลองตรวจสอบดูว่า repo ปรากฏออกมาในรูปแบบที่สมควรจะเป็นบนหน้าของคุณ ก่อนที่จะลบมันออกไป + + + +อย่างที่คุณได้เห็น คำสั่ง `push_to_hub()` สามารถรับ arguments ได้มากมาย ทำให้สามารถอัพไฟล์ไปยัง repository หรือ namespace ขององค์กรแบบเจาะจง หรือใช้งานโทเค็น API ที่ต่างกันได้ เราแนะนำให้คุณลองเปิดดูรายละเอียดของคำสั่งนี้ได้โดยตรงที่ [🤗 Transformers documentation](https://huggingface.co/transformers/model_sharing.html) เพื่อจะได้เข้าใจมากขึ้นว่าคำสั่งนี้สามารถทำอะไรได้บ้าง + +คำสั่ง `push_to_hub()` ได้รับการหนุนหลังโดย [`huggingface_hub`](https://github.com/huggingface/huggingface_hub) Python package ซึ่งให้ API โดยตรงไปสู่ Hugging Face Hub มันถูกบูรณาการเข้ากับ 🤗 Transformers และ machine learning libraries อื่นๆอีกหลายอันด้วย เช่น [`allenlp`](https://github.com/allenai/allennlp) แม้ว่าเราเจาะจงแค่การบูรณาการกับ 🤗 Transformers ในบทนี้ แต่การบูรณาการกับการใช้โค้ดของคุณเองหรือ library อื่นนั้นเรียบง่ายมาก + +ข้ามไปส่วนสุดท้ายเพื่อดูวิธีการอัพโหลดไฟล์ขึ้นไปบน repository ที่คุณสร้างขึ้นมาใหม่! + +## ใช้ `huggingface_hub` Python library + +`huggingface_hub` Python library คือ package หนึ่งที่บรรจุชุดเครื่องมือสำหรับ hub ของโมเดลและชุดข้อมูล มันมีคำสั่งและคลาสที่เรียบง่ายไว้สำหรับงานทั่วไปอย่าง +การดึงข้อมูลเกี่ยวกับ repositories บน hub และการจัดการมัน มันมี API ง่ายๆที่สามารถทำงานบน git เพื่อที่จะจัดการเนื้อหาของ repositories เหล่านั้นและบูรณาการเข้ากับ Hub +ในงานโปรเจคและ libraries ของคุณ + +คล้ายคลึงกับการใช้ `push_to_hub` API คุณจำเป็นจะต้องมีโทเค็น API เก็บไว้ใน cache ของคุณ เพื่อที่จะมีมันได้ คุณจะต้องใช้คำสั่ง `login` จาก CLI อย่างที่เราเคยกล่าวถึงไปแล้วในส่วนก่อนหน้านี้ (ย้ำอีกครั้ง ทำให้มั่นใจว่าคุณใส่เครื่องหมาย `!` ไว้ข้างหน้าคำสั่งถ้าคุณกำลังรันใน Google Colab): + +```bash +huggingface-cli login +``` + +`huggingface_hub` package บรรจุคำสั่งและคลาสซึ่งเป็นประโยชน์สำหรับจุดประสงค์ของเราเอาไว้หลายอย่าง อย่างแรก มีคำสั่งจำนวนหนึ่งที่ใช้จัดการกับการสร้าง, การลบ และการจัดการอื่นๆของ repository + +```python no-format +from huggingface_hub import ( + # User management + login, + logout, + whoami, + + # Repository creation and management + create_repo, + delete_repo, + update_repo_visibility, + + # And some methods to retrieve/change information about the content + list_models, + list_datasets, + list_metrics, + list_repo_files, + upload_file, + delete_file, +) +``` + + +มากไปกว่านั้น มันยังมี `Repository` class ที่ทรงพลังมากๆไว้จัดการกับ local repository เราจะมาสำรวจคำสั่งเหล่านี้และคลาสนั้นกันในอีกส่วนไม่ไกลข้างหน้า เพื่อที่จะได้เข้าใจวิธีการนำมันมาใช้ + +คำสั่ง `create_repo` สามารถใช้ในการสร้าง repository ใหม่บน hub ได้ + +```py +from huggingface_hub import create_repo + +create_repo("dummy-model") +``` + +โค้ดนี้จะสร้าง repository ชื่อ `dummy-model` ใน namespace ของคุณ ถ้าคนชอบ คุณสามารถระบุอย่างเจาะจงไปได้ว่า repository นี้เป็นขององค์กรไหน โดยการใช้ `organization` argument: + +```py +from huggingface_hub import create_repo + +create_repo("dummy-model", organization="huggingface") +``` + +โค้ดนี้จะสร้าง repository ชื่อ `dummy-model` ใน namespace ของ `huggingface` สมมุติว่าคุณเป็นคนขององค์กรนั้น +Arguments อื่นที่อาจจะเป็นประโยชน์: + +- `private` ใช้ในการระบุว่าคนอื่นควรเห็น repository นี้ได้หรือไม่ +- `token` ใช้ในกรณีที่คุณอยากจะแทนที่โทเค็นที่ถูกเก็บเอาไว้ใน cache ของคุณด้วยอีกโทเค็นที่ให้ไว้ +- `repo_type` ใช้ในกรณีที่คุณอยากจะสร้าง `dataset` หรือ `space` แทนที่จะเป็นโมเดล ค่าที่รับได้คือ `"dataset"` และ `"space"` + +เมื่อ repository ถูกสร้างขึ้นมาแล้ว เราสามารถเพิ่มไฟล์ไปในนั้นได้! ข้ามไปส่วนถัดไปเพื่อดูสามวิธีในการทำสิ่งนี้ + + +## ใช้ web interface + +web interface บรรจุเครื่องมือมากมายที่ใช้จัดการ repositories โดยตรงใน Hub ด้วยการใช้งาน web interface คุณสามารถสร้าง repositories, เพิ่มไฟล์ (รวมถึงไฟล์ขนาดใหญ่ด้วย!), สำรวจโมเดลต่างๆ, แสดงผลความแตกต่าง และอื่นๆอีกมากมายได้อย่างง่ายดาย + +สร้าง repository ใหม่ได้โดยการไปที่ [huggingface.co/new](https://huggingface.co/new): + +
+Page showcasing the model used for the creation of a new model repository. +
+ +ขั้นแรก ระบุเจ้าของของ repository ซึ่งสามารถเป็นคุณเองหรือองค์กรใดๆที่คุณเกี่ยวข้องด้วย ถ้าคุณเลือกองค์กร โมเดลจะถูกนำไปขึ้นบนหน้าขององค์กรด้วย และสมาชิกทุกคนขององค์กรนั้นจะมีสิทธิ์ในการมีส่วนร่วมกับ repository นี้ + +ถัดไป ใส่ชื่อโมเดลของคุณ ซึ่งจะเหมือนกับชื่อของ repository ก็ได้ และสุดท้าย คุณสามารถระบุได้ว่าคุณต้องการให้โมเดลของคุณเป็นสาธารณะหรือส่วนบุคคล โมเดลส่วนบุคคลนั้นจะถูกซ่อนจากมุมมองสาธารณะ + +หลังจากที่คุณสร้าง model repository ของคุณแล้ว คุณควรจะเห็นหน้าแบบนี้: + +
+An empty model page after creating a new repository. +
+ +นี่คือที่ที่โมเดลของคุณจะถูก host เอาไว้ สำหรับการเริ่มปรับแต่งเพิ่มเติมนั้น คุณสามารถเพิ่มไฟล์ README ได้โดยตรงจาก web interface + +
+The README file showing the Markdown capabilities. +
+ +ไฟล์ README อยู่ในรูปแบบของ Markdown — สามารถปรับแต่งมันแบบจัดเต็มได้เลย! ในส่วนที่สามของบทนี้ถูกอุทิศให้กับการสร้างการ์ดโมเดล (model card) ซึ่งนี่เป็นส่วนที่สำคัญเป็นอันดับหนึ่งในการสร้างคุณค่าให้โมเดลของคุณ เพราะว่ามันจะเป็นสิ่งที่ใช้บอกคนอื่นว่าโมเดลของคุณทำอะไรได้บ้าง + +ถ้าคุณดูที่แท็บ "Files and versions" คุณจะเห็นว่ามันยังไม่มีไฟล์อะไรมากมายเลย — แค่ไฟล์ *README.md* ที่คุณเพิ่งได้สร้างและไฟล์ *.gitattributes* สำหรับไว้ติดตามไฟล์ขนาดใหญ่ + +
+The 'Files and versions' tab only shows the .gitattributes and README.md files. +
+ +ต่อไปเราจะมาดูวิธีการเพิ่มไฟล์ใหม่กัน + +## การอัพโหลดไฟล์โมเดลต่างๆ + +ระบบที่ใช้จัดการไฟล์บน Hugging Face Hub มีพื้นฐานมาจาก git สำหรับไฟล์ทั่วไป และ git-lfs (ย่อมาจาก [Git Large File Storage](https://git-lfs.github.com/)) สำหรับไฟล์ที่ใหญ่ขึ้น + +ในส่วนถัดไปนี้ เราจะพามาดูสามวิธีในการอัพโหลดไฟล์ต่างๆไปบน Hub: ผ่าน `huggingface_hub` และ ผ่านคำสั่ง git ต่างๆ + +### แนวทางแบบใช้ `upload_file` + +การใช้ `upload_file` ไม่จำเป็นต้องมี git และ git-lfs ติดตั้งอยู่บนระบบของคุณ มันดันไฟล์โดยตรงไปสู่ 🤗 Hub โดยใช้ HTTP POST requests ข้อจำกัดของแนวทางนี้คือมันไม่สามารถรองรับไฟล์ที่มีขนาดมากกว่า 5GB ได้ +ถ้าไฟล์ของคุณมีขนาดใหญ่กว่า 5GB โปรดทำตามอีกสองขั้นตอนที่ระบุรายละเอียดไว้ด้านล่าง + +API สามารถถูกใช้แบบนี้ได้: + +```py +from huggingface_hub import upload_file + +upload_file( + "/config.json", + path_in_repo="config.json", + repo_id="/dummy-model", +) +``` + +โค้ดนี้จะทำการอัพโหลดไฟล์ `config.json` ที่อยู่ใน `` ไปสู่รากของ repository โดยใช้ชื่อ `config.json` ไปสู่ `dummy-model` repository +Arguments อื่นที่อาจจะเป็นประโยชน์: + +- `token` ใช้ในกรณีที่คุณอยากจะแทนที่โทเค็นที่ถูกเก็บเอาไว้ใน cache ของคุณด้วยอีกโทเค็นที่ให้ไว้ +- `repo_type` ใช้ในกรณีที่คุณอยากจะสร้าง `dataset` หรือ `space` แทนที่จะเป็นโมเดล ค่าที่รับได้คือ `"dataset"` และ `"space"` + + +### คลาส `Repository` + +คลาส `Repository` จัดการ local repository ในลักษณะคล้าย git มันเอาปัญหาส่วนมากที่ผู้คนมักเจอเวลาใช้ git ออกเพื่อจัดสรรทุกฟีเจอร์ทุกอย่างที่เราจำเป็นต้องใช้ + +การใช้คลาสนี้จำเป็นต้องติดตั้ง git และ git-lfs ดังนั้นคุณควรทำให้มั่นใจว่าคุณได้ติดตั้ง git-lfs แล้ว (ดู [ที่นี่](https://git-lfs.github.com/) สำหรับขั้นตอนการติดตั้ง) และตั้งค่าให้เสร็จก่อนที่คุณจะเริ่มไปต่อ + +เพื่อที่จะเริ่มเล่นกับ repository ที่เราเพิ่งจะได้สร้างกัน เราสามารถเริ่มตั้งต้นมันไปใน local folder ได้โดยการโคลน (clone) remote repository: + +```py +from huggingface_hub import Repository + +repo = Repository("", clone_from="/dummy-model") +``` + +โค้ดนี้จะสร้างโฟลเดอร์ `` ในไดเรกทอรีที่คุณทำงานอยู่ (working directory) โฟลเดอร์นี้เก็บไฟล์ `.gitattributes` เอาไว้เพียงไฟล์เดียวเพราะว่ามันเป็นไฟล์เดียวที่จะถูกสร้างเมื่อมีการสร้าง repository ตั้งต้นด้วยคำสั่ง `create_repo` + +จากจุดนี้เป็นต้นไป เราสามารถใช้คำสั่ง git แบบดั่งเดิมต่างๆได้: + +```py +repo.git_pull() +repo.git_add() +repo.git_commit() +repo.git_push() +repo.git_tag() +``` + +และอื่นๆอีก! เราแนะนำให้ลองไปดูที่หนังสืออ้างอิง (documentation) ของ `Repository` ซึ่งเข้าถึงได้จาก [ที่นี่](https://github.com/huggingface/huggingface_hub/tree/main/src/huggingface_hub#advanced-programmatic-repository-management) สำหรับภาพรวมของคำสั่งทั้งหมดที่ใช้ได้ + +ณ ปัจจุบัน เรามีโมเดลและ tokenizer ซึ่งเราต้องการที่จะดันขึ้นสู่ hub แล้ว เราได้โคลน repository มาอย่างเสร็จสมบูรณ์ ดังนั้นเราสามารถเก็บไฟล์ต่างๆไว้ใน repository นั้นได้แล้ว + +อันดับแรกเราต้องทำให้มั่นใจว่า local clone ของเรานั้นเป็นปัจจุบัน ซึ่งทำได้โดยการดึง (pull) การเปลี่ยนแปลงใหม่ล่าสุดเข้ามา: + +```py +repo.git_pull() +``` + +เมื่อโค้ดทำงานเสร็จแล้ว เราเก็บไฟล์โมเดลและ tokenizer: + +```py +model.save_pretrained("") +tokenizer.save_pretrained("") +``` + +ที่ `` ตอนนี้มีไฟล์โมเดลและ tokenizer ทั้งหมดแล้ว เราจะทำตาม workflow ของ git ทั่วไปโดยการ เพิ่มไฟล์ไปยัง staging area, ทำการ commit และดัน (push) ไฟล์เหล่านั้นสู่ hub: + +```py +repo.git_add() +repo.git_commit("Add model and tokenizer files") +repo.git_push() +``` + +ขอแสดงความยินดีด้วย! คุณเพิ่งได้ทำการดันไฟล์ชุดแรกของคุณสู่ hub + +### แนวทางแบบใช้ git + +แนวทางนี้เป็นแนวทางที่ตรงๆมากสำหรับทำการอัพโหลดไฟล์ นั่นคือเราจะใช้ git และ git-lfs โดยตรง ส่วนที่ยากส่วนใหญ่ถูกในออกไปในแนวทางก่อนๆ แต่มันมีข้อแม้บางอย่างกับขั้นตอนแต่ไปนี้ ดังนั้นเราจะทำตามการใช้งานแบบที่ซับซ้อนขึ้นกว่าปกติ + +การใช้งานต่อจากนี้จำเป็นต้องติดตั้ง git และ git-lfs ดังนั้นคุณควรทำให้มั่นใจว่าคุณได้ติดตั้ง git-lfs แล้ว (ดู [ที่นี่](https://git-lfs.github.com/) สำหรับขั้นตอนการติดตั้ง) และตั้งค่าให้เสร็จก่อนที่คุณจะเริ่มไปต่อ + +เริ่มแรกโดยการเริ่มต้นสร้าง git-lfs: + +```bash +git lfs install +``` + +```bash +Updated git hooks. +Git LFS initialized. +``` + +เมื่อโค้ดทำงานเสร็จแล้ว ขั้นตอนแรกคือการโคลน model repository ของคุณ: + +```bash +git clone https://huggingface.co// +``` + +username ของฉันคือ `lysandre` และฉันใช้ `dummy` เป็นชื่อโมเดล ดังนั้นสำหรับฉันแล้ว คำสั่งจะมีหน้าตาประมาณแบบนี้: + +``` +git clone https://huggingface.co/lysandre/dummy +``` + +ตอนนี้ฉันมีโฟลเดอร์ชื่อ *dummy* ในไดเรกทอรีที่ฉันทำงานอยู่ (working directory) ฉันสามารถ `cd` เข้าไปในโฟลเดอร์และดูว่ามีอะไรข้างในบ้าง: + +```bash +cd dummy && ls +``` + +```bash +README.md +``` + +ถ้าคุณสร้าง repository ด้วยการใช้คำสั่ง `create_repo` ของ Hugging Face Hub โฟลเดอร์นี้ควรจะมีไฟล์ `.gitattributes` ถูกซ่อนอยู่ด้วย ถ้าคุณทำตามขั้นตอนในส่วนก่อนหน้านี้ในการสร้าง repository โดยใช้ web interface ในโฟลเดอร์นี้ควรจะมี *README.md* หนึ่งไฟล์มาพร้อมกับไฟล์ `.gitattributes` ที่ถูกซ่อนอยู่ อย่างที่แสดงให้เห็นนี้ + +การเพิ่มไฟล์หนึ่งไฟล์ที่มีขนาดปกติ เช่น ไฟล์สำหรับกำหนดค่า (configuration file), ไฟล์สำหรับเก็บคำศัพท์ (vocabulary file) หรือโดยง่ายๆแล้วไฟล์อะไรก็ตามที่มีขนาดน้อยกว่าสองสาม megabytes สามารถทำได้ด้วยการทำแบบที่ทำปกติกับระบบที่พึ่งพา git อย่างไรก็ตามไฟล์ที่ใหญ่กว่านั้นจะต้องถูกลงทะเบียนผ่าน git-lfs เพื่อที่จะดันไฟล์เหล่านั้นขึ้นสู่ *huggingface.co* ได้ + +กลับไปหา Python กันสักหน่อยเพื่อจะสร้างโมเดลและ tokenizer ที่เราต้องการจะ commit ไปสู่ repository จำลองของเรา + +{#if fw === 'pt'} +```py +from transformers import AutoModelForMaskedLM, AutoTokenizer + +checkpoint = "camembert-base" + +model = AutoModelForMaskedLM.from_pretrained(checkpoint) +tokenizer = AutoTokenizer.from_pretrained(checkpoint) + +# Do whatever with the model, train it, fine-tune it... + +model.save_pretrained("") +tokenizer.save_pretrained("") +``` +{:else} +```py +from transformers import TFAutoModelForMaskedLM, AutoTokenizer + +checkpoint = "camembert-base" + +model = TFAutoModelForMaskedLM.from_pretrained(checkpoint) +tokenizer = AutoTokenizer.from_pretrained(checkpoint) + +# Do whatever with the model, train it, fine-tune it... + +model.save_pretrained("") +tokenizer.save_pretrained("") +``` +{/if} + +ถึงตอนนี้เราได้ทำการบันทึกไฟล์จากโมเดลและ tokenizer บางส่วนแล้ว ลองไปดูโฟลเดอร์ *dummy* อีกรอบกันเถอะ: + +```bash +ls +``` + +{#if fw === 'pt'} +```bash +config.json pytorch_model.bin README.md sentencepiece.bpe.model special_tokens_map.json tokenizer_config.json tokenizer.json +``` + +ถ้าคุณดูที่ขนาดของไฟล์ (อย่างเช่น ใช้คำสั่ง `ls -lh`) คุณควรจะเห็นได้ว่าไฟล์ model state dict (*pytorch_model.bin*) มีขนาดที่โดดมาก นั่นคือมากกว่า 400 MB + +{:else} +```bash +config.json README.md sentencepiece.bpe.model special_tokens_map.json tf_model.h5 tokenizer_config.json tokenizer.json +``` + +ถ้าคุณดูที่ขนาดของไฟล์ (อย่างเช่น ใช้คำสั่ง `ls -lh`) คุณควรจะเห็นได้ว่าไฟล์ model state dict (*t5_model.h5*) มีขนาดที่โดดมาก นั่นคือมากกว่า 400 MB + +{/if} + + +✏️ ตอนที่สร้าง repository จาก web interface ไฟล์ *.gitattributes* ถูกตั้งค่าอย่างอัตโนมัติเพื่อให้พิจารณาไฟล์บางประเภท เช่น *.bin* และ *.h5* ว่าเป็นไฟล์ขนาดใหญ่ และ git-lfs จะติดตามไฟล์เหล่านั้นโดยคุณไม่จำเป็นต้องตั้งค่าอะไรเลย + + +ต่อไปเราจะทำต่อโดยการทำแบบที่เราทำกับ Git repositories ดั้งเดิม เราสามารถเพิ่มไฟล์ทั้งหมดไปยัง staging environment ของ Git ได้ด้วยการใช้คำสั่ง `git add`: + +```bash +git add . +``` + +เราสามารถดูได้ว่าไฟล์ที่อยู่ในสถานะ staged มีอะไรบ้าง: + +```bash +git status +``` + +{#if fw === 'pt'} +```bash +On branch main +Your branch is up to date with 'origin/main'. + +Changes to be committed: + (use "git restore --staged ..." to unstage) + modified: .gitattributes + new file: config.json + new file: pytorch_model.bin + new file: sentencepiece.bpe.model + new file: special_tokens_map.json + new file: tokenizer.json + new file: tokenizer_config.json +``` +{:else} +```bash +On branch main +Your branch is up to date with 'origin/main'. + +Changes to be committed: + (use "git restore --staged ..." to unstage) + modified: .gitattributes + new file: config.json + new file: sentencepiece.bpe.model + new file: special_tokens_map.json + new file: tf_model.h5 + new file: tokenizer.json + new file: tokenizer_config.json +``` +{/if} + +ในแบบเดียวกัน เราสามารถทำให้มั่นใจได้ว่า git-lfs กำลังติดตามไฟล์ที่ถูกต้องอยู่ ได้โดยการใช้คำสั่ง status: + +```bash +git lfs status +``` + +{#if fw === 'pt'} +```bash +On branch main +Objects to be pushed to origin/main: + + +Objects to be committed: + + config.json (Git: bc20ff2) + pytorch_model.bin (LFS: 35686c2) + sentencepiece.bpe.model (LFS: 988bc5a) + special_tokens_map.json (Git: cb23931) + tokenizer.json (Git: 851ff3e) + tokenizer_config.json (Git: f0f7783) + +Objects not staged for commit: + + +``` + +เราสามารถเห็นได้ว่าทุกไฟล์มี `Git` เป็นตัวจัดการ (handler) ยกเว้น *pytorch_model.bin* และ *sentencepiece.bpe.model* ซึ่งเป็น `LFS` เยี่ยม! + +{:else} +```bash +On branch main +Objects to be pushed to origin/main: + + +Objects to be committed: + + config.json (Git: bc20ff2) + sentencepiece.bpe.model (LFS: 988bc5a) + special_tokens_map.json (Git: cb23931) + tf_model.h5 (LFS: 86fce29) + tokenizer.json (Git: 851ff3e) + tokenizer_config.json (Git: f0f7783) + +Objects not staged for commit: + + +``` + +เราสามารถเห็นได้ว่าทุกไฟล์มี `Git` เป็นตัวจัดการ (handler) ยกเว้น *t5_model.h5* ซึ่งเป็น `LFS` เยี่ยม! + +{/if} + +มาทำขั้นตอนสุดท้ายต่อกันเถอะ ทำการ commit และดัน (push) ขึ้นสู่ *huggingface.co* remote repository: + +```bash +git commit -m "First model version" +``` + +{#if fw === 'pt'} +```bash +[main b08aab1] First model version + 7 files changed, 29027 insertions(+) + 6 files changed, 36 insertions(+) + create mode 100644 config.json + create mode 100644 pytorch_model.bin + create mode 100644 sentencepiece.bpe.model + create mode 100644 special_tokens_map.json + create mode 100644 tokenizer.json + create mode 100644 tokenizer_config.json +``` +{:else} +```bash +[main b08aab1] First model version + 6 files changed, 36 insertions(+) + create mode 100644 config.json + create mode 100644 sentencepiece.bpe.model + create mode 100644 special_tokens_map.json + create mode 100644 tf_model.h5 + create mode 100644 tokenizer.json + create mode 100644 tokenizer_config.json +``` +{/if} + +การดันไฟล์นั้นอาจจะใช้เวลาสักหน่อย ขึ้นอยู่กับความเร็วของการเชื่อมต่ออินเทอร์เน็ตและขนาดไฟล์ของคุณ: + +```bash +git push +``` + +```bash +Uploading LFS objects: 100% (1/1), 433 MB | 1.3 MB/s, done. +Enumerating objects: 11, done. +Counting objects: 100% (11/11), done. +Delta compression using up to 12 threads +Compressing objects: 100% (9/9), done. +Writing objects: 100% (9/9), 288.27 KiB | 6.27 MiB/s, done. +Total 9 (delta 1), reused 0 (delta 0), pack-reused 0 +To https://huggingface.co/lysandre/dummy + 891b41d..b08aab1 main -> main +``` + +{#if fw === 'pt'} +ถ้าเราดูที่ model repository เมื่อโค้ดทำงานเสร็จแล้ว เราจะเห็นทุกไฟล์ที่เพิ่งถูกเพิ่มเข้าไปอยู่ในนั้น: + +
+The 'Files and versions' tab now contains all the recently uploaded files. +
+ +UI ช่วยให้คุณสามารถสำรวจไฟล์โมเดลและ commits และดูความแตกต่างของแต่ละ commit ได้: + +
+The diff introduced by the recent commit. +
+{:else} +ถ้าเราดูที่ model repository เมื่อโค้ดทำงานเสร็จแล้ว เราจะเห็นทุกไฟล์ที่เพิ่งถูกเพิ่มเข้าไปอยู่ในนั้น: + +
+The 'Files and versions' tab now contains all the recently uploaded files. +
+ +UI ช่วยให้คุณสามารถสำรวจไฟล์โมเดลและ commits และดูความแตกต่างของแต่ละ commit ได้: + +
+The diff introduced by the recent commit. +
+{/if} diff --git a/chapters/th/chapter4/4.mdx b/chapters/th/chapter4/4.mdx new file mode 100644 index 000000000..9f609ed56 --- /dev/null +++ b/chapters/th/chapter4/4.mdx @@ -0,0 +1,81 @@ +# การสร้างการ์ดโมเดล (model card) + +การ์ดโมเดลเป็นไฟล์ที่เรียกได้ว่าสำคัญพอๆกับไฟล์โมเดลและ tokenizer ใน model repository มันคือคำนิยามส่วนกลางของโมเดล เป็นสิ่งที่ทำให้มั่นใจว่าสมาชิกของชุมชนสามารถนำไปใช้ได้ (reusability) และสามารถทำซ้ำและได้ผลลัพธ์เหมือนเดิมได้ (reproducibility) และมันยังจัดเตรียมแพลตฟอร์มให้สมาชิกคนอื่นๆอาจใช้สร้างสิ่งประดิษฐ์ (artifacts) ของเขาเองได้ + +การสร้างหนังสืออ้างอิง (documenting) ถึงกระบวนการเทรนและประเมินผลช่วยให้ผู้อื่นเข้าใจถึงสิ่งที่คาดหวังได้จากโมเดลๆหนึ่ง และการให้ข้อมูลที่เพียงพอเกี่ยวกับข้อมูลที่ถูกใช้, กระบวนการเตรียมข้อมูล (preprocessing) และกระบวนการหลังจากใช้โมเดล (postprocessing) ที่ถูกทำมาทำให้มั่นใจถึงขีดจำกัด (limitations), ความลำเอียง (biases) และบริบท (contexts) ที่โมเดลเป็นและไม่เป็น ซึ่งเป็นสิ่งที่เป็นประโยชน์มากถ้าหากสามารถระบุและเข้าใจได้ + +ดังนั้นการสร้างการ์ดโมเดลที่อธิบายถึงโมเดลของคุณอย่างละเอียดถือเป็นขั้นตอนหนึ่งที่สำคัญมาก ในส่วนนี้เรามีเคล็ดลับบางอย่างที่จะช่วยให้คุณทำสิ่งนี้ได้ การสร้างการ์ดโมเดลนั้นถูกทำผ่านไฟล์ *README.md* ที่คุณได้เห็นก่อนหน้านี่ ซึ่งมันก็คือไฟล์ Markdown ไฟล์หนึ่ง + +แนวคิด “การ์ดโมเดล” เกิดขึ้นมาจากทิศทางของงานวิจัยชิ้นหนึ่งจาก Google ซึ่งถูกแบ่งปันครั้งแรกใน ["Model Cards for Model Reporting"](https://arxiv.org/abs/1810.03993) โดย Margaret Mitchell et al. ข้อมูลส่วนใหญ่ที่เราจะพูดถึงในที่นี้มีฐานมาจากงานวิจัยชิ้นนี้ และเราแนะนำให้คุณลองดูงานวิจัยนี้เพื่อจะได้เข้าใจถึงว่าทำไมการ์ดโมเดลถึงมีความสำคัญต่อโลกที่ให้ค่าแก่ความสามารถในการทำซ้ำ (reproducibility), ความสามารถในการนำกลับมาใช้ (reusability) และความเท่าเทียม (fairness) อย่างมาก + +โดยทั่วไปแล้วการ์ดโมเดลมักเริ่มต้นด้วยภาพรวมแบบสรุปย่อของโมเดลว่าโมเดลนี้มีไว้ทำอะไร ตามมาด้วยข้อมูลเพิ่มเติมในส่วนต่างๆต่อไปนี้: + +- คำอธิบายโมเดล +- การนำไปใช้งานที่ควรจะเป็นและข้อจำกัดต่างๆ +- วิธีใช้ +- ข้อจำกัดและความลำเอียง +- ข้อมูลที่ใช้เทรน +- ขั้นตอนการเทรน +- ผลจากการประเมิน + +มาดูกันดีกว่าว่าแต่ละส่วนนี้ควรมีอะไรบ้าง + +### คำอธิบายโมเดล + +คำอธิบายโมเดลควรบอกรายละเอียดพื้นฐานเกี่ยวกับโมเดล ซึ่งหมายถึงสถาปัตยกรรม (architecture), เวอร์ชั่น, มาจากงานวิจัยหรือไม่, มี implementation จากแหล่งต้นทางหรือไม่, ผู้เขียน และข้อมูลทั่วไปเกี่ยวกับโมเดล ลิขสิทธิ์ทุกอย่างควรจะถูกระบุอยู่ในส่วนนี้ ข้อมูลโดยทั่วไปเกี่ยวกับกระบวนการเทรน, พารามิเตอร์ และข้อจำกัดความรับผิดชอบ (disclaimers) ที่สำคัญสามารถถูกพูดถึงในส่วนนี้ได้เช่นกัน + +### การนำไปใช้งานที่ควรจะเป็นและข้อจำกัดต่างๆ + +ในส่วนนี้คุณควรอธิบายกรณีการใช้งาน (use cases) ที่โมเดลถูกตั้งใจสร้างขึ้นมาเพื่อให้ใช้งาน รวมถึงภาษา, ประเภทงาน และโดเมนที่โมเดลสามารถประยุกต์ใช้ได้ ในส่วนนี้ของการ์ดโมเดลสามารถพูดถึงเกี่ยวกับสายงานที่ไม่อยู่ในขอบเขตของโมเดล และสายงานที่โมเดลไม่สามารถปฏิบัติการได้ดีที่สุด + +### วิธีใช้ + +ส่วนนี้ควรมีตัวอย่างของการใช้งานโมเดล สามารถเป็นในรูปแบบของการใช้งานฟังก์ชั่น `pipeline()`, การใช้งานคลาสโมเดลและ tokenizer และโค้ดอื่นๆที่คุณคิดว่าน่าจะเป็นประโยชน์ได้ + +### ข้อมูลที่ใช้เทรน + +ส่วนนี้ควรระบุถึงชุดข้อมูลที่โมเดลได้ถูกเทรนมา ถ้าหากมีคำอธิบายโดยสรุปของชุดข้อมูลก็จะดีมาก + +### ขั้นตอนการเทรน + +ในส่วนนี้คุณควรอธิบายทุกอย่างที่เกี่ยวข้องกับการเทรนที่เป็นประโยชน์ในมุมมองของการนำไปทำซ้ำ ซึ่งควรมีกระบวนการเตรียมข้อมูล (preprocessing) และกระบวนการหลังจากใช้โมเดล (postprocessing) ที่ถูกทำไว้กับชุดข้อมูลนี้ รวมถึงรายละเอียดเกี่ยวกับจำนวนรอบ (epochs) ที่ใช้ในการเทรนโมเดล, ขนาด batch (batch size), อัตราการเรียนรู้ (learning rate) และอื่นๆ + +### ตัวแปรและเมตริก + +ส่วนนี้คุณควรอธิบายเมตริก (metrics) ที่คุณใช้ในการประเมินผล และปัจจัยต่างๆที่คุณตรวจวัด การกล่าวถึงเมตริกต่างๆที่ถูกใช้ กับชุดข้อมูลไหนและแบ่งอย่างไร ช่วยทำให้การเปรียบเทียบประสิทธิภาพของโมเดลของคุณกับโมเดลอื่นๆเป็นไปได้ง่าย ซึ่งสิ่งเหล่านี้ควรจะถูกระบุอยู่ในส่วนที่ผ่านมา เช่น ผู้ใช้และการนำไปใช้งานที่ควรจะเป็น + +### ผลจากการประเมิน + +ส่วนสุดท้าย คุณควรระบุข้อบ่งชี้ว่าโมเดลของคุณทำงานได้ดีแค่ไหนกับชุดข้อมูลสำหรับประเมินผล (evaluation dataset) ถ้าโมเดลมีการใช้เกณฑ์ในการตัดสินใจ (decision threshold) คุณควรระบุค่าที่ใช้เป็นเกณฑ์นั้นในการประเมินผล หรือระบุรายละเอียดของการประเมินผลที่เกณฑ์ต่างกันสำหรับการใช้งานที่ควรจะเป็น + +## ตัวอย่าง + +ลองเข้าไปดู links เหล่านี้เป็นตัวอย่างสำหรับการ์ดโมเดลที่ถูกขัดเกลามาอย่างดี: + +- [`bert-base-cased`](https://huggingface.co/bert-base-cased) +- [`gpt2`](https://huggingface.co/gpt2) +- [`distilbert`](https://huggingface.co/distilbert-base-uncased) + +ตัวอย่างเพิ่มเติมจากองค์กรและบริษัทต่างๆ สามารถดูได้จาก [ที่นี่](https://github.com/huggingface/model_card/blob/master/examples.md) + +## หมายเหตุ + +การ์ดโมเดลไม่ได้เป็นหนึ่งในสิ่งที่เรียกร้อง (requirement) เมื่อจะทำการเปิดเผยโมเดลสู่สาธารณะ คุณไม่จำเป็นต้องใส่ทุกส่วนที่เราได้พูดถึงไปข้างบนถ้าคุณต้องการจะทำมัน อย่างไรก็ได้หนังสืออ้างอิงที่ชัดเจนของโมเดลสามารถสร้างประโยชน์กับผู้ใช้ในอนาคตได้ ดังนั้นเราจึงแนะนำให้คุณเติมส่วนต่างๆที่คุณรู้ให้ได้มากที่สุดเท่าที่จะเป็นไปได้ +## ข้อมูลเมตาของการ์ดโมเดล (Model card metadata) + +ถ้าคุณได้ทำการสำรวจ Hugging Face Hub มาบ้างแล้ว คุณน่าจะได้เห็นบางโมเดลในหมวดหมู่ต่างๆ ที่คุณสามารถคัดกรองพวกมันได้ด้วยประเภทงาน, ภาษา, libraries และอื่นๆ หมวดหมู่ที่โมเดลๆหนึ่งอยู่ถูกระบุตามข้อมูลเมตา (metadata) ที่คุณเพิ่มเข้าไปในหัวของการ์ดโมเดล + +ตัวอย่างเช่น ถ้าคุณลองดูที่ [การ์ดโมเดล `camembert-base`](https://huggingface.co/camembert-base/blob/main/README.md) คุณจะเห็นบรรทัดต่อไปนี้ในหัวการ์ดโมเดล: + +``` +--- +language: fr +license: mit +datasets: +- oscar +--- +``` + +ข้อมูลเมตานี้ถูกแยกวิเคราะห์โดย Hugging Face Hub ซึ่งต่อจากนั้นจะถูกใช้เป็นตัวระบุว่าโมเดลนี้เป็นโมเดลภาษาฝรั่งเศส มีใบอนุญาต MIT และถูกเทรนมากับชุดข้อมูล Oscar + +[รายละเอียดการ์ดโมเดลแบบเต็ม](https://github.com/huggingface/hub-docs/blame/main/modelcard.md) ช่วยให้สามารถระบุภาษา, ใบอนุญาต, แท็ก, ชุดข้อมูล, เมตริก รวมไปถึงผลลัพธ์จากการประเมินผลที่โมเดลได้จากการเทรน \ No newline at end of file diff --git a/chapters/th/chapter4/5.mdx b/chapters/th/chapter4/5.mdx new file mode 100644 index 000000000..e810397d8 --- /dev/null +++ b/chapters/th/chapter4/5.mdx @@ -0,0 +1,7 @@ +# จบพาร์ทที่ 1! + +นี่คือจุดจบของพาร์ทแรกในคอร์สนี้! พาร์ทที่ 2 จะถูกปล่อยในวันที่ 15 พฤศจิกายน พร้อมกับงานอีเว้นท์ชุมชนใหญ่ ดูรายละเอียดเพิ่มเติม [ที่นี่](https://huggingface.co/blog/course-launch-event) + +ตอนนี้คุณควรจะสามารถทำ fine-tune โมเดลที่ผ่านการเทรนมาแล้ว (pretrained model) กับปัญหาการจำแนกประเภทตัวหนังสือ (text classification) (แบบประโยคเดี่ยวหรือคู่ประโยค) และอัพโหลดผลลัพธ์ขึ้นสู่ Model Hub ได้ เพื่อที่จะทำให้มั่นใจว่าคุณเชี่ยวชาญส่วนแรกนี้แล้วจริงๆ คุณควรจะฝึกทำแบบนี้เป๊ะๆกับปัญหาที่คุณสนใจ (และไม่จำเป็นจะต้องเป็นภาษาอังกฤษถ้าคุณพูดภาษาอื่น)! คุณสามารถหาความช่วยเหลือได้ใน [Hugging Face forums](https://discuss.huggingface.co/) และแบ่งปันโปรเจคของคุณได้ใน [หัวข้อนี้](https://discuss.huggingface.co/t/share-your-projects/6803) เมื่อคุณทำเสร็จ + +เรารอไม่ไหวแล้วที่จะได้เห็นว่าคุณจะสร้างอะไรได้บ้างจากความรู้นี้! \ No newline at end of file diff --git a/chapters/th/chapter4/6.mdx b/chapters/th/chapter4/6.mdx new file mode 100644 index 000000000..078accc9a --- /dev/null +++ b/chapters/th/chapter4/6.mdx @@ -0,0 +1,224 @@ + + + + +# คำถามท้ายบท + +มาทดสอบความรู้ที่คุณได้เรียนในบทนี้กันเถอะ! + +### 1. อะไรคือข้อจำกัดของโมเดลบน Hub? + + + +### 2. คุณสามารถจัดการโมเดลบน Hub ได้อย่างไร? + +git-lfs สำหรับไฟล์ขนาดใหญ่", + correct: true + } + ]} +/> + +### 3. คุณสามารถใช้ web interface ของ Hugging Face Hub ทำอะไรได้บ้าง? + + + +### 4. การ์ดโมเดลคืออะไร? + + + +### 5. วัตถุ (objects) ใดต่อไปนี้ของ 🤗 Transformers library ที่สามารถถูกแบ่งปันได้โดยตรงบน Hub ผ่านคำสั่ง `push_to_hub()`? + +{#if fw === 'pt'} +push_to_hub และใช้มันในการดันไฟล์ทั้งหมดของ tokenizer (คำศัพท์ (vocabulary), สถาปัตยกรรมของ tokenizer และอื่นๆ) ไปยัง repo ที่กำหนดได้ แต่นี่ก็ไม่ใช่คำตอบที่ถูกเพียงข้อเดียว!", + correct: true + }, + { + text: "model configuration", + explain: "ถูกต้องแล้ว! ไฟล์สำหรับกำหนดค่าของโมเดล (model configurations) ทั้งหมดมีคำสั่ง push_to_hub และใช้มันในการดันพวกมันขึ้นไปยัง repo ที่กำหนดได้ มีอะไรอีกที่คุณสามารถแบ่งปันได้?", + correct: true + }, + { + text: "model", + explain: "ถูกต้องแล้ว! โมเดลทั้งหมดมีคำสั่ง push_to_hub และใช้มันในการดันพวกมันและไฟล์กำหนดค่าของพวกมันขึ้นไปยัง repo ที่กำหนดได้ แต่นั่นก็ไม่ใช่ทั้งหมดที่คุณแบ่งปันได้", + correct: true + }, + { + text: "Trainer", + explain: "ถูกต้อง — Trainer ก็มีคำสั่ง push_to_hub และใช้มันในการอัพโหลดโมเดล, ไฟล์กำหนดค่า, tokenizer และดราฟของการ์ดโมเดลไปยัง repo ที่กำหนดได้ ลองตอบข้ออื่นดู!", + correct: true + } + ]} +/> +{:else} +push_to_hub และใช้มันในการดันไฟล์ทั้งหมดของ tokenizer (คำศัพท์ (vocabulary), สถาปัตยกรรมของ tokenizer และอื่นๆ) ไปยัง repo ที่กำหนดได้ แต่นี่ก็ไม่ใช่คำตอบที่ถูกเพียงข้อเดียว!", + correct: true + }, + { + text: "model configuration", + explain: "ถูกต้องแล้ว! ไฟล์สำหรับกำหนดค่าของโมเดล (model configurations) ทั้งหมดมีคำสั่ง push_to_hub และใช้มันในการดันพวกมันขึ้นไปยัง repo ที่กำหนดได้ มีอะไรอีกที่คุณสามารถแบ่งปันได้?", + correct: true + }, + { + text: "model", + explain: "ถูกต้องแล้ว! โมเดลทั้งหมดมีคำสั่ง push_to_hub และใช้มันในการดันพวกมันและไฟล์กำหนดค่าของพวกมันขึ้นไปยัง repo ที่กำหนดได้ แต่นั่นก็ไม่ใช่ทั้งหมดที่คุณแบ่งปันได้", + correct: true + }, + { + text: "ทั้งหมดที่กล่าวมารวมกับ callback ที่อุทิศให้", + explain: "ถูกต้อง — โดยปกติ PushToHubCallback จะส่งวัตถุทั้งหมดเหล่านั้นไปยัง repo ระหว่างการเทรน", + correct: true + } + ]} +/> +{/if} + +### 6. อะไรคือขั้นตอนแรกในการใช้คำสั่ง `push_to_hub()` หรือเครื่องมือ CLI? + + + +### 7. คุณกำลังใช้งานโมเดลและ tokenizer อยู่ — คุณจะสามารถอัพโหลดพวกมันขึ้นไปบน Hub ได้อย่างไร? + +huggingface_hub utility", + explain: "โมเดลและ tokenizers ถ้ารับประโยชน์จาก huggingface_hub utilities อยู่แล้ว: ไม่จำเป็นจะต้องมีการคลุมเพิ่ม!" + }, + { + text: "โดยการบันทึกพวกมันลงบนเครื่องและเรียกใช้คำสั่ง transformers-cli upload-model", + explain: "ไม่มีคำสั่ง upload-model นี้อยู่" + } + ]} +/> + +### 8. มีการดำเนินการ git (git operations) ใดบ้างที่คุณสามารถทำได้กับคลาส `Repository`? + +git_commit() มีไว้สำหรับสิ่งนี้", + correct: true + }, + { + text: "pull", + explain: "นั่นคือวัตถุประสงค์ของคำสั่ง git_pull()", + correct: true + }, + { + text: "push", + explain: "คำสั่ง git_push() มีไว้ทำสิ่งนี้", + correct: true + }, + { + text: "merge", + explain: "ไม่ การดำเนินการนี้ไม่สามารถทำได้กับ API นี้" + } + ]} +/>