Three-dimensional object reconstruction via physics-augmented neural rendering

Abstract

A neural rendering system may receive an image capturing an object. The system may deploy a renderer network to generate a model representing a state of the object at a time stamp. The system may train a convolutional network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation. The system may deploy the convolutional network to generate new models representing news states of the object at different time stamps. The system may generate images from the new models. The images may show the object with the new states. The model generated by the renderer network may include particles representing features of the object. The convolutional network may predict new positions of the particles to generate the new models. A new model may be converted to a grid representation of the object, and the grid representation may be rendered to generate an image.

Description

THREE-DIMENSIONAL OBJECT RECONSTRUCTION VIA PHYSICS-AUGMENTED NEURAL RENDERINGCross-Reference to Related Application

[0001] This application claims the benefit of International Application No. PCT / CN2025 / 073238, filed January 20, 2025, and titled “THREE-DIMENSIONAL OBJECT RECONSTRUCTION VIA PHYSICS-AUGMENTED NEURAL RENDERING, ” which is incorporated by reference in its entirety.Technical Field

[0002] This disclosure relates generally to artificial intelligence (AI) , and more specifically, three-dimensional (3D) object reconstruction via physics-augmented neural rendering.Background

[0003] Computer vision tasks include methods for acquiring, processing, analyzing, or understanding visual images to produce information, such as descriptions of objects in the images, decisions, and so on. Many computer vision tasks are performed using graph-structured data. A graph is a data structure comprising a collection of nodes (or vertices) and one or more edges. An edge is a connection of two nodes.Brief Description of the Drawings

[0004] Embodiments can be readily understood by the following detailed description in conjunction with the accompanying drawings. To facilitate this description, like reference numerals designate like structural elements. Embodiments are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings.

[0005] Figure (FIG. ) 1 is a block diagram of a neural rendering system, in accordance with various embodiments.

[0006] FIG. 2 illustrates a neural rendering process, in accordance with various embodiments.

[0007] FIG. 3 illustrates a training process, in accordance with various embodiments.

[0008] FIG. 4 illustrates representation transfer in a differential simulator, in accordance with various embodiments.

[0009] FIG. 5 illustrates a particle-to-grid conversion, in accordance with various embodiments.

[0010] FIG. 6 illustrates images generated using different voxel sizes, in accordance with various embodiments.

[0011] FIG. 7 illustrates an exemplary renderer network, in accordance with various embodiments.

[0012] FIG. 8 illustrates an exemplary ConvNet, in accordance with various embodiments.

[0013] FIG. 9 is a flowchart showing a method of object reconstruction, in accordance with various embodiments.

[0014] FIG. 10 is a block diagram of a computing device, in accordance with various embodiments.Detailed Description

[0015] The last decade has witnessed a rapid rise in AI based data processing, particularly based on DNNs. DNNs are widely used in the domains of computer vision, speech recognition, image, and video processing mainly due to their ability to achieve beyond human-level accuracy. A DNN typically includes a sequence of layers. A DNN layer may include one or more operations, such as convolution, interpolation, layer normalization, batch normalization, SoftMax operation, pooling, elementwise operation, linear operation, nonlinear operation, and so on. These operations are referred to as deep learning operations or neural network operations.

[0016] Neural network operations may be tensor operations. Input or output data of neural network operations may be arranged in data structures called tensors. Taking a convolutional layer for example, the input tensors include an activation tensor (also referred to as “input feature map (IFM) ” or “input activation tensor” ) including one or more activations (also referred to as “input elements” ) and a weight tensor. The weight tensor may be a kernel (a 2D weight tensor) , a filter (a 3D weight tensor) , or a group of filters (a 4D weight tensor) . A convolution may be performed on the input activation tensor and weight tensor to compute an output activation tensor in the convolutional layer.

[0017] A tensor is a data structure having multiple elements across one or more dimensions. Examples of tensors include vector (which is one-dimensional (1D) tensor) , matrix (which is two-dimensional (2D) tensor) , 3D tensors, four-dimensional (4D) tensors, and even higher dimensional tensors. A dimension of a tensor may correspond to an axis, e.g., an axis in a coordinate system. A dimension may be measured by the number of data points along the axis. The dimensions of a tensor may define the shape of the tensor. A DNN layer may receive one or more input tensors and compute an output tensor from the one or more input tensors. In some embodiments, a 3D tensor may have an X-dimension, a Y-dimension, and Z-dimension. The X-dimension of a tensor may be the horizontal dimension, the length of which may be the width of the tensor; the Y-dimension may be the vertical dimension, the length of which may be the height of the tensor; and the Z-dimension may be the channel dimension, the length of which may be the number of channels. The coordinates of the elements along a dimension may be integers in an inclusive range from 0 to (L-1) , where L is the length of the tensor in the dimension. For instance, the x coordinate of the first element in a row may be 0, the x coordinate of the second element in a row may be 1, and so on. Similarly, the y coordinate of the first element in a column may be 0, the y coordinate of the second element in a column may be 1, and so on. A 4D tensor may have a fourth dimension, which may indicate the number of batches in the operation.

[0018] Neural rendering relates to a family of techniques that can leverage DNNs to synthesize, reconstruct, or manipulate images and videos in a way that is informed by an understanding of real-world geometry, appearance, and physics. The data-driven paradigm can guide neural rendering models to understand the complexity of the visual world by seeing large datasets of images. But this is far from reasoning the underlying complex physics, hence apt to generate artifacts when capturing or synthesizing dynamic visual content.

[0019] Some neural rendering techniques explicitly model physical dynamics of the scene by manipulating visual content at a coarse level, including articulate transformation, rigid rotation and translation, and nonrigid deformation. However, they usually treat the visual content as a whole entity and it is difficult to address complex particle-level dynamics, such as soft body, fluid, and sand. As modeling physical dynamics from material conditions is a challenging task, currently available neural rendering methods usually adopt dedicated physics simulators to simulate particle / grid motion, basically positions and velocities, eventually achieving visually decent quality without blurring and following the conservation laws of continuum mechanics. Physical simulators can be categorized into two classes: traditional simulator and neural simulator. Traditional simulators are usually dedicated to solving partial differential equation (PDE) by numerical solvers, which have fantastic quality performance, but are computation-intensive plus assumed of knowing boundary conditions and initial conditions. Whereas neural simulator learns from large-scale annotated data and infers particle / grid motion by neural networks, which is expected to run much faster owing to lower computation demands and more concise operations (convolution, matrix multiplication, and activation, instead of complex matrix decomposition) , but less realistic.

[0020] In the scope of physics-augmented neural rendering, existing methods construct first-frame scenes by neural field. As for constructing dynamics of following frames, the solution can vary. Some methods formulate the process as differentiable simulation. It can be numerically stable but requires intensive computation on solving PDE. Some methods borrow 3D convolutional network (ConvNet) Deep Lagrangian Fluids (DLF) to learn the motion on massive particles, which can run faster and can be less sensitive to numerical precision. During training phase, as ground truth of particle trajectories are unknown, ConvNet can be learned with only perceptual supervision signal, hence suffers non-convergence issue and produces artifacts when simulates long sequence at runtime. Some methods address the problem of capturing object geometry and intricate physics from multi-view images input by constituting a neural rendering model with a rendering module and a simulation module. These methods usually adopt neural simulators as their simulation module to model viscous fluid material (such as water) but are impaired by failing to model other types of materials. These methods sometimes use material point method (MPM) simulators that can handle a wide range of materials but run much slower due to heavy simulating computation.

[0021] Embodiments of this disclosure may improve on at least some of the challenges and issues described above by providing a physics-augmented neural rendering platform that can perform fast object reconstruction, including 3D dynamic object reconstruction, and model complex physical dynamics. This platform has a neural simulator based neural radiance field (N2RF) . This platform can incorporate merits of traditional material point method (MPM) into a fully learnable model to accelerate the inference speed of rendering 3D object motion by distilling knowledge from a traditional simulator to a neural simulator in the training stage. The simulator used during runtime may have a neural architecture to enable fast rendering of physical scenes. This method can be significantly faster (e.g., approximately three times faster) than currently available methods.

[0022] In various embodiments of this disclosure, a neural rendering system may receive an input, which may be an image or video capturing an object. The object may be a dynamic object. In an example, the object may include a soft body, fluid, sand etc. The neural rendering system may deploy a renderer network to generate a model representing a state of the object at a time stamp. The state of the object may include a geometric or appearance state. The neural rendering system may train a convolutional neural network (ConvNet) by concurrently optimizing the ConvNet with a differentiable MPM (diff-MPM) simulator through knowledge distillation. The system may deploy the convolutional network to generate new models representing news states of the object. The new states of the object may correspond to different time stamps or different view angles from the input. The neural rendering system may generate images from the new models. The images may show the object with the new states. In some implementations, the model generated by the renderer network may include particles representing features of the object. The ConvNet may predict new positions of the particles to generate the new models. Anew model may be converted to a grid representation of the object, and the grid representation may be rendered to generate an image.

[0023] Compared with currently available methods, the neural rendering method in this disclosure can achieve comparable reconstruction quality for complicated dynamic scenes. It can maintain high-fidelity reconstruction appearance and geometry among various materials inputs, including Newtonian materials, elastic materials, sand, and so on. Also, this method can achieve significant acceleration (e.g., approximately 3x-7x acceleration) across thorough pipelines.

[0024] This disclosure provides a completely new perspective of augmenting physics in neural rendering algorithms. The neural rendering method in this disclosure can combine robustness of MPM simulation and efficiency of convolution-based neural simulation. It enables the convolution-based simulator to learn to simulate by distilling the knowledge from a mature traditional simulator. This method can provide significant efficiency improvement for 3D dynamic object viewing applications. It can render 3D object motion clip in an arbitrary novel view, enabling the application of 3D object viewing and motion editing. It can also dramatically reduce interaction cost and hardware requirement, potentially bringing better experience on entertainment applications on low-end devices.

[0025] This disclosure also provides an unlabeled training solution to obtain decent neural simulator. Developing a simulator typically requires years of engineering effort and frequently involves making trade-offs between generalization ability and accuracy. Neural rendering-based self-supervision paradigm can offer a low-cost solution to nurture visually plausible simulators from observed images. This approach can alleviate the demand of collecting labeled data from intricate real-world environments, as typically required in the standard supervised paradigm. This method can also support the capability of AI hardware that runs complex, high-fidelity simulations, and physics-augmented rendering at high speed.

[0026] For purposes of explanation, specific numbers, materials and configurations are set forth in order to provide a thorough understanding of the illustrative implementations. However, it can be apparent to one skilled in the art that the present disclosure may be practiced without the specific details or / and that the present disclosure may be practiced with only some of the described aspects. In other instances, well known features are omitted or simplified in order not to obscure the illustrative implementations.

[0027] Further, references are made to the accompanying drawings that form a part hereof, and in which is shown, by way of illustration, embodiments that may be practiced. It is to be understood that other embodiments may be utilized, and structural or logical changes may be made without departing from the scope of the present disclosure. Therefore, the following detailed description is not to be taken in a limiting sense.

[0028] Various operations may be described as multiple discrete actions or operations in turn, in a manner that is most helpful in understanding the claimed subject matter. However, the order of description should not be construed as to imply that these operations are necessarily order dependent. In particular, these operations may not be performed in the order of presentation. Operations described may be performed in a different order from the described embodiment. Various additional operations may be performed or described operations may be omitted in additional embodiments.

[0029] For the purposes of the present disclosure, the phrase “A or B” or the phrase "A and / or B" means (A) , (B) , or (A and B) . For the purposes of the present disclosure, the phrase “A, B, or C” or the phrase "A, B, and / or C" means (A) , (B) , (C) , (A and B) , (A and C) , (B and C) , or (A, B, and C) . The term "between, " when used with reference to measurement ranges, is inclusive of the ends of the measurement ranges.

[0030] The description uses the phrases "in an embodiment" or "in embodiments, " which may each refer to one or more of the same or different embodiments. The terms "comprising, " "including, " "having, " and the like, as used with respect to embodiments of the present disclosure, are synonymous. The disclosure may use perspective-based descriptions such as "above, " "below, " "top, " "bottom, " and "side" to explain various features of the drawings, but these terms are simply for ease of discussion, and do not imply a desired or required orientation. The accompanying drawings are not necessarily drawn to scale. Unless otherwise specified, the use of the ordinal adjectives “first, ” “second, ” and “third, ” etc., to describe a common object, merely indicates that different instances of like objects are being referred to and are not intended to imply that the objects so described must be in a given sequence, either temporally, spatially, in ranking or in any other manner.

[0031] In the following detailed description, various aspects of the illustrative implementations are described using terms commonly employed by those skilled in the art to convey the substance of their work to others skilled in the art.

[0032] The terms “substantially, ” “close, ” “approximately, ” “near, ” and “about, ” generally refer to being within+ / -20%of a target value as described herein or as known in the art. Similarly, terms indicating orientation of various elements, e.g., “coplanar, ” “perpendicular, ” “orthogonal, ” “parallel, ” or any other angle between the elements, generally refer to being within+ / -5-20%of a target value as described herein or as known in the art.

[0033] In addition, the terms “comprise, ” “comprising, ” “include, ” “including, ” “have, ” “having” or any other variation thereof, are intended to cover a non-exclusive inclusion. For example, a method, process, device, or DNN accelerator that comprises a list of elements is not necessarily limited to only those elements but may include other elements not expressly listed or inherent to such method, process, device, or DNN accelerators. Also, the term “or” refers to an inclusive “or” and not to an exclusive “or. ”

[0034] The systems, methods and devices of this disclosure each have several innovative aspects, no single one of which is solely responsible for all desirable attributes disclosed herein. Details of one or more implementations of the subject matter described in this specification are set forth in the description below and the accompanying drawings.

[0035] FIG. 1 is a block diagram of a neural rendering system 100, in accordance with various embodiments. The neural rendering system 100 may use machine learning models to perform computer vision tasks, such as action recognition tasks. The neural rendering system 100 includes an interface module 110, a renderer network 120, a dynamic simulation module 130, a image generator 140, a training module 150, a validating module 160, and a datastore 170. In other embodiments, alternative configurations, different or additional components may be included in the neural rendering system 100. Further, functionality attributed to a component of the neural rendering system 100 may be accomplished by a different component included in the neural rendering system 100 or by a different system.

[0036] The interface module 110 facilitates communication of the neural rendering system 100 with other modules or systems. In some embodiments, the interface module 110 may establish communication between the neural rendering system 100 with an external device or system for receiving images of objects or information associated with such images. In an example, the interface module 110 may receive one or more images of an object. The one or more images may capture one or more views of the object. In another example, the interface module 110 may receive a multi-view video capturing an object. Objects may include dynamic objects. A dynamic object may chang its state and have different states at different times. The object state may be geometry, appearance, pose (orientation or position) , or other types of states of the object. Examples of the objects may include objects with Newtonian materials, elastic materials, sand, and so on. The images received by the interface module 110 may be static images. For instance, a static image of a dynamic object may capture the dynamic object at a particular time stamp. The static image may show the static state of the object at the time stamp.

[0037] The interface module 110 may also establish communication between the neural rendering system 100 with an external device or system for training the renderer network 120 or dynamic simulation module 130. For example, the interface module 110 may receive training dataset from the external device or system. In some embodiments, the interface module 110 may facilitate transmitting data (e.g., object reconstruction images) generated by the neural rendering system 100 to one or more external devices or systems.

[0038] The renderer network 120 converts images of objects to particle-based models of objects. The images may be received through the neural rendering system 100. A particle-based model of an object may include a set of particles that represent one or more features of the object. For instance, the particle-based model may include a plurality of particles the represents the geometry, appearance, pose, or other types of features of the object. The renderer network 120 may determine the position of each particle in the model based on the image. The particle-based model may represent a simulation volume that may be used by the other components of the neural rendering system 100 (e.g., the dynamic simulation module 130) to run dynamic simulation. In some embodiments, the renderer network 120 may be at least a multilayer perceptron (MLP) .

[0039] In some embodiments, the renderer network 120 is denoted asψ, which comprises MLPs with learnable parameterθren. The renderer network 120 may estimate volume density fieldσ0 (x) and view-dependent appearance (color) field c0 (x, ω) , where x is 3D point position andωis the view direction. The appearance Ct of a pixel specified by ray direction r is given by standard radiance rendering as follows: where t denotes time. In some embodiments, t=0 for the static reconstruction at the first  frame.

[0040] The learnable parameterθren of the renderer network 120 may be determined by training the renderer network 120. The training of the renderer network 120 may be performed by the training module 150 as described below. The renderer network 120, after being trained, may be denoted as afterthe training. can generate 3D points x0 sampled fromσ0, which may be termed as particles and drive motion simulation in the next stage. The initial particles x0 may be sampled from the volume density fieldσ0 by scattering midpoint on the 8 sides of each voxel. In some embodiments, initial velocity v0 is estimated from first 2 frame reconstructed results following

[0041] The dynamic simulation module 130 may run dynamic simulation based on models of objects generated by the renderer network 120. For instance, the dynamic simulation module 130 may generate a temporal sequence of models of an object based on an input model of the object. The input model may be a model generated by the renderer network 120 and input into the dynamic simulation module 130. The temporal sequence of models includes new models of the object that correspond to different times stamps. These time stamps may be later than the time stamp of the input model. The new models may capture features of the object for these time stamps. The new models may represent different states of the object from the state represented by the input model.

[0042] As shown in FIG. 1, the dynamic simulation module 130 includes a differentiable simulator 180 and a ConvNet 190. The differentiable simulator 180 may be used to train the ConvNet 190. The training of the ConvNet 190 based on the differentiable simulator 180 may be performed by the training module 150 as described below. In some embodiments, the differentiable simulator 180 may be a diff-MPM simulator. The differentiable simulator 180 may use a hybrid Euler-Lagrangian method to run repeat simulation. The differentiable simulator 180 may be denoted asΦmpm. In some embodiments, the differentiable simulator 180 may take a volume density field as input and converts the grid representation to particles. Then it may take particle position xt-Δt, velocity vt-Δt, and material parameters at last substep Δt as input, and predictes particle position xt and velocity vt one substep forward. Further, it may scatter particles back to the grid for boundary collision handling. In particle representation, xt may be calculated from historical state and vt. vt may obey momentum conservation for continuum materials (Navier–Stokes equations) , such as: Where denotes the derivate of velocity, and denotes the accelerations  enforced by internal pressure, incompressibility and gravity. In some embodiments,  which denotes the incompressibility that is inherent in most fluid materials.

[0043] The ConvNet 190 may be used to run dynamic simulation after it is trained. For instance, during runtime, a model from the renderer network 120 may be input into the ConvNet 190 and the ConvNet 190 may output one or more new models. In an example where the ConvNet 190 receives a particle-based model of an object, the ConvNet 190 may predict new positions of the particles in the model and generate new particle-based modes in which the particles are at the new positions.

[0044] In some embodiments, the ConvNet 190, which may be denoted asΦconv, is a lagrangian convolutional network that uses continuous convolution to mimic smooth particle hydrodynamics (SPH) method. The input toΦconv may be a set of particles with corresponding features. Φconv may first compute intermediate position and velocity enforced by external forces aext (e.g. gravity) as follows:

[0045] In some embodiments, the intermediate state may lack interactions between particles. Φconv include a plurality of layers of continuous convolution to estimate position correction Δxt: where G denotes convolutional filter and R denotes the neighboring search radius. In an  example, Φconv includes four layers of continuous convolution to estimate position correction. The output position and velocity may be denoted as:

[0046] Φconv may learn from synthetic fluid scenarios that are generated by mature physics engine. In some embodiments, Δt varies betweenΦmpm andΦconv. In an example, Φmpm runs 200 substeps per frame (Δt≈0.2ms) , andΦconv runs once per frame (Δt≈40ms) . The ConvNet 190 can accelerate the simulation phase by bypassing numerical stability issues and substitute robust traditional simulator in the neural rendering pipeline after it achieves comparable quality by knowledge distillation from it. Certain aspects of the ConvNet 190 are described below in conjunction with FIG. 8.

[0047] The image generator 140 converts particle-based models generated by the dynamic simulation module 130 into grid representations. In some embodiments, the image generator 140 may convert a particle-based model of an object to a grid representation of the object based on positions of the particles in the particle-based model. For instance, the image generator 140 may divide a space into a grid of voxels. The space may be a 2D space or 3D space. The image generator 140 may scatter the particles in the particle-based model to the grid of voxels based on the positions of the particles inside the particle-based model. For instance, the image generator 140 may update each voxel of the grid with a particle in the particle-based model.

[0048] In some embodiments, the image generator 140 may down-sample the particle-based model. The image generator 140 may remove one or more particles from the particle-based model to down-sample the simulation volume. The down-sampled simulation volume includes a subset of the particles in the particle-based model. The image generator 140 may scatter the subset of particles to the grid of voxels. For instance, the image generator 140 may update each voxel of the grid with a particle in the subset. After the voxels of the grid are updated, the image generator 140 may output the grid representation of the object.

[0049] In some embodiments, the image generator 140 may use a kernel to perform particle-to-grid conversion. The image generator 140 may determine the size of the kernel. The image generator 140 may determine a voxel size and a sampling ratio, the combination of which may determine the size of the kernel. The voxel size may indicate a length of each voxel. The smaller the voxel size, the higher resolution the images would have. The image generator 140 may interpolate the voxel size continuously during inference to get continuous, multi-resolution. The sampling ratio may indicate how much the simulation volume is down-sampled. In an example where the sampling ratio is 2, the simulation volume is down-sampled two times. The higher the sampling ratio, the lower the quality of the images would be. The image generator 140 may determine an optimal voxel size or optimal sampling ratio to achieve a desirable combination of efficiency and quality. In some embodiments, the image generator 140 may implement a particle-to-grid algorithm in Pytorch. The image generator 140 may further post tune the particle-based model or grid representation for more precise appearance.

[0050] The image generator 140 may also render the grid representations to generate images. In some embodiments, the image generator 140 may create a blank image, which may be used as an image canvas. The image generator 140 may then calculate the dimensions of the input grid. The image generator 140 may iterate through the grid to color each pixel on the image canvas to generate an image. The image may show the state of the object that is represented by the grid representation.

[0051] In some embodiments, the image generator 140 outputs a temporal sequence of images that shows a temporal change of the object. The temporal sequence of images may be a simulation of how the object behaves over time. The temporal change may be motion, deformation, or other types of changes. The temporal sequence of images may constitute a video, in which each image may be a frame at a particular time stamp. In an example, the first frame of the video may be the image used by the renderer network 120 to generate the first model of the object. The images generated by the image generator 140 from the models predicted by the ConvNet 190 may be the subsequent frames of the video.

[0052] The training module 150 trains DNNs, such as the renderer network 120 and ConvNet 190. In the process of training a DNN, the training module 150 may form a training dataset. The training dataset includes training samples and ground-truth labels. Each training sample may be associated with one or more ground-truth labels. Aground-truth label of a training sample may be a known or verified label that answers the problem or question that the DNN is to be used to answer. Taking the renderer network 120 for example, a training sample may be an image of an object, which may be captured by a camera or other types of sensors. The training sample may be considered as the first frame. The ground-truth label of the training sample may be a known or verified particle-based model representing a state of the object that is captured in the image. Taking the ConvNet 190 for example, a training sample may be a particle-based model of an object at a particular time, and the ground-truth label of the training sample may include one or more known or verified particle-based models of the object at one or more subsequent times.

[0053] In some embodiments, the training module 150 may jointly train the renderer network 120 and ConvNet 190. The training module 150 may use the same training samples to train the renderer network 120 and ConvNet 190. For instance, the training module 150 may input a training dataset into the renderer network 120 to trigger two training stages. The training module 150 may update internal parameters of the renderer network 120 in the first training stage and update internal parameters of the ConvNet 190 in the second training stage.

[0054] In some embodiments, the training module 150 may perform a training process that involves other components of the neural rendering system 100, such as the image generator 140. For instance, the training module 150 may compute loss for the renderer network 120 or ConvNet 190 based on the pixel colors rendered by the image generator 140. In some embodiments, the training module 150 may train the renderer network 120 by enforcing the rendered pixel colors to match those in the first-frame observations. The reconstruction loss function may be defined as below:

[0055] In some embodiments, the training module 150 may train the ConvNet 190 through knowledge distillation. For instance, the training module 150 may input the same data into the differentiable simulator 180 and ConvNet 190 and distill knowledge from the differentiable simulator 180 to the ConvNet 190 as the differentiable simulator 180 performs dynamic simulation. Certain aspects of training the renderer network 120 and ConvNet 190 are provided below in conjunction with FIG. 3.

[0056] In some embodiments, the training module 150 may also form validation datasets for validating performance of the renderer network 120 or ConvNet 190 after training by the training module 150. A validation dataset may include validation samples and ground-truth labels of the validation samples. The validation dataset may include different samples from the training dataset used for training the renderer network 120 or ConvNet 190. In an embodiment, a part of a training dataset may be used to initially train the renderer network 120 or ConvNet 190, and the rest of the training dataset may be held back as a validation subset used by the validating module 160 to validate performance of the interface module 110. The portion of the training dataset not including the validation subset may be used to train the renderer network 120 or ConvNet 190.

[0057] The training module 150 also determines hyperparameters for training the renderer network 120 or ConvNet 190. Hyperparameters are variables specifying the training process. Hyperparameters are different from parameters inside the renderer network 120 or ConvNet 190. In some embodiments, hyperparameters include variables determining the architecture of at least part of the renderer network 120 or ConvNet 190, such as number of hidden layers in the renderer network 120 or ConvNet 190, and so on. Hyperparameters also include variables which determine how the renderer network 120 or ConvNet 190 is trained, such as batch size, number of epochs, etc. Abatch size defines the number of training samples to work through before updating the parameters of the renderer network 120 or ConvNet 190. The batch size is the same as or smaller than the number of samples in the training dataset. The training dataset can be divided into one or more batches. The number of epochs defines how many times the entire training dataset is passed forward and backwards through the entire network. The number of epochs defines the number of times that the deep learning algorithm works through the entire training dataset. One epoch means that each training sample in the training dataset has had an opportunity to update the internal parameters of the renderer network 120 or ConvNet 190. An epoch may include one or more batches. The number of epochs may be 15, 150, 500, 1500, or even larger.

[0058] The training module 150 may train the renderer network 120 or ConvNet 190 for a predetermined number of epochs. The number of epochs is a hyperparameter that defines the number of times that the deep learning algorithm would work through the entire training dataset. One epoch means that each sample in the training dataset has had an opportunity to update the internal parameters of the renderer network 120 or ConvNet 190. After the training module 150 finishes the predetermined number of epochs, the training module 150 may stop updating the internal parameters of the renderer network 120 or ConvNet 190, and the renderer network 120 or ConvNet 190 is considered trained.

[0059] The validating module 160 may verify accuracy of the renderer network 120 or ConvNet 190 after the renderer network 120 or ConvNet 190 is trained. In some embodiments, the validating module 160 inputs samples in a validation dataset into the renderer network 120 or ConvNet 190 and uses the outputs of the renderer network 120 or ConvNet 190 (or the outputs of the image generator 140) to determine the prediction accuracy of the renderer network 120 or ConvNet 190. In some embodiments, a validation dataset may be formed of some or all the samples in the training dataset. Additionally or alternatively, the validation dataset includes additional samples, other than those in the training sets. In some embodiments, the validating module 160 determines may determine an accuracy score measuring the precision, recall, or a combination of precision and recall of the interface module 110. The validating module 160 may use the following metrics to determine the accuracy score: Precision=TP /  (TP+FP) and Recall=TP /  (TP+FN) , where precision may be how many the DNN correctly predicted (TP or true positives) out of the total it predicted (TP+FP or false positives) , and recall may be how many the DNN correctly predicted (TP) out of the total number of objects that did have the property in question (TP+FN or false negatives) . The F-score (F-score=2*PR /  (P+R) ) unifies precision and recall into a single measure.

[0060] The validating module 160 may compare the accuracy score with a threshold score. In an example where the validating module 160 determines that the accuracy score is lower than the threshold score, the validating module 160 instructs the training module 150 to further train the interface module 110. In one embodiment, the validating module 160 may iteratively re-train the renderer network 120 or ConvNet 190 until the occurrence of a stopping condition, such as the accuracy measurement indication that the renderer network 120 or ConvNet 190 may be sufficiently accurate, or a number of training rounds having taken place.

[0061] The datastore 170 stores data received, generated, used, or otherwise associated with the neural rendering system 100. For example, the datastore 170 stores the datasets received by the interface module 110. The datastore 170 may also store data generated by the training module 150 and validating module 160, such as the hyperparameters for training the interface module 110, internal parameters of the interface module 110, and so on. As another example, the datastore 170 may store data generated by the renderer network 120, dynamic simulation module 130, and image generator 140, such as particle-based models, grid-based models, images, and so on. In the embodiment of FIG. 2, the datastore 170 is a component of the neural rendering system 100. In other embodiments, the datastore 170 may be external to the neural rendering system 100and communicate with the neural rendering system 100 through a network.

[0062] FIG. 2 illustrates a neural rendering process 200, in accordance with various embodiments. The neural rendering process 200 is an exemplary pipeline to reconstruct 3D object geometry, appearance, and motion by giving temporal image sequences from sparse views. For the purpose of illustration, FIG. 2 shows dynamic reconstruction of a fluid drop to simulate how the fluid drop behaves over time. The neural rendering process 200 can be used for reconstruction of other types of objects.

[0063] The neural rendering process 200 starts with receiving an input. For the purpose of simplicity, the input in FIG. 1 is an image 201. In other embodiments, the input may be multiple images. The images may capture different views of the fluid drop. For instance, the input may be a multi-view video capturing the fluid drop. In the example of FIG. 2, the image 201 captured a static state of fluid drop at a particular time. This time is referred to as the initial time. The image is provided to a renderer network 210. The renderer network 210 may be an example of the renderer network 120 in FIG. 1. In an example, the renderer network 210 includes one or more MLPs. Certain details regarding MLP are described below in conjunction with FIG. 7. In the embodiments of FIG. 2, the renderer network 210 outputs a model 202 representing the fluid drop. The model 202 is a particle-based model of the fluid drop. The particles in the model 202 have their particular position to represent the geometry and appearance of the fluid drop that is shown in the image 201. In some embodiments, the model 202 may be a 3D model. The model 202 may represent a simulation volume. In some embodiments, the renderer network 210 compresses the static object in the image 201 into a view-independent volume density field and view-dependent appearance (color) field.

[0064] The model 202 is provided to a neural simulator 220. An example of the neural simulator 220 is the ConvNet 190 in FIG. 1. The neural simulator 220 and a non-neural simulator (e.g., a diff-MPM simulator) may be concurrently optimized in a knowledge distillation framework. During the neural rendering process 200, the non-neural simulator is discarded and the neural simulator 220 is committed to perform dynamic reconstruction to maximize the runtime efficiency. In some embodiments, the neural simulator 220 may reconstruct the dynamic motion of the static object within the window of witnessed frames and predict change of the object beyond observation.

[0065] In the example of FIG. 2, the neural simulator 220 outputs a temporal sequence of models. The temporal sequence of models includes a model 203, model 204, and model 205. In some embodiments, the model 203 is the same as the model 202; the model 204 and model 205 are new models generated by the neural simulator 220. In other embodiments, the model 203, model 204, and model 205 are all new models generated by the neural simulator 220. The model 203, model 204, and model 205 are input into an image generator 230. An example of the image generator 230 is the image generator 140 in FIG. 1. The image generator 230 generates a video 206. The video 206 includes a frame 207, frame 208, and frame 209. The frame 207, frame 208, and frame 209 are arranged in a temporal sequence. The image generator 230 may generate the frame 207 from the model 203 through particle-to-grid conversion and rendering. Similarly, the image generator 230 may generate the frame 208 from the 204 and generate the frame 209 from the model 205. The frame 207 may show the state of the object at the initial time. In some embodiments, the image 201 may be reused as the frame 207. In other embodiments, the frame 207 is a different or separate image generated by the image generator 230. As shown in FIG. 2, the video 206 is a simulation of a temporal transformation and motion of the fluid drop.

[0066] FIG. 3 illustrates a training process 300, in accordance with various embodiments. The training process 300 may be performed by the training module 150 in FIG. 1. For the purpose of illustration, the training process 300 in FIG. 3 incorporates at least part of the neural rendering process 200 in FIG. 2. The image 201 is used as a training sample of the training process 300. Different from the neural rendering process 200 in FIG. 2, the training process 300 in FIG. 3 involves a differential simulator 310. An example of the differential simulator 310 is the differentiable simulator 180 in FIG. 1. During the training process 300, the model 202 is input into both the neural simulator 220 and differential simulator 310. The differential simulator 310 may run dynamic reconstruction repeatedly and generate a plurality of temporal sequences of particle or grid-based representations of the fluid drop.

[0067] The image 201 is associated with n views: view 301-1 through view 301-n. Each view may be an observation of a temporal change of the fluid drop and may be used as a ground-truth label. The renderer network 210 and neural simulator 220 may be trained jointly during the training process 300. For instance, internal parameters of the renderer network 210 may be updated in the first training stage of the training process 300, and internal parameters of the neural simulator 220 may be updated in the second training stage of the training process 300. The update of the internal parameters of the renderer network 210 or neural simulator 220 may be based on a loss computed based on the video 206 and the views 201-1 through 201-n.

[0068] In some embodiments, both the neural simulator 220 and differential simulator 310 are optimized during the training process 300. For instance, both the neural simulator 220 and differential simulator 310 are optimized during the second training stage. An objective of this stage is to incubate a computation-efficient neural model (i.e., the neural simulator 220) that can estimate the movements of various object materials. The second training stage may be a snapshot knowledge distillation process, during which the differential simulator 310 functions as a computation-heavy teacher model and the neural simulator 220 functions as a light-weight student model. The differential simulator 310, which is an optimization-based physics simulator, is computation heavy because it simulates movements within a tiny time window to ensure numerical stability during the training process 300. For instance, the differential simulator 310 may subdivide one frame step into 200 substeps. The neural simulator 220 is capable of simulating movements frame by frame, jumping over substep simulation and hence accelerating the inference speed.

[0069] Using snapshot knowledge distillation, the neural simulator 220 can learn from rollouts of physics-realism particle movements generated by the differential simulator 310 during the loop of its optimization. In an example, snapshot knowledge distillation can snapshot the output position and velocity snapshotted by the differential simulator 310 at each frame and optimizes the neural simulator 220 in a full-sequence supervision mode. The snapshot knowledge distillation may be formed as: whereΦconv denotes the neural simulator 220. Φconv takes predicted results(xt-1, vt-1)as  input to infer the next frame rather than using ground truth input, which takes long-term error accumulation into consideration. The loss LKD may indicate a difference between the prediction of the neural simulator 220 and the position and velocity determined by the differential simulator 310. The neural simulator 220 may be optimized (e.g., internal parameters of the neural simulator 220 are updated) to minimize the loss.

[0070] Distillation-based training strategy, such as the snapshot knowledge distillation strategy described above, can address the difficulty of neural simulator learning in absence of labeled data. The two simulators can keep evolving on the fly. The differential simulator (e.g., a diff-MPM simulator) may repeat differentiable simulation to fit reconstruction results with observed images, recurrently correcting initial parameters including material parameters and initial velocities towards ground truth. Intermediate simulation results (e.g., positions, velocities, etc. ) can be collected as distillation samples and used as easy-to-learn knowledge to guide the learning of the ConvNet simulator. As the diff-MPM simulator can run at a much higher frequency than the ConvNet simulator, the training module may snapshot its output once per 100～200 simulation substeps (depending on how many substeps it segments one frame) . Interframe snapshots may be grouped into input / output pairs to train the ConvNet simulator. To enrich diversity of the collection and facilitate generalization ability on various granularities of particle clusters, the distillation training can be further enhanced to multi-resolution pyramid. Certain aspects of multi-resolution neural rendering are described below in conjunction with FIG. 5.

[0071] In some embodiments, a runtime-efficient model may be retained by discarding the differential simulator 310 but includes the renderer network 210 and neural simulator 220. The neural simulator 220 can predict particle trajectories from their recent positions and velocities, and the renderer network 210 can cast rays on the morphed geometry and generates novel appearance based on the neural field attributes (color and occupancy initialized at first frame) that are bounded to those particles.

[0072] FIG. 4 illustrates representation transfer in a differential simulator, in accordance with various embodiments. The differential simulator may be an example of the differentiable simulator 180 in FIG. 1. In the embodiments of FIG. 4, the differential simulator may be performing dynamic reconstruction of an object. The differential simulator converts a grid representation 401 of an object to a particle representation 402 of the object. In some embodiments, the grid representation 401 is denoted asσt-1 and represents the object at a timestamp t-1. For the purpose of illustration, the grid representation 401 is in a space represented by a 9×9 grid, the grid representation 401 itself is a 3×3 grid that includes 9 voxels. Each voxel may be an element of the grid representation 401 and may be a representation of a value.

[0073] The particle representation 402 may be denoted as xt-1. The particle representation 402 represents the object at a timestamp t-1. The particle representation 402 includes 9 particles distributed in the space. The 9 particles each have its own position in the space. The differential simulator constructs a particle representation 403 from the particle representation 402. The particle representation 403 may be denoted as xt. The particle representation 403 represents the object at a timestamp t, when the state of the object may be different from the timestamp t-1. For instance, the object may have a different shape, color, appearance, pose, and so on. As shown in FIG. 4, the positions of the 9 particles in the particle representation 403 are different from the positions of the 9 particles in the particle representation 402. The differential simulator may determine the new positions of the 9 particles through dynamic simulation.

[0074] The differential simulator further converts the particle representation 403 to a grid representation 404. The grid representation 404 may be denoted as The grid representation 404 also represents the object at a timestamp t. The grid representation 404 is a 3×3 grid that includes 9 voxels. Each voxel in the grid representation 404 corresponding to a particle in the particle representation 403. The position of a voxel in the grid representation 404 may be determined based on the position of the particle in the space.

[0075] The representation transfer process in FIG. 4 may be a single round of dynamic reconstruction. In some embodiments, the differential simulator may perform multiple rounds of dynamic reconstruction. For instance, the differential simulator may generate from then generate from and so on. The knowledge in the differential simulator may be distilled into a neural simulator, such as the ConvNet 190 in FIG. 1 or the neural simulator 220 in FIG. 2, during a training process.

[0076] FIG. 5 illustrates a particle-to-grid conversion, in accordance with various embodiments. The particle-to-grid conversion may be performed by the image generator 140 of the neural rendering system 100 in FIG. 1 for generating images from grid representations of objects. The particle-to-grid conversion in FIG. 5 involves scattering particles to a 3D grid. For the purpose of illustrate, FIG. 5 shows a 2D space and a 2×2 grid 510. FIG. 5 shows a particle 520 in the 2D space. The particle-to-grid conversion is conversion of the particle 520 to the grid 510. In some embodiments, the particle-to-grid conversion is based on a scattered kernel 530. In an example, the scattered kernel 530 is a B-Spline kernel. In an example, the size of the scattered kernel is denoted as k=sX, where is specified for low-resolution simulation. For example, in a 3D scene with size of 1×1×1 and base voxel size X=0.02, the space may be divided into 50×50×50 voxels for rendering. When X=0.04, initial particles may be down-sampled by 23 times for simulation, and each particle may be scattered to neighbored 4×4×4 grid during the particle-to-grid conversion.

[0077] The kernel size may determine the resolution of the images to be generated based on the particle-to-grid conversion. As the 3D space is divided into volume by specifying voxel size X, the value of X can affect the static reconstruction precision, the simulation grid scale, or particle number. Simulation can consume most time during inference, adjusting the value of X can bring faster run speed with minor quality loss. Multi-resolution neural rendering may be performed to further excavate the efficiency. In some embodiments, multi-resolution snapshot knowledge distillation may be formed as follows: where s∈ {1, 1.5, 2} denotes the voxel size sampling ratio with respect to the one for static  reconstruction. For example, s=2 denotes that the volume for simulation is down-sampled 2 times to generate less particles for faster running speed. Although around 87.5%particles are removed during the 2 times down-sampling, the reconstruction results suffer minor reconstruction quality loss. The neural rendering system 100 can be generalized for maintaining geometry details for low-resolution inference. In some embodiments, after the renderer network 120 and ConvNet 190 are trained on a few milestones, the neural rendering system 100 can interpolate the voxel size continuously during inference.

[0078] FIG. 6 illustrates images generated using different voxel sizes, in accordance with various embodiments. For the purpose of illustration, FIG. 6 shows images generated using voxel sizes of 0.02, 0.024, 0.032, and 0.04. As the voxel size increases, the resolution of the generated images decreases. In some embodiments, the resolution may drop by 50%as the voxel size is doubled. Downgrading the resolution can bring up to inference acceleration. In some embodiments, simulation particles decrease tri-linearly to the voxel size. In an example, 2x down-sampling can remove around 87.5%particles, leading to slight mosaic artifacts whereas still presenting consistent reconstruction quality with currently available neural rendering techniques.

[0079] FIG. 7 illustrates an exemplary renderer network 700, in accordance with various embodiments. The renderer network 700 may be an example of the renderer network 210 in FIG. 2. In the embodiments of FIG. 7, the renderer network 700 is a MLP. As shown in FIG. 7, the renderer network 700 includes an input layer 710, hidden layer 720, hidden layer 730, hidden layer 740, and output layer 750. In other embodiments, the renderer network 700 may have fewer, more, or different layers. For instance, the renderer network 700 may have fewer or more than three hidden layers.

[0080] The input layer 710 may receive the input to the renderer network 700. In some embodiments, the input layer 710 receives raw data features, such as bounding boxes, images, point clouds, and so on. In an example for kinematics calculation, the input may be a context input, such as the context inputs described above. The hidden layer 720, hidden layer 730, and hidden layer 740 may transform the input using learned weights and activation functions. The hidden layer 720, hidden layer 730, and hidden layer 740 may each include one or more neural network operations. In an example, the input to the renderer network 700 may be processed in the hidden layer 720 by performing a neural network operation of the hidden layer 720 on the input. The output of the hidden layer 720 is then processed in the hidden layer 730 by performing a neural network operation of the hidden layer 730 on the output of the hidden layer 720. The output of the hidden layer 730 is then processed in the hidden layer 740 by performing a neural network operation of the hidden layer 740 on the output of the hidden layer 730. The output of the hidden layer 740 is provided to the output layer 750. The output layer 750 may produce the output of the renderer network 700, such as the final prediction result.

[0081] In some embodiments, each layer includes a plurality of nodes. Each node (or neuron) in one layer connects to every node in the next layer, forming a fully-connected architecture. In FIG. 7, each node is represented by a circle. For the purpose of illustration, the input layer 710 and output layer 750 each have three nodes, the hidden layer 720 and hidden layer 740 each have four nodes, and the hidden layer 730 has five nodes. In other embodiments, the input layer 710, hidden layer 720, hidden layer 730, hidden layer 740, or output layer 750 may have a different number of nodes. In some embodiments, a node may perform a weighted sum of its inputs followed by a nonlinear activation function, such as Rectified Linear Unit (ReLU) , Sigmoid, or Tanh function.

[0082] FIG. 8 illustrates an exemplary ConvNet 800, in accordance with various embodiments. The ConvNet 800 may be an example of the ConvNet 190 in FIG. 1. For the purpose of illustration, the ConvNet 800 includes a sequence of layers comprising a plurality of convolutional layers 810 (individually referred to as “convolutional layer 810” ) , a plurality of pooling layers 820 (individually referred to as “pooling layer 820” ) , and a plurality of fully-connected layers 830 (individually referred to as “fully-connected layer 830” ) . In other embodiments, the ConvNet 800 may include fewer, more, or different layers. In an execution of the ConvNet 800, the layers of the ConvNet 800 execute tensor computation that includes many tensor operations, such as convolutions, interpolations, pooling operations, elementwise operations (e.g., elementwise addition, elementwise multiplication, etc. ) , other types of tensor operations, or some combination thereof.

[0083] The convolutional layers 810 summarize the presence of features in inputs to the ConvNet 800. The convolutional layers 810 function as feature extractors. The first layer of the ConvNet 800 is a convolutional layer 810. In an example, a convolutional layer 810 performs a convolution on an input tensor 840 (also referred to as IFM 840) and a filter 850. As shown in FIG. 8, the IFM 840 is represented by a 7×7×33D matrix. The IFM 840 includes 3 input channels, each of which is represented by a 7×7 2D matrix. The 7×7 2D matrix includes 7 input elements (also referred to as input points) in each row and 7 input elements in each column. The filter 850 is represented by a 3×3×3 3D matrix. The filter 850 includes 3 kernels, each of which may correspond to a different input channel of the IFM 840. A kernel is a 2D matrix of weights, where the weights are arranged in columns and rows. A kernel can be smaller than the IFM. In the embodiments of FIG. 8, each kernel is represented by a 3×3 2D matrix. The 3×3 kernel includes 3 weights in each row and 3 weights in each column. Weights can be initialized and updated by backpropagation using gradient descent. The magnitudes of the weights can indicate importance of the filter 850 in extracting features from the IFM 840.

[0084] The convolution includes multiply-accumulate (MAC) operations with the input elements in the IFM 840 and the weights in the filter 850. The convolution may be a standard convolution 863 or a depthwise convolution 883. In the standard convolution 863, the whole filter 850 slides across the IFM 840. All the input channels are combined to produce an output tensor 860 (also referred to as output feature map (OFM) 860) . The OFM 860 is represented by a 5×5 2D matrix. The 5×5 2D matrix includes 5 output elements (also referred to as output points) in each row and 5 output elements in each column. For the purpose of illustration, the standard convolution includes one filter in the embodiments of FIG. 8. In embodiments where there are multiple filters, the standard convolution may produce multiple OCs in the OFM 860.

[0085] The multiplication applied between a kernel-sized patch of the IFM 840 and a kernel may be a dot product. Adot product is the elementwise multiplication between the kernel-sized patch of the IFM 840 and the corresponding kernel, which is then summed, always resulting in a single value. Because it results in a single value, the operation is often referred to as the “scalar product. ” Using a kernel smaller than the IFM 840 is intentional as it allows the same kernel (set of weights) to be multiplied by the IFM 840 multiple times at different points on the IFM 840. Specifically, the kernel is applied systematically to each overlapping part or kernel-sized patch of the IFM 840, left to right, top to bottom. The result from multiplying the kernel with the IFM 840 one time is a single value. As the kernel is applied multiple times to the IFM 840, the multiplication result is a 2D matrix of output elements. As such, the 2D output matrix (i.e., the OFM 860) from the standard convolution 863 is referred to as an OFM.

[0086] In the depthwise convolution 883, the input channels are not combined. Rather, MAC operations are performed on an individual input channel and an individual kernel and produce an OC. As shown in FIG. 8, the depthwise convolution 883 produces a depthwise output tensor 880. The depthwise output tensor 880 is represented by a 5×5×3 3D matrix. The depthwise output tensor 880 includes 3 OCs, each of which is represented by a 5×5 2D matrix. The 5×5 2D matrix includes 5 output elements in each row and 5 output elements in each column. Each OC is a result of MAC operations of an input channel of the IFM 840 and a kernel of the filter 850. For instance, the first OC (patterned with dots) is a result of MAC operations of the first input channel (patterned with dots) and the first kernel (patterned with dots) , the second OC (patterned with horizontal strips) is a result of MAC operations of the second input channel (patterned with horizontal strips) and the second kernel (patterned with horizontal strips) , and the third OC (patterned with diagonal stripes) is a result of MAC operations of the third input channel (patterned with diagonal stripes) and the third kernel (patterned with diagonal stripes) . In such a depthwise convolution, the number of input channels equals the number of OCs, and each OC corresponds to a different input channel. The input channels and output channels are referred to collectively as depthwise channels. After the depthwise convolution, a pointwise convolution 893 is then performed on the depthwise output tensor 880 and a 8×1×3 tensor 890 to produce the OFM 860.

[0087] The OFM 860 is then passed to the next layer in the sequence. In some embodiments, the OFM 860 is passed through an activation function. An example activation function is rectified linear unit (ReLU) . ReLU is a calculation that returns the value provided as input directly, or the value zero if the input is zero or less. The convolutional layer 810 may receive several images as input and calculate the convolution of each of them with each of the kernels. This process can be repeated several times. For instance, the OFM 860 is passed to the subsequent convolutional layer 810 (i.e., the convolutional layer 810 following the convolutional layer 810 generating the OFM 860 in the sequence) . The subsequent convolutional layers 810 perform a convolution on the OFM 860 with new kernels and generate a new feature map. The new feature map may also be normalized and resized. The new feature map can be kernelled again by a further subsequent convolutional layer 810, and so on.

[0088] In some embodiments, a convolutional layer 810 has four hyperparameters: the number of kernels, the size F kernels (e.g., a kernel is of dimensions F×F×D pixels) , the S step with which the window corresponding to the kernel is dragged on the image (e.g., a step of one means moving the window one pixel at a time) , and the zero-padding P (e.g., adding a black contour of P pixels thickness to the input image of the convolutional layer 810) . The convolutional layers 810 may perform various types of convolutions, such as 2-dimensional convolution, dilated or atrous convolution, spatial separable convolution, depthwise separable convolution, transposed convolution, and so on. The ConvNet 800 includes 86 convolutional layers 810. In other embodiments, the ConvNet 800 may include a different number of convolutional layers.

[0089] The pooling layers 820 down-sample feature maps generated by the convolutional layers, e.g., by summarizing the presence of features in the patches of the feature maps. A pooling layer 820 is placed between two convolution layers 810: a preceding convolutional layer 810 (the convolution layer 810 preceding the pooling layer 820 in the sequence of layers) and a subsequent convolutional layer 810 (the convolution layer 810 subsequent to the pooling layer 820 in the sequence of layers) . In some embodiments, a pooling layer 820 is added after a convolutional layer 810, e.g., after an activation function (e.g., ReLU, etc. ) has been applied to the OFM 860.

[0090] A pooling layer 820 receives feature maps generated by the preceding convolution layer 810 and applies a pooling operation to the feature maps. The pooling operation reduces the size of the feature maps while preserving their important characteristics. Accordingly, the pooling operation improves the efficiency of the DNN and avoids over-learning. The pooling layers 820 may perform the pooling operation through average pooling (calculating the average value for each patch on the feature map) , max pooling (calculating the maximum value for each patch of the feature map) , or a combination of both. The size of the pooling operation is smaller than the size of the feature maps. In various embodiments, the pooling operation is 2×2 pixels applied with a stride of two pixels, so that the pooling operation reduces the size of a feature map by a factor of 2, e.g., the number of pixels or values in the feature map is reduced to one quarter the size. In an example, a pooling layer 820 applied to a feature map of 8×6 results in an output pooled feature map of 3×3. The output of the pooling layer 820 is inputted into the subsequent convolution layer 810 for further feature extraction. In some embodiments, the pooling layer 820 operates upon each feature map separately to create a new set of the same number of pooled feature maps.

[0091] The fully-connected layers 830 are the last layers of the DNN. The fully-connected layers 830 may be convolutional or not. The fully-connected layers 830 receive an input operand. The input operand defines the output of the convolutional layers 810 and pooling layers 820 and includes the values of the last feature map generated by the last pooling layer 820 in the sequence. The fully-connected layers 830 apply a linear combination and an activation function to the input operand and generate a vector. The vector may contain as many elements as there are classes: element i represents the probability that the image belongs to class i. Each element is therefore between 0 and 8, and the sum of all is worth one. These probabilities are calculated by the last fully-connected layer 830 by using a logistic function (binary classification) or a SoftMax function (multi-class classification) as an activation function. In some embodiments, the fully-connected layers 830 multiply each input element by weight, make the sum, and then apply an activation function (e.g., logistic if N=2, SoftMax if N>2) . This is equivalent to multiplying the input operand by the matrix containing the weights.

[0092] FIG. 9 is a flowchart showing a method 900 of object reconstruction, in accordance with various embodiments. The method 900 may be performed by the neural rendering system 100 in FIG. 1. Although the method 900 is described with reference to the flowchart illustrated in FIG. 9, many other methods for object reconstruction may alternatively be used. For example, the order of execution of the steps in FIG. 9 may be changed. As another example, some of the steps may be changed, eliminated, or combined.

[0093] The neural rendering system 100 receives 910 one or more images of an object. In some embodiments, the one or more images are captured by a camera. In some embodiments, an image is a static image. In some embodiments, the neural rendering system 100 receives multiple images that constitute a video of the object. In some embodiments, the video is a multi-view video.

[0094] The neural rendering system 100 generates 920, by a renderer network using the one or more images, a model of the object. The model of the object represents a state of the object at a time stamp or at a view angle. In some embodiments, the model of the object comprises a plurality of particles representing one or more features of the object. In some embodiments, the state of the object includes a geometry or appearance of the object.

[0095] The neural rendering system 100 generates 930, by a convolutional neural network using the model of the object, one or more new models of the object. The one or more new models of the object represent one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle. In some embodiments, the neural rendering system 100 generates a new model of the one or more new models by predicting new positions of the plurality of particles. The new model of the object is a particle-based representation of the object.

[0096] The neural rendering system 100 generates 940 one or more new images from the one or more new models of the object. The one or more new images show the object with the one or more states. In some embodiments, the neural rendering system 100 generates a new image of the one or more new images by generating a grid representation of the object based on the new positions of the plurality of particles and rendering the grid representation to generate the new image. In some embodiments, the neural rendering system 100 generates the grid representation by dividing a three-dimensional space into a grid of voxels. The neural rendering system 100 generates the grid representation from the grid of voxels based on the new positions of the plurality of particles.

[0097] In some embodiments, the neural rendering system 100 scatters the plurality of particles to the grid of voxels based on the new positions of the plurality of particles. In other embodiments, the neural rendering system 100 down-samples a simulation volume by removing one or more particles from the plurality of particles. The down-sampled simulation volume comprises a subset of particles. The neural rendering system 100 scatters the subset of particles to the grid of voxels.

[0098] In some embodiments, the neural rendering system 100 trains the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation. In some embodiments, the neural rendering system 100 receives a training sample set. The neural rendering system 100 trains the renderer network using the training sample set in a training stage and trains the convolutional neural network using the training sample set in another training stage.

[0099] FIG. 10 is a block diagram of a computing device 1000, in accordance with various embodiments. In some embodiments, the computing device 1000 can be used as at least part of the neural rendering system 100 in FIG. 1. A number of components are illustrated in FIG. 10 as included in the computing device 1000, but any one or more of these components may be omitted or duplicated, as suitable for the application. In some embodiments, some or all of the components included in the computing device 1000 may be attached to one or more motherboards. In some embodiments, some or all of these components are fabricated onto a single system on a chip (SoC) die. Additionally, in various embodiments, the computing device 1000 may not include one or more of the components illustrated in FIG. 10, but the computing device 1000 may include interface circuitry for coupling to the one or more components. For example, the computing device 1000 may not include a display device 1006, but may include display device interface circuitry (e.g., a connector and driver circuitry) to which a display device 1006 may be coupled. In another set of examples, the computing device 1000 may not include an audio input device 1018 or an audio output device 1008, but may include audio input or output device interface circuitry (e.g., connectors and supporting circuitry) to which an audio input device 1018 or audio output device 1008 may be coupled.

[0100] The computing device 1000 may include a processing device 1002 (e.g., one or more processing devices) . The processing device 1002 processes electronic data from registers and / or memory to transform that electronic data into other electronic data that may be stored in registers and / or memory. The computing device 1000 may include a memory 1004, which may itself include one or more memory devices such as volatile memory (e.g., DRAM) , nonvolatile memory (e.g., read-only memory (ROM) ) , high bandwidth memory (HBM) , flash memory, solid state memory, and / or a hard drive. In some embodiments, the memory 1004 may include memory that shares a die with the processing device 1002. In some embodiments, the memory 1004 includes one or more non-transitory computer-readable media storing instructions executable to perform operations for performing object reconstruction tasks, e.g., the method 900 described above in conjunction with FIG. 9 or some operations performed by the neural rendering system 100 described above in conjunction with FIG. 1. The instructions stored in the one or more non-transitory computer-readable media may be executed by the processing device 1002.

[0101] In some embodiments, the computing device 1000 may include a communication chip 1012 (e.g., one or more communication chips) . For example, the communication chip 1012 may be configured for managing wireless communications for the transfer of data to and from the computing device 1000. The term "wireless" and its derivatives may be used to describe circuits, devices, systems, methods, techniques, communications channels, etc., that may communicate data through the use of modulated electromagnetic radiation through a nonsolid medium. The term does not imply that the associated devices do not contain any wires, although in some embodiments they might not.

[0102] The communication chip 1012 may implement any of a number of wireless standards or protocols, including but not limited to Institute for Electrical and Electronic Engineers (IEEE) standards including Wi-Fi (IEEE 802.10 family) , IEEE 802.16 standards (e.g., IEEE 802.16-2005 Amendment) , Long-Term Evolution (LTE) project along with any amendments, updates, and / or revisions (e.g., advanced LTE project, ultramobile broadband (UMB) project (also referred to as "3GPP2" ) , etc. ) . IEEE 802.16 compatible Broadband Wireless Access (BWA) networks are generally referred to as WiMAX networks, an acronym that stands for worldwide interoperability for microwave access, which is a certification mark for products that pass conformity and interoperability tests for the IEEE 802.16 standards. The communication chip 1012 may operate in accordance with a Global System for Mobile Communication (GSM) , General Packet Radio Service (GPRS) , Universal Mobile Telecommunications System (UMTS) , High Speed Packet Access (HSPA) , Evolved HSPA (E-HSPA) , or LTE network. The communication chip 1012 may operate in accordance with Enhanced Data for GSM Evolution (EDGE) , GSM EDGE Radio Access Network (GERAN) , Universal Terrestrial Radio Access Network (UTRAN) , or Evolved UTRAN (E-UTRAN) . The communication chip 1012 may operate in accordance with Code-division Multiple Access (CDMA) , Time Division Multiple Access (TDMA) , Digital Enhanced Cordless Telecommunications (DECT) , Evolution-Data Optimized (EV-DO) , and derivatives thereof, as well as any other wireless protocols that are designated as 3G, 4G, 5G, and beyond. The communication chip 1012 may operate in accordance with other wireless protocols in other embodiments. The computing device 1000 may include an antenna 1022 to facilitate wireless communications and / or to receive other wireless communications (such as AM or FM radio transmissions) .

[0103] In some embodiments, the communication chip 1012 may manage wired communications, such as electrical, optical, or any other suitable communication protocols (e.g., the Ethernet) . As noted above, the communication chip 1012 may include multiple communication chips. For instance, a first communication chip 1012 may be dedicated to shorter-range wireless communications such as Wi-Fi or Bluetooth, and a second communication chip 1012 may be dedicated to longer-range wireless communications such as global positioning system (GPS) , EDGE, GPRS, CDMA, WiMAX, LTE, EV-DO, or others. In some embodiments, a first communication chip 1012 may be dedicated to wireless communications, and a second communication chip 1012 may be dedicated to wired communications.

[0104] The computing device 1000 may include battery / power circuitry 1014. The battery / power circuitry 1014 may include one or more energy storage devices (e.g., batteries or capacitors) and / or circuitry for coupling components of the computing device 1000 to an energy source separate from the computing device 1000 (e.g., AC line power) .

[0105] The computing device 1000 may include a display device 1006 (or corresponding interface circuitry, as discussed above) . The display device 1006 may include any visual indicators, such as a heads-up display, a computer monitor, a projector, a touchscreen display, a liquid crystal display (LCD) , a light-emitting diode display, or a flat panel display, for example.

[0106] The computing device 1000 may include an audio output device 1008 (or corresponding interface circuitry, as discussed above) . The audio output device 1008 may include any device that generates an audible indicator, such as speakers, headsets, or earbuds, for example.

[0107] The computing device 1000 may include an audio input device 1018 (or corresponding interface circuitry, as discussed above) . The audio input device 1018 may include any device that generates a signal representative of a sound, such as microphones, microphone arrays, or digital instruments (e.g., instruments having a musical instrument digital interface (MIDI) output) .

[0108] The computing device 1000 may include a GPS device 1016 (or corresponding interface circuitry, as discussed above) . The GPS device 1016 may be in communication with a satellite-based system and may receive a location of the computing device 1000, as known in the art.

[0109] The computing device 1000 may include another output device 1010 (or corresponding interface circuitry, as discussed above) . Examples of the other output device 1010 may include an audio codec, a video codec, a printer, a wired or wireless transmitter for providing information to other devices, or an additional storage device.

[0110] The computing device 1000 may include another input device 1020 (or corresponding interface circuitry, as discussed above) . Examples of the other input device 1020 may include an accelerometer, a gyroscope, a compass, an image capture device, a keyboard, a cursor control device such as a mouse, a stylus, a touchpad, a bar code reader, a Quick Response (QR) code reader, any sensor, or a radio frequency identification (RFID) reader.

[0111] The computing device 1000 may have any desired form factor, such as a handheld or mobile computer system (e.g., a cell phone, a smart phone, a mobile internet device, a music player, a tablet computer, a laptop computer, a netbook computer, an ultrabook computer, apersonal digital assistant (PDA) , an ultramobile personal computer, etc. ) , a desktop computer system, a server or other networked computing component, a printer, a scanner, a monitor, a set-top box, an entertainment control unit, a vehicle control unit, a digital camera, a digital video recorder, or a wearable computer system. In some embodiments, the computing device 1000 may be any other electronic device that processes data.

[0112] The following paragraphs provide various examples of the embodiments disclosed herein.

[0113] Example 1 provides one or more non-transitory computer-readable media storing instructions executable to perform operations, the operations including accessing one or more images of an object; generating, by a renderer network, a model of the object from the one or more images, the model of the object representing a state of the object at a time stamp or view angle; generating, by a convolutional neural network, one or more new models of the object from the model of the object, the one or more new models of the object representing one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle; and generating one or more new images from the one or more new models of the object.

[0114] Example 2 provides the one or more non-transitory computer-readable media of example 1, in which the model of the object includes a plurality of particles representing one or more features of the object.

[0115] Example 3 provides the one or more non-transitory computer-readable media of example 2, in which generating a new model of the one or more new models includes predicting new positions of the plurality of particles, in which the new model of the object is a particle-based representation of the object.

[0116] Example 4 provides the one or more non-transitory computer-readable media of example 3, in which generating a new image of the one or more new images includes generating a grid representation of the object based on the new positions of the plurality of particles; and rendering the grid representation to generate the new image.

[0117] Example 5 provides the one or more non-transitory computer-readable media of example 4, in which generating the grid representation includes dividing a three-dimensional space into a grid of voxels; and generating the grid representation from the grid of voxels based on the new positions of the plurality of particles.

[0118] Example 6 provides the one or more non-transitory computer-readable media of example 5, in which generate the grid representation from the grid of voxels includes scattering the plurality of particles to the grid of voxels based on the new positions of the plurality of particles.

[0119] Example 7 provides the one or more non-transitory computer-readable media of example 5, in which generate the grid representation from the grid of voxels includes down-sampling a simulation volume by removing one or more particles from the plurality of particles, the down-sampled simulation volume including a subset of particles; and scattering the subset of particles to the grid of voxels.

[0120] Example 8 provides the one or more non-transitory computer-readable media of any one of examples 1-7, in which the operations further include training the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation.

[0121] Example 9 provides the one or more non-transitory computer-readable media of any one of examples 1-8, in which the operations further include receiving a training sample set; training the renderer network using the training sample set in a training stage; and training the convolutional neural network using the training sample set in another training stage.

[0122] Example 10 provides an apparatus, including a computer processor for executing computer program instructions; and a non-transitory computer-readable memory storing computer program instructions executable by the computer processor to perform operations, the operations including accessing one or more images of an object, generating, by a renderer network, a model of the object from the one or more images, the model of the object representing a state of the object at a time stamp or view angle, generating, by a convolutional neural network, one or more new models of the object from the model of the object, the one or more new models of the object representing one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle, and generating one or more new images from the one or more new models of the object.

[0123] Example 11 provides the apparatus of example 10, in which the model of the object includes a plurality of particles representing one or more features of the object.

[0124] Example 12 provides the apparatus of example 11, in which generating a new model of the one or more new models includes predicting new positions of the plurality of particles, in which the new model of the object is a particle-based representation of the object.

[0125] Example 13 provides the apparatus of example 12, in which generating a new image of the one or more new images includes generating a grid representation of the object based on the new positions of the plurality of particles; and rendering the grid representation to generate the new image.

[0126] Example 14 provides the apparatus of example 13, in which generating the grid representation includes dividing a three-dimensional space into a grid of voxels; and generating the grid representation from the grid of voxels based on the new positions of the plurality of particles.

[0127] Example 15 provides the apparatus of example 14, in which generate the grid representation from the grid of voxels includes scattering the plurality of particles to the grid of voxels based on the new positions of the plurality of particles.

[0128] Example 16 provides the apparatus of example 14, in which generate the grid representation from the grid of voxels includes down-sampling a simulation volume by removing one or more particles from the plurality of particles, the down-sampled simulation volume including a subset of particles; and scattering the subset of particles to the grid of voxels.

[0129] Example 17 provides the apparatus of any one of examples 10-16, in which the operations further include training the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation.

[0130] Example 18 provides the apparatus of any one of examples 10-17, in which the operations further include receiving a training sample set; training the renderer network using the training sample set in a training stage; and training the convolutional neural network using the training sample set in another training stage.

[0131] Example 19 provides a method, including accessing one or more images of an object; generating, by a renderer network, a model of the object from the one or more images, the model of the object representing a state of the object at a time stamp or view angle; generating, by a convolutional neural network, one or more new models of the object from the model of the object, the one or more new models of the object representing one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle; and generating one or more new images from the one or more new models of the object.

[0132] Example 20 provides the method of example 19, in which the model of the object includes a plurality of particles representing one or more features of the object.

[0133] Example 21 provides the method of example 20, in which generating a new model of the one or more new models includes predicting new positions of the plurality of particles, in which the new model of the object is a particle-based representation of the object.

[0134] Example 22 provides the method of example 21, in which generating a new image of the one or more new images includes generating a grid representation of the object based on the new positions of the plurality of particles; and rendering the grid representation to generate the new image.

[0135] Example 23 provides the method of example 22, in which generating the grid representation includes dividing a three-dimensional space into a grid of voxels; and generating the grid representation from the grid of voxels based on the new positions of the plurality of particles.

[0136] Example 24 provides the method of any one of examples 19-23, further including training the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation.

[0137] Example 25 provides the method of any one of examples 19-24, further including receiving a training sample set; training the renderer network using the training sample set in a training stage; and training the convolutional neural network using the training sample set in another training stage.

[0138] The above description of illustrated implementations of the disclosure, including what is described in the Abstract, is not intended to be exhaustive or to limit the disclosure to the precise forms disclosed. While specific implementations of, and examples for, the disclosure are described herein for illustrative purposes, various equivalent modifications are possible within the scope of the disclosure, as those skilled in the relevant art can recognize. These modifications may be made to the disclosure in light of the above detailed description.

Claims

1.One or more non-transitory computer-readable media storing instructions executable to perform operations, the operations comprising:accessing one or more images of an object;generating, by a renderer network, a model of the object from the one or more images, the model of the object representing a state of the object at a time stamp or view angle;generating, by a convolutional neural network, one or more new models of the object from the model of the object, the one or more new models of the object representing one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle; andgenerating one or more new images from the one or more new models of the object.2.The one or more non-transitory computer-readable media of claim 1, wherein the model of the object comprises a plurality of particles representing one or more features of the object.3.The one or more non-transitory computer-readable media of claim 2, wherein generating a new model of the one or more new models comprises predicting new positions of the plurality of particles, wherein the new model of the object is a particle-based representation of the object.4.The one or more non-transitory computer-readable media of claim 3, wherein generating a new image of the one or more new images comprises:generating a grid representation of the object based on the new positions of the plurality of particles; andrendering the grid representation to generate the new image.5.The one or more non-transitory computer-readable media of claim 4, wherein generating the grid representation comprises:dividing a three-dimensional space into a grid of voxels; andgenerating the grid representation from the grid of voxels based on the new positions of the plurality of particles.6.The one or more non-transitory computer-readable media of claim 5, wherein generate the grid representation from the grid of voxels comprises:scattering the plurality of particles to the grid of voxels based on the new positions of the plurality of particles.7.The one or more non-transitory computer-readable media of claim 5, wherein generate the grid representation from the grid of voxels comprises:down-sampling a simulation volume by removing one or more particles from the plurality of particles, the down-sampled simulation volume comprising a subset of particles; andscattering the subset of particles to the grid of voxels.8.The one or more non-transitory computer-readable media of any one of claims 1-7, wherein the operations further comprise:training the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation.9.The one or more non-transitory computer-readable media of any one of claims 1-8, wherein the operations further comprise:receiving a training sample set;training the renderer network using the training sample set in a training stage; andtraining the convolutional neural network using the training sample set in another training stage.10.An apparatus, comprising:a computer processor for executing computer program instructions; anda non-transitory computer-readable memory storing computer program instructions executable by the computer processor to perform operations, the operations comprising:accessing one or more images of an object,generating, by a renderer network, a model of the object from the one or more images, the model of the object representing a state of the object at a time stamp or view angle,generating, by a convolutional neural network, one or more new models of the object from the model of the object, the one or more new models of the object representing one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle, andgenerating one or more new images from the one or more new models of the object.11.The apparatus of claim 10, wherein the model of the object comprises a plurality of particles representing one or more features of the object.12.The apparatus of claim 11, wherein generating a new model of the one or more new models comprises predicting new positions of the plurality of particles, wherein the new model of the object is a particle-based representation of the object.13.The apparatus of claim 12, wherein generating a new image of the one or more new images comprises:generating a grid representation of the object based on the new positions of the plurality of particles; andrendering the grid representation to generate the new image.14.The apparatus of claim 13, wherein generating the grid representation comprises:dividing a three-dimensional space into a grid of voxels; andgenerating the grid representation from the grid of voxels based on the new positions of the plurality of particles.15.The apparatus of claim 14, wherein generate the grid representation from the grid of voxels comprises:scattering the plurality of particles to the grid of voxels based on the new positions of the plurality of particles.16.The apparatus of claim 14, wherein generate the grid representation from the grid of voxels comprises:down-sampling a simulation volume by removing one or more particles from the plurality of particles, the down-sampled simulation volume comprising a subset of particles; andscattering the subset of particles to the grid of voxels.17.The apparatus of any one of claims 10-16, wherein the operations further comprise:training the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation.18.The apparatus of any one of claims 10-17, wherein the operations further comprise:receiving a training sample set;training the renderer network using the training sample set in a training stage; andtraining the convolutional neural network using the training sample set in another training stage.19.A method, comprising:accessing one or more images of an object;generating, by a renderer network, a model of the object from the one or more images, the model of the object representing a state of the object at a time stamp or view angle;generating, by a convolutional neural network, one or more new models of the object from the model of the object, the one or more new models of the object representing one or more states of the object at one or more time stamps different from the time stamp or at one or more view angles different from the view angle; andgenerating one or more new images from the one or more new models of the object.20.The method of claim 19, wherein the model of the object comprises a plurality of particles representing one or more features of the object.21.The method of claim 20, wherein generating a new model of the one or more new models comprises predicting new positions of the plurality of particles, wherein the new model of the object is a particle-based representation of the object.22.The method of claim 21, wherein generating a new image of the one or more new images comprises:generating a grid representation of the object based on the new positions of the plurality of particles; andrendering the grid representation to generate the new image.23.The method of claim 22, wherein generating the grid representation comprises:dividing a three-dimensional space into a grid of voxels; andgenerating the grid representation from the grid of voxels based on the new positions of the plurality of particles.24.The method of any one of claims 19-23, further comprising:training the convolutional neural network by concurrently optimizing the convolutional neural network with a differentiable simulator through knowledge distillation.25.The method of any one of claims 19-24, further comprising:receiving a training sample set;training the renderer network using the training sample set in a training stage; andtraining the convolutional neural network using the training sample set in another training stage.

Images