1 Introduction

In recent years, 3D shape representation learning has aroused much attention [16, 26, 30, 31, 33]. Compared with images indexed by regular 2D grids, there has not been a single standard representation for 3D shapes in the literature. Existing 3D shape representations can be cast into several categories including: point-based  [1, 10, 31, 33, 34, 49], voxel-based  [7, 26, 32, 51], mesh-based  [16, 17, 42, 48], and multi-view  [32, 43, 45].

More recently, implicit function representations have gained an increasing amount of interest due to their high fidelity and efficiency. An implicit function depicts a shape through assigning a gauge value to each point in the object space  [6, 27, 28, 30]. Typically, a negative, a positive or a zero gauge value represents that the corresponding point lies inside, outside or on the surface of the 3D shape. Hence, the shape is implicitly encoded by the iso-surface (e.g., zero-level-set) of the function, which can then be rendered by Marching Cubes  [24] or similar methods. Implicit functions can also be considered as a shape-conditioned binary classifier whose decision boundary is the surface of the 3D shape. As each shape is represented by a continuous field, it can be evaluated at arbitrary resolution, irrespective of the resolution of the training data and limitations in the memory footprint.

Fig. 1.
figure 1

3D reconstruction results of shapes with complex local details. From top to bottom: ground truth, DeepSDF  [30], and Curriculum DeepSDF. We observe that the network benefits from the designed shape curriculum so as to better reconstruct local details. It is worth noting that the training data, training epochs and network architecture are the same for both methods.

Full size image

One of the main challenges in implicit function learning lies in accurate reconstruction of shape surfaces, especially around complex or fine structure. Figure 1 shows some 3D shape reconstruction results where we can observe that DeepSDF  [30] fails to precisely reconstruct complex local details. Note that the implicit function is less smooth in these areas and hence difficult for the network to parameterize precisely. Furthermore, as the magnitudes of SDF values inside small parts are usually close to zero, a tiny mistake may lead to a wrong sign, resulting in inaccurate surface reconstruction.

Inspired by the works on curriculum learning  [3, 11], we aim to address this problem in learning SDF by starting small: starting from easier geometry and gradually increasing the difficulty of learning. In this paper, we propose a Curriculum DeepSDF method for shape representation learning. We design a shape curriculum where we first teach the network using coarse shapes, and gradually move on to more complex geometry and fine structure once the network becomes more experienced. In particular, our shape curriculum is designed according to two criteria: surface accuracy and sample difficulty. We consider these two criteria both important and complementary to each other for shape representation learning: surface accuracy cares about the stringency in supervising with training loss, while sample difficulty focuses on the weights of hard training samples containing complex geometry.

Surface Accuracy. We design a tolerance parameter \(\varepsilon \) that allows small errors in estimating the surfaces. Starting with a relatively large \(\varepsilon \), the network aims for a smooth approximation, focusing on the global structure of the target shape and ignoring hard local details. Then, we gradually decrease \(\varepsilon \) to expose more shape details until \(\varepsilon =0\). We also use a shallow network to reconstruct coarse shapes at the beginning and then progressively add more layers to learn more accurate details.

Sample Difficulty. Signs greatly matter in implicit function learning. The points with incorrect sign estimations lead to significant errors in shape reconstruction, suggesting that we treat these as hard samples during training. We gradually increase the weights of hard and semi-hardFootnote 1 training samples to make the network more and more focused on difficult local details.

One advantage of curriculum shape representation learning is that, it provides a training path for the network to start from coarse shapes and finally reach fine-grained geometries. At the beginning, it is substantially more stable for the network to reconstruct coarse surfaces with the complex details omitted. Then, we continuously ask for more accurate shapes which are relatively simple tasks, benefiting from the previous reconstruction results. Lastly, we focus on hard samples to obtain complete reconstruction with precise shape details. This training process can help avoid poor local minima as compared with learning to reconstruct the precise complex shapes directly. Figure 1 shows that Curriculum DeepSDF obtains better reconstruction accuracy than DeepSDF. Experimental results illustrate the effectiveness of the designed shape curriculum. Code will be available at https://github.com/haidongz-usc/Curriculum-DeepSDF.

In summary, the key contributions of this work are:

  1. 1)

    We design a shape curriculum for shape representation learning, starting from coarse shapes to complex details. The curriculum includes two aspects of surface accuracy and sample difficulty.

  2. 2)

    For surface accuracy, we introduce a tolerance parameter \(\varepsilon \) in the training objective to control the smoothness of the learned surfaces. We also progressively grow the network according to different training stages.

  3. 3)

    For sample difficulty, we define hard, semi-hard and easy training samples for SDF learning based on sign estimations. We re-weight the samples to make the network gradually focus more on hard local details.

2 Related Work

Implicit Function. Different from point-based, voxel-based, mesh-based and multi-view methods which explicitly represent shape surfaces, implicit functions aim to learn a continuous field and represent the shape with the iso-surface. Conventional implicit function based methods include  [4, 29, 41, 46, 47]. For example, Carr et al.  [4] used polyharmonic Radial Basis Functions (RBFs) to implicitly model the surfaces from point clouds. Shen et al.  [41] created implicit surfaces by moving least squares. In recent years, several deep learning based methods have been proposed to capture more complex topologies  [6, 12, 13, 15, 22, 23, 27, 28, 30, 36, 52]. For example, Park et al.  [30] proposed DeepSDF by learning an implicit field where the magnitude represents the distance to the surface and the sign shows whether the point lies inside or outside of the shape. Mescheder et al.  [27] presented Occupancy Networks by approximating the 3D continuous occupancy function of the shape, which indicates the occupancy probability of each point. Chen and Zhang  [6] proposed IM-NET by only encoding the signs of SDF, which can be used for representation learning (IM-AE) and shape generation (IM-GAN). Saito et al.  [36] and Liu et al.  [23] learned implicit surfaces of 3D shapes from 2D images. These methods show promising results in 3D shape representation. However, the challenges still remains to reconstruct the local details accurately. Instead of proposing new implicit functions, our approach studies how to design a curriculum of shapes for more effective model training.

Curriculum Learning. The idea of curriculum learning can be at least traced back to  [11]. Inspired by the learning system of humans, Elman  [11] demonstrated the importance of starting small in neural network training. Sanger  [37] extended the idea to robotics by gradually increasing the difficulty of the task. Bengio et al.  [3] further formalized this training strategy and explored curriculum learning in various cases including vision and language tasks. They introduced one formulation of curriculum learning by using a family of functions \(L_\mu (\theta )\), where \(L_0\) is the highly smoothed version and \(L_1\) is the real objective. One could start with \(L_0\) and gradually increase \(\mu \) to 1, keeping \(\theta \) at a local minimum of \(L_\mu (\theta )\). They also explained the advantage of curriculum learning as a continuation method  [2], which could benefit the optimization of a non-convex training criterion to find better local minima. Graves et al.  [14] designed an automatic curriculum learning method by automatically selecting the training path to address the sensitivity of progression mode. Recently, curriculum learning has been successfully applied to varying tasks  [8, 18,19,20,21, 38, 40, 50]. For example, deep metric learning methods learn hierarchical mappings by gradually selecting hard training samples  [9, 25, 44]. FaceNet  [38] proposed an online negative sample mining strategy for face recognition, which was improved by DE-DSP  [8] to learn a discriminative sampling policy. Progressive growing of GANs  [21, 40] learned to sequentially generate images from low-resolution to high-resolution, and also grew both generator and discriminator symmetrically. Although curriculum learning has improved the performance of many tasks, the problem of how to design a curriculum for 3D shape representation learning still remains. Unlike 2D images where the pixels are regularly arranged, 3D shapes usually have irregular structures, which makes the effective curriculum design more challenging.

3 Proposed Approach

Our shape curriculum is designed based on DeepSDF  [30], which is a popular implicit function based 3D shape representation learning method. In this section, we first review DeepSDF and then describe the proposed Curriculum DeepSDF approach. Finally, we introduce the implementation details.

3.1 Review of DeepSDF [30]

DeepSDF is trained on a set of N shapes \(\{X_i\}\), where K points \(\{x_j\}\) are sampled around each shape \(X_i\) with the corresponding SDF values \(\{s_j\}\) precomputed. This results in K (point, SDF value) pairs:

$$\begin{aligned} X_i := \{(x_j,s_j) : s_j=SDF^i(x_j)\}, \end{aligned}$$
(1)

A deep neural network \(f_\theta (z_i,x)\) is trained to approximate SDF values of points x, with an input latent code \(z_i\) representing the target shape.

The loss function given \(z_i\), \(x_j\) and \(s_j\) is defined by the \(L_1\)-norm between the estimated and ground truth SDF values:

$$\begin{aligned} L(f_\theta (z_i,x_j),s_j) = |\text {clamp}_{\delta }(f_\theta (z_i,x_j)) - \text {clamp}_{\delta }(s_j)|, \end{aligned}$$
(2)

where \(\text {clamp}_{\delta }(s) := \text {min}(\delta ,\text {max}(-\delta , s))\) uses a parameter \(\delta \) to clamp an input value s. For simplicity, we use \(\bar{s}\) to represent a clamping function with \(\delta =0.1\) in the rest of the paper.

DeepSDF also designs an auto-decoder structure to directly pair a latent code \(z_i\) with a target shape \(X_i\) without an encoder. Please refer to  [30] for more details. At training time, \(z_i\) is randomly initialized from \(\mathcal {N}(0,0.01^2)\) and optimized along with the parameters \(\theta \) of the network through back-propagation:

$$\begin{aligned} \arg \min _{\theta ,z_i}\sum _{i=1}^N\left( \sum _{j=1}^K L(f_\theta (z_i,x_j),s_j) + \frac{1}{\sigma ^2}||z_i||_2^2\right) , \end{aligned}$$
(3)

where \(\sigma = 10^{-2}\) is the regularization parameter.

At inference time, an optimal z can be estimated with the network fixed:

$$\begin{aligned} \hat{z} = \arg \min _{z}\sum _{j=1}^K L(f_\theta (z,x_j),s_j) + \frac{1}{\sigma ^2}||z||_2^2. \end{aligned}$$
(4)

3.2 Curriculum DeepSDF

Different from DeepSDF which trains the network with a fixed objective all the time, Curriculum SDF starts from learning smooth shape approximations and then gradually strives for more local details. We carefully design the curriculum from the following two aspects: surface accuracy and sample difficulty.

Surface Accuracy. A smoothed approximation for a target shape could capture the global shape structure without focusing too much on local details, and thus is a good starting point for the network to learn. With a changing smoothness level at different training stages, more and more local details can be exposed to improve the network. Such smoothed approximations could be generated by traditional geometry processing algorithms. However, the generation process is time-consuming, and it is also not clear whether such fixed algorithmic routines could meet the needs of network training. In this paper, we address the problem from another view by introducing surface error tolerance \(\varepsilon \) which represents the upper bound of the allowed errors in the predicted SDF values. We observe that starting with relatively high surface error tolerance, the network tends to omit complex details and aims for a smooth shape approximation. Then, we gradually reduce the tolerance to expose more details.

More specifically, we allow small mistakes for the SDF estimation within the range of \([-\varepsilon , \varepsilon ]\) for Curriculum DeepSDF. In other words, all the estimated SDF values whose errors are smaller than \(\varepsilon \) are considered correct without any punishment, and we can control the difficulty of the task by changing \(\varepsilon \). Figure 2 illustrates the physical meaning of the tolerance parameter \(\varepsilon \). Compared with DeepSDF which aims to reconstruct the exact surface of the shape, Curriculum DeepSDF provides a tolerance zone with the thickness of \(2\varepsilon \), and the objective becomes to reconstruct any surface in the zone. At the beginning of network training, we set a relatively large \(\varepsilon \) which allows the network to learn general and smooth surfaces in a wide tolerance zone. Then, we gradually decrease \(\varepsilon \) to expose more details and finally set \(\varepsilon =0\) to predict the exact surface.

Fig. 2.
figure 2

The comparison between original SDF and SDF with the tolerance parameter \(\varepsilon \). With the tolerance parameter \(\varepsilon \), all the surfaces inside the tolerance zone are considered correct. The training of Curriculum DeepSDF starts with a relative large \(\varepsilon \) and then gradually reduces it until \(\varepsilon =0\).

Full size image

We can formulate the objective function with \(\varepsilon \) as follows:

$$\begin{aligned} L_\varepsilon (f_\theta (z_i,x_j),s_j) = \max \{|\bar{f}_\theta (z_i,x_j) - \bar{s}_j|-\varepsilon , 0\}, \end{aligned}$$
(5)

where (5) will degenerate to (2) if \(\varepsilon =0\).

Unlike most recent curriculum learning methods that rank training samples by difficulty  [18, 50], our designed curriculum on shape accuracy directly modifies the training loss. It follows the formulation in  [3] and also has a clear physical meaning for the task of SDF estimation. It is also relevant to label smoothing methods, where our curriculum has clear geometric meanings by gradually learning more precise shapes. We summarize the two advantages of the tolerance parameter based shape curriculum as follows:

  1. 1)

    We only need to change the hyperparameter \(\varepsilon \) to control the surface accuracy, instead of manually creating series of smooth shapes. The network automatically finds the surface that is easy to learn in the tolerance zone.

  2. 2)

    For any \(\varepsilon \), the ground truth surface of the original shape is always an optimal solution of the objective, which has good optimization consistency.

Fig. 3.
figure 3

The network architecture of Curriculum DeepSDF. We apply the same final network architecture with DeepSDF for fair comparisons, which contains 8 fully connected layers followed by hyperbolic tangent non-linear activation to obtain SDF value. The input is the concatenation of latent vector z and 3D point x, which is also concatenated to the output of the fourth layer. When \(\varepsilon \) decreases during training, we add one more layer to learn more precise shape surface.

Full size image

In addition to controlling the surface accuracy by the tolerance parameter, we also use a shallow network to learn coarse shapes with a large \(\varepsilon \), and gradually add more layers to improve the surface accuracy when \(\varepsilon \) decreases. This idea is mainly inspired by  [21]. Figure 3 shows the network architecture of the proposed Curriculum DeepSDF, where we employ the same network as DeepSDF for fair comparisons. After adding a new layer with random initialization to the network, the well-trained lower layers may suffer from sudden shocks if we directly train the new network in an end-to-end manner. Inspired by  [21], we treat the new layer as a residual block with a weight of \(\alpha \), where the original link has a weight of \(1-\alpha \). We linearly increase \(\alpha \) from 0 to 1, so that the new layer can be faded in the original network smoothly.

Sample Difficulty. In DeepSDF, the sampled points \(\{x_j\}\) in \(X_i\) all share the same weights in training, which presumes that every point is equally important. However, this assumption may result in the following two problems for reconstructing complex local details:

  1. 1)

    Points depicting local details are usually undersampled, and they could be ignored by the network during training due to their small population. We take the second lamp in Fig. 1 as an example. The number of sampled points around the lamp rope is nearly 1/100 of all the sampled points, which is too small to affect the network training.

  2. 2)

    In these areas, the magnitudes of SDF values are small as the points are close to surfaces (e.g. points inside the lamp rope). Without careful emphasis, the network could easily predict the wrong signs. Followed by a surface reconstruction method like Marching Cubes, the wrong sign estimations will further lead to inaccurate surface reconstructions.

To address these issues, we weight the sampled points differently during training. An intuitive idea is to locate all the complex local parts at first, and then weight or sort the training samples according to some difficulty measurement  [3, 18, 50]. However, it is difficult to detect complex regions and rank the difficulty of points exactly. In this paper, we propose an adaptive difficulty measurement based upon the SDF estimation of each sample and re-weight the samples to gradually emphasize more on hard and semi-hard samples on the fly.

Most deep embedding learning methods judge the difficulty of samples according to the loss function  [8, 38]. However, the \(L_1\)-norm loss can be very small for the points with wrong sign estimations. As signs play an important role in implicit representations, we directly define the hard and semi-hard samples based on their sign estimations. More specifically, we consider the points with wrong sign estimations as hard samples, with the estimated SDF values between zero and ground truth values as semi-hard samples, and the others as easy samples. Figure 4 shows the examples. For the semi-hard samples, although currently they obtain correct sign estimations, they are still at high risk of becoming wrong as their predictions are closer to the boundary than the ground truth positions.

Fig. 4.
figure 4

Examples of hard, semi-hard and easy samples for (a) \(s>0\), and (b) \(s<0\). In the figure, s is the ground truth SDF, and we define the difficulty of each sample according to its estimation \(f_\theta (z,x)\).

Full size image

To increase the weights of both hard and semi-hard samples, and also decrease the weights of easy samples, we formulate the objective function as below:

$$\begin{aligned} L_{\varepsilon ,\lambda }(f_\theta (z_i,x_j),s_j) = \left( 1 + \lambda sgn(\bar{s}_j)sgn(\bar{s}_j - \bar{f}_\theta (z_i,x_j))\right) L_\varepsilon (f_\theta (z_i,x_j),s_j), \end{aligned}$$
(6)

where \(0\le \lambda <1\) is a hyperparameter controlling the importance of the hard and semi-hard samples, \(sgn(v) = 1\) if \(v\ge 0\) and \(-1\) otherwise.

The physical meaning of (6) is that we increase the weights of hard and semi-hard samples to \(1+\lambda \), and also decrease the weights of easy samples to \(1-\lambda \). Although we treat hard and semi-hard samples similarly, their properties are different due to the varying physical meanings as we will demonstrate in the experiments. Our hard sample mining strategy always targets at the weakness of the current network rather than using the predefined weights. Still, (6) will degenerate to (5) if we set \(\lambda =0\). Another understanding of (6) is that \(sgn(\bar{s}_j)\) shows the ground truth sign while \(sgn(\bar{s}_j - \bar{f}_\theta (z_i,x_j))\) indicates the direction of optimization. We increase the weights if this direction matches the ground truth sign and decrease the weights otherwise.

We also design a curriculum for sample difficulty by controlling \(\lambda \) at different training stages. At the beginning of training, we aim to teach the network global structures and allow small errors in shape geometry. To this end, we set a relatively small \(\lambda \) to make the network equally focused on all training samples. Then, we gradually increase \(\lambda \) to emphasize more on hard and semi-hard samples, which helps the network to address its weaknesses and reconstruct better local details. Strictly speaking, the curriculum of sample difficulty is slightly different from the formulation in  [3], as it starts from the original task and gradually increases the difficulty to a harder objective. However, they share similar thoughts and the ablation study also shows the effectiveness of the designed curriculum.

3.3 Implementation Details

In order to make fair comparisons, we applied the same training data, training epochs and network architecture as DeepSDF  [30]. More specifically, we prepared the input samples \(X_i\) from each shape mesh which was normalized to a unit sphere. We sampled 500,000 points from each shape. The points were sampled more aggressively near the surface to capture more shape details. The learning rate for training the network was set as \(N_b\times 10^{-5}\) where \(N_b\) is the batch size and \(10^{-3}\) for the latent vectors. We trained the models for 2,000 epochs. Table 1 presents the training details, which will degenerate to DeepSDF if we train all the 8 fully connected layers by setting \(\varepsilon =\lambda =0\) from beginning to the end.

Table 1. The training details of our method. Layer shows the number of fully connected layers. Residual represents whether we use a residual block to add layers smoothly.
Full size table

4 Experiments

In this section, we perform a thorough comparison of our proposed Curriculum DeepSDF to DeepSDF along with comprehensive ablation studies for the shape reconstruction task on the ShapeNet dataset  [5]. We use the missing part recovery task as an application to demonstrate the usage of our method.

Following  [30], we report the standard distance metrics of mesh reconstruction including the mean and the median of Chamfer distance (CD), mean Earth Mover’s distance (EMD)  [35], and mean mesh accuracy  [39]. For evaluating CD, we sample 30,000 points from mesh surfaces. For evaluating EMD, we follow  [30] by sampling 500 points from mesh surfaces due to a high computation cost. For evaluating mesh accuracy, following  [30, 39], we sample 1,000 points from mesh surfaces and compute the minimum distance d such that 90% of the points lie within d of the ground truth surface.

4.1 Shape Reconstruction

We conducted experiments on the ShapeNet dataset  [5] for the shape reconstruction task. In the following, we will introduce quantitative results, ablation studies and visualization results.

Quantitative Results. We compare our method to the state-of-the-art methods, including AtlasNet  [16] and DeepSDF  [30] in Table 2. We also include several variants of our own method for ablation studies. Ours, representing the proposed Curriculum DeepSDF method, performs a complete curriculum learning considering both surface accuracy and sample difficulty. As variants of our method, ours-sur and ours-sur w/o only employ the surface accuracy based curriculum learning with/without progressively growth of the network layers, where ours-sur w/o uses the fixed architecture with the deepest size; ours-sam only employs sample difficulty based curriculum learning. For a fair comparison, we evaluated all SDF-based methods following the same training and testing protocols as DeepSDF, including training/test split, the number of training epochs, and network architecture, etc. For AtlasNet-based methods, we directly report the numbers from  [30]. Here are the three key observations from Table 2:

  1. 1)

    Compared to vanilla DeepSDF, curriculum learning on either surface accuracy or sample difficulty can lead to a significant performance gain. The best performance is achieved by simultaneously performing both curricula.

  2. 2)

    In general, the curriculum of sample difficulty helps more on lamp and plane as these categories suffer more from reconstructing slender or thin structures. The curriculum of surface accuracy is more effective for the categories of chair, sofa and table where shapes are more regular.

  3. 3)

    As we only sample 500 points for computing EMD, even the ground truth mesh has non-zero EMD to itself rising from the randomness in point sampling. Our performance is approaching the upper bound on plane and sofa.

Table 2. Reconstructing shapes from the ShapeNet test set. Here we report shape reconstruction errors in term of several distance metrics on five ShapeNet classes. Note that we multiply CD by \(10^3\) and mesh accuracy by \(10^1\). The average column shows the average distance and the relative column shows the relative distance reduction compared to DeepSDF. For all metrics except for relative, the lower, the better.
Full size table

Hard Sample Mining Strategies. We conducted ablation studies for a more detailed analysis of different hard sample mining strategies on the lamp category due to its large variations and complex shape details. In the curriculum of sample difficulty, we gradually increase \(\lambda \) to make the network more and more focused on the hard samples. We compared it with the simple strategy by fixing a single \(\lambda \). Table 3 shows that the performance improves as \(\lambda \) increases until reaching a sweet spot, after which further increasing \(\lambda \) could hurt the performance. The best result is achieved by our method which gradually increases \(\lambda \) as it encourages the network to focus more and more on hard details.

Table 3. Experimental comparisons with using fixed \(\lambda \) for hard sample mining. The method degenerates to ours-sur when \(\lambda =0\). CD is multiplied by \(10^3\).
Full size table
Table 4. Experimental comparisons of different hard sample mining strategies. In the table, H, S and E are the hard, semi-hard and easy samples, respectively. For the symbols, \(\uparrow \) is to increase the weights to \(1+\lambda \), \(\downarrow \) is to decrease the weights to \(1-\lambda \) and - is to maintain the weights. \({H(\uparrow )S(\uparrow )E(\downarrow )}\) is the sampling strategy used in our method, while H(-)S(-)E(-) degenerates to ours-sur. CD is multiplied by \(10^3\).
Full size table

For hard sample mining, we increase the weights of hard and semi-hard samples to \(1+\lambda \) and also decrease the weights of easy samples to \(1-\lambda \). As various similar strategies can be used, we demonstrate the effectiveness of our design in Table 4. We observe that both increasing the weights of semi-hard samples and decreasing the weights of easy samples can boost the performance. However, it is risky to only increase weights for hard samples excluding semi-hard ones in which case the performance drops. One possible reason is that focusing too much on hard samples may lead to more wrong sign estimations for the semi-hard ones as they are close to the boundary. Hence, it is necessary to increase the weights of semi-hard samples as well to maintain their correct sign estimations. The best performance is achieved by simultaneously increasing the weights of hard and semi-hard samples and decreasing the weights of easy ones.

Table 5. Comparison of mean of EMD on the lamp category of the ShapeNet dataset with varying numbers of sampled points.
Full size table

Number of Points for EMD. In Table 2, we followed  [30] by sampling 500 points to compute accurate EMD, which would lead to relatively large distance even for ground truth meshes. To this end, we increase the number of sampled points during EMD computation and tested the performance on lamps. Results in Table 5 show that the number of sampled points can affect EMD due to the randomness in sampling, and the EMD of resampled ground truth decreases when using more points. Our method continuously obtains better results.

Fig. 5.
figure 5

The visualization of shape reconstruction at the end of each training stage. From left to right: ground truth, 200 epochs, 600 epochs, 1000 epochs, and 2000 epochs.

Full size image

Visualization Results. We visualize the shape reconstruction results in Fig. 1 to qualitatively compare DeepSDF and Curriculum DeepSDF. We observe that Curriculum DeepSDF reconstructs more accurate shape surfaces. The curriculum of surface accuracy helps to better capture the general structure, and sample difficulty encourages the recovery of complex local details. We also provide the reconstructed shapes at key epochs in Fig. 5. Curriculum DeepSDF learns coarse shapes at early stages which omits complex details. Then, it gradually refines local parts based on the learned coarse shapes. This training procedure improves the performance of the learned shape representation.

Table 6. Experimental comparisons under different ratios of removed points. CD and mesh accuracy are multiplied by \(10^3\) and \(10^1\), respectively.
Full size table

4.2 Missing Part Recovery

One of the main advantages of the DeepSDF framework is that we can optimize a shape code based upon a partial shape observation, and then render the complete shape through the learned network. In this subsection, we compare DeepSDF with Curriculum DeepSDF on the task of missing part recovery.

Fig. 6.
figure 6

The visualization results of missing part recovery. The green points are the remaining points that we use to recover the whole mesh. From top to bottom: ground truth, DeepSDF, and Curriculum DeepSDF. (Color figure online)

Full size image

To create partial shapes with missing parts, we remove a subset of points from each shape \(X_i\) As random point removal may still preserve the holistic structures, we remove all the points in a local area to create missing parts. More specifically, we randomly select a point from the shape and then remove a certain quantity of its nearest neighbor points including itself, so that all the points within a local range can be removed. We conducted the experiments on three ShapeNet categories: plane, sofa and lamp. In these categories, plane and sofa have more regular and symmetric structures, while lamp is more complex and contains large variations. Table 6 shows that part removal largely affects the performance on the lamp category compared with plane and sofa, and Curriculum DeepSDF continuously obtains better results than DeepSDF under different ratios of removed points. A visual comparison is provided in Fig. 6.

5 Conclusion

In this paper, we have proposed Curriculum DeepSDF by designing a shape curriculum for shape representation learning. Inspired by the learning principle of humans, we organize the learning task into a series of difficulty levels from surface accuracy and sample difficulty. For surface accuracy, we design a tolerance parameter to control the global smoothness, which gradually increases the accuracy of the learned shape with more layers. For sample difficulty, we define hard, semi-hard and easy training samples in SDF learning, and gradually re-weight the samples to focus more and more on difficult local details. Experimental results show that our method largely improves the performance of DeepSDF with the same training data, training epochs and network architecture.