Neural Radiance Fields หรือที่เรียกขานว่า NeRF ได้ถล่มโลกด้วยพายุในปี 2020 เผยแพร่พร้อมกับกระดาษ “NeRF: การแสดงฉากเป็นฟิลด์ Radiance ของระบบประสาทสำหรับการสังเคราะห์มุมมอง”และยังคงเป็นรากฐานที่สำคัญของการสังเคราะห์มุมมองใหม่ที่มีคุณภาพสูง เนื่องจากภาพและตำแหน่งกล้องที่เบาบาง
ตั้งแต่นั้นมา พวกเขาพบแอปพลิเคชันมากมาย แต่น่าจะโดดเด่นที่สุดในการสร้างแบบจำลองปริมาตรเชิงพื้นที่ โดยบริษัทต่างๆ เช่น Google พึ่งพา NeRF ในการสร้างโครงสร้าง 3 มิติของอาคารและแหล่งมรดกจากมุมต่างๆ ของภาพถ่ายดาวเทียม และบริษัทที่เชี่ยวชาญในการดำเนินการสร้างใหม่ 3 มิติและ การแปลงเป็นดิจิทัลของแหล่งวัฒนธรรมที่มีชื่อเสียง
ในคู่มือนี้ เราจะฝึกโมเดล Neural Radiance Field (NeRF) บนชุดข้อมูล Tiny NeRF ดั้งเดิม โดยใช้ TensorFlow/Keras และ DeepVision เพื่อดำเนินการสังเคราะห์มุมมองใหม่/สร้างใหม่ 3 มิติ
ในหนึ่งชั่วโมง บนเครื่องเชิงพาณิชย์ คุณจะแสดงมุมมองใหม่ๆ ของรูปภาพจากชุดข้อมูล TinyNeRF:
Novel View Synthesis และ Neural Radiance Fields
ส่วนนี้ให้ข้อมูลสรุป/บทนำที่เรียบง่ายเกี่ยวกับวิธีการทำงานของ Neural Radiance Fields แต่อาจต้องใช้เวลาพอสมควรในการแยกแยะวิธีการทำงานของฟิลด์เหล่านี้โดยสัญชาตญาณ หากคุณยังใหม่กับฟิลด์นี้
หมายเหตุ เอกสารต้นฉบับ ตลอดจนวิดีโอเพื่อการศึกษาและกราฟิกที่เกี่ยวข้องเป็นสื่อการเรียนรู้ที่ยอดเยี่ยม หากคุณสนใจที่จะเข้าใจแนวคิดพื้นฐานของ เขตความกระจ่างใส ที่ NeRF พึ่งพาเพื่อเป็นตัวแทนของฉาก รายการ Wikipedia สำหรับ "ทุ่งแสง" ให้การแนะนำที่ดี แต่สามารถสรุปได้ในระดับสูงเช่น
"สนามแสงเป็นฟังก์ชันเวกเตอร์ที่อธิบายปริมาณของแสงที่ไหลไปในทุกทิศทางผ่านทุกจุดในอวกาศ"
NeRF ใช้สำหรับ การสังเคราะห์มุมมองใหม่ – สร้างมุมมองใหม่ของวัตถุและรูปภาพ ในบางมุมมอง ในความเป็นจริง คุณสามารถนึกถึงการสังเคราะห์มุมมองใหม่เป็นการแปลง 2D->3D และมีหลายแนวทางในการแก้ปัญหานี้ ซึ่งบางวิธีก็ประสบความสำเร็จมากกว่าวิธีอื่นๆ
ในอดีตเป็นปัญหาที่ท้าทาย วิธีแก้ปัญหาที่เสนอโดย NeRFs นั้นเรียบง่ายมากแต่ให้ผลลัพธ์ที่ทันสมัย สร้างภาพคุณภาพสูงมากจากมุมที่แปลกใหม่:
โดยธรรมชาติแล้วสิ่งนี้วางตำแหน่งเหล่านี้เป็นแนวทางพื้นฐานในการแก้ปัญหาการสังเคราะห์มุมมองที่แปลกใหม่ โดยมีเอกสารมากมายที่ตามมาสำรวจ ปรับเปลี่ยน และปรับปรุงแนวคิดที่มีอยู่ในนั้น
คำแนะนำ: พื้นที่ เว็บไซต์ เผยแพร่พร้อมกับกระดาษที่มีการจัดแสดงวิธีการและผลที่น่าตื่นตาตื่นใจและ วิดีโอการศึกษา ที่สร้างสัญชาตญาณที่ดีเกี่ยวกับวิธีการทำงานของเครือข่ายเหล่านี้ได้รับการเผยแพร่อย่างเป็นทางการ
ขั้นตอนจากข้อมูลไปยังผลลัพธ์สามารถสรุปได้ดังนี้:
ที่ซึ่งโครงข่ายประสาทเทียมเรียนรู้จากภาพที่กระจัดกระจายด้วยการสร้างแบบสังเคราะห์ มยูข ที่ฉายและสุ่มตัวอย่างเป็นระยะๆ ภาพจะอยู่ในที่ว่างโดยให้ข้อมูลเมตาเกี่ยวกับภาพ เช่น ตำแหน่งกล้องเมื่อถ่ายภาพ ด้วยเหตุนี้ คุณจึงไม่สามารถป้อนรูปภาพใดๆ ได้ และ ต้องการ ตำแหน่งกล้องเพื่อให้สามารถวางตำแหน่งภาพในอวกาศได้อย่างแม่นยำเพื่อให้รังสีสร้างชุดจุดที่เข้าใจได้ จากนั้นจุดตัวอย่างจะสร้างชุดจุด 3 มิติที่แสดงถึงฉากเชิงปริมาตร:
โครงข่ายประสาทเทียมประมาณก ฟังก์ชั่นฉากปริมาตร – ค่า RGB และความหนาแน่น (σ) ของฉาก ผลก็คือ เราฝึกเครือข่ายให้ จดจำ สีและความหนาแน่นของแต่ละจุดอินพุต เพื่อให้สามารถสร้างภาพจากมุมมองใหม่ได้ ดังที่ได้กล่าวไปแล้ว – NeRF ไม่ได้รับการฝึกฝนเกี่ยวกับชุดภาพและสามารถอนุมานเป็นภาพใหม่ได้ NeRF ได้รับการฝึกฝนให้เข้ารหัสฉาก และจากนั้นจะใช้กับฉากนั้นเพียงฉากเดียวเท่านั้น เนื่องจากน้ำหนักของตาข่ายเป็นตัวแทนของฉาก
นี่คือ “ข้อเสียเปรียบ” หลักของ NeRF – คุณต้องฝึกเครือข่ายสำหรับแต่ละฉากที่คุณต้องการเข้ารหัส และกระบวนการฝึกก็ค่อนข้างช้าและต้องใช้หน่วยความจำจำนวนมากสำหรับอินพุตขนาดใหญ่ การปรับปรุงเวลาในการฝึกอบรมเป็นส่วนหนึ่งของการวิจัย ด้วยเทคนิคใหม่ๆ เช่น “การเพิ่มประสิทธิภาพ Direct Voxel Grid” ซึ่งช่วยปรับปรุงเวลาการฝึกอบรมได้อย่างมากโดยไม่ต้องแลกกับคุณภาพของภาพในกระบวนการ
Neural Radiance Fields ใน DeepVision และ TensorFlow
การใช้งาน NeRF อาจเป็นเรื่องที่น่ากังวลเล็กน้อยสำหรับผู้ที่เพิ่งเริ่มใช้การแสดงผลเชิงปริมาตร และที่เก็บโค้ดโดยทั่วไปจะมีวิธีการช่วยเหลือมากมายในการจัดการกับข้อมูลเชิงปริมาตร ซึ่งอาจดูไม่เป็นธรรมชาติสำหรับบางคน DeepVision เป็นไลบรารีการมองเห็นของคอมพิวเตอร์แบบใหม่ที่มีจุดประสงค์เพื่อรวมการมองเห็นของคอมพิวเตอร์เข้าด้วยกันภายใต้ API ทั่วไป โดยมีแบ็กเอนด์ที่เปลี่ยนแทนกันได้ (TensorFlow และ PyTorch) การแปลงน้ำหนักอัตโนมัติระหว่างโมเดล และโมเดลที่มีการใช้งานเหมือนกันทั่วทั้งเฟรมเวิร์กแบ็กเอนด์
เพื่อลดสิ่งกีดขวางทางเข้า ดีพวิชั่น นำเสนอการใช้งานโมเดล Neural Radiance Field ที่เรียบง่ายแต่เหมือนจริง โดยมีการตั้งค่าหลายอย่างเพื่อรองรับเครื่องที่มีประสิทธิภาพมากขึ้นและน้อยลงด้วยการตั้งค่าฮาร์ดแวร์ที่แตกต่างกัน:
NeRFTiny
NeRFSmall
NeRFMedium
NeRF
NeRFLarge
ใช้พารามิเตอร์สองตัวเพื่อสร้างการตั้งค่าเหล่านี้ - width
และ depth
. เนื่องจากโดยพื้นฐานแล้ว NeRFs เป็นเพียงโมเดล MLP ที่ประกอบด้วย tf.keras.layers.Dense()
ชั้น (ที่มีการต่อชั้นเดียวระหว่างชั้น), the depth
แสดงถึงจำนวนโดยตรง Dense
ชั้นในขณะที่ width
หมายถึงจำนวนหน่วยที่ใช้ในแต่ละอัน
NeRF
สอดคล้องกับการตั้งค่าที่ใช้ในกระดาษต้นฉบับ แต่อาจทำได้ยากในเครื่องบางเครื่อง ซึ่งในกรณีนี้ NeRFMedium
ให้ประสิทธิภาพที่คล้ายกันมากกับความต้องการหน่วยความจำที่น้อยกว่า
ไปข้างหน้าและติดตั้ง DeepVision ด้วย pip
:
$ pip install deepvision-toolkit
การสร้างอินสแตนซ์ของโมเดลนั้นง่ายเหมือน:
import deepvision
model = deepvision.models.NeRFMedium(input_shape=(num_pos, input_features), backend='tensorflow') model.summary()
ตัวแบบนั้นง่ายมาก:
Model: "ne_rftf"
__________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 640000, 195 0 [] )] dense (Dense) (None, 640000, 128) 25088 ['input_1[0][0]'] dense_1 (Dense) (None, 640000, 128) 16512 ['dense[0][0]'] dense_2 (Dense) (None, 640000, 128) 16512 ['dense_1[0][0]'] dense_3 (Dense) (None, 640000, 128) 16512 ['dense_2[0][0]'] dense_4 (Dense) (None, 640000, 128) 16512 ['dense_3[0][0]'] concatenate (Concatenate) (None, 640000, 323) 0 ['dense_4[0][0]', 'input_1[0][0]'] dense_5 (Dense) (None, 640000, 128) 41472 ['concatenate[0][0]'] dense_6 (Dense) (None, 640000, 4) 516 ['dense_5[0][0]'] ==================================================================================================
Total params: 133,128
Trainable params: 133,124
Non-trainable params: 4
__________________________________________________________________________________________________
ดูคู่มือเชิงปฏิบัติสำหรับการเรียนรู้ Git ที่มีแนวทางปฏิบัติที่ดีที่สุด มาตรฐานที่ยอมรับในอุตสาหกรรม และเอกสารสรุปรวม หยุดคำสั่ง Googling Git และจริงๆ แล้ว เรียน มัน!
เราจะมาดูรายละเอียดเพิ่มเติมเกี่ยวกับวิธีจัดการกับเอาต์พุตของโมเดลและวิธีเรนเดอร์ภาพที่เกิดจากน้ำหนักของโมเดลในอีกสักครู่
กำลังโหลดชุดข้อมูล TinyNeRF
เนื่องจาก NeRF อาจมีราคาค่อนข้างแพงในการฝึกกับอิมเมจอินพุตขนาดใหญ่ พวกเขาจึงเผยแพร่ด้วยชุดข้อมูลขนาดเล็กที่มีอิมเมจ 100×100 ซึ่งขนานนามว่า จิ๋วเนรเอฟ เพื่อให้การทดสอบและการทำซ้ำง่ายขึ้น ต่อมาได้กลายเป็นชุดข้อมูลแบบคลาสสิกสำหรับทดลองใช้ NeRF และสำหรับการเข้าสู่สนาม คล้ายกับการที่ MNIST กลายเป็น "Hello World" ของการรู้จำตัวเลข
ชุดข้อมูลพร้อมใช้งานในรูปแบบ .npz
ไฟล์ และมีรูปภาพ จุดโฟกัส (ใช้สำหรับการปรับมาตรฐาน) และท่าทางของกล้อง และสามารถรับได้จากการเผยแพร่รหัสอย่างเป็นทางการ:
import requests
import numpy as np
import matplotlib.pyplot as plt url = "https://people.eecs.berkeley.edu/~bmild/nerf/tiny_nerf_data.npz"
save_path = 'tiny_nerf.npz' file_data = requests.get(url).content
with open(save_path, "wb") as file: file.write(file_data) data = np.load(save_path) images, poses, focal = data["images"], data["poses"], data["focal"] print(images.shape) print(poses.shape) print(focal)
มี 106 ภาพ แต่ละภาพ 100×100 มี 3 ช่องสัญญาณ (RGB) รูปภาพทั้งหมดเป็นภาพของรถปราบดินเลโก้ขนาดเล็ก มาวางแผนห้าภาพแรกกัน:
fig, ax = plt.subplots(1, 5, figsize=(20, 12))
for i in range(5): ax[i].imshow(images[i])
พื้นที่ ตำแหน่งกล้อง ที่จัดมาให้ในชุดข้อมูลมีความสำคัญต่อการสร้างพื้นที่ที่ถ่ายภาพขึ้นมาใหม่ ซึ่งทำให้เราสามารถฉายรังสีผ่านภาพและสร้างพื้นที่ปริมาตรด้วยจุดตัวอย่างในแต่ละเส้นโครง
อย่างไรก็ตาม เนื่องจากชุดข้อมูลนี้ต้องมีการเตรียมการมากมายสำหรับขั้นตอนการฝึกอบรม – DeepVision จึงนำเสนอ load_tiny_nerf()
ตัวโหลดชุดข้อมูลที่จะดำเนินการเตรียมการให้คุณโดยมีตัวเลือก validation_split
, pos_embed
และ num_ray_samples
และส่งกลับวานิลลา tf.data.Dataset
ที่คุณสามารถสร้างไปป์ไลน์ที่มีประสิทธิภาพสูงด้วย:
import deepvision train_ds, valid_ds = deepvision.datasets.load_tiny_nerf(pos_embed=16, num_ray_samples=32, save_path='tiny_nerf.npz', validation_split=0.2, backend='tensorflow')
คุณไม่จำเป็นต้องสร้างชุดการตรวจสอบความถูกต้องที่นี่ตั้งแต่ประเด็นนี้ is เพื่อให้พอดีและจดจำภาพได้อย่างเต็มที่ และชุดการตรวจสอบความถูกต้องที่นี่ถูกสร้างขึ้นโดยหลักแล้วเป็นการตรวจสอบสติ
มาดูความยาวและรูปร่างอินพุตในชุดข้อมูลการฝึก:
print('Train dataset length:', len(train_ds))
print(train_ds)
ผลลัพธ์นี้ใน:
Train dataset length: 84
<ZipDataset element_spec=(TensorSpec(shape=(100, 100, 3), dtype=tf.float32, name=None), (TensorSpec(shape=(320000, 99), dtype=tf.float32, name=None), TensorSpec(shape=(100, 100, 32), dtype=tf.float32, name=None)))>
พื้นที่ pos_embed
อาร์กิวเมนต์กำหนดจำนวนของ การฝังตำแหน่ง ใช้เพื่อแปลงพิกัด 5D (x, y, z และมุมมอง Theta และ Phi) การฝังตำแหน่งคือ สำคัญมาก เพื่อให้เครือข่ายสามารถแสดงฟังก์ชันความถี่ที่สูงขึ้นได้ ซึ่งเป็น "ส่วนผสมที่ขาดหายไป" ในการทำให้เทคนิคประเภทนี้ใช้งานได้ในอดีต เนื่องจากเครือข่ายมีปัญหาในการประมาณฟังก์ชันที่แสดงการแปรผันของสีและรูปทรงเรขาคณิตความถี่สูง เนื่องจากความเอนเอียง ไปสู่การเรียนรู้ฟังก์ชันความถี่ต่ำแทน:
พื้นที่ num_ray_samples
แสดงจำนวนตัวอย่างที่ถ่ายตามความยาวของรังสีแต่ละเส้นที่ฉายในภาพ
โดยธรรมชาติ ยิ่งคุณใช้การฝังตำแหน่งและตัวอย่างรังสีมากเท่าใด ความละเอียดของฉากเชิงปริมาตรที่คุณประมาณก็จะยิ่งสูงขึ้นเท่านั้น ดังนั้น ภาพสุดท้ายจะมีรายละเอียดมากขึ้น โดยเสียค่าใช้จ่ายในการคำนวณที่สูงขึ้น
ฝึกอบรม NeRF ด้วย TensorFlow/Keras และ DeepVision
มาดูตัวอย่างแบบ end-to-end ของการโหลดข้อมูล การเตรียมชุดข้อมูล การสร้างตัวอย่างแบบจำลอง และการฝึกอบรมโดยใช้ DeepVision และระบบนิเวศ TensorFlow/Keras:
import deepvision
from deepvision.datasets import load_tiny_nerf
import tensorflow as tf config = { 'img_height': 100, 'img_width': 100, 'pos_embed': 32, 'num_ray_samples': 64, 'batch_size': 1
} num_pos = config['img_height'] * config['img_width'] * config['num_ray_samples']
input_features = 6 * config['pos_embed'] + 3 train_ds, valid_ds = load_tiny_nerf(pos_embed=config['pos_embed'], num_ray_samples=config['num_ray_samples'], save_path='tiny_nerf.npz', validation_split=0.2, backend='tensorflow') train_ds = train_ds.batch(config['batch_size']).prefetch(tf.data.AUTOTUNE)
valid_ds = valid_ds.batch(config['batch_size']).prefetch(tf.data.AUTOTUNE) model = deepvision.models.NeRFMedium(input_shape=(num_pos, input_features), backend='tensorflow') model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3), loss=tf.keras.losses.MeanSquaredError()) callbacks = [tf.keras.callbacks.ReduceLROnPlateau()] history = model.fit(train_ds, epochs=50, validation_data=valid_ds, callbacks=callbacks)
ใน Nvidia GTX1660Super การฝึกด้วยการฝังตำแหน่ง 32 ตำแหน่งและตัวอย่างรังสี 64 ตัวอย่างใช้เวลาประมาณ 1 นาทีต่อยุค แต่การตั้งค่าที่เล็กลง เช่น การฝังตำแหน่ง 8-16 ตำแหน่งและตัวอย่างรังสี 32 ตัวอย่างอาจใช้เวลาเพียง ~7 วินาทีต่อยุค:
Epoch 1/50
84/84 [==============================] - 65s 746ms/step - loss: 0.0603 - psnr: 12.6432 - val_loss: 0.0455 - val_psnr: 13.7601 - lr: 0.0010
...
Epoch 50/50
84/84 [==============================] - 55s 658ms/step - loss: 0.0039 - psnr: 24.1984 - val_loss: 0.0043 - val_psnr: 23.8576 - lr: 0.0010
หลังจากผ่านไปประมาณหนึ่งชั่วโมง บน GPU เชิงพาณิชย์เพียงตัวเดียว รุ่นนี้ก็บรรลุ ~24 PSNR ข้อดีของ NeRF คือ ยิ่งคุณฝึกนานเท่าไร ก็ยิ่งเข้าใกล้การแสดงภาพต้นฉบับมากขึ้นเท่านั้น หมายความว่าโดยปกติแล้วคุณจะเห็นเมตริกเพิ่มขึ้นเมื่อเวลาผ่านไปเมื่อคุณฝึกฝนมากขึ้น มันช่วยให้มี ReduceLROnPlateau
โทรกลับเพื่อจัดการกับการลดอัตราการเรียนรู้เพื่อปรับแต่งผลลัพธ์เมื่อใกล้สิ้นสุดการฝึกอบรม
โมเดลรายงานสองเมตริก – loss
และ psnr
. การสูญเสียคือข้อผิดพลาดกำลังสองเฉลี่ยสำหรับแต่ละพิกเซล และทำงานเป็นฟังก์ชันการสูญเสียที่ยอดเยี่ยมสำหรับ NeRF แต่ตีความได้ยาก
อัตราส่วนสัญญาณต่อสัญญาณรบกวนสูงสุด (PSNR) คืออัตราส่วนระหว่างสัญญาณ (กำลังสูงสุดของสัญญาณ) และสัญญาณรบกวน (พลังของสัญญาณรบกวนที่ทำลายความเที่ยงตรงของสัญญาณ) ซึ่งทำให้ภาพเสื่อมคุณภาพ อัตราส่วนสัญญาณต่อสัญญาณรบกวนสูงสุดสามารถใช้เป็น คุณภาพของภาพ เมตริกและง่ายต่อการตีความสำหรับมนุษย์
เมื่อ PSNR อยู่ที่ 24 ภาพจะค่อนข้างชัดเจน และ NeRF สามารถเข้าถึง PSNR ที่มากกว่า 40 บน TinyNeRF ได้หากมีเวลาฝึกฝนเพียงพอ
การแสดงผลลัพธ์
เครือข่ายส่งสัญญาณรูปร่างของเทนเซอร์ [batch_size, 640000, 4]
โดยที่ช่องแสดง RGB และความหนาแน่น และ 640000 จุดเข้ารหัสฉาก ในการแสดงภาพเหล่านี้ เราต้องการปรับรูปร่างเทนเซอร์ใหม่ให้เป็นรูปร่างของ (batch_size, img_height, img_width, num_ray_samples, 4)
จากนั้นผ่า 4 แชนเนลเป็น RGB และ sigma แล้วประมวลผลเป็นภาพ (และเลือกได้ แผนที่ความลึก/ความแม่นยำ)
โดยเฉพาะอย่างยิ่ง ช่องสัญญาณ RGB จะถูกส่งผ่าน ซิกมอยด์ การเปิดใช้งานในขณะที่ช่องสัญญาณซิกม่าถูกส่งผ่าน รีลู การเปิดใช้งานก่อนที่จะถูกประมวลผลต่อไปและลดลงเป็นรูปร่างของเทนเซอร์ (batch_size, img_height, img_width, rgb_channels)
และสองเทนเซอร์ของรูปร่าง (batch_size, img_height, img_width, depth_channel)
และ (batch_size, img_height, img_width, accuracy)
.
เพื่อให้กระบวนการนี้ง่ายขึ้น เราสามารถใช้ nerf_render_image_and_depth_tf()
ฟังก์ชันจาก volumetric_utils
ซึ่งยอมรับโมเดลเพื่อทำนาย RGB และซิกม่าจากอินพุต และส่งคืนชุดรูปภาพ แผนที่เชิงลึก และแผนที่ความแม่นยำ:
import matplotlib.pyplot as plt
from deepvision.models.volumetric.volumetric_utils import nerf_render_image_and_depth_tf for batch in train_ds.take(5): (images, rays) = batch (rays_flat, t_vals) = rays image_batch, depth_maps, _ = nerf_render_image_and_depth_tf(model=model, rays_flat=rays_flat, t_vals=t_vals, img_height=config['img_height'], img_width=config['img_width'], num_ray_samples=config['num_ray_samples']) fig, ax = plt.subplots(1, 2) ax[0].imshow(tf.squeeze(image_batch[0])) ax[1].imshow(tf.squeeze(depth_maps[0]))
ที่นี่ เรากำลังวางแผน 5 ชุด (แต่ละชุดมีภาพเดียว) และแผนที่ความลึก
ในระหว่างการฝึกอบรม ตัวแบบต้องอาศัย nerf_render_image_and_depth_tf()
ฟังก์ชันแปลงการคาดคะเนเป็นรูปภาพและคำนวณค่าความคลาดเคลื่อนกำลังสองเฉลี่ยและ PSNR สำหรับผลลัพธ์ การรันโค้ดนี้ส่งผลให้:
สรุป
ในคู่มือนี้ – เราได้สรุปองค์ประกอบหลักบางประการของ Neural Radiance Fields เพื่อเป็นการแนะนำสั้นๆ เกี่ยวกับหัวข้อนี้ ตามด้วยการโหลดและเตรียมชุดข้อมูล TinyNeRF ใน TensorFlow โดยใช้ tf.data
และฝึกอบรมโมเดล NeRF กับระบบนิเวศ Keras และ DeepVision
- เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
- เพลโตบล็อคเชน Web3 Metaverse ข่าวกรอง ขยายความรู้. เข้าถึงได้ที่นี่.
- ที่มา: https://stackabuse.com/training-a-neural-radiance-field-nerf-model-with-keras-tensorflow-and-deepvision/
- 1
- 100
- 1984
- 2020
- 3d
- 7
- 84
- 9
- a
- สามารถ
- เกี่ยวกับเรา
- อย่างแน่นอน
- ยอมรับ
- ความถูกต้อง
- แม่นยำ
- ประสบความสำเร็จ
- ข้าม
- การกระตุ้น
- จริง
- ก่อน
- จุดมุ่งหมาย
- เตือนภัย
- ทั้งหมด
- ช่วยให้
- คู่ขนาน
- น่าอัศจรรย์
- จำนวน
- และ
- API
- การใช้งาน
- เข้าใกล้
- วิธีการ
- AREA
- อาร์กิวเมนต์
- ศิลปะ
- ที่เกี่ยวข้อง
- อัตโนมัติ
- ใช้ได้
- แบ็กเอนด์
- อุปสรรค
- ทุบตี
- เพราะ
- กลายเป็น
- ก่อน
- กำลัง
- เบิร์กลีย์
- ระหว่าง
- อคติ
- บิต
- ชายแดน
- สร้าง
- คำนวณ
- ห้อง
- กรณี
- ท้าทาย
- ช่อง
- ช่อง
- ตรวจสอบ
- คลาสสิก
- ชัดเจน
- ใกล้ชิด
- รหัส
- สี
- เชิงพาณิชย์
- ร่วมกัน
- บริษัท
- คอมพิวเตอร์
- วิสัยทัศน์คอมพิวเตอร์
- แนวคิด
- ข้อสรุป
- งานที่เชื่อมต่อ
- ประกอบด้วย
- มี
- เนื้อหา
- การแปลง
- แปลง
- แปลง
- สอดคล้อง
- ราคา
- ค่าใช้จ่าย
- สร้าง
- ที่สร้างขึ้น
- การสร้าง
- สำคัญมาก
- ด้านวัฒนธรรม
- ข้อมูล
- ชุดข้อมูล
- จัดการ
- การซื้อขาย
- ความลึก
- รายละเอียด
- ยาก
- ย่อยอาหาร
- แปลง
- โดยตรง
- ทิศทาง
- โดยตรง
- ขนานนามว่า
- แต่ละ
- ง่ายดาย
- ระบบนิเวศ
- ระบบนิเวศ
- เกี่ยวกับการศึกษา
- ผล
- องค์ประกอบ
- จบสิ้น
- พอ
- การเข้า
- ยุค
- ความผิดพลาด
- แก่นแท้
- ทุกๆ
- ตัวอย่าง
- แพง
- สำรวจ
- อย่างเป็นธรรม
- แฟชั่น
- ความจงรักภักดี
- สนาม
- สาขา
- เนื้อไม่มีมัน
- สุดท้าย
- ปลาย
- ชื่อจริง
- ที่ไหล
- โฟกัส
- ตาม
- ฟอร์ม
- พบ
- กรอบ
- เวลา
- ราคาเริ่มต้นที่
- อย่างเต็มที่
- ฟังก์ชัน
- ฟังก์ชั่น
- ต่อไป
- สร้าง
- การสร้าง
- ได้รับ
- ไป
- GitHub
- กำหนด
- Go
- ดี
- GPU
- กราฟิก
- ยิ่งใหญ่
- ตะแกรง
- ให้คำแนะนำ
- จัดการ
- มือบน
- ฮาร์ดแวร์
- ช่วย
- โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม
- มรดก
- จุดสูง
- ความถี่สูง
- ระดับสูง
- ประสิทธิภาพสูง
- สูงกว่า
- ประวัติ
- โฉบ
- สรุป ความน่าเชื่อถือของ Olymp Trade?
- ทำอย่างไร
- HTTPS
- มนุษย์
- ICON
- ความคิด
- identiques
- ภาพ
- ภาพ
- การดำเนินงาน
- ปรับปรุง
- การปรับปรุง
- การปรับปรุง
- in
- ประกอบด้วย
- รวม
- ที่เพิ่มขึ้น
- อินพุต
- ติดตั้ง
- แทน
- สนใจ
- บทนำ
- ใช้งานง่าย
- IT
- ซ้ำ
- ตัวเอง
- Keras
- คีย์
- ที่รู้จักกัน
- ใหญ่
- ที่มีขนาดใหญ่
- ชั้น
- ชั้น
- การเรียนรู้
- ความยาว
- LG
- ห้องสมุด
- เบา
- ทุ่งแสง
- น้อย
- loader
- โหลด
- ในประเทศ
- อีกต่อไป
- ดู
- ปิด
- การสูญเสีย
- เครื่อง
- เครื่อง
- หลัก
- ทำ
- การทำ
- หลาย
- แผนที่
- แผนที่
- วัสดุ
- matplotlib
- สูงสุด
- ความหมาย
- หน่วยความจำ
- เมตาดาต้า
- วิธี
- วิธีการ
- เมตริก
- ตัวชี้วัด
- หายไป
- แบบ
- โมเดล
- ขณะ
- ข้อมูลเพิ่มเติม
- มากที่สุด
- หลาย
- ใกล้
- จำเป็นต้อง
- Nerf
- เครือข่าย
- เครือข่าย
- เครือข่ายประสาท
- ใหม่
- สัญญาณรบกวน
- นวนิยาย
- จำนวน
- มากมาย
- มึน
- Nvidia
- วัตถุ
- ที่ได้รับ
- เสนอ
- เป็นทางการ
- อย่างเป็นทางการ
- ONE
- การเพิ่มประสิทธิภาพ
- ใบสั่ง
- เป็นต้นฉบับ
- ผลิตภัณฑ์อื่นๆ
- กระดาษ
- เอกสาร
- พารามิเตอร์
- ผ่าน
- อดีต
- จุดสูงสุด
- ดำเนินการ
- การปฏิบัติ
- ที่มีประสิทธิภาพ
- ระยะ
- ท่อ
- พิกเซล
- เพลโต
- เพลโตดาต้าอินเทลลิเจนซ์
- เพลโตดาต้า
- จุด
- จุด
- โพสท่า
- ตำแหน่ง
- ตำแหน่ง
- ตำแหน่ง
- อำนาจ
- ที่มีประสิทธิภาพ
- ประยุกต์
- คาดการณ์
- การคาดการณ์
- การเตรียมความพร้อม
- นำเสนอ
- ส่วนใหญ่
- อาจ
- ปัญหา
- กระบวนการ
- แปรรูปแล้ว
- ผลิต
- โครงการ
- ที่คาดการณ์
- เงื้อม
- เสนอ
- ให้
- ไฟฉาย
- คุณภาพ
- คะแนน
- อัตราส่วน
- RAY
- RE
- มาถึง
- การรับรู้
- ลดลง
- ปกติ
- ปล่อย
- การเผยแพร่
- การแสดงผล
- รายงาน
- แสดง
- เป็นตัวแทนของ
- แสดงให้เห็นถึง
- การร้องขอ
- ความต้องการ
- ต้อง
- การวิจัย
- ความละเอียด
- ผลสอบ
- รับคืน
- RGB
- แหวน
- ลวก
- วิ่ง
- วิ่ง
- กล่าวว่า
- ฉาก
- ฉาก
- Section
- ชุด
- ชุดอุปกรณ์
- การติดตั้ง
- เงา
- รูปร่าง
- รูปร่าง
- แสดง
- ซิกม่า
- สัญญาณ
- อย่างมีความหมาย
- คล้ายคลึงกัน
- ง่าย
- ที่เรียบง่าย
- ตั้งแต่
- เดียว
- สถานที่ทำวิจัย
- ช้า
- เล็ก
- มีขนาดเล็กกว่า
- ทางออก
- แก้
- การแก้
- บาง
- ค่อนข้าง
- ช่องว่าง
- ความเชี่ยวชาญ
- squared
- สแต็ค
- มาตรฐาน
- สถานะ
- ยังคง
- หยุด
- พายุ
- หรือ
- ภายหลัง
- ต่อจากนั้น
- ที่ประสบความสำเร็จ
- อย่างเช่น
- ที่จัดมา
- SVG
- สังเคราะห์
- เอา
- ใช้เวลา
- เทคนิค
- tensorflow
- การทดสอบ
- พื้นที่
- โลก
- ของพวกเขา
- ในนั้น
- theta
- สิ่ง
- ตลอด
- เวลา
- ไปยัง
- รวม
- ไปทาง
- เทรด
- รถไฟ
- ผ่านการฝึกอบรม
- การฝึกอบรม
- แปลง
- การเปลี่ยนแปลง
- จริง
- เป็นปกติ
- ภายใต้
- พื้นฐาน
- เข้าใจ
- ไม่สัญชาตญาณ
- หน่วย
- URL
- us
- ใช้
- การตรวจสอบ
- ความคุ้มค่า
- ต่างๆ
- Ve
- วีดีโอ
- รายละเอียด
- ยอดวิว
- วิสัยทัศน์
- voxel
- น้ำหนัก
- ที่
- ในขณะที่
- วิกิพีเดีย
- จะ
- ไม่มี
- งาน
- โรงงาน
- โลก
- X
- อัตราผลตอบแทน
- คุณ
- YouTube
- ลมทะเล