gpt neo ดาวน์โหลด - ดาวน์โหลด gpt neo ซอร์สโค้ด

gpt neo

โค้ดแหล่งที่มา AI

v1.1.1

ดาวน์โหลด

จีพีที นีโอ

* ณ เดือนสิงหาคม 2021 จะไม่มีการบำรุงรักษาโค้ดอีกต่อไป มันถูกเก็บรักษาไว้ที่นี่ในรูปแบบจดหมายเหตุสำหรับผู้ที่ต้องการใช้ต่อไป

- 1T หรือจับพวกของฉัน ?

การใช้งานโมเดลและข้อมูลแบบขนาน GPT3 โดยใช้ไลบรารี mesh-tensorflow

หากคุณเพียงมาที่นี่เพื่อเล่นกับโมเดลที่ผ่านการฝึกอบรมมาแล้วของเรา เราขอแนะนำให้คุณลองใช้การผสานรวม HuggingFace Transformer

การฝึกอบรมและการอนุมานได้รับการสนับสนุนอย่างเป็นทางการบน TPU และควรใช้ได้กับ GPU เช่นกัน พื้นที่เก็บข้อมูลนี้จะถูกเก็บถาวร (ส่วนใหญ่) ในขณะที่เราย้ายโฟกัสไปที่ repo เฉพาะ GPU ของเรา GPT-NeoX

นอกจากฟังก์ชันการทำงานที่นำเสนอโดย GPT-3 แล้ว เรายังนำเสนอสิ่งต่อไปนี้ด้วย:

ความสนใจในท้องถิ่น
ความสนใจเชิงเส้น
การผสมผสานของผู้เชี่ยวชาญ
การฝังตำแหน่งตามแนวแกน

หมายเหตุ แม้ว่านีโอสามารถรันขั้นตอนการฝึกใน ทางเทคนิค ที่พารามิเตอร์ 200B+ ได้ แต่ก็ไม่มีประสิทธิภาพมากในระดับเหล่านั้น สิ่งนี้ประกอบกับความจริงที่ว่า GPU จำนวนมากพร้อมใช้งานสำหรับเรา เหนือสิ่งอื่นใด กระตุ้นให้เราย้ายการพัฒนาไปยัง GPT-NeoX

โมเดลที่ผ่านการฝึกอบรมมาแล้ว

อัปเดต 21/03/2021:

เราภูมิใจที่จะเปิดตัวรุ่น GPT-Neo ที่ได้รับการฝึกล่วงหน้าสองรุ่นที่ได้รับการฝึกบน The Pile โดยสามารถดาวน์โหลดน้ำหนักและการกำหนดค่าได้ฟรีจาก the-eye.eu

1.3B: https://mystic.the-eye.eu/public/AI/gptneo-release/GPT3_XL/

2.7B: https://mystic.the-eye.eu/public/AI/gptneo-release/GPT3_2-7B/

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับวิธีตั้งค่าเหล่านี้ โปรดดูสมุดบันทึก colab หรืออ่านส่วนที่เหลือของ Readme

การประเมินแบบจำลอง

การใช้เหตุผลทางภาษาศาสตร์

รุ่นและขนาด	เสาเข็ม BPB	ไพล์ พีพีแอล	วิกิข้อความ PPL	แลมบาดา พีพีแอล	แลมบาดาแอค	วิโนแกรนด์	เฮลลาสวัก
จีพีที-นีโอ 125เอ็ม	-	-	32.285	30.266	37.36%	50.43%	28.67%
จีพีที-3 125เอ็ม	-	-	-	18.6	42.7%	52.0%	33.7%
จีพีที-นีโอ 350เอ็ม	-	-	22.5657	13.876	47.27%	51.14%	32.16%
จีพีที-3 350เอ็ม	-	-	-	9.09	54.3%	52.1%	43.6%
GPT-3 เอดา	0.9631	-	-	9.954	51.60%	52.90%	35.93%
จีพีที-นีโอ 1.3B	0.7527	6.159	13.10	7.498	57.23%	55.01%	38.66%
จีพีที-3 1.3B	-	-	-	5.44	63.6%	58.7%	54.7%
จีพีที-2 1.5B	1.0468	-	17.48	10.634	51.21%	59.40%	40.03%
จีพีที-นีโอ 2.7B	0.7165	5.646	11.39	5.626	62.22%	56.50%	42.73%
จีพีที-3 2.7B	-	-	-	4.60	67.1%	62.3%	62.8%

การใช้เหตุผลทางกายภาพและทางวิทยาศาสตร์

รุ่นและขนาด	MathQA	PubMedQA	ปิกา
จีพีที-นีโอ 125เอ็ม	22.78%	55.10%	63.06%
จีพีที-3 125เอ็ม	-	-	64.6%
จีพีที-นีโอ 350เอ็ม	23.45%	53.80%	65.07%
จีพีที-3 350เอ็ม	-	-	70.2%
GPT-3 เอดา	24.29%	52.80%	68.88%
จีพีที-นีโอ 1.3B	24.05%	54.40%	71.11%
จีพีที-3 1.3B	-	-	75.1%
จีพีที-2 1.5B	23.64%	58.33%	70.78%
จีพีที-นีโอ 2.7B	24.72%	57.54%	72.14%
จีพีที-3 2.7B	-	-	75.6%

หมายเหตุ: การประเมินทั้งหมดดำเนินการโดยใช้สายรัดการประเมินของเรา ผลลัพธ์บางอย่างสำหรับ GPT-2 และ GPT-3 ไม่สอดคล้องกับค่าที่รายงานในเอกสารที่เกี่ยวข้อง ขณะนี้เรากำลังพิจารณาสาเหตุ และยินดีอย่างยิ่งที่ได้รับคำติชมและการทดสอบสายรัด Eval ของเราเพิ่มเติม

ตั้งค่า

git clone https://github.com/EleutherAI/GPTNeo
cd GPTNeo
pip3 install -r requirements.txt

การตั้งค่าการฝึกอบรม

TPU:

ลงชื่อสมัครใช้ Google Cloud Platform และสร้างที่เก็บข้อมูล

สร้าง VM ของคุณผ่าน Google Shell ( https://ssh.cloud.google.com/ ) ด้วย ctpu up --vm-only เพื่อให้สามารถเชื่อมต่อกับที่เก็บข้อมูล Google และ TPU ของคุณและติดตั้งข้อกำหนดด้วย pip (ดูด้านบน) .

Google colab ให้บริการ tpu-v8 ฟรี ซึ่งน่าจะเพียงพอที่จะปรับแต่งโมเดลของเราให้มีขนาดสูงสุดเป็น GPT3XL (พารามิเตอร์ 1.5B) คลิกเพื่อดูสมุดบันทึก Colab ตัวอย่างของเรา

หากต้องการคำแนะนำโดยละเอียดเพิ่มเติม โปรดดูคู่มือการฝึกอบรมด้านล่าง

GPU:

คุณยังสามารถเลือกที่จะฝึก GPTNeo ภายในเครื่องบน GPU ของคุณได้ ในการทำเช่นนั้น คุณสามารถละเว้นขั้นตอนการตั้งค่า Google Cloud ด้านบนได้ และคอมไพล์ Repo ในเครื่อง ดำเนินการตามคู่มือการฝึกอบรมด้านล่าง จากนั้นเมื่อเรียกใช้ main.py คุณเพียงแค่ต้องละเว้นแฟล็ก tpu และส่งผ่าน GPU id แทน

หมายเหตุ: ผู้ใช้บางรายรายงานว่ามีปัญหาในการทำให้ MTF จดจำ GPU ของตนได้ ดูรายละเอียดและคำแนะนำเกี่ยวกับวิธีการแก้ไขได้ที่นี่

กำลังสร้างข้อความ

เมื่อคุณมีโมเดลที่ได้รับการฝึกอบรมแล้ว หรือดาวน์โหลดหนึ่งในโมเดลที่ได้รับการฝึกอบรมมาแล้วของเรา การสร้างข้อความก็ทำได้ง่ายเพียงแค่เรียกใช้สคริปต์ main.py โดยเปิดแฟล็ก --predict คุณสามารถส่งเส้นทางไปยังไฟล์ prompt txt ของคุณได้โดยใช้แฟล็ก --prompt เช่น:

python3 main.py --predict --prompt < example_prompt.txt > --tpu < tpu_name > --model < config_name >

หรือหากใช้ GPU:

python3 main.py --predict --prompt < example_prompt.txt > --gpu_ids < device:GPU:0 device:GPU: 1> --model < config_name >

คู่มือการฝึกอบรม

1. สร้าง Tokenizer ของคุณ (ไม่บังคับ)

เราขอแนะนำให้คุณใช้โทเค็น GPT2 ที่ได้รับการฝึกล่วงหน้าของ Huggingface กับ repo ของเรา (คำแนะนำด้านล่าง) แต่หากคุณต้องการฝึกโมเดลที่มีขนาดคำศัพท์ที่แตกต่างกัน เราก็จัดเตรียมสิ่งอำนวยความสะดวกในการฝึกโทเค็นไนเซอร์ของคุณเองดังนี้:

python data/train_tokenizer.py 
    --base_dir ./path/to/your/txt/files 
    --output_dir ./output/path 
    --file_type txt 
    --vocab_size 50257

# if it succeeded, you should see the message
# 'tokenizer saved at ./output/path/byte-level-bpe.tokenizer.json'

2. Tokenizing ชุดข้อมูลของคุณ

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

 wget https://storage.googleapis.com/connors-datasets/bundestag/bundestag_0.tfrecords

จากนั้นคัดลอกข้อมูลไปยังบัคเก็ตของคุณ หรือหากใช้ GPU ไดเรกทอรีในเครื่อง:

 gsutil cp bundestag_0.tfrecords gs://<your bucket>/

หากใช้ข้อมูลของคุณเองในการฝึก คุณสามารถใช้สคริปต์ data/create_tfrecords.py เพื่อเข้ารหัสข้อมูลข้อความของคุณเป็น tfrecords

ข้อมูลของคุณต้องอยู่ในรูปแบบไฟล์ .txt ปกติจำนวนมาก (หนึ่งเอกสารต่อไฟล์) หรือในรูปแบบใดๆ ที่ lm_dataformat รองรับ

คุณสามารถเรียกใช้สคริปต์โดยไม่มีพารามิเตอร์เพื่อดูวิธีใช้สำหรับตัวเลือกทั้งหมด

ใน โหมดเอกสาร แต่ละตัวอย่างใน tfrecords คือเอกสารหนึ่งฉบับ (ขนาดแปรผัน) ซึ่งจะใช้กับโหมดการสุ่มตัวอย่าง documents_fixed และ documents_random (สำหรับรายละเอียดเพิ่มเติม โปรดดูส่วนอ้างอิงพารามิเตอร์) โหมดเอกสารเป็นโหมดเริ่มต้น

คำสั่งด้านล่างจะสร้างโทเค็นไฟล์ทั้งหมดในรูปแบบที่ยอมรับได้ใน base_dir โดยใช้โทเค็น gpt2 และบันทึกลงใน output_dir

 python3 create_tfrecords.py --mode documents --input_dir <base> --name <name> --output_dir <output> --use_gpt2_tokenizer --minimum_size <min>

input_dir : กำหนดโฟลเดอร์ที่มีข้อมูลของคุณอยู่ สคริปต์จะเข้ารหัสไฟล์ทั้งหมดที่อยู่ในโฟลเดอร์นี้
name : ชื่อของไฟล์เอาต์พุตจะเป็น name_i.tfrecords โดยที่ i คือหมายเลขของไฟล์
output_dir : ตำแหน่งที่จะบันทึก tfrecords ไว้
use_gpt2_tokenizer : จะใช้โทเค็น HuggingFace GPT2 ที่ผ่านการฝึกอบรมมาแล้วหรือไม่ ซึ่งในกรณีนี้ตัวคั่นจะถูกตั้งค่าเป็น [50256]
encoder_path : หากไม่ได้ใช้โทเค็นไนเซอร์ gpt2 ที่ได้รับการฝึกล่วงหน้า ให้ใช้แฟล็กนี้เพื่อจัดเตรียมเส้นทางไปยัง tokenizer json ที่คุณสร้างขึ้น
separator : เขียนในรูปแบบรายการ โทเค็นตัวคั่นเพื่อแทรกระหว่างเอกสาร (เช่น "[0]") จะขึ้นอยู่กับตัวเข้ารหัสของคุณ
minimum_size : ขนาดขั้นต่ำ (เป็นโทเค็น) ที่เอกสารต้องมี ไม่เช่นนั้นจะถูกละทิ้ง นี่คือสิ่งที่จะกำหนดพารามิเตอร์ stitch ของคุณในภายหลัง: stitch * minimum_size จะต้องมากกว่าหรือเท่ากับ n_ctx เสมอ (สำหรับรายละเอียดเพิ่มเติม โปรดดูส่วนอ้างอิงพารามิเตอร์)

4. การใช้ชุดข้อมูลในแบบจำลอง

หากต้องการใช้ชุดข้อมูลในโมเดล คุณต้องลงทะเบียนชุดข้อมูลนั้นในโฟลเดอร์ ./configs/dataset_configs ก่อน ขั้นแรก เลือกชื่อไฟล์ที่มีนามสกุล .json ชื่อไฟล์นั้นจะทำหน้าที่เป็นการระบุชุดข้อมูล ควรกรอกการกำหนดค่าในลักษณะต่อไปนี้

หากคุณมีชุดข้อมูลที่เข้ารหัสโดยใช้โทเค็นไนเซอร์ gpt2 ที่ได้รับการฝึกล่วงหน้า คุณสามารถระบุได้ดังนี้:

{
    "n_vocab" : 50257 ,
    "path" : " gs://neo-datasets/openwebtext-documents/openwebtext_*.tfrecords " ,
    "eval_path" : " gs://neo-datasets/openwebtext-documents/openwebtext_*.tfrecords " ,
    "tokenizer_is_pretrained" : true ,
    "tokenizer_path" : " gpt2 "
}

หรือหากคุณได้ฝึกฝนโทเค็นไนเซอร์แบบกำหนดเองแล้ว เช่น:

{
    "n_vocab" : 32768 ,
    "path" : " ./path/to/your/*.tfrecords " ,
    "eval_path" : " ./path/to/your/eval/*.tfrecords " ,
    "tokenizer_path" : " ./path/to/your/byte-level-bpe.tokenizer.json "
}

สุดท้าย ในการกำหนดค่าโมเดลของคุณ ให้เพิ่มชื่อไฟล์ที่คุณสร้างด้านบนลงในอาร์เรย์ datasets

<dataset id> จะเป็นชื่อไฟล์ ยกเว้น .json ที่คุณสร้างไว้ด้านบน

 "datasets": [[<dataset id>, <stitch>, <datatype>, <weight>]] # datasets key defines at run time how each dataset is processed for training

5. เลือกการกำหนดค่าโมเดล

เมื่อคุณตั้งค่าชุดข้อมูลแล้ว ให้ค้นหาการกำหนดค่าที่เหมาะสมใน /configs

ที่นี่เราใช้โมเดลขนาด GPT3-XL เป็นตัวอย่าง แต่มีโมเดลอื่นๆ อีกมากมายใน ./configs ซึ่งทั้งหมดมีบทสรุปสั้นๆ ในส่วน Available Configs

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

{
    "n_head" : 32 ,
    "n_vocab" : 50257 ,
    "embed_dropout" : 0.1 ,
    "lr" : 0.0002 ,
    "lr_decay" : " cosine " ,
    "warmup_steps" : 3000 ,
    "beta1" : 0.9 ,
    "beta2" : 0.95 ,
    "epsilon" : 1e-8 ,
    "opt_name" : " adam " ,
    "weight_decay" : 0.1 ,
    "train_batch_size" : 512 ,
    "attn_dropout" : 0.1 ,
    "train_steps" : 286150 ,
    "eval_steps" : 0 ,
    "predict_steps" : 1 ,
    "res_dropout" : 0.1 ,
    "eval_batch_size" : 128 ,
    "predict_batch_size" : 1 ,
    "iterations" : 2500 ,
    "n_embd" : 2048 ,
    "datasets" : [[ " your_dataset_name " , 25 , " documents_random " , 1.0 ]],
    "model_path" : " gs://neo-models/GPT3_XL " ,
    "n_ctx" : 2048 ,
    "n_layer" : 24 ,
    "scale_by_depth" : true ,
    "scale_by_in" : false ,
    "attention_types" :  [[[ " global " ], 24 ]],
    "mesh_shape" : " x:128,y:2 " ,
    "layout" : " batch:x,memory_length:y,embd:y " ,
    "activation_function" : " gelu " ,
    "recompute_grad" : true ,
    "gradient_clipping" : 1.0 ,
    "tokens_per_mb_per_replica" : 2048
}

6. ดำเนินการฝึกอบรม

 python3 main.py --model <your_config_name> --steps_per_checkpoint <n> --tpu <tpu-name>

tpu : ชื่อของ TPU ที่จะใช้
steps_per_checkpoint : ความถี่ในขั้นตอนที่จะบันทึกจุดตรวจ
--auto_layout และ --auto_layout_and_mesh_shape (ไม่บังคับ): ปิดการใช้งานการฝึกอบรมและสร้างเลย์เอาต์ที่มีประสิทธิภาพ layout ความจำโดยอัตโนมัติ (และ mesh_shape )
gpu_ids : หากฝึกโดยใช้ GPU ให้ละเว้นแฟล็ก tpu และส่งรหัสของ gpus ของคุณ ในตัวอย่างด้านล่าง เราฝึก GPU 3 ตัว โดยระบุรหัสอุปกรณ์โดยคั่นด้วยช่องว่าง:

 python3 main.py --model <your_config_name> --steps_per_checkpoint <n> --gpu_ids <device:GPU:0 device:GPU:1>

การกำหนดค่าที่มีอยู่

เรามีโมเดลให้เลือกหลายขนาด แต่การกำหนดค่าบางอย่างต้องใช้ TPU ขนาดใหญ่ และจะต้องปรับแต่งเพื่อให้ทำงานบนเครื่องขนาดเล็กหรือ GPU ได้ ด้านล่างนี้เป็นคำแนะนำสั้นๆ สำหรับแต่ละรุ่นในไดเร็กทอรี configs:

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

คุณสมบัติพิเศษ:

การอบรม (อันศักดิ์สิทธิ์)

Sacred ช่วยติดตามการทดลองและใช้งานได้ดีกว่าเทนเซอร์บอร์ดมาก

วิธีตั้งค่า:

ติดตั้ง Docker และ Docker-compose
เรียกใช้ docker-compose up

วิธีใช้:

ตรวจสอบให้แน่ใจว่า model_dir ไม่มีบันทึกเมตริกใด ๆ อยู่ในนั้น (โดยจะสะดุดข้อมูลเมตริกสำหรับเทนเซอร์บอร์ด ซึ่งถือว่ามันเป็นความต่อเนื่องของการรันที่มีอยู่) คุณสามารถใช้ gsutil rm -r ... เพื่อลบ model dir
เรียกใช้ python3 run_experiment.py --tpu sometpuhere --model someconfig.json ตัวเลือกเหมือนกับ main.py
คุณสามารถไปที่ http://server_ip_goes_here:8081/ เพื่อดูภาพรวม Omniboard หากคุณต้องการที่จะเห็นเทนเซอร์บอร์ด สคริปต์ก็จะหมุนขึ้นหนึ่งอันและกำหนดพอร์ตให้กับมันโดยอัตโนมัติ สคริปต์ควรพิมพ์พอร์ตเทนเซอร์บอร์ดใกล้กับด้านบนของบันทึก

การดูชุดข้อมูล

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

python main --model {config_name} --check_dataset

การสร้างแบบจำลองภาษามาสก์

นอกจากความสามารถในการฝึกอบรม GPT ขนาดใหญ่แล้ว พื้นที่เก็บข้อมูลนี้ยังช่วยให้คุณสร้างแบบจำลองภาษาที่สวมหน้ากาก (BERT, RoBERTa) ได้อย่างง่ายดาย คุณต้องทำตามขั้นตอนเพิ่มเติมอีกสองขั้นตอนจึงจะทำเช่นนั้นได้

เมื่อสร้างโทเค็นชุดข้อมูล คุณต้องจองรหัสพิเศษสำหรับโทเค็น [mask]
ในการกำหนดค่า คุณจะต้องกำหนดฟิลด์เพิ่มเติมอีกสองฟิลด์

 "mlm_training" : true ,                           # must be set to true
"mlm_mask_id" : < mask id >                        # the mask id that you reserved from above

นั่นคือทั้งหมดที่คุณต้องใช้ในการฝึกฝนโมเดลโดยมีวัตถุประสงค์ MLM ซึ่งเหมาะสำหรับข้อมูลทุกประเภทที่คุณเข้ารหัสอย่างถูกต้อง หากคุณต้องการปรับแต่งไฮเปอร์พารามิเตอร์อื่นๆ ที่เกี่ยวข้อง โปรดอ่านต่อ

 "mlm_cls_token_id" : < cls token id > ,                # auto append specified CLS token id on the left
"mlm_mask_prob" : 0.15 ,                             # the probability of masking a token, defaults to 15%
"mlm_same_token_prob" : 0.10 ,                       # probability of keeping the token the same, defaults to 10%
"mlm_random_token_prob" : 0.10 ,                     # probability of tokens that are replaced with random tokens, 10% was recommended by the BERT paper
"mlm_mask_ignore_ids" : [ < cls token > , < sep token > ]  # ignore masking other special tokens, if any

การอ้างอิงพารามิเตอร์

เลือกการกำหนดค่าที่ถูกต้องจาก /configs และปรับแต่งพารามิเตอร์ตามต้องการ:

n_heads : จำนวนหัวความสนใจ
n_embd : ขนาดของเลเยอร์ที่ซ่อนอยู่จะต้องหารด้วย n_heads ลงตัว
n_vocab : ขนาดคำศัพท์
embed_dropout , res_dropout , attn_dropout : ความน่าจะเป็นของการออกกลางคันสำหรับการฝังคำ/สิ่งตกค้าง/ความสนใจ
lr : อัตราการเรียนรู้
warmup_steps : จำนวนก้าวก่อนที่จะถึงอัตราการเรียนรู้เต็ม (ทางลาดเชิงเส้นจาก 0 ถึง lr )
lr_decay : cosine หรือ linear
opt_name : adam หรือ adafactor
beta1 , beta2 และ epsilon : พารามิเตอร์ของเครื่องมือเพิ่มประสิทธิภาพ adam
beta1 , ada_epsilon1 และ ada_epsilon2 : พารามิเตอร์เครื่องมือเพิ่ม adafactor
weight_decay : พารามิเตอร์การลดน้ำหนัก หากไม่มีอยู่ ก็จะไม่มีการใช้การลดน้ำหนัก (ใช้การแก้ไขการลดน้ำหนักสำหรับ Adam) (ค่าเริ่มต้น: 0.01) (เป็นทางเลือก)
train_batch_size : ขนาดแบตช์ระหว่างการฝึก
train_steps : จำนวนขั้นตอนการฝึกอบรม (แบทช์) ตั้งค่าเป็นประมาณ ~ 1 ยุคสำหรับตอนนี้ (จำนวนโทเค็นทั้งหมดในชุดข้อมูลของคุณ / จำนวนโทเค็นต่อชุด (= train_batch_size / n_ctx ))
eval_steps : จำนวนขั้นตอนที่ต้องดำเนินการสำหรับการประเมินแต่ละครั้ง ตั้งค่าเป็น 0 หากไม่มีการประเมิน กล่าวคือ หลังจากทุกจุดตรวจสอบ โมเดลจะได้รับการทดสอบสำหรับ eval_steps
iterations : จำนวนขั้นตอนที่อยู่ในคิวไปยัง TPU ต้องน้อยกว่า steps_per_checkpoint (ค่าเริ่มต้น: 500)
datasets : รายการชุดข้อมูล tfrecords ที่จะใช้ ชุดข้อมูลแต่ละชุดเป็นรายการที่มีพารามิเตอร์ต่อไปนี้: [train glob , eval glob, stitch, sampling_mode, weight] ตัวอย่างเช่นสำหรับชุดข้อมูลเดียว (สังเกตรายการคู่): [["bundestag_*.tfrecords", "", 10, "random_sample", 1.0]]
- dataset_id : ชื่อของไฟล์การกำหนดค่าชุดข้อมูลใน ./configs/dataset_configs
- stitch : หากใช้ sampling_mode random_sample ไปป์ไลน์อินพุตจะสุ่มตัวอย่างข้อความจำนวนนี้ให้เป็นหนึ่งเดียวเพื่อสุ่มตัวอย่าง คุณต้องเลือกตะเข็บเพื่อให้ stitch * minimum_document_length >= n_ctx
- sampling_mode : chunks (tfrecords ถูกประมวลผลล่วงหน้าเป็นความยาวที่ถูกต้องและอ่านตามลำดับ) หรือ documents_random (จำนวน stitch ของเอกสารถูกต่อเข้าด้วยกันแล้วชิ้น n_ctx จะถูกสุ่มย่อยแบบสุ่ม)
- weights : ชุดข้อมูลนี้ควรมีน้ำหนักสัมพัทธ์มากน้อยเพียงใดเมื่อเทียบกับชุดอื่นๆ
model : โมเดลไหนที่จะฝึก ปัจจุบันรองรับเฉพาะ GPT เท่านั้น และจะมีค่าเริ่มต้นเป็นเช่นนี้หากไม่มี
model_path : ตำแหน่งที่เก็บข้อมูลของ Google (หรือเส้นทางในเครื่อง หากใช้ GPU) เพื่อบันทึกจุดตรวจสอบและบันทึกของโมเดล
n_ctx : ขนาดของหน้าต่างบริบท ค่าเริ่มต้นคือ 2048
n_layer : จำนวนเลเยอร์ (บล็อก) ในโมเดล
scale_by_depth : หากเป็นจริง การเริ่มต้นน้ำหนักของเลเยอร์จะถูกปรับขนาดตามความลึกเช่นเดียวกับในกระดาษ GPT2
scale_by_in : หากเป็นจริง การเริ่มต้นน้ำหนักของเลเยอร์จะถูกปรับขนาดตามจำนวนอินพุตเช่นเดียวกับในกระดาษ GPT2
mesh_shape : Mesh คืออาร์เรย์ n มิติของโปรเซสเซอร์ที่มีขนาดที่ระบุชื่อซึ่งใช้สำหรับการขนานในไลบรารี mesh-tensorflow เทนเซอร์แต่ละตัวจะแบ่งเท่าๆ กันตามขนาดตาข่ายตามเค้าโครง (ดูด้านล่าง) 'mesh_shape' คือรูปร่างของอาร์เรย์นี้ และจะต้องเท่ากับจำนวนโปรเซสเซอร์ เช่น สำหรับ v3-128 TPU "mesh_shape": “x:16,y:8”
layout : Tensor ถูกวางบนตาข่ายโดยมีหนึ่งชิ้นบนโปรเซสเซอร์แต่ละตัว "เค้าโครง" ของเทนเซอร์เป็นแผนที่บางส่วนแบบฉีดซึ่งระบุขนาดของเทนเซอร์ที่แยก (เท่ากัน) ตามขนาดของตาข่าย ไม่มีมิติของเทนเซอร์ที่จะแยกออกเป็นสองมิติของตาข่าย และไม่สามารถแยกเทนเซอร์สองมิติในมิติเดียวกันของตาข่ายได้ ผู้ใช้กำหนดชุดกฎโครงร่างส่วนกลางในรูปแบบของคู่ (ชื่อมิติเทนเซอร์ ชื่อมิติมิติ) มิติของเทนเซอร์จะถูกแบ่งไปตามมิติของเมชหากมีกฎที่ตรงกัน เช่น (สำหรับตัวอย่างด้านบน mesh_shape: "layout":batch:x,heads:y"
activation_function : selu (การทำให้ตัวเองเป็นมาตรฐาน) หรือ gelu (ใช้โดย OA) ฟังก์ชันการเปิดใช้งานที่ใช้ในการส่งต่อฟีด (ค่าเริ่มต้น: gelu)
attention_types : ประเภทของความสนใจสำหรับแต่ละเลเยอร์ในรายการรูปแบบต่อไปนี้ [[["attention_type"], n_layers]] เช่นสำหรับตาข่าย 12 ชั้น [[["global"], 12]] หรือ [[["local"], 10], [["global"], 2]]
- เลือกจาก: linear , global , local หรือ none เราพบว่าการผสมผสานระหว่าง global และ linear 50/50 เพื่อให้ทำงานได้ดี none อนุญาตให้คุณสร้างเลเยอร์ฟีดไปข้างหน้าเท่านั้นสำหรับโมเดล PAR Transformer ที่มีประสิทธิภาพมากขึ้น
precision : float32 หรือ bfloat16
tokens_per_mb_per_replica : หากไม่ใช่ไม่มี จะแบ่งแบทช์ออกเป็นไมโครแบทช์เล็กๆ ที่มีโทเค็น tokens_per_mb_per_replica เพื่อหลีกเลี่ยง OOM การไล่ระดับสีจะสะสมในพื้นที่และลดลงหนึ่งครั้ง สิ่งสำคัญ: mb หมายถึง minibatch ไม่ใช่เมกะไบต์ที่นี่

การผสมผสานของผู้เชี่ยวชาญ

moe_layers : รายการหมายเลขเลเยอร์ที่จะต่อท้ายส่วนผสมของผู้เชี่ยวชาญที่เลเยอร์ไว้ เช่น: [2,4,6,8,10,12] . เราได้ทดลองพบชั้น moe เพื่อให้ชั้นการเอาใจใส่ตนเองทุก ๆ สองชั้นทำงานได้ดี
moe_params : พจนานุกรมของ kwargs เพิ่มเติมที่จะส่งผ่านไปยังเลเยอร์ moe เช่น {"moe_dropout_rate": 0.0 }

คุณสมบัติการทดลอง

axial_pos_emb_ : หากเป็นจริง ให้ใช้ [การฝังตำแหน่งตามแนวแกน](https://arxiv.org/abs/1912.12180
mlp_glu : หากเป็นจริง ให้ใช้ตัวแปรหน่วยเชิงเส้นที่มีรั้วรอบขอบชิดของเลเยอร์ฟีดไปข้างหน้า
scalenorm : หากเป็นจริง ให้ใช้ scalenorm แทน layernorm
rezero : หากเป็นจริง ให้ใช้ rezero แทน layernorm
num_mem_kv : เพิ่มหน่วยความจำ / ค่าคีย์จากเอกสารที่ให้ความสนใจทั้งหมด Param เป็น int ที่มีค่า mem/key ที่ต้องการ
macaron : ถ้าเป็นจริง - ใช้หม้อแปลงมาการองสำหรับบล็อกแต่ละเลเยอร์

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

จัดทำเอกสารให้เสร็จสิ้น
อัปเดตการกำหนดค่า

อ้างถึง GPT-Neo

หากคุณพบว่า GPT-Neo มีประโยชน์ในการทำงานของคุณ คุณสามารถอ้างอิงที่เก็บนี้เป็นได้

 @software{gpt-neo,
  author       = {Black, Sid and
                  Gao, Leo and
                  Wang, Phil and
                  Leahy, Connor and
                  Biderman, Stella},
  title        = {{GPT-Neo: Large Scale Autoregressive Language 
                   Modeling with Mesh-Tensorflow}},
  month        = mar,
  year         = 2021,
  note         = {{If you use this software, please cite it using 
                   these metadata.}},
  publisher    = {Zenodo},
  version      = {1.0},
  doi          = {10.5281/zenodo.5297715},
  url          = {https://doi.org/10.5281/zenodo.5297715}
}

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

หากคุณสนใจโดยเฉพาะในการอ้างอิงรุ่น GPT-Neo ที่ได้รับการฝึกบน Pile เราขอขอบคุณที่อ้างอิงเช่นกัน

 @article{gao2020pile,
  title={The Pile: An 800GB Dataset of Diverse Text for Language Modeling},
  author={Gao, Leo and Biderman, Stella and Black, Sid and Golding, Laurence and Hoppe, Travis and Foster, Charles and Phang, Jason and He, Horace and Thite, Anish and Nabeshima, Noa and others},
  journal={arXiv preprint arXiv:2101.00027},
  year={2020}
}

ขยาย

ข้อมูลเพิ่มเติม