minGPT

minGPT

การปรับใช้ PyTorch ของ GPT อีกครั้ง ทั้งการฝึกอบรมและการอนุมาน minGPT พยายามที่จะมีขนาดเล็ก สะอาด ตีความได้ และให้ความรู้ เนื่องจากการใช้งานโมเดล GPT ที่มีอยู่ในปัจจุบันส่วนใหญ่อาจขยายออกไปเล็กน้อย GPT ไม่ใช่โมเดลที่ซับซ้อน และการใช้งานนี้มีโค้ดประมาณ 300 บรรทัดอย่างเหมาะสม (ดู mingpt/model.py) สิ่งที่เกิดขึ้นก็คือลำดับของดัชนีจะป้อนเข้าสู่ Transformer และการกระจายความน่าจะเป็นของดัชนีถัดไปในลำดับนั้นจะปรากฏขึ้น ความซับซ้อนส่วนใหญ่เป็นเพียงความฉลาดในการแบทช์ (ทั้งข้ามตัวอย่างและความยาวลำดับ) เพื่อประสิทธิภาพ

note (ม.ค. 2023) : แม้ว่าฉันอาจยังคงยอมรับและเปลี่ยนแปลงรายละเอียดบางอย่างต่อไป แต่ minGPT อยู่ในสถานะกึ่งเก็บถาวร สำหรับการพัฒนาล่าสุด โปรดดูที่ nanoGPT ที่เขียนใหม่ของฉัน โดยพื้นฐานแล้ว minGPT ได้ถูกอ้างอิงในที่ต่างๆ มากมาย (สมุดบันทึก บล็อก หลักสูตร หนังสือ ฯลฯ) ซึ่งทำให้ฉันไม่เต็มใจที่จะทำการเปลี่ยนแปลงที่ใหญ่กว่าที่ฉันต้องการทำเพื่อย้ายโค้ดไปข้างหน้า ฉันยังต้องการเปลี่ยนทิศทางเล็กน้อยจากการมุ่งเน้นที่การศึกษาเพียงอย่างเดียวไปสู่สิ่งที่ยังเรียบง่ายและแฮ็กได้ แต่มีข้อดี (สร้างมาตรฐานอุตสาหกรรมขนาดกลาง ยอมรับข้อดีข้อเสียบางอย่างเพื่อให้ได้ประสิทธิภาพรันไทม์ ฯลฯ)

ไลบรารี minGPT เป็นไฟล์สามไฟล์: mingpt/model.py มีคำจำกัดความของโมเดล Transformer จริง ส่วน mingpt/bpe.py มี Byte Pair Encoder ที่ได้รับการปรับโครงสร้างใหม่เล็กน้อย ซึ่งแปลระหว่างข้อความและลำดับของจำนวนเต็มเหมือนกับที่ OpenAI ทำใน GPT, mingpt/trainer py คือโค้ดสำเร็จรูป PyTorch (ไม่ขึ้นกับ GPT) ที่ฝึกฝนโมเดล จากนั้นจะมีการสาธิตและโปรเจ็กต์จำนวนหนึ่งที่ใช้ไลบรารีในโฟลเดอร์ projects :

• projects/adder ฝึก GPT ตั้งแต่เริ่มต้นเพื่อเพิ่มตัวเลข (ได้รับแรงบันดาลใจจากส่วนเพิ่มเติมในรายงาน GPT-3)
• projects/chargpt ฝึก GPT ให้เป็นโมเดลภาษาระดับอักขระในไฟล์ข้อความอินพุตบางไฟล์
• demo.ipynb แสดงการใช้งาน GPT และ Trainer ในรูปแบบโน้ตบุ๊กน้อยที่สุดด้วยตัวอย่างการเรียงลำดับแบบง่ายๆ
• generate.ipynb แสดงให้เห็นว่าสามารถโหลด GPT2 ที่ได้รับการฝึกล่วงหน้าและสร้างข้อความพร้อมท์ได้อย่างไร

การติดตั้งห้องสมุด

หากคุณต้องการ import mingpt ในโครงการของคุณ:

 git clone https://github.com/karpathy/minGPT.git
cd minGPT
pip install -e .

การใช้งาน

ต่อไปนี้เป็นวิธีการสร้างอินสแตนซ์ GPT-2 (เวอร์ชันพารามิเตอร์ 124M):

 from mingpt . model import GPT
model_config = GPT . get_default_config ()
model_config . model_type = 'gpt2'
model_config . vocab_size = 50257 # openai's model vocabulary
model_config . block_size = 1024  # openai's model block_size (i.e. input context length)
model = GPT ( model_config )

และนี่คือวิธีที่คุณจะฝึกมัน:

 # your subclass of torch.utils.data.Dataset that emits example
# torch LongTensor of lengths up to 1024, with integers from [0,50257)
train_dataset = YourDataset ()

from mingpt . trainer import Trainer
train_config = Trainer . get_default_config ()
train_config . learning_rate = 5e-4 # many possible options, see the file
train_config . max_iters = 1000
train_config . batch_size = 32
trainer = Trainer ( train_config , model , train_dataset )
trainer . run ()

ดู demo.ipynb สำหรับตัวอย่างที่เป็นรูปธรรมมากขึ้น

การทดสอบหน่วย

ความครอบคลุมยังไม่น่าทึ่งมากนัก แต่:

 python -m unittest discover tests

สิ่งที่ต้องทำ

• เพิ่มการสาธิตการปรับแต่ง gpt-2 ในไฟล์ข้อความที่กำหนดโดยพลการ
• เพิ่มการสาธิตเอเจนต์โต้ตอบ
• เอกสารผลลัพธ์ที่ดีขึ้นสำหรับโครงการที่มีอยู่ (adder, chargpt)
• เพิ่มความแม่นยำแบบผสมและสารพัดการปรับขนาดการฝึกอบรมที่เกี่ยวข้อง
• การสนับสนุนการฝึกอบรมแบบกระจาย
• สร้างเกณฑ์มาตรฐานบางอย่างในโครงการ/ เช่น text8 หรือการสร้างแบบจำลองภาษาอื่นๆ
• การบันทึกที่เหมาะสมแทนที่จะพิมพ์คำสั่งชั่วโมงสมัครเล่น ฮ่าๆ
• ฉันน่าจะมีไฟล์require.txt...
• ควรโหลดด้วยตุ้มน้ำหนักโมเดลอื่นๆ มากมายนอกเหนือจาก gpt2-*

อ้างอิง

รหัส:

• openai/gpt-2 มีคำจำกัดความของโมเดลใน TensorFlow แต่ไม่ใช่โค้ดการฝึกอบรม
• openai/image-gpt มี gpt-3 ที่ทันสมัยกว่าเช่นการแก้ไขในโค้ด ซึ่งเป็นข้อมูลอ้างอิงที่ดีเช่นกัน
• Huggingface/Transformers มีตัวอย่างการสร้างแบบจำลองภาษา มันมีคุณลักษณะครบถ้วนแต่ผลที่ได้ก็ค่อนข้างท้าทายในการติดตาม เช่น ฟังก์ชันขนาดใหญ่บางฟังก์ชันมีโค้ดที่ไม่ได้ใช้มากถึง 90% อยู่เบื้องหลังคำสั่งแยกย่อยต่างๆ ซึ่งไม่ได้ใช้ในการตั้งค่าเริ่มต้นของการสร้างแบบจำลองภาษาอย่างง่าย

เอกสาร + บันทึกการใช้งานบางส่วน:

การปรับปรุงความเข้าใจภาษาโดย Generative Pre-Training (GPT-1)

• โมเดลของเราเป็นไปตามงานหม้อแปลงดั้งเดิมเป็นส่วนใหญ่
• เราได้ฝึกอบรมหม้อแปลงที่ใช้ตัวถอดรหัสเท่านั้น 12 ชั้น พร้อมด้วยหัวควบคุมการเอาใจใส่ตัวเองแบบสวมหน้ากาก (สถานะ 768 มิติและหัวควบคุม 12 หัว) สำหรับเครือข่ายฟีดไปข้างหน้าตามตำแหน่ง เราใช้สถานะภายในมิติ 3072
• อัตราการเรียนรู้สูงสุดของอดัมคือ 2.5e-4 (ภายหลัง GPT-3 สำหรับรุ่นนี้ขนาดใช้ 6e-4)
• การสลายตัวของ LR: เพิ่มขึ้นเชิงเส้นจากศูนย์ในช่วงการอัปเดต 2,000 ครั้งแรกและอบอ่อนเป็น 0 โดยใช้กำหนดการโคไซน์
• เราฝึกฝน 100 epochs บนมินิแบทช์ที่สุ่มตัวอย่าง 64 ลำดับต่อเนื่องกันด้วยโทเค็น 512 อัน
• เนื่องจากมีการใช้เลเยอร์นอร์มอย่างกว้างขวางตลอดทั้งโมเดล การกำหนดค่าเริ่มต้นน้ำหนักอย่างง่ายที่ N(0, 0.02) ก็เพียงพอแล้ว
• คำศัพท์การเข้ารหัสไบต์คู่ (BPE) พร้อมการผสาน 40,000 รายการ
• สิ่งตกค้าง การฝัง และการลดความสนใจด้วยอัตรา 0.1 สำหรับการทำให้เป็นมาตรฐาน
• เวอร์ชันแก้ไขของการทำให้เป็นมาตรฐาน L2 ที่เสนอใน (37) โดยมี w = 0.01 ในทุกอคติหรือรับน้ำหนัก
• สำหรับฟังก์ชันการเปิดใช้งาน เราใช้ Gaussian Error Linear Unit (GELU)
• เราใช้การฝังตำแหน่งที่เรียนรู้แทนเวอร์ชันไซน์ซอยด์ที่เสนอในงานต้นฉบับ
• สำหรับการปรับแต่ง: เราเพิ่มการออกกลางคันให้กับตัวแยกประเภทด้วยอัตรา 0.1 อัตราการเรียนรู้ 6.25e-5 และขนาดแบทช์ 32. 3 ยุค เราใช้ตารางการสลายตัวของอัตราการเรียนรู้เชิงเส้นโดยมีการวอร์มอัพมากกว่า 0.2% ของการฝึก แลมถูกตั้งค่าเป็น 0.5
• รุ่น GPT-1 มี 12 เลเยอร์และ d_model 768, ~117M พารามิเตอร์

โมเดลภาษาเป็นผู้เรียนมัลติทาสก์แบบไม่ได้รับการดูแล (GPT-2)

• LayerNorm ถูกย้ายไปยังอินพุตของแต่ละบล็อกย่อย คล้ายกับเครือข่ายที่เหลือก่อนการเปิดใช้งาน
• มีการเพิ่มการทำให้เป็นมาตรฐานของเลเยอร์เพิ่มเติมหลังจากบล็อกการเอาใจใส่ตนเองขั้นสุดท้าย
• มีการใช้การกำหนดค่าเริ่มต้นที่แก้ไขซึ่งพิจารณาการสะสมบนเส้นทางที่เหลือพร้อมความลึกของแบบจำลอง เราปรับขนาดน้ำหนักของชั้นที่เหลือเมื่อเริ่มต้นเป็นปัจจัย 1/√N โดยที่ N คือจำนวนชั้นที่เหลือ (แปลกเพราะในโค้ดที่ปล่อยออกมา ฉันพบเพียงการใช้งานอย่างง่าย ๆ ของ 0.02... ในการเปิดตัว image-gpt ฉันพบว่ามันใช้สำหรับ c_proj และแม้กระทั่งสำหรับ attn เท่านั้น ไม่ใช่สำหรับ mlp หือ https: //github.com/openai/image-gpt/blob/master/src/model.py)
• คำศัพท์ขยายเป็น 50,257
• เพิ่มขนาดบริบทจาก 512 เป็น 1,024 โทเค็น
• ใช้ขนาดแบตช์ที่ใหญ่กว่า 512
• GPT-2 ใช้ 48 เลเยอร์และ d_model 1600 (เทียบกับ 12 เลเยอร์ดั้งเดิมและ d_model 768) ~1.542B พารามิเตอร์

โมเดลภาษาเป็นผู้เรียนเพียงไม่กี่คน (GPT-3)

• GPT-3: 96 เลเยอร์ 96 หัว พร้อม d_model 12,288 (พารามิเตอร์ 175B)
• GPT-1-like: 12 ชั้น 12 หัว d_model 768 (125M)
• เราใช้โมเดลและสถาปัตยกรรมเดียวกันกับ GPT-2 รวมถึงการกำหนดค่าเริ่มต้นที่แก้ไข การทำให้เป็นมาตรฐานล่วงหน้า และโทเค็นแบบย้อนกลับที่อธิบายไว้ในนั้น
• เราใช้รูปแบบความสนใจแบบกระจัดกระจายสลับหนาแน่นและมีแถบสีเฉพาะในชั้นของหม้อแปลง คล้ายกับ Sparse Transformer
• เรามีเลเยอร์ feedforward สี่เท่าของขนาดของเลเยอร์คอขวดเสมอ dff = 4 ∗ dmodel
• ทุกรุ่นใช้หน้าต่างบริบทของโทเค็น nctx = 2048
• อดัมที่มี β1 = 0.9, β2 = 0.95 และ eps = 10−8
• ทุกรุ่นใช้น้ำหนักที่ลดลง 0.1 เพื่อให้มีการปรับให้เป็นมาตรฐานเล็กน้อย (หมายเหตุ: GPT-1 ใช้ 0.01 ฉันเชื่อว่าดูด้านบน)
• ตัดบรรทัดฐานสากลของการไล่ระดับสีที่ 1.0
• การอุ่นเครื่อง Linear LR ใน 375 ล้านโทเค็นแรก จากนั้นใช้การสลายตัวของโคไซน์สำหรับอัตราการเรียนรู้ลดลงเหลือ 10% ของมูลค่า มากกว่า 260 พันล้านโทเค็น
• ค่อยๆ เพิ่มขนาดแบตช์เชิงเส้นจากค่าเล็กน้อย (32,000 โทเค็น) ไปเป็นมูลค่าเต็มในช่วง 4-12 พันล้านโทเค็นแรกของการฝึก ขึ้นอยู่กับขนาดของโมเดล
• หน้าต่างบริบทเวลาขนาดเต็ม 2048 จะถูกใช้เสมอ โดยมีตัวคั่นโทเค็น END OF DOCUMENT พิเศษ

การฝึกอบรมเบื้องต้นจากพิกเซล (Image GPT)

• เมื่อทำงานกับรูปภาพ เราจะเลือกการเรียงสับเปลี่ยนเอกลักษณ์ πi = i สำหรับ 1 ≤ i ≤ n หรือที่เรียกว่าลำดับแรสเตอร์
• เราสร้างจานสี 9 บิตของเราเองโดยการจัดกลุ่มค่าพิกเซล (R, G, B) โดยใช้ k-mean โดยมี k = 512
• iGPT-XL รุ่นที่ใหญ่ที่สุดของเรามีเลเยอร์ L = 60 เลเยอร์และใช้ขนาดการฝัง d = 3072 สำหรับพารามิเตอร์ทั้งหมด 6.8B
• iGPT-L โมเดลที่ใหญ่ที่สุดถัดไปของเรานั้นโดยพื้นฐานแล้วจะเหมือนกับ GPT-2 ที่มีเลเยอร์ L = 48 แต่มีขนาดการฝังที่เล็กกว่าเล็กน้อยคือ d = 1536 (เทียบกับ 1600) สำหรับพารามิเตอร์ทั้งหมด 1.4B
• เราใช้โค้ดโมเดลเดียวกันกับ GPT-2 ยกเว้นว่าเราเริ่มต้นน้ำหนักในลักษณะที่ขึ้นกับเลเยอร์เช่นเดียวกับใน Sparse Transformer (Child et al., 2019) และเตรียมค่าเริ่มต้นเป็นศูนย์การฉายภาพทั้งหมดที่สร้างการบันทึก
• นอกจากนี้เรายังฝึก iGPT-M ซึ่งเป็นโมเดลพารามิเตอร์ 455M ที่มี L = 36 และ d = 1,024
• iGPT-S ซึ่งเป็นโมเดลพารามิเตอร์ 76M ที่มี L = 24 และ d = 512 (โอเค ​​แล้วมีกี่หัวล่ะ ดูเหมือนโค้ด Github จะอ้างสิทธิ์ 8)
• เมื่อฝึก iGPT-XL ล่วงหน้า เราจะใช้ขนาดแบทช์ 64 และฝึกสำหรับการวนซ้ำ 2M และสำหรับรุ่นอื่นๆ ทั้งหมดที่เราใช้ขนาดแบทช์ 128 และฝึกฝนสำหรับการวนซ้ำ 1M
• อดัมที่มี β1 = 0.9 และ β2 = 0.95
• อัตราการเรียนรู้จะอุ่นขึ้นสำหรับหนึ่งยุค และจากนั้นจะลดลงเหลือ 0
• เราไม่ได้ใช้การสลายตัวของน้ำหนักเนื่องจากการใช้การสลายตัวของน้ำหนักเล็กน้อยที่ 0.01 ไม่ได้เปลี่ยนคุณภาพการเป็นตัวแทน
• iGPT-S lr 0.003
• ไม่มีการใช้ dropout

ใบอนุญาต

เอ็มไอที