หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>หลาม
ดาวน์โหลด

Pytorch pretrained biggan

การเปิดตัว Pytorch Op-Op การปรับแต่งรุ่น Biggan ของ DeepMind ด้วยน้ำหนักที่ได้รับการฝึกอบรมล่วงหน้าจาก DeepMind

การแนะนำ

พื้นที่เก็บข้อมูลนี้มีการเปิดตัว Pytorch Op-for-op ของ Biggan ของ DeepMind ที่ได้รับการปล่อยตัวด้วยการฝึกอบรม GAN ขนาดใหญ่สำหรับการสังเคราะห์ภาพธรรมชาติที่มีความเที่ยงตรงสูงโดย Andrew Brock, Jeff Donahue และ Karen Simonyan

การใช้งาน Pytorch ของ Biggan นี้มาพร้อมกับรุ่น 128x128, 256x256 และ 512x512 ที่ได้รับการฝึกฝนโดย DeepMind นอกจากนี้เรายังให้สคริปต์ที่ใช้ในการดาวน์โหลดและแปลงรุ่นเหล่านี้จากรุ่น Tensorflow Hub

การปรับปรุงใหม่นี้ทำจากกราฟการคำนวณแบบดิบของรุ่น Tensorflow และทำงานคล้ายกับรุ่น Tensorflow (ความแปรปรวนของความแตกต่างของเอาต์พุตของลำดับของ 1E-5)

การใช้งานนี้มีเพียงเครื่องกำเนิดไฟฟ้าเท่านั้นเนื่องจากน้ำหนักของ discriminator ไม่ได้ถูกปล่อยออกมา (แม้ว่าโครงสร้างของ discriminator นั้นคล้ายกับเครื่องกำเนิดไฟฟ้ามากดังนั้นจึงสามารถเพิ่มได้อย่างง่ายดายบอกฉันว่าคุณต้องการทำ PR หรือไม่

การติดตั้ง

repo นี้ได้รับการทดสอบใน Python 3.6 และ Pytorch 1.0.1

Pytorch Biggan สามารถติดตั้งได้จาก PIP ดังนี้: 

pip install pytorch-pretrained-biggan

หากคุณเพียงแค่ต้องการเล่นกับกานก็ควรจะเพียงพอ

หากคุณต้องการใช้สคริปต์การแปลงและยูทิลิตี้ Imagenet จำเป็นต้องมีข้อกำหนดเพิ่มเติมโดยเฉพาะอย่างยิ่ง tensorflow และ NLTK หากต้องการติดตั้งข้อกำหนดทั้งหมดโปรดใช้ไฟล์ full_requirements.txt : 

git clone https://github.com/huggingface/pytorch-pretrained-BigGAN.git
cd pytorch-pretrained-BigGAN
pip install -r full_requirements.txt

แบบจำลอง

พื้นที่เก็บข้อมูลนี้ให้การเข้าถึงโดยตรงและง่าย ๆ ในเวอร์ชัน "ลึก" ของ Biggan สำหรับการแก้ปัญหา 128, 256 และ 512 พิกเซลตามที่อธิบายไว้ในสิ่งพิมพ์ที่เกี่ยวข้อง นี่คือรายละเอียดบางอย่างเกี่ยวกับโมเดล:

  • BigGAN-deep-128 : โมเดลพารามิเตอร์ 50.4m ที่สร้างภาพ 128x128 พิกเซลรุ่น Dump Dumps Model 201 MB
  • BigGAN-deep-256 : โมเดลพารามิเตอร์ 55.9m สร้างภาพ 256x256 พิกเซลรุ่น Dump Dump น้ำหนัก 224 MB
  • BigGAN-deep-512 : โมเดลพารามิเตอร์ 56.2m ที่สร้างภาพ 512x512 พิกเซลรุ่น Dump Dump รุ่น 225 MB

โปรดดูภาคผนวก B ของกระดาษสำหรับรายละเอียดเกี่ยวกับสถาปัตยกรรม

ทุกรุ่นประกอบด้วยสถิติบรรทัดฐานแบทช์ที่คำนวณไว้ล่วงหน้าสำหรับ 51 ค่าการตัดทอนระหว่าง 0 ถึง 1 (ดูภาคผนวก c.1 ในกระดาษเพื่อดูรายละเอียด)

การใช้งาน

นี่คือตัวอย่างที่เริ่มต้นอย่างรวดเร็วโดยใช้ BigGAN กับรุ่นที่ผ่านการฝึกอบรมมาก่อน

ดูส่วนเอกสารด้านล่างสำหรับรายละเอียดเกี่ยวกับคลาสและวิธีการเหล่านี้ 

 import torch
from pytorch_pretrained_biggan import ( BigGAN , one_hot_from_names , truncated_noise_sample ,
                                       save_as_images , display_in_terminal )

# OPTIONAL: if you want to have more information on what's happening, activate the logger as follows
import logging
logging . basicConfig ( level = logging . INFO )

# Load pre-trained model tokenizer (vocabulary)
model = BigGAN . from_pretrained ( 'biggan-deep-256' )

# Prepare a input
truncation = 0.4
class_vector = one_hot_from_names ([ 'soap bubble' , 'coffee' , 'mushroom' ], batch_size = 3 )
noise_vector = truncated_noise_sample ( truncation = truncation , batch_size = 3 )

# All in tensors
noise_vector = torch . from_numpy ( noise_vector )
class_vector = torch . from_numpy ( class_vector )

# If you have a GPU, put everything on cuda
noise_vector = noise_vector . to ( 'cuda' )
class_vector = class_vector . to ( 'cuda' )
model . to ( 'cuda' )

# Generate an image
with torch . no_grad ():
    output = model ( noise_vector , class_vector , truncation )

# If you have a GPU put back on CPU
output = output . to ( 'cpu' )

# If you have a sixtel compatible terminal you can display the images in the terminal
# (see https://github.com/saitoha/libsixel for details)
display_in_terminal ( output )

# Save results as png images
save_as_images ( output )

output_0output_1output_2

เอกสาร

โหลดน้ำหนักที่ได้รับการฝึกอบรมล่วงหน้าของ DeepMind

หากต้องการโหลดโมเดลที่ผ่านการฝึกอบรมล่วงหน้าของ DeepMind ให้สร้างอินสแตนซ์โมเดล BigGAN ด้วย from_pretrained() เป็น: 

 model = BigGAN . from_pretrained ( PRE_TRAINED_MODEL_NAME_OR_PATH , cache_dir = None )

ที่ไหน

  • PRE_TRAINED_MODEL_NAME_OR_PATH เป็น:

    • ชื่อทางลัดของโมเดลที่ผ่านการฝึกอบรมมาก่อนของ Google AI หรือ OpenAI ที่เลือกไว้ในรายการ:

      • biggan-deep-128 : 12-layer, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110m
      • biggan-deep-256 : 24 ชั้น, 1024 ซ่อน, 16 หัว, พารามิเตอร์ 340m
      • biggan-deep-512 : 12-layer, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110m

    • เส้นทางหรือ URL ไปยังที่เก็บถาวรแบบจำลองที่มีอยู่:

      • config.json : ไฟล์กำหนดค่าสำหรับรุ่นและ
      • pytorch_model.bin a pytorch dump ของอินสแตนซ์ที่ผ่านการฝึกอบรมมาก่อนของ BigGAN (บันทึกด้วย torch.save() )

    ~/.pytorch_pretrained_biggan/ PRE_TRAINED_MODEL_NAME_OR_PATH เป็นชื่อทางลัดน้ำหนักที่ได้รับการฝึกอบรมล่วงหน้าจะถูกดาวน์โหลดจาก AWS S3 (ดูลิงก์ที่นี่) และเก็บไว้ในโฟลเดอร์แคชเพื่อหลีกเลี่ยงการดาวน์โหลดในอนาคต

  • cache_dir สามารถเป็นเส้นทางเสริมไปยังไดเรกทอรีเฉพาะเพื่อดาวน์โหลดและแคชน้ำหนักรุ่นที่ผ่านการฝึกอบรมมาก่อน

การกำหนดค่า

BigGANConfig เป็นคลาสที่จะจัดเก็บและโหลดการกำหนดค่า Biggan มันถูกกำหนดไว้ใน config.py

นี่คือรายละเอียดบางอย่างเกี่ยวกับคุณลักษณะ:

  • output_dim : ความละเอียดเอาต์พุตของ GAN (128, 256 หรือ 512) สำหรับรุ่นที่ผ่านการฝึกอบรมมาก่อน
  • z_dim : ขนาดของเวกเตอร์เสียง (128 สำหรับรุ่นที่ผ่านการฝึกอบรมมาก่อน)
  • class_embed_dim : ขนาดของเวกเตอร์ฝังคลาส (128 สำหรับรุ่นที่ผ่านการฝึกอบรมมาก่อน)
  • channel_width : ขนาดของแต่ละช่อง (128 สำหรับรุ่นที่ผ่านการฝึกอบรมมาก่อน)
  • num_classes : จำนวนคลาสในชุดข้อมูลการฝึกอบรมเช่น ImageNet (1,000 สำหรับรุ่นที่ผ่านการฝึกอบรมมาก่อน)
  • layers : รายการคำจำกัดความของเลเยอร์ คำจำกัดความแต่ละคำสำหรับเลเยอร์เป็นสามเท่าของ [ตัวอย่างในเลเยอร์? (บูล), จำนวนช่องสัญญาณอินพุต (int), จำนวนช่องสัญญาณเอาต์พุต (int)]
  • attention_layer_position : ตำแหน่งของเลเยอร์การดูแลตนเองในลำดับชั้นของเลเยอร์ (8 สำหรับโมเดลที่ผ่านการฝึกอบรมมาก่อน)
  • eps : ค่า epsilon ที่จะใช้สำหรับเลเยอร์การทำให้เป็นมาตรฐานสเปกตรัมและชุด (1E-4 สำหรับรุ่นที่ผ่านการฝึกอบรมมาก่อน)
  • n_stats : จำนวนสถิติที่คำนวณล่วงหน้าสำหรับเลเยอร์การทำให้เป็นมาตรฐานของแบทช์ที่เกี่ยวข้องกับค่าการตัดทอนต่างๆระหว่าง 0 และ 1 (51 สำหรับโมเดลที่ผ่านการฝึกอบรมมาก่อน)

แบบอย่าง

BigGAN เป็นรุ่น Pytorch ( torch.nn.Module ) ของ Biggan ที่กำหนดไว้ใน model.py โมเดลนี้ประกอบด้วยคลาส Embeddings (เลเยอร์เชิงเส้น) และเครื่องกำเนิดไฟฟ้าที่มีชุดของ convolutions และบรรทัดฐานชุดเงื่อนไข ขณะนี้ discriminator ไม่ได้ใช้งานเนื่องจากน้ำหนักที่ได้รับการฝึกอบรมมาก่อนยังไม่ได้รับการปล่อยตัว

อินพุตและเอาต์พุต เหมือนกับอินพุตและเอาต์พุตแบบจำลอง TensorFlow

เราให้รายละเอียดที่นี่

BigGAN ใช้เป็น อินพุต :

  • z : คบเพลิง floattensor ของรูปร่าง [batch_size, config.z_dim] พร้อมเสียงรบกวนจากการแจกแจงปกติที่ถูกตัดทอนและ
  • class_label : คบเพลิงเสริม longtensor ของรูปร่าง [batch_size, sequence_length] พร้อมดัชนีประเภทโทเค็นที่เลือกใน [0, 1] Type 0 สอดคล้องกับ sentence A และ Type 1 สอดคล้องกับโทเค็น sentence B (ดู Bert Paper สำหรับรายละเอียดเพิ่มเติม)
  • truncation : ลอยระหว่าง 0 (ไม่ประกอบด้วย) และ 1 การตัดทอนของปกติที่ถูกตัดทอนที่ใช้สำหรับการสร้างเวกเตอร์เสียง ค่าการตัดทอนนี้ใช้เพื่อเลือกระหว่างชุดของสถิติที่คำนวณล่วงหน้า (หมายถึงและความแปรปรวน) สำหรับเลเยอร์บรรทัดฐานแบทช์

BigGAN ส่งออก อาร์เรย์ของรูปร่าง [batch_size, 3, ความละเอียด, ความละเอียด] โดยที่ความละเอียดคือ 128, 256 หรือ 512 ขึ้นอยู่กับแบบจำลอง:

ยูทิลิตี้: รูปภาพ, เสียง, คลาส Imagenet

เรามีวิธีการยูทิลิตี้สองสามอย่างในการใช้แบบจำลอง พวกเขาถูกกำหนดไว้ใน utils.py

นี่คือรายละเอียดบางอย่างเกี่ยวกับวิธีการเหล่านี้:

  • truncated_noise_sample(batch_size=1, dim_z=128, truncation=1., seed=None) :

    สร้างเวกเตอร์เสียงรบกวนที่ถูกตัดทอน

    • params:
      • batch_size: ขนาดแบทช์
      • dim_z: มิติของ z
      • การตัดทอน: ค่าการตัดทอนที่จะใช้
      • เมล็ด: เมล็ดสำหรับเครื่องกำเนิดไฟฟ้าแบบสุ่ม
    • เอาท์พุท: อาร์เรย์ของรูปร่าง (batch_size, dim_z)

  • convert_to_images(obj) :

    แปลงเทนเซอร์เอาท์พุทจาก Biggan ในรายการรูปภาพ

    • params:
      • OBJ: เทนเซอร์หรืออาร์เรย์ numpy (batch_size, ช่อง, ความสูง, ความกว้าง)
    • เอาท์พุท:
      • รายการภาพหมอนขนาด (ความสูงความกว้าง)

  • save_as_images(obj, file_name='output') :

    แปลงและบันทึกเทนเซอร์เอาท์พุทจาก Biggan ในรายการรูปภาพที่บันทึกไว้

    • params:
      • OBJ: เทนเซอร์หรืออาร์เรย์ numpy (batch_size, ช่อง, ความสูง, ความกว้าง)
      • file_name: พา ธ และขอทานในชื่อไฟล์เพื่อบันทึก รูปภาพจะถูกบันทึกเป็น file_name_{image_number}.png

  • display_in_terminal(obj) :

    แปลงและแสดงเทนเซอร์เอาท์พุทจาก Biggan ในเทอร์มินัล ฟังก์ชั่นนี้ใช้ libsixel และจะทำงานในเทอร์มินัลที่เข้ากันได้กับ Libsixel เท่านั้น โปรดดูที่ https://github.com/saitoha/libsixel สำหรับรายละเอียดเพิ่มเติม

    • params:
      • OBJ: เทนเซอร์หรืออาร์เรย์ numpy (batch_size, ช่อง, ความสูง, ความกว้าง)
      • file_name: พา ธ และขอทานในชื่อไฟล์เพื่อบันทึก รูปภาพจะถูกบันทึกเป็น file_name_{image_number}.png

  • one_hot_from_int(int_or_list, batch_size=1) :

    สร้างเวกเตอร์ร้อนหนึ่งตัวจากดัชนีคลาสหรือรายการดัชนีคลาส

    • params:
      • int_or_list: int หรือรายการ int, ของคลาส Imagenet (ระหว่าง 0 ถึง 999)
      • batch_size: ขนาดแบทช์
        • ถ้า int_or_list เป็น int สร้างชุดของคลาสที่เหมือนกัน
        • ถ้า int_or_list เป็นรายการเราควรมี len(int_or_list) == batch_size
    • เอาท์พุท:
      • อาร์เรย์ของรูปร่าง (batch_size, 1,000)

  • one_hot_from_names(class_name, batch_size=1) :

    สร้างเวกเตอร์ร้อนหนึ่งอันจากชื่อของคลาส Imagenet ('Tennis Ball', 'Daisy', ... ) เราใช้การค้นหา WordNet ของ NLTK เพื่อพยายามค้นหาซินเซ็ตที่เกี่ยวข้องของ ImageNet และใช้สิ่งแรก หากเราไม่พบมันอย่างแน่นอนเราจะดูที่ hyponyms และ hypernyms ของชื่อคลาส

    • params:
      • class_name: สตริงที่มีชื่อของวัตถุ Imagenet
    • เอาท์พุท:
      • อาร์เรย์ของรูปร่าง (batch_size, 1,000)

ดาวน์โหลดและแปลงสคริปต์

สคริปต์เพื่อดาวน์โหลดและแปลงรุ่น TensorFlow จาก Hub TensorFlow มีให้ใน./scripts

สคริปต์สามารถใช้โดยตรงเป็น: 

./scripts/download_tf_hub_models.sh
./scripts/convert_tf_hub_models.sh
ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด