Neural Radiance Fields, conosciuti colloquialmente come NeRF hanno colpito il mondo nel 2020, pubblicato insieme al giornale "NeRF: Rappresentazione di scene come campi di radianza neurale per la sintesi visiva", e sono ancora la pietra angolare della sintesi di alta qualità di nuovi punti di vista, date le immagini sparse e le posizioni della telecamera.
Da allora, hanno trovato numerose applicazioni, ma probabilmente soprattutto nella modellazione volumetrica geospaziale, con aziende come Google che si affidano a NeRF per creare strutture 3D di edifici e siti del patrimonio da varie angolazioni di immagini satellitari e aziende specializzate nell'esecuzione di ricostruzioni 3D e digitalizzazione di noti siti culturali.
In questa guida addestreremo un modello NeRF (Neural Radiance Field) sul set di dati Tiny NeRF originale, utilizzando TensorFlow/Keras e DeepVision, per eseguire una nuova sintesi di viste/ricostruzione 3D.
In una sola ora, su una macchina commerciale, eseguirai il rendering di nuove viste di immagini dal set di dati TinyNeRF:
Sintesi di nuove viste e campi di radianza neurale
Questa sezione fornisce un riepilogo/introduzione semplificato al modo in cui funzionano i campi di radianza neurale, ma potrebbe volerci del tempo per digerire in modo veramente intuitivo come funzionano se sei nuovo nel campo.
Nota: Il documento originale così come il video educativo e la grafica ad esso associati sono ottimi materiali didattici. Se sei interessato a capire il concetto sottostante di campi di radianza su cui i NeRF fanno affidamento per rappresentare una scena, il Voce di Wikipedia per "campi luminosi" fornisce un'ottima introduzione, ma possono essere riassunti in modo di alto livello come
“Il campo luminoso è una funzione vettoriale che descrive la quantità di luce che fluisce in ogni direzione attraverso ogni punto dello spazio”.
I NeRF sono usati per sintesi vista romanzo – creare nuove viste di oggetti e immagini, date alcune viste. In effetti, puoi pensare alla sintesi di nuove viste come conversione 2D->3D, ed esistono molti approcci per risolvere questo problema, alcuni più efficaci di altri.
Storicamente un problema impegnativo, la soluzione proposta dai NeRF è estremamente semplice ma produce risultati all'avanguardia, generando immagini di altissima qualità da nuove angolazioni:
Questo, naturalmente, li ha posizionati come un approccio fondamentale per risolvere la sintesi di nuove visioni, con molti articoli successivi che esplorano, adattano e migliorano le idee ivi presenti.
Consigli: Il sito web pubblicato insieme al documento contiene una straordinaria vetrina del metodo e dei suoi risultati, e un video educativo che costruisce una buona intuizione su come funzionano queste reti è stato rilasciato ufficialmente.
La pipeline dai dati ai risultati può essere riassunta come segue:
Dove la rete neurale apprende da immagini sparse generate sinteticamente raggi proiettati e campionati a intervalli regolari. Le immagini sono posizionate nello spazio dati i metadati sulle immagini, come le posizioni della fotocamera quando sono state scattate le immagini. Per questo motivo, non puoi semplicemente inserire immagini e richiedere posizioni della telecamera per poter posizionare con precisione le immagini nello spazio affinché i raggi creino un insieme comprensibile di punti. I punti campionati formano quindi un insieme 3D di punti che rappresentano la scena volumetrica:
La rete neurale approssima a funzione di scena volumetrica – i valori RGB e la densità (σ) di una scena. In effetti, addestriamo la rete a memorizzazione il colore e la densità di ogni punto di ingresso, per poter ricostruire le immagini da nuovi punti di vista. Detto questo, i NeRF non sono addestrati su una serie di immagini e possono estrapolarne di nuove. I NeRF sono addestrati per codificare una scena e vengono quindi utilizzati solo per quella scena, in quanto i pesi della rete stessa rappresentano la scena.
Questo è il principale "svantaggio" dei NeRF: devi addestrare una rete per ogni scena che desideri codificare e il processo di addestramento è piuttosto lento e richiede molta memoria per input di grandi dimensioni. I miglioramenti nel tempo di formazione sono un'area di ricerca, con nuove tecniche come "Ottimizzazione diretta della griglia Voxel" che migliorano significativamente i tempi di formazione senza compromettere la qualità dell'immagine nel processo.
Campi di radianza neurale in DeepVision e TensorFlow
Le implementazioni NeRF possono essere un po' scoraggianti per chi è nuovo al rendering volumetrico e i repository di codice in genere includono molti metodi di supporto per gestire i dati volumetrici, che potrebbero sembrare poco intuitivi per alcuni. DeepVision è una nuova libreria di visione artificiale che mira a unificare la visione artificiale in un'API comune, con backend intercambiabili (TensorFlow e PyTorch), conversioni automatiche del peso tra modelli e modelli con implementazioni identiche nei framework di backend.
Per abbassare la barriera all'ingresso, Deep Vision offre un'implementazione semplice ma fedele all'originale dei modelli Neural Radiance Field, con configurazioni multiple per adattarsi a macchine più e meno potenti con diverse configurazioni hardware:
NeRFTiny
NeRFSmall
NeRFMedium
NeRF
NeRFLarge
Per creare queste impostazioni vengono utilizzati due parametri: width
ed depth
. Poiché i NeRF sono, in sostanza, solo un modello MLP composto da tf.keras.layers.Dense()
strati (con un'unica concatenazione tra strati), il depth
rappresenta direttamente il numero di Dense
strati, mentre width
rappresenta il numero di unità utilizzate in ciascuna di esse.
NeRF
corrisponde alla configurazione utilizzata nel documento originale, ma potrebbe essere difficile da eseguire su alcune macchine locali, nel qual caso, NeRFMedium
fornisce prestazioni molto simili con requisiti di memoria inferiori.
Andiamo avanti e installiamo DeepVision con pip
:
$ pip install deepvision-toolkit
Creare un'istanza di un modello è facile come:
import deepvision
model = deepvision.models.NeRFMedium(input_shape=(num_pos, input_features), backend='tensorflow') model.summary()
Il modello stesso è estremamente semplice:
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
__________________________________________________________________________________________________
Dai un'occhiata alla nostra guida pratica e pratica per l'apprendimento di Git, con le migliori pratiche, gli standard accettati dal settore e il cheat sheet incluso. Smetti di cercare su Google i comandi Git e in realtà imparare esso!
Daremo un'occhiata più da vicino a come gestire gli output del modello e come rendere le immagini prodotte dai pesi del modello, in un momento.
Caricamento del set di dati TinyNeRF
Poiché i NeRF possono essere piuttosto costosi da addestrare su immagini di input più grandi, sono stati rilasciati con un piccolo set di dati di immagini 100 × 100, soprannominato TinyNeRF per semplificare i test e le iterazioni. Successivamente è diventato un set di dati classico per provare i NeRF e per entrare nel campo, in modo simile a come MNIST è diventato il "Hello World" del riconoscimento delle cifre.
Il set di dati è disponibile come file .npz
file e contiene immagini, punti focali (utilizzati per la normalizzazione) e pose della fotocamera e può essere ottenuto dal rilascio del codice ufficiale:
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)
Ci sono 106 immagini, 100×100 ciascuna, con 3 canali (RGB). Tutte le immagini sono di un piccolo bulldozer lego. Tracciamo le prime cinque immagini:
fig, ax = plt.subplots(1, 5, figsize=(20, 12))
for i in range(5): ax[i].imshow(images[i])
Il posizioni della telecamera forniti nel set di dati sono fondamentali per poter ricostruire lo spazio in cui sono state scattate le immagini, che ci consente di proiettare i raggi attraverso le immagini e formare uno spazio volumetrico con i punti campionati su ogni proiezione.
Tuttavia, poiché questo set di dati richiede molta preparazione per la fase di addestramento, DeepVision offre a load_tiny_nerf()
caricatore di set di dati, che eseguirà la preparazione per te, con un optional validation_split
, pos_embed
ed num_ray_samples
, e restituisce una vaniglia tf.data.Dataset
che puoi creare pipeline ad alte prestazioni con:
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')
Non è assolutamente necessario creare un set di convalida qui, poiché il punto is per sovradimensionare e memorizzare completamente le immagini e la convalida impostata qui viene creata principalmente come controllo di integrità.
Diamo un'occhiata alla lunghezza e alle forme di input nel set di dati di addestramento:
print('Train dataset length:', len(train_ds))
print(train_ds)
Questo risulta in:
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)))>
Il pos_embed
argomento imposta il numero di incorporamenti posizionali utilizzato per trasformare le coordinate 5D (x, y, z e angoli di visione Theta e Phi). Gli incorporamenti posizionali erano cruciale affinché la rete fosse in grado di rappresentare funzioni a frequenza più alta, che era un "ingridiente mancante" per far funzionare questo tipo di tecnica in passato, poiché le reti faticavano ad approssimare le funzioni che rappresentavano la variazione ad alta frequenza nel colore e nella geometria, a causa della loro polarizzazione verso l'apprendimento delle funzioni a bassa frequenza invece:
Il num_ray_samples
rappresenta il numero di campioni prelevati lungo la lunghezza di ciascun raggio proiettato nell'immagine.
Naturalmente, più incorporamenti posizionali e campioni di raggi si utilizzano, maggiore è la risoluzione della scena volumetrica che si sta approssimando e, quindi, più dettagliate saranno le immagini finali, al costo di maggiori costi computazionali.
Addestrare un NeRF con TensorFlow/Keras e DeepVision
Diamo un'occhiata a un esempio end-to-end di caricamento dei dati, preparazione del set di dati, istanziazione di un modello e addestramento utilizzando DeepVision e l'ecosistema 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)
Su una Nvidia GTX1660Super, l'addestramento con 32 incorporamenti posizionali e 64 campioni di raggi richiede circa 1 minuto per epoca, ma configurazioni più piccole, come 8-16 incorporamenti posizionali e 32 campioni di raggi possono richiedere fino a circa 7 secondi per epoca:
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
Dopo circa un'ora, con una singola GPU commerciale, il modello raggiunge ~24 PSNR. La cosa con i NeRF è che più a lungo ti alleni, più ti avvicinerai alle rappresentazioni delle immagini originali, il che significa che in genere vedrai le metriche aumentare nel tempo man mano che ti alleni di più. Aiuta avere un ReduceLROnPlateau
richiamata per gestire la riduzione del tasso di apprendimento per ottimizzare i risultati verso la fine della formazione.
Il modello riporta due metriche: loss
ed psnr
. La perdita è l'errore quadratico medio per ogni pixel e funziona come una grande funzione di perdita per i NeRF, ma è difficile da interpretare.
Rapporto segnale/rumore di picco (PSNR) è il rapporto tra il segnale (potenza massima di un segnale) e il rumore (potenza del rumore che corrompe la fedeltà del segnale) che degrada l'immagine. Il rapporto segnale/rumore di picco può essere utilizzato come qualità delle immagini metrico ed è molto intuitivo da interpretare per gli esseri umani.
Già a un PSNR di 24, le immagini diventano abbastanza chiare e i NeRF possono raggiungere PSNR di oltre 40 su TinyNeRF con un tempo di addestramento sufficiente.
Visualizzazione degli output
La rete emette un tensore di forma [batch_size, 640000, 4]
dove i canali rappresentano RGB e densità, ei 640000 punti codificano la scena. Per rappresentarli come immagini, vorremo rimodellare il tensore in una forma di (batch_size, img_height, img_width, num_ray_samples, 4)
, quindi sezionare i 4 canali in RGB e sigma ed elaborarli in un'immagine (e, facoltativamente, una mappa di profondità/precisione).
Nello specifico, i canali RGB vengono fatti passare attraverso a sigma attivazione, mentre il canale sigma viene fatto passare attraverso a Relu attivazione, prima di essere ulteriormente elaborato e ridotto a un tensore di forma (batch_size, img_height, img_width, rgb_channels)
, e due tensori di forma (batch_size, img_height, img_width, depth_channel)
ed (batch_size, img_height, img_width, accuracy)
.
Per semplificare questo processo, possiamo utilizzare il file nerf_render_image_and_depth_tf()
funzione da volumetric_utils
, che accetta il modello per prevedere RGB e sigma dagli input e restituisce un batch di immagini, mappe di profondità e mappe di precisione:
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]))
Qui stiamo tracciando 5 batch (ciascuno con un'immagine) e le loro mappe di profondità.
Durante l'addestramento, il modello stesso si basa su nerf_render_image_and_depth_tf()
funzione per convertire le previsioni in immagini e calcolare l'errore quadratico medio e il PSNR per i risultati. L'esecuzione di questo codice si traduce in:
Conclusione
In questa guida, abbiamo riassunto alcuni degli elementi chiave di Neural Radiance Fields, come una breve introduzione all'argomento, seguita dal caricamento e dalla preparazione del set di dati TinyNeRF in TensorFlow, utilizzando tf.data
e addestrare un modello NeRF con gli ecosistemi Keras e DeepVision.
- Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
- Platoblockchain. Web3 Metaverse Intelligence. Conoscenza amplificata. Accedi qui.
- Fonte: https://stackabuse.com/training-a-neural-radiance-field-nerf-model-with-keras-tensorflow-and-deepvision/
- 1
- 100
- 1984
- 2020
- 3d
- 7
- 84
- 9
- a
- capace
- Chi siamo
- assolutamente
- accetta
- precisione
- con precisione
- Realizza
- operanti in
- Attivazione
- effettivamente
- avanti
- mira
- Mettere in guardia
- Tutti
- consente
- a fianco di
- stupefacente
- quantità
- ed
- api
- applicazioni
- approccio
- approcci
- RISERVATA
- argomento
- Arte
- associato
- Automatico
- disponibile
- BACKEND
- barriera
- bash
- perché
- diventare
- prima
- essendo
- Berkeley
- fra
- pregiudizio
- Po
- sistema
- costruisce
- calcolare
- stanza
- Custodie
- impegnativo
- canale
- canali
- dai un'occhiata
- classico
- pulire campo
- più vicino
- codice
- colore
- Uncommon
- Aziende
- computer
- Visione computerizzata
- concetto
- conclusione
- collegato
- Consistente
- contiene
- contenuto
- Conversione
- conversioni
- convertire
- corrisponde
- Costo
- Costi
- creare
- creato
- Creazione
- cruciale
- la cultura della
- dati
- dataset
- affare
- trattare
- profondità
- dettagliati
- difficile
- digerire
- digitalizzazione
- dirette
- direzione
- direttamente
- soprannominato
- ogni
- più facile
- ecosistema
- ecosistemi
- educativo
- effetto
- elementi
- da un capo all'altro
- abbastanza
- iscrizione
- epoca
- errore
- essenza
- Ogni
- esempio
- costoso
- Esplorare
- abbastanza
- Moda
- fedeltà
- campo
- campi
- Compila il
- finale
- sottile
- Nome
- fluente
- Focus
- seguito
- modulo
- essere trovato
- quadri
- Frequenza
- da
- completamente
- function
- funzioni
- ulteriormente
- generato
- la generazione di
- ottenere
- Idiota
- GitHub
- dato
- Go
- buono
- GPU
- grafiche
- grande
- Griglia
- guida
- maniglia
- mani su
- Hardware
- Aiuto
- qui
- eredità
- Alta
- Alta frequenza
- alto livello
- Alte prestazioni
- superiore
- storia
- librarsi
- Come
- Tutorial
- HTTPS
- Gli esseri umani
- ICON
- idee
- identico
- Immagine
- immagini
- implementazione
- competenze
- miglioramenti
- miglioramento
- in
- includere
- incluso
- crescente
- ingresso
- install
- invece
- interessato
- Introduzione
- intuitivo
- IT
- iterazioni
- stessa
- keras
- Le
- conosciuto
- grandi
- superiore, se assunto singolarmente.
- strato
- galline ovaiole
- apprendimento
- Lunghezza
- LG
- Biblioteca
- leggera
- Campi di luce
- piccolo
- caricatore
- Caricamento in corso
- locale
- più a lungo
- Guarda
- spento
- perdite
- macchina
- macchine
- Principale
- make
- Fare
- molti
- carta geografica
- Maps
- Materiale
- matplotlib
- massimo
- significato
- Memorie
- Metadati
- metodo
- metodi
- metrico
- Metrica
- mancante
- modello
- modelli
- momento
- Scopri di più
- maggior parte
- multiplo
- in via di
- Bisogno
- Nerf
- Rete
- reti
- rete neurale
- New
- Rumore
- romanzo
- numero
- numerose
- numpy
- Nvidia
- oggetti
- ottenuto
- Offerte
- ufficiale
- Ufficialmente
- ONE
- ottimizzazione
- minimo
- i
- Altri
- Carta
- documenti
- parametri
- Passato
- passato
- Corrente di
- Eseguire
- performance
- esecuzione
- fase
- conduttura
- pixel
- Platone
- Platone Data Intelligence
- PlatoneDati
- punto
- punti
- pone
- posizione
- posizionato
- posizioni
- energia
- potente
- Pratico
- predire
- Previsioni
- preparazione
- presenti
- principalmente
- probabilmente
- Problema
- processi
- Elaborato
- Prodotto
- progetto
- proiettato
- Proiezione
- proposto
- fornisce
- pytorch
- qualità
- tasso
- rapporto
- RAY
- RE
- raggiungere
- riconoscimento
- Ridotto
- Basic
- rilasciare
- rilasciato
- interpretazione
- Report
- rappresentare
- che rappresenta
- rappresenta
- richieste
- Requisiti
- richiede
- riparazioni
- Risoluzione
- Risultati
- problemi
- RGB
- Anello
- approssimativamente
- Correre
- running
- Suddetto
- scena
- Scene
- Sezione
- set
- Set
- flessibile.
- Shadow
- Forma
- forme
- vetrina
- Sigma
- Signal
- significativamente
- simile
- Un'espansione
- semplificata
- da
- singolo
- Siti
- rallentare
- piccole
- inferiore
- soluzione
- RISOLVERE
- Soluzione
- alcuni
- piuttosto
- lo spazio
- specializzata
- Squared
- Impilamento
- standard
- Regione / Stato
- Ancora
- Fermare
- Tempesta
- soggetto
- successivo
- Successivamente
- di successo
- tale
- in dotazione
- SVG
- sinteticamente
- Fai
- prende
- tecniche
- tensorflow
- Testing
- Il
- il mondo
- loro
- in essa
- Theta
- cosa
- Attraverso
- tempo
- a
- Totale
- verso
- Trading
- Treni
- allenato
- Training
- Trasformare
- transizione
- vero
- tipicamente
- per
- sottostante
- capire
- poco intuitivo
- unità
- URL
- us
- uso
- convalida
- Valori
- vario
- Ve
- Video
- Visualizza
- visualizzazioni
- visione
- voxel
- peso
- quale
- while
- wikipedia
- volere
- senza
- Lavora
- lavori
- mondo
- X
- i rendimenti
- Tu
- youtube
- zefiro