ปรับใช้โมเดลการเรียนรู้ของเครื่องของคุณด้วย Python

เมื่อทำงานในสาขาวิทยาศาสตร์ข้อมูล คุณมักจะพบว่าตัวเองเผชิญกับความท้าทายใหม่หลังจากเสร็จสิ้นการฝึกอบรม การปรับแต่ง และปรับปรุงอันยาวนาน ขอแสดงความยินดีกับการสร้างแบบจำลอง ML ที่มีประสิทธิภาพที่ดีและตอบสนองความต้องการของคุณ ตอนนี้ความท้าทายที่คุณมีคือคุณจะส่งมอบเทคโนโลยีดีๆ นี้ให้กับผู้ใช้ที่ต้องการได้อย่างไร หรือบางทีคุณจะสื่อสารผลลัพธ์ของคุณกับผู้มีส่วนได้ส่วนเสียในบริษัทของคุณอย่างมีประสิทธิภาพได้อย่างไร? หรือแม้กระทั่งคุณจะแบ่งปันผลลัพธ์แบบจำลองของคุณกับเพื่อนร่วมงานอย่างมีประสิทธิภาพเพื่อการทำงานร่วมกันที่ดีขึ้นได้อย่างไร

การปรับใช้การเรียนรู้ของเครื่องอาจเป็นเรื่องยากในบางครั้ง เนื่องจากเราจะใช้เทคโนโลยีและเทคนิคนอกเหนือจากชุดทักษะปกติที่จำเป็นในการสร้างแบบจำลอง

ในบทความนี้ เราจะค้นพบวิธีการปรับใช้โมเดลการเรียนรู้ของเครื่องโดยใช้ Python เท่านั้น และในระหว่างนี้ เราจะสร้างโมเดลการแปลด้วยเครื่องและหน้าเว็บ

ต่อไปนี้เป็นขั้นตอนที่เราจะได้เห็น:

1. การใช้โมเดลการแปลด้วยเครื่อง Huggingface

2. ค้นพบ Anvil และสร้าง UI ของเว็บสำหรับโมเดลของเรา

3. การเชื่อมต่อแบ็กเอนด์และฟรอนต์เอนด์และรับใช้โลก งานของเรา!

สร้างโมเดล Machine Translation

Huggingface คือชุมชน AI ที่ทำงานเพื่อ "ทำให้แมชชีนเลิร์นนิงที่ดีเป็นประชาธิปไตย" ภายใต้โครงการริเริ่มนี้ คุณจะพบกับโมเดลที่ได้รับการฝึกอบรมมากมายเกี่ยวกับ งานแมชชีนเลิร์นนิงที่แตกต่างกัน: การแบ่งส่วนรูปภาพ การอ่านออกเสียงข้อความ การสร้างข้อความ... และการแปลด้วยเครื่อง!

การแปลด้วยเครื่องเป็นเพียงงานการแปลระหว่างสองภาษาที่ดำเนินการโดยซอฟต์แวร์ชิ้นหนึ่ง ในกรณีของเราคือโมเดลการเรียนรู้ของเครื่องที่สร้างด้วยหม้อแปลงไฟฟ้า

หม้อแปลงไฟฟ้าเป็นสถาปัตยกรรมการเรียนรู้เชิงลึกที่อิงตามความสนใจ มาทำให้มันทำงานบนเครื่องของคุณกันเถอะ!

เราจะใช้ transformers ซึ่งเป็นไลบรารี Python เพื่อดาวน์โหลดโมเดล MT และดำเนินการแปล

pip install torch
pip install transformers

หลังจากติดตั้งแพ็คเกจที่จำเป็นแล้ว ให้นำเข้าโมดูลต่อไปนี้:

from transformers import MarianTokenizer, MarianMTModel
from typing import List

มารับแบบจำลองที่แปลประโยคจากภาษาเยอรมันเป็นภาษาอังกฤษกันดีกว่า เราต้องการชื่อรุ่น:

src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'

ตอนนี้เรามานำเข้าโมเดลที่ได้รับการฝึกและโทเค็นไนเซอร์โดยใช้บรรทัดต่อไปนี้:

model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)

ขนาดการดาวน์โหลดประมาณ 300mb หลังจากเสร็จสิ้น คุณสามารถจัดเก็บโมเดลไว้ในไดเร็กทอรีภายในเครื่องได้โดยใช้สิ่งต่อไปนี้:

model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")

มาเป็นโมเดล:

text="ich habe keine ahnung"
gen = model.generate(**tok.prepare_seq2seq_batch(src_texts=[text], return_tensors="pt"))
words: List[str] = tok.batch_decode(gen, skip_special_tokens=True)
print(words[0])

ตอนนี้คุณควรมีการแปลประโยคภาษาอังกฤษเก็บไว้ใน words[0]

ค้นพบ Anvil และสร้าง UI ของเว็บ

Anvil เป็นเฟรมเวิร์กและชุดโซลูชันที่ช่วยให้คุณสร้างเว็บแอปพลิเคชันได้โดยใช้โค้ด Python เท่านั้น มีตัวแก้ไขแบบลากและวางเพื่อสร้าง UI ของเว็บ และช่วยให้คุณสามารถเชื่อมต่อโค้ดจากเครื่องของคุณกับ UI ที่คุณสร้างและโฮสต์แอปพลิเคชันของคุณโดยให้ลิงก์ที่คุณสามารถแชร์ได้

เรามาเริ่มต้นด้วยการสร้างแอปพลิเคชันจากที่นี่ เลือกแอปพลิเคชันเปล่า จากนั้นเลือกการออกแบบวัสดุ

คุณควรเห็นสิ่งนี้:

ตอนนี้ฉันจะวางใจให้คุณใช้โปรแกรมแก้ไขและสร้างสิ่งที่คล้ายกับสิ่งต่อไปนี้:

ใน UI ที่เรียบง่ายนี้ เรามีดรอปดาวน์สองรายการสำหรับเลือกภาษาต้นทางและปลายทาง นอกจากนี้เรายังมีกล่องข้อความสำหรับป้อนข้อความต้นฉบับและส่วนประกอบ richText เพื่อแสดงข้อความที่แปล คุณยังสามารถเห็นปุ่มเพื่อเริ่มงานแปล

หากต้องการซิงโครไนซ์กับข้อมูลโค้ดที่คุณจะเห็นด้านล่าง ให้ระบุรหัสเดียวกันให้กับส่วนประกอบต่างๆ ด้านล่างนี้คุณจะพบตัวอย่างตำแหน่งที่คุณสามารถตั้งค่า ID ของส่วนประกอบได้:

ID ที่เราใช้คือ:

<เส้นขอบตาราง="2">

<หัว>

ส่วนประกอบ

รหัส

</หัว>

ภาษาต้นฉบับแบบเลื่อนลง source_lang ภาษาปลายทางแบบเลื่อนลง dest_lang กล่องข้อความภาษาต้นฉบับ source_text RichText ข้อความที่แปล translated_text

</ตาราง>

ฟังก์ชั่น Onclick

เราได้เพิ่มปุ่มที่ใช้ในการเริ่มการแปล จากตัวแก้ไขของคุณ คลิกที่ปุ่ม จากนั้นเลื่อนลงในแผงคุณสมบัติ ที่ด้านล่างคุณจะเห็นส่วนกิจกรรม ในโซนข้อความถัดจาก "คลิก" ให้ป้อน "แปล" จากนั้นคลิกที่ลูกศรทางด้านขวาของโซนข้อความนี้

นี่จะนำคุณไปสู่มุมมองโค้ดซึ่งคุณจะเห็นโค้ดหลามที่สร้างขึ้นโดยอัตโนมัติ

คุณจะพบว่าทั่งตี๋ได้เพิ่มฟังก์ชันที่เรียกว่าแปลโดยอัตโนมัติ มันจะถูกเรียกทุกครั้งที่คลิกปุ่มใน UI ของเรา

นี่คือลักษณะของฟังก์ชัน:

def translate(self, **event_args):
 """This method is called when the button is clicked"""
 src_lang=self.source_lang.selected_value #get the selected source language
 dest_lang=self.dest_lang.selected_value #get the selected destination language
 text=self.source_text.text   #get the text written in source language
 #call the server function
 translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
 #write the translated text to the UI
 self.translated_text.content=translated_text

ฟังก์ชันนี้ทำหน้าที่หลัก 3 ประการ:

1. รับข้อมูลจาก UI

2. ส่งข้อมูลไปยังแบ็กเอนด์ของเราโดยใช้ฟังก์ชันเซิร์ฟเวอร์ “การแปล” (เราจะอธิบายในส่วนถัดไป)

3. ส่งข้อความที่แปลไปยัง UI

ฟังก์ชั่นเซิร์ฟเวอร์

มาเน้นที่โค้ดบรรทัดนี้:

translated_text=anvil.server.call("translation",text,src_lang,dest_lang)

เราใช้ anvil.server.call เพื่อเรียกใช้ฟังก์ชันเซิร์ฟเวอร์ที่เรียกว่า translation ซึ่งเราจะกำหนดไว้ในโค้ดแบ็กเอนด์ของเราในเครื่องท้องถิ่น

ฟังก์ชันนี้จะทำหน้าที่เป็นการเชื่อมต่อระหว่าง UI ของเว็บและโค้ดแบ็กเอนด์ที่จะทำงานบนโมเดลการแปลด้วยเครื่องของเรา

ดังที่คุณสังเกตเห็น เรายังส่งพารามิเตอร์ของฟังก์ชันนี้ไปยังฟังก์ชัน anvil.server.call

ปรับใช้โมเดล MT ของเรา

มาติดตั้งทั่งตีเหล็กกันก่อน

pip install anvil-uplink

ตอนนี้เราได้สร้างเว็บอินเตอร์เฟสในโปรแกรมแก้ไขทั่งตีเหล็กแล้ว และเรามีบล็อคโค้ดพื้นฐานเพื่อรันโมเดลการแปลด้วยเครื่องและทำการแปล

ขั้นตอนต่อไปคือการกำหนดฟังก์ชันเซิร์ฟเวอร์ที่เราได้กล่าวถึงในส่วนที่แล้ว

นี่คือรหัสของฟังก์ชัน:

@anvil.server.callable
def translation(text,src,dest):
 lang_code={"English":"en",
       "German":"de",
       "French":"fr",
       "Spanish":"es"}
      model=MarianMTModel.from_pretrained("./models/"+lang_code[src]+"_"+lang_code[dest])
 tok=MarianTokenizer.from_pretrained("./models/"+lang_code[src]+"_"+lang_code[dest]+"/tok")
 gen = model.generate(**tok.prepare_seq2seq_batch(src_texts=[text], return_tensors="pt"))
 words: List[str] = tok.batch_decode(gen, skip_special_tokens=True)
 return words[0]

ฟังก์ชันจะใช้พารามิเตอร์ 3 ตัวที่ส่งจากส่วนหน้า แปลงภาษาต้นทางและปลายทางเป็นรหัสภาษาที่เกี่ยวข้อง จากนั้นโหลดโมเดลและคำนวณการแปล และส่งคืนผลลัพธ์

วิธีการประกาศฟังก์ชันนี้ให้กับทั่งตีเป็นฟังก์ชันเซิร์ฟเวอร์คือการใช้มัณฑนากร

@anvil.server.callable.

เรามีขั้นตอนสุดท้ายที่ต้องทำเพื่อเชื่อมต่อโค้ดแบ็กเอนด์ที่เราสามารถเรียกใช้ในสมุดบันทึก jupyter กับแอปพลิเคชันทั่งตีเหล็กของเรา

ไปที่ anvil online editor คลิกที่ไอคอนรูปเฟือง จากนั้นคลิกที่ “Uplink…”

ดูหน้าจอด้านล่าง

คุณจะเห็นป๊อปอัปปรากฏขึ้น จากนั้นคลิกที่ "เปิดใช้งานเซิร์ฟเวอร์อัปลิงก์สำหรับแอปนี้" เพื่อรับรหัสการเชื่อมต่อที่คุณคัดลอก

คุณวางรหัสลงในบรรทัดรหัสต่อไปนี้:

anvil.server.connect("code here")

บรรทัดนี้จะเริ่มเซิร์ฟเวอร์ที่เชื่อมต่อสคริปต์โค้ดในเครื่องหรือสมุดบันทึก jupyter ของคุณกับแอปพลิเคชันทั่งตีเหล็กด้วยฟังก์ชัน translation ที่ลงทะเบียนเป็นฟังก์ชันเซิร์ฟเวอร์

##ขั้นตอนสุดท้าย

ถึงจุดนี้ คุณมีเซิร์ฟเวอร์แบ็คเอนด์ที่ทำงานด้วยฟังก์ชันเซิร์ฟเวอร์ที่โหลดโมเดลการแปลด้วยเครื่อง และทำการแปลหลังจากพิจารณาพารามิเตอร์ที่ส่งจากส่วนหน้าแล้ว ตัวเลขนี้สรุปสิ่งที่เราได้ดำเนินการร่วมกันจนถึงขณะนี้

ขั้นตอนสุดท้ายคือการรันแอปพลิเคชันโดยคลิกปุ่มรันที่ตรงกลางด้านบนของตัวแก้ไขทั่ง

หลังจากเรียกใช้แอปพลิเคชัน คุณจะเห็นปุ่ม "เผยแพร่แอปนี้" ที่มุมขวาบน ซึ่งจะมีลิงก์ที่คุณสามารถแชร์เพื่อเข้าถึงแอปพลิเคชันและทำการแปลของคุณ!

บทสรุป

การติดตามบทความนี้ทำให้คุณสามารถปรับใช้โมเดล MT และสร้างเว็บอินเทอร์เฟซเพื่อใช้งานได้

ยังมีอะไรอีกมากมายให้ค้นพบเกี่ยวกับวิธีการปรับใช้โมเดลอย่างมีประสิทธิภาพโดยใช้ทั่งตีเหล็ก แต่ตอนนี้คุณมีพื้นฐานแล้วเพื่อเริ่มต้นเส้นทางการปรับใช้และเพิ่มศักยภาพจากความรู้เดิมของคุณใน Python เพื่อทำอะไรได้อีกมาก!

เชิญเข้าร่วมเวิร์คช็อปฟรีของเรา

เริ่มต้นอาชีพของคุณในฐานะนักวิทยาศาสตร์ข้อมูลด้วยเวิร์กช็อปฟรี ซึ่งอิงตามหลักสูตรที่ปรับเปลี่ยนได้และได้รับคำแนะนำจากผู้เชี่ยวชาญในอุตสาหกรรม