Rethinking Design and Evaluation of 3D Point Cloud Segmentation Models

Abstract

Currently, the use of 3D point clouds is rapidly increasing in many engineering fields, such as geoscience and manufacturing. Various studies have developed intelligent segmentation models providing accurate results, while only a few of them provide additional insights into the efficiency and robustness of their proposed models. The process of segmentation in the image domain has been studied to a great extent and the research findings are tremendous. However, the segmentation analysis with point clouds is considered particularly challenging due to their unordered and irregular nature. Additionally, solving downstream tasks with 3D point clouds is computationally inefficient, as point clouds normally consist of thousands or millions of points sparsely distributed in 3D space. Thus, there is a significant need for rigorous evaluation of the design characteristics of segmentation models, to be effective and practical. Consequently, in this paper, an in-depth analysis of five fundamental and representative deep learning models for 3D point cloud segmentation is presented. Specifically, we investigate multiple experimental dimensions, such as accuracy, efficiency, and robustness in part segmentation (ShapeNet) and scene segmentation (S3DIS), to assess the effective utilization of the models. Moreover, we create a correspondence between their design properties and experimental properties. For example, we show that convolution-based models that incorporate adaptive weight or position pooling local aggregation operations achieve superior accuracy and robustness to point-wise MLPs, while the latter ones show higher efficiency in time and memory allocation. Our findings pave the way for an effective 3D point cloud segmentation model selection and enlighten the research on point clouds and deep learning.

1. Introduction

Point clouds have emerged as one of the most important data formats for 3D analysis. Their popularity is constantly increasing as more acquisition technologies become available, such as LIDARs (Light Imaging, Detection, and Ranging) and RGB-D (RGB-Depth sensor) cameras, and they are utilized as input for a wide range of applications in various domains, such as autonomous driving [1,2], geoscience [3,4], construction and manufacturing [5,6] and digital heritage [7,8]. Commonly, a point cloud is a set of data points in 3D metric space, which normally includes the x, y, and z coordinates and the normals for each point, and represents specific properties of a 3D object or shape [6]. They consist of thousands or millions of points, specifically in large-scale point cloud understanding tasks.

The analysis of 3D point cloud data is mainly performed using deep learning techniques [9]. Specifically, deep learning is highly utilized in the segmentation of 3D point clouds, i.e., the process to delineate groups of points of an object into distinct parts. The functionality of segmentation is based on the assumption that the points in a specific area of a surface or part of an object share the same local and global characteristics. Point cloud segmentation separates spatial-spectral information into its components [5]. Applying segmentation in point cloud data is a challenging process because of the lack of explicit structure in such data and often with high redundancy, and uneven sampling densities [10].

Furthermore, point clouds contain precisely detailed information, which makes them a computationally expensive data format. Additionally, multiple computational challenges are commonly present because of the noisy and sparse nature of such datasets [3]. Additionally, their high dimensionality generates varying behavior in deep learning models, arising many challenges in downstream tasks, such as 3D point cloud segmentation. Consequently, it is of crucial importance for researchers to focus on the internal and endogenous properties of the deep learning architectures that work on point clouds, i.e., their design properties, and their relation to specific experimental performance properties. Rather than using exclusively segmentation accuracy as a performance metric, the efficiency and robustness of the models should also be rigorously evaluated.

In this article, we investigate several point cloud segmentation models in terms of design and experimental properties. On the one hand, we study the design properties of two broad families of neural networks, namely multi-layer perceptron (MLP)-based and convolution-based ones. Those design properties are related to high-level characteristics of the models such as local/global point aggregation behavior, invariance to point size, point density, rotations, etc. On the other hand, we focus on experimental properties such as accuracy, efficiency, and robustness. We analyze five well-known deep learning models on 3D point cloud segmentation, namely PointNet [11], PointNet++ [12], as representatives of the MLP-based family, and Kernel Point Convolution Network (KPConv) [13], Position Pooling Network (PPNet) [14] and Relation Shape Convolutional Network (RSConv or RS-CNN) [15] as cases of convolution-based approaches. For the analysis, we utilize two well-established datasets, the ShapeNet-part dataset for part segmentation [16] and the Stanford 3D Indoor Semantics (S3DIS) dataset for scene segmentation [17]. Such a selection of data is made in order to evaluate the behavior of segmentation models in two different tasks, i.e., part segmentation and scene segmentation. Additionally, we apply various common and sophisticated metrics to analyze the accuracy, efficiency, and robustness of the aforementioned neural networks. In addition, considering that the existing neural networks differ significantly in their endogenous components, we provide a deeper analysis of their key components to advance the guidelines on the correct utilization of them.

Therefore, our contribution is two-fold:

• We conduct a multivariate analysis of well-known and representative 3D point cloud segmentation models using design and experimental properties;
• We assess the behavior of the individual inner model components and provide a correspondence between their design and experimental properties.

The paper is organized as follows. Section 2 provides an overview of the related work in the field. Section 3 presents our framework, where we analytically show our methodology. Section 4 portrays the evaluation of the utilized models and our results. Finally, we display our concluding remarks and potential future research in Section 6.

2. Related Work

This section presents a literature review related to our study. We divided the related work into two subsections according to the analyzed topics. First, in Section 2.1, we briefly analyze 2D and 3D imaging, where sampling strategies are regular in structured grids, such as pixels or voxels. Next, in Section 2.2, we show the correspondence in 3D point clouds, where the sampling is irregular in non-structured grids, providing an overview of the related studies. We also indicate and highlight specific issues and flaws in 3D point cloud segmentation with deep learning models. Finally, we contextualize our work in Section 2.3.

2.1. 2D and 3D Imaging

There are several experimental metrics to evaluate the accuracy-related performance of deep learning models in segmentation tasks. For instance, in the image domain, Minaee et al. [18] reports that the most common accuracy-related performance metrics for segmentation models are the Pixel Accuracy, the Mean Pixel Accuracy, Intersection over Union ($IoU$), the Mean $IoU$, the Dice coefficient, and the more traditional classification metrics such as Precision, Recall and F1-score. Furthermore, in 2D and 3D image segmentation, researchers correlate and compare specific design characteristics of the utilized models, such as patch-wise model architecture using local and global convolutional operations, or semantic-wise model architecture, with their achieved segmentation accuracy using some of the aforementioned metrics [19]. Additionally, Dou et al. [20] proposed a mixture of architectural model properties, with model design components such as cascaded layers with 3D semantic-wise and patch-wise convolutional operations, while mainly evaluating their models with performance metrics such as Sensitivity and Precision. However, even in the heavily researched domain of image and 2D data, there are very few studies that provide additional information on the model’s general performance, such as execution time and memory footprint, which is important for industrial applications that make use of segmentation models, as highlighted by Minaee et al. [18]. Although there are some studies that evaluate their models’ performance using additional execution times [19,20], they do not clearly relate them to their recorded accuracy or their design properties.

An intriguing study on deep learning techniques and their application to segmentation problem is presented by Garcia-Garcia et al. [21], which highlights not only the common accuracy-related metrics but also the efficiency of a variety of approaches. They emphasize the importance of doing more in-depth performance evaluations on segmentation models in order to be regarded as helpful and valid in practice. Despite the fact that they claim that the execution time, memory footprint, and accuracy are the most important metrics for evaluating deep learning segmentation models and that the trade-off between them should be parameterized depending on the system’s or analysis’ objective, their analysis, in [21], only provides accuracy-related results. The robustness of segmentation models has been recently studied as a sole experimental property in depth in the image domain involving benchmark studies [22]. Other studies attempt to increase the robustness of specialized image segmentation models by data augmentation techniques [23]. Indeed, researchers of a biomedical image segmentation study relate some low-level design properties or hyperparameters of the models, namely batch size, patch size, or learning optimization-based parameters, with the segmentation accuracy and robustness in order to facilitate the interpretation of their proposed adaptable neural network for image segmentation [24]. Nevertheless, there is still room for improvement, which can be achieved by focusing on the high-level design properties of the models and studying the efficiency of their adaptable deep-learning architecture in terms of time or memory consumption. Last but not least, robustness is closely related to the architectural properties and the design elements of the deep neural network models, as highlighted by Kamann et al. in their survey [22]. Although they do a benchmarking on the robustness of multiple deep learning segmentation models, their work is based on image data rather than point cloud data.

2.2. Current State in 3D Point Cloud Analysis

In the field of 3D point cloud analysis, the majority of the research studies in the intersection of deep learning and point cloud data segmentation evaluate the performance of the utilized models with accuracy-related metrics such as ($IoU$) [11,12,13,14,15]. In point cloud segmentation research there are review studies such as [3,9] that mainly focus on the segmentation accuracy, while a few works such as Qi et al. [11] briefly talk on the efficiency of their model by including a complexity analysis of it. Other studies such as [25] analyze feature subsets in order to improve accuracy in 3D scene segmentation while reducing both time and memory consumption. However, their study is related to feature engineering to reduce processing time and memory consumption while achieving high accuracy rather than studying the design characteristics of the utilized algorithms. Additionally, Xie et al. [26] conduct in-depth research on point cloud segmentation models, providing information on the workflow of the utilized neural networks. However, their analysis is a theoretical study of the general context of point cloud segmentation and semantic segmentation models and does not provide any experimental insights into their accuracy nor efficiency, or robustness of them. Moreover, Zhang et al. [27] conduct a survey of direct and indirect segmentation, in which they study several architectures of deep learning models. It is a very interesting study, where they experimentally analyze models’ performance utilizing metrics such as execution time, space complexity, and segmentation accuracy. Our proposal deepens and extends some of the aforementioned metrics and shifts the research focus by evaluating the models using high-level design properties. In the next Section 2.3 we clearly differentiate our research from the above-mentioned study.

Furthermore, the bulk of new and cutting-edge deep learning models are solely concerned with improving segmentation accuracy while giving little or no information on the efficiency or the robustness of the models [12,13,15,28,29,30,31]. Additionally, others compare their developed models to previous research, demonstrating a benchmark that is primarily focused on accuracy and endogenous neural network characteristics, such as architectural width and depth [14]. Indeed, they show that local aggregation operators, when properly calibrated, may yield comparable performance. However, they do not clearly relate the endogenous design characteristics, such as the neural network method, the aggregation level, or type, with the experimental properties, such as the accuracy-related performance metrics.

As the point cloud data domain is fairly new compared to the image domain, the present few studies on the robustness of point cloud segmentation models focus on the improvement and the rigorous evaluation of this property, mainly because of the utilization of 3D segmentation models in critical applications, such as autonomous driving [1]. Most of the research has been focused on the crucial challenges of robustness against adversarial cases, where researchers employ adversarial training techniques to handle these issues. Other robustness-related studies develop a benchmark based on common 3D point cloud corruptions in order to study corruption robustness [32]. Robustness is closely related to error measuring and as we do not test the selected models against data alterations or corruptions to measure such error rates as in [32], we measure the error of the average accuracy values across all different classes in our data.

2.3. Contextualising Our Work

As previously indicated, the closest related work to our approach is the study of Zhang et al. [27]. They review the taxonomy of indirect or direct segmentation methods, and they present an initial proposal to experimentally evaluate deep learning models using performance metrics related to execution time, space complexity, and segmentation accuracy. In our work, we focus on direct segmentation deep learning models, evaluating not only the classic and fundamental architectures such as PointNet [11] and PointNet++ [12], as they do, but we also evaluate newer and pioneering state-of-the-art deep learning models such as KPConv [13], PPNet [14] and RSConv [15]. Moreover, our study should not be considered as a review of deep learning models for point cloud segmentation, but an in-depth analysis of deep learning point cloud segmentation models, in which their high-level design properties are correlated and cross-validated with well-known experimental properties including several performance metrics.

Considering performance metrics, Zhang et al. [27] evaluate the execution time by measuring only the forward pass time of a neural network, which corresponds to single testing of a deep learning model, in four distinct model architectures. Instead, in our study, the time efficiency is addressed by measuring the total run time of a model, which corresponds to the sum of training, validation, and testing time in order to provide an all-around time performance measurement. Moreover, in terms of space complexity evaluation, they rely only on the number of parameters of the neural networks. Conversely, we evaluate the space complexity, i.e., memory efficiency, by also measuring the GPU memory allocation instead of just the number of parameters of the models. Indeed, we further include the number of parameters and several other high-level design properties of the neural networks. Finally, apart from segmentation accuracy, time, and memory efficiency, we further study the robustness of the neural networks and propose generalized performance metrics aiming to give an overall evaluation of the deep learning segmentation models working with 3D point clouds. These generalized performance metrics encapsulate accuracy, efficiency, and robustness in a single all-around performance evaluation.

Please note that we do not deal with low-level design properties or hyper-parameterization of the models, such as batch size tuning, as [24] presented. Basically, we work on the main higher-level internal design properties of the utilized models. At the time of writing, there are no relative studies able to provide concrete results and insights taking into account multivariate comparison dimensions.

In summary, according to our analysis of the existing literature, we have identified certain evaluation weaknesses in the current research on 3D point cloud segmentation with deep learning models. This fact leads us to perform a fine-graded in-depth analysis of five fundamental and representative models and examine their design and experimental properties. Our work provides novelty in the analysis of 3D point clouds.

3. Conceptual Analysis Framework

This section portrays our analysis framework. Following, we describe in detail the design characteristics of the 3D point cloud segmentation models in Section 3.1, the utilized performance metrics, and the derived experimental properties in Section 3.2. Finally, in Section 3.3, we present and introduce the five selected deep learning models for our analysis and highlight their relative design properties that we consider in this study.

3.1. Design Properties

There are many deep learning architectures aiming to provide state-of-the-art results in 3D point cloud segmentation [9]. However, most of them are mainly neural networks from two broad families of models, MLP-based and Convolution-based [9]. Thus, in this study, we focus on the MLP-based and the Convolutional ones since they are heavily utilized [3,9]. Following, we define the identified high-level model design properties, based on the characteristics of the most utilized models on 3D point cloud part segmentation. Thus, we consider the following design characteristics:

• Aggregation Level
  • Local Aggregation operation features the models that focus on the local characteristics and structures of the point cloud object precisely capturing the points’ topology. Specifically, local aggregation enables the matching of features and relative positions of a neighborhood of points to a center point and outputs the transformed feature vector for this center point [14].
  • Global Aggregation operation features the models that focus on the global characteristics and structure of the point cloud object. In order to aggregate information globally from all points, global aggregation operators analyze the input 3D point cloud using point-by-point $1\times 1$ transformations followed by a global pooling layer [14].
• Aggregation Type
  • Point-wise methods analyze and aggregate the input point cloud data focusing either on point by point [11] or sets of points [12] operations. These methods are usually conducted with shared MLPs.
  • Pseudo Grid approaches project characteristics of neighborhoods of points into several types of pseudo grids, such as grid cells [13,33], spherical grid points [34] and tangent planes [35]. Pseudo grid-based methods allow the use of normal kernel weights for convolution.
  • Adaptive Weight techniques conduct weighted point neighborhood aggregation by taking into account the relative placements of the points [15,36] or point density [37]. Such techniques mostly rely either on the design of specialized modules, which typically necessitate computationally costly parameter tuning for distinct applications, or on the execution of computationally expensive graph kernels. These adaptive weigh-based strategies are considered more accurate than point-wise methods but at the cost of increased computational complexity.
  • Position Pooling aggregation combines neighboring point features through element-wise multiplication followed by an average pooling layer. It is a novel technique that uses no learnable weights while performing on par with the other operators [14].
• Neural Network Method
  • MLP -based models utilize point-wise operations using fully connected layers in their design architecture. Shared MLPs are typically used as the basic units in point-wise MLP-based methods. Please note, that a shared MLP denotes the use of an identical MLP on each point in the point cloud, as utilized in PointNet [11].
  • Convolution -based models use point-based convolutional operations in their network design to extract point cloud geometrical features.
• The Invariance of a model to permutations or affine transformations is denoted below in Equation (1).

  $$f\left(\lambda x\right)=f\left(x\right),$$

  (1)

  where x is an input 3D point cloud, $f\left(x\right)$ is a geometric function and $\lambda$ is a transformation (scale, density, rotation) or permutation.
  • Permutation invariance refers to the invariability of the results of a model to $N!$ permutations of the unordered input point cloud;
  • Size invariance features the models that show regularity and non-variability to different sizes and scales of the input point cloud;
  • Density invariance features the regularity and invariance to variable point density of the input point cloud;
  • Rotation invariance refers to the constant and stable results of models in presence of geometrical transformations of a point cloud object;
• The Number of Parameters denotes the total amount of parameters of a model according to its initial design.

It is noteworthy that we refer to transformation invariant properties, i.e size, density, and rotation, denoting the robustness (strong or weak) of a model to input size, scale, density changes, and arbitrary rotations, following the terminology in the literature [11,38,39]. Commonly, the terms strong and weak robustness of a model indicate the ability of a model to maintain its accuracy under the application of a specific transformation to the input data. For clarification, in this study, we use the terms strong or weak invariance to denote the aforementioned robustness.

3.2. Experimental Properties

Below, we report the performance metrics that define the experimental properties of the neural network models. We divide them into four evaluation dimensions, segmentation accuracy, efficiency, robustness, and generalized metrics that incorporate all the priors together in stand-alone and specialized metrics.

3.2.1. Accuracy

The most well-known metric to evaluate the accuracy of 3D point cloud segmentation models is the point Intersection over Union ($IoU$) performance metric, as it is used in the majority of studies [11,12,13,14,15]. The formulation of $IoU$ is defined as $IoU=\frac{A\cap B}{A\cup B}$, where B is the area of points belonging to the prediction point cloud and A to the ground-truth point cloud. Specifically, two variants of the $IoU$ metric are commonly used, which are calculated by averaging across all Instances ($ImIoU$) and all classes ($CmIoU$), as shown also in [15]. Following, $ImIoU$ and $CmIoU$ are shown in Equations (2) and (3) respectively.

$$ImIoU=\frac{{\displaystyle \sum _{k=1}^n}Io{U}_k}{n},$$

(2)

where n denotes the number of instances or alternatively the number of point clouds and the summation subscript k takes values in the range [1, n].

$$CmIoU=\frac{{\displaystyle \sum _{v=1}^{n_C}}{\displaystyle \sum _{p=1}^{k_v}}Io{U}_{vp}}{n_C},$$

(3)

where $n_C$ denotes the number of classes in our data and $k_v$ denotes the number of point cloud instances contained in a class. Please note that the v in $k_v$ denotes a specific class, i.e., ($k_1,k_2,\dots ,k_v$). Additionally, the summation subscripts v and p take values in the range [1, $n_C$] and [1, $k_v$] respectively.

Intuitively, in model evaluation cases where $CmIoU\approx ImIoU$ indicates that everything seems fine in our models’ performance. In occasions where $CmIoU<ImIoU$, we may have evidence of poor performance in specific classes. For completion, where $CmIoU>ImIoU$, this may indicate poor model performance in individual instances of point clouds. However, the last one is a rather rare incidence.

3.2.2. Efficiency

Efficiency is addressed by measuring both the total run time ($t_{total}$) and the average GPU memory allocation ($GP{U}_{mem}$). Total run time refers to the time needed to train, validate and test a model, which is displayed in Equation (4). We show the average GPU memory allocation ($GP{U}_{mem}$) in percentage values in the whole learning procedure of each utilized model, denoted in Equation (5). To be clear, the models are validated and tested after the training process on each epoch. Additionally, we calculate the number of epochs ($n_{epoch}$) and time needed to achieve the best performance in relation to $CmIoU$, ($CmIo{U}_{time\left(h\right)}^{best}$), and $ImIoU$ metrics in the test data as, ($ImIo{U}_{time\left(h\right)}^{best}$). For clarification, we show the $CmIo{U}_{time\left(h\right)}^{best}$ and $ImIo{U}_{time\left(h\right)}^{best}$, which denote the time spent by a model during its learning process to achieve the best $CmIoU$ and $ImIoU$ in the test set respectively. Additionally, we indicate the exact epoch number ($n_{epoch}$), in which the best $CmIoU$ and $ImIoU$ values correspond. We consider these metrics to measure efficiency, because they involve an all-around performance evaluation of critical metrics in the design and development of intelligent models, such as time and memory.

$$t_{total}=t_{training}+t_{validation}+t_{testing},$$

(4)

where $t_{training}$, $t_{validation}$ and $t_{testing}$ denote the time spent in the training, validation, and testing phases of a model.

$$GP{U}_{mem}=\frac{{\displaystyle \sum _{t=1}^k}\frac{GP{U}_{mem}\left(t\right)}{GP{U}_{mem}^{total}}}{k}\times 100\%,$$

(5)

where $GP{U}_{mem}\left(t\right)$ denotes the amount of GPU memory allocated in a single time step t, e.g., a second. $GP{U}_{mem}^{total}$ is the total amount of available GPU memory in our system and k portrays the total amount of time steps.

3.2.3. Robustness

For measuring robustness, we consider the per-class robustness of each method in the testing procedure. It can be defined as $\mu \pm ϵ$ of the $mIoU$ of each class, where $\mu$ is the mean and $ϵ$ is the standard error of the mean in percentage values. Thus, we study and display robustness according to each class’ $mIoU$ and the error of it in the test data.

Once we obtain the $\mu \pm ϵ$ of the $mIoU$ of each class, we continue by employing a statistical ranking mechanism. The ranking mechanism follows the Friedman–Nemenyi non-parametric statistical tests as described in [40]. Initially, we apply the Friedman test to check the randomness in our measurements, or alternatively, whether the measured average ranks are significantly different from the calculated average rank [41]. Specifically, we utilize the Iman and Davenport Friedman test as shown in [40]. Hence, the null hypothesis $H_0$, states that all the models are equal so their ranks should be equal or alternatively all the measured dependent groups have identical distributions. We rank all scores per class across the models from 1 to $n_{models}$ (total number of models), concerning $\mu$, and in case of a tie, we give the advantage to the model that has the lowest $ϵ$. Please note that rank 1 denotes the best model and rank $n_{models}$ the worst one. The Friedman test statistic $F_F$ follows the F distribution with $(n_{models}-1)$ and $(n_{models}-1)·(N-1)$ degrees of freedom, where N denotes the number of classes or alternatively the number of distinct tests conducted. The utilized $F_F$ is denoted in Equations (6) and (7), where ${\overline{r}}_{·j}=\frac{1}{N}{\sum }_{i=1}^N{r}_{ij}$ indicates the average ranking of each model in the N classes. The critical values can be taken from the F distribution statistical table (http://www.socr.ucla.edu/Applets.dir/F_Table.html) (accessed on 26 November 2022). Then the null hypothesis, $H_0$, can be rejected, if the obtained $F_F$ is greater than the critical value of the corresponding F distribution at a chosen $\alpha$ level of statistical significance. Alternatively, the $H_0$ can be rejected at an $\alpha$ level of statistical significance if the $p_{value}<\alpha$, denoting that the test results are significant at this $\alpha$ level.

$${\chi }_F^2=\frac{12N{\sum }_{j=1}^{n_{models}}{\left({\overline{r}}_{·j}-\frac{n_{models}+1}{2}\right)}^2}{n_{models}(n_{models}+1)}$$

(6)

$$F_F=\frac{(N-1){\chi }_F^2}{N(n_{models}-1){\chi }_F^2}$$

(7)

We define in Figure 1 the robustness term R, which is the ranking of the models according to their $\mu \pm ϵ$, i.e., the mean $IoU$ achieved in each class plus/minus the standard error of this mean. It is worth noticing that the lower R the better the model.

Moreover, to analyze whether the differences between the models are statistically significant, we perform the Nemenyi post-hoc statistical test. In this way, we can deduce that two deep learning models are statistically different if their average ranks differ by at least the critical difference. The critical difference, $CD$, is calculated with the following formula [40]:

$$CD=q_{\alpha }\sqrt{\frac{n_{models}(n_{models}+1)}{6N}}$$

(8)

where $q_{\alpha }$ is the two-tailed Nemenyi test’s critical value, which is determined by the specified $\alpha$ level of statistical significance, the number of models, $n_{models}$, and the number of performance tests (in our case, namely the segmentation task, this corresponds to the number of classes (N) in our data).

3.2.4. Generalized Metrics

Additionally, we consider generalized metrics in order to provide a compact and multidimensional model evaluation, incorporating metrics of segmentation accuracy, efficiency, and robustness into single individual metrics. We have recently proposed such generalized metrics, in which accuracy and efficiency are combined in a balanced way. These metrics are $F_{CmIoU}$, $F_{ImIoU}$, $F_{general}$, which provide a balanced benchmarking of segmentation accuracy and efficiency combined [42].

In this study, we extend these metrics by improving their formulation and also taking into account the robustness term (R), which is defined in Section 3.2.3. Following, we formulate these advanced metrics.

$$F_{CmIoU}^R={\beta }_1\ast CmIoU+{\beta }_2\ast (1-t_{total})+{\beta }_3\ast (1-GP{U}_{mem})+{\beta }_4\ast (1-R)$$

(9)

The following rules may apply simultaneously in the Equation (9):

• $0\le {\beta }_1\le 1$,
• $0\le {\beta }_2\le 1-{\beta }_1$,
• $0\le {\beta }_3\le 1-{\beta }_1-{\beta }_2$,
• $0\le {\beta }_4\le 1-{\beta }_1-{\beta }_2-{\beta }_3.$

$$F_{ImIoU}^R={\alpha }_1\ast ImIoU+{\alpha }_2\ast (1-t_{total})+{\alpha }_3\ast (1-GP{U}_{mem})+{\alpha }_4\ast (1-R)$$

(10)

Similarly to the Equation (9), we apply the following rules in Equation (10):

• $0\le {\alpha }_1\le 1$,
• $0\le {\alpha }_2\le 1-{\alpha }_1$,
• $0\le {\alpha }_3\le 1-{\alpha }_1-{\alpha }_2$,
• $0\le {\alpha }_4\le 1-{\alpha }_1-{\alpha }_2-{\alpha }_3$.

It is worth mentioning that in terms of efficiency the winning model is the one that has the lowest run time and the lowest amount of allocated GPU memory. For this, we consider the multiplication by $1-t_{total}$ and $1-GP{U}_{mem}$, instead of $t_{total}$ and $GP{U}_{mem}$ respectively. Additionally, we multiply by $(1-R)$ because the min-max normalization (in the range of [0,1]) of the ranking vector has an inverted meaning. That is, naively the lowest value in the ranking vector denotes the best option, but it is displayed as $R=0$ in min-max normalization. On the contrary, $R=1$ denotes the worst case or alternatively the model that has the lowest rank.

Although we allow the values of ${\alpha }_1$, ${\alpha }_2$, ${\alpha }_3,{\alpha }_4$ and ${\beta }_1$, ${\beta }_2$, ${\beta }_3$, ${\beta }_4$ to take values in the range of $[0,1]$, in this study, to select an accurate model but also balanced in terms of efficiency and robustness, we limit the ${\alpha }_i$ and ${\beta }_i$ coefficients ($i=1,2,3,4$) according to the following rule: ${\alpha }_2={\alpha }_3={\alpha }_4=\frac{1-{\alpha }_1}{3}$ and ${\beta }_2={\beta }_3={\beta }_4=\frac{1-{\beta }_1}{3}$.

$$F_{general}^R=\frac{F_{CmIoU}^R+F_{ImIoU}^R}{2}$$

(11)

$F_{CmIoU}^R$ provides a balanced way of displaying the per-class accuracy of the point cloud segmentation model ($CmIoU$) among time efficiency, memory efficiency, and robustness. On the other hand, $F_{ImIoU}^R$ can be used the same way as the $F_{CmIoU}^R$ but for the per-instance segmentation accuracy ($ImIoU$). Please note that all the ${\alpha }_i$ and ${\beta }_i$ coefficients ($i=1,2,3,4$) are balancing coefficients and they are ranging between 0 and 1. The $F_{general}^R$ is a naive combination of $F_{CmIoU}^R$ and $F_{ImIoU}^R$.

For clarification, in order to allow the comparison of different metrics and values, we normalize $CmIoU$, $ImIoU$, $t_{total}$, $GP{U}_{mem}$ and R per metric in the range [0, 1]. Consequently, the proposed metrics $F_{CmIoU}^R$, $F_{ImIoU}^R$, $F_{general}^R$ take values in between [0,1], with the 1 denoting the best and 0 the worst model.

3.2.5. Experimental Properties Summary

Having defined and presented a set of performance metrics, next, we evaluate the experimental properties of the models based on this. In particular, for the evaluation of the models we consider the following four groups of experimental properties:

• Accuracy
  • Per-Instance Accuracy shows the performance evaluation according to the $ImIoU$ metric.
  • Per-Class Accuracy portrays the performance evaluation according to the $CmIoU$ metric.
• Efficiency
  • Time Efficiency evaluates the models according to the $t_{total}$, $CmIo{U}_{time\left(h\right)}^{best}$, $ImIo{U}_{time\left(h\right)}^{best}$ and $n_{epoch}$. Please remind that $t_{total}$ is the total run time of the learning process, $CmIo{U}_{time\left(h\right)}^{best}$ and $ImIo{U}_{time\left(h\right)}^{best}$, the time spent to achieve the best $CmIoU$ and $ImIoU$ in the test set respectively and $n_{epoch}$ the number of epochs needed to achieve the aforementioned accuracy scores.
  • GPU Memory Efficiency evaluates the models according to the $GP{U}_{mem}$, i.e., the average memory allocation in percentage values in the whole learning process.
• Robustness characterizes the per-class robust models in the testing phase of the learning process, based on a statistical ranking strategy.
• Generalized Performance
  • Per-Class $F^R$ evaluates the models according to the $F_{CmIoU}^R$ metric, which incorporates per-class segmentation accuracy, time efficiency and memory efficiency, and robustness.
  • Per-Instance $F^R$ evaluates the models according to the $F_{ImIoU}^R$ metric, which embodies per-instance segmentation accuracy, time efficiency and memory efficiency, and robustness.
  • Generalized $F^R$ evaluates the models according to the generalized $F_{general}^R$ metric, i.e., the arithmetic mean of $F_{CmIoU}^R$ and $F_{ImIoU}^R$.

Table 1. Summary of experimental properties.

Evaluation Dimensions	Experimental Properties
Accuracy	$ImIoU$, $CmIoU$
Efficiency	$t_{total}$, $CmIo{U}_{time\left(h\right)}^{best}$, $ImIo{U}_{time\left(h\right)}^{best}$, $GP{U}_{mem}$, $n_{epoch}$
Robustness	ranking based on $\mu \pm ϵ$
Generalized Performance	$F_{CmIoU}^R$, $F_{ImIoU}^R$, $F_{general}^R$

summarises all the evaluation dimensions and their corresponding experimental properties. Please note that we detail the exact metrics that we use to assess the performance in each evaluation dimension.

3.3. Models

Initially, we investigate each model and identify its most relevant design elements to our study. We experiment with five of the most representative and accurate neural networks in 3D point cloud part segmentation. Following, we briefly describe them.

PointNet [11] is one of the essential and pioneering deep learning architectures on point cloud data, capable of performing both classification and segmentation tasks utilizing point-wise operations. It is a point-wise MLP-based neural network. Additionally, it is symmetrical or invariant by point cloud input order and focuses the learning on the global features of a point cloud. PointNet captures well the global properties of the point clouds and has also point-wise robustness against noisy elements, perturbation, and missing data. Its point-wise feature extraction procedures, on the other hand, do not take the topology of the points into account.

PointNet++ [12] is the PointNet’s successor and capable of capturing local features of a point cloud object. It is based on multiple point-wise MLP-based neural networks, as it applies PointNet recursively on hierarchical partitions of the input point clouds. Additionally, PointNet++ takes into account the geometrical characteristics of the point cloud. It is resistant to size variance and point density variance per point and per neighborhood of points.

KPConv [13] method focuses on local features of the point cloud, by using pseudo-grid feature-based local aggregation operations. It employs point-based convolutional kernel operations, which are specified by a collection of points spread throughout a sphere. The convolutions are determined by the dimensions of the input data and are based on a predetermined metric system. As a result, they must be changed to the appropriate point cloud input size for each situation. KPConv is one of the greatest cutting-edge point cloud segmentation algorithms, achieving excellent performance while being robust in the face of variable-density neighborhoods.

RSConv [15] emphasizes learning through local aggregation operations utilizing adaptive weight-based local aggregation. To extract meaningful features from the input point cloud, convolutional procedures are employed. These procedures are defined by spherical-shaped neighborhoods, which are featured by the centroids of subsets of input points. The point characteristics are mostly generated from a chosen relation, such as the Euclidean distance, between the points and the aforementioned centroids. Because the weights of the convolution matrix are dependent on the position of each point with respect to the center of the convolutional operation, RSConv is considered an extension of standard 2D convolutions. Furthermore, it is permutation invariant, robust to rigid transformations, and captures effectively the relationships between the points.

PPNet [14] places also an emphasis on local aggregation calculations among the points. It is a deep residual neural network that uses position pooling local aggregation operation, which combines neighboring point features through element-wise multiplication followed by an average pooling layer. Rather than employing complicated structures, PPNet employs a simpler method of calculating the local characteristics of point clouds. It has comparable computing capabilities and is more resistant and robust to noisy or missing data than most of its rivals, even when employing zero learnable parameters for local aggregation operations. For clarification, in this study, we utilize the network with the position pooling operators with sinusoidal position embeddings, named as PosPool* in [14].

Table 2. Summary of deep learning models and their design characteristics. Please note that we use certain abbreviations, i.e NN: Neural Network, Conv: Convolution, MLP: Multi-Layer Perceptron, Rot: Rotation, Per: Permutation, Dens: Density, #: number.

Model	Aggregation Level	Aggregation Type	NN Method	Invariance	# of Parameters
PointNet	Global	Point-wise	MLP	Rot, Per	3.5 M
PointNet++	Local	Point-wise	MLP	Rot, Per, Size, Dens	1.4 M
KPConv	Local	Pseudo Grid	Conv	Rot, Per, Size, Dens	14.2 M
PPNet	Local	Position Pooling	Conv	Per, Size, Dens	18.5 M
RSConv	Local	Adaptive Weight	Conv	Rot, Perm, Size, Dens	3.5 M

summarises the neural network models and their design properties. Specifically, we highlight the aggregation level, aggregation type, the neural network method, their invariance, and the number of parameters as stated in the original studies of the models. Mainly, the point aggregation operation is one of the most important design characteristics of the task of 3D point cloud segmentation. The Aggregation level describes the focus of the learning process of the networks, i.e., the models focus on the local or global properties of a point cloud. Aggregation type denotes the main aggregation technique that the models utilize in order to learn, i.e., Point-wise, Pseudo Grid, Position Pooling, and Adaptive Weight based. In this study, we investigate and work with the design parameters related to Aggregation Level, Aggregation Type, the Neural Network Method, Invariance and we further include the number of parameters of the models.

4. Evaluation

This section describes our evaluation process and our results. First, we explain in detail the protocol according to which all the models are evaluated, in Section 4.1. Then, we describe the utilized data in Section 4.2 according to which we conduct the analysis and finally our results in Section 4.3.

4.1. Evaluation Protocol

All experiments have been run on the following system setup: (i) CPU: Intel Core i9-10900, (ii) RAM: 32GB, (iii) GPU: Quadro RTX 5000-16 GB, (iv) OS: Ubuntu 20.04. In addition, we utilized the Torch-Points3D [43] framework to run the deep learning architectures, with Python 3.8.5, CUDA 10.2, and PyTorch 1.7.0 version.

For clarification and completion purposes, we explain below the specific properties of the learning procedure. We train the models in the ShapeNet-part dataset with scale normalization and random noise, and in S3DIS we use a random rotation of 180${}^{\circ }$ in the z axis. The batch size for the learning process is set at 16, and Adam is selected as the network optimizer. We also utilize exponential learning rate decay and batch normalization methods to combat overfitting problems. Finally, all networks were trained for 200 epochs. The models are validated and tested after each epoch’s training phase.

In S3DIS, to validate the effectiveness and the comparisons among the neural networks, a learning scheme of 6-fold cross-validation is used. As the S3DIS dataset contains six different Areas, separate independent learning sessions of the neural networks take place, where in each session five Areas of the S3DIS dataset are used for training while the remaining Area is utilized for testing, as explained in [44].

4.2. Data

The data used in this study consists of two well-known datasets for point cloud segmentation, ShapeNet-part [16] and Stanford 3D Indoor Semantics (S3DIS) datasets [17,45].

ShapeNet-part contains 16881 3D objects of point clouds grouped in 16 different shapes. Figure 2 displays the included point cloud objects with a brief description of the labels and classes, and

Table 3. Description of ShapeNet-part segmentation data. We denote with n the number of annotated parts. We further show the training, validation, and test splits with the total number of samples per class.

	n	Training	Validation	Test	Total
Aeroplane	4	1958	391	341	2690
Bag	2	54	8	14	76
Cap	2	39	5	11	55
Car	4	659	81	158	898
Chair	4	2658	396	704	3758
Earphone	3	49	6	14	69
Guitar	3	550	78	159	787
Knife	2	277	35	80	392
Lamp	4	1118	143	286	1547
Laptop	2	324	44	83	451
Motorbike	6	125	26	51	202
Mug	2	130	16	38	184
Pistol	3	209	30	44	283
Rocket	3	46	8	12	66
Skateboard	3	106	15	31	152
Table	3	3835	588	848	5271
Total	50	12,137	1870	2874	16,881

summarizes the dataset and includes all the relative information, i.e., the number of annotated parts per class (n), number of samples of shapes in training, validation and test splits and the total number of samples per class. Each shape category is annotated with two to six parts that are summed to 50 total annotated parts. The labeled shapes are the following: airplane, bag, cap, car, chair, earphone, guitar, knife, lamp, laptop, motor, mug, pistol, rocket, skateboard, and table, in alphabetical order. In the learning process of the models, we use the original split following [16] for the training, validating, and testing phases. We utilize a training set of 12137 point clouds, a validation set of 1870 point clouds, and a test set of 2874 point clouds.

On the other hand, the S3DIS dataset consists of six large indoor Areas from three different buildings. It includes several annotated objects inside a variety of different rooms. Figure 3 portrays the six Areas of the dataset. We utilize the 3D point clouds of these Areas, where each point in the scene point cloud is annotated with one semantic category. There are in total 13 semantic categories representing ceilings, walls, windows, etc. Moreover, as in this work we use this dataset to analyze segmentation performance, we should clarify that the focus is set on the whole scene segmentation instead of on the inner category metrics. More information on this dataset on its classes and rooms can be found in [17,45].

4.3. Analysis of Results

In this section, we analyze the impact of the different properties of models by considering four evaluation dimensions, namely the accuracy, efficiency, robustness, and proposed specialized and generalized metrics. Finally, we relate their design and experimental properties in order to find performance patterns.

4.3.1. Accuracy

In this section, we investigate the segmentation accuracy of the selected models by analyzing the results presented in

Table 4. Comparison of deep learning models in terms of segmentation accuracy evaluation of the learning process in 200 epochs. In table (a), we display $ImIoU$ and $CmIoU$ metrics (best-achieved score) on the ShapeNet-part dataset and, similarly, in the table (b) we show the $mIoU$ (or alternatively the $ImIoU$) metric on all the Areas of S3DIS dataset. We use dark grey and light grey cell colors to denote the best and the second best score per metric respectively.

(a) ShapeNet-part dataset.
Data	Metric		PointNet	PointNet++	KPConv	PPNet	RSConv
Training Set	$ImIoU$	$Value$	89.80	90.45	91.99	92.37	91.53
		$n_{epoch}$	182	181	189	174	194
	$CmIoU$	$Value$	89.81	90.85	91.91	92.89	92.39
		$n_{epoch}$	183	185	188	179	177
Validation Set	$ImIoU$	$Value$	86.39	86.83	86.61	86.46	87.12
		$n_{epoch}$	169	144	54	46	66
	$CmIoU$	$Value$	79.87	83.08	82.43	82.56	82.82
		$n_{epoch}$	167	174	166	174	123
Test Set	$ImIoU$	$Value$	84.24	84.93	84.22	83.87	85.47
		$n_{epoch}$	170	88	53	167	71
	$CmIoU$	$Value$	79.03	82.50	82.39	82.50	82.73
		$n_{epoch}$	178	146	189	151	194
(b) S3DIS dataset
Data		Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
Training set	Areas 2, 3, 4, 5, 6	$Value$	93.24	94.65	95.66	96.46	96.22
		$n_{epoch}$	196	198	183	194	175
Test Set	Area 1	$Value$	60.64	66.62	69.21	70.89	68.00
		$n_{epoch}$	140	166	186	169	124
Training Set	Areas 1, 3, 4, 5, 6	$Value$	92.91	94.82	95.46	96.58	96.13
		$n_{epoch}$	196	188	197	190	185
Test Set	Area 2	$Value$	34.41	42.28	45.38	45.24	47.34
		$n_{epoch}$	131	74	64	38	26
Training Set	Areas 1, 2, 4, 5, 6	$Value$	93.78	95.00	95.63	96.59	96.31
		$n_{epoch}$	196	197	187	191	196
Test Set	Area 3	$Value$	44.52	50.28	57.43	57.55	53.41
		$n_{epoch}$	183	111	180	175	80
Training Set	Areas 1, 2, 3, 5, 6	$Value$	93.18	94.45	95.52	96.51	96.09
		$n_{epoch}$	198	193	197	175	189
Test Set	Area 4	$Value$	62.49	69.73	72.64	75.00	71.98
		$n_{epoch}$	144	130	70	136	119
Training Set	Areas 1, 2, 3, 4, 6	$Value$	92.94	94.31	95.19	96.38	95.87
		$n_{epoch}$	195	190	194	196	197
Test Set	Area 5	$Value$	69.93	74.99	76.51	77.35	75.68
		$n_{epoch}$	170	185	158	143	90
Training Set	Areas 1, 2, 3, 4, 5	$Value$	93.14	94.94	95.60	96.46	96.27
		$n_{epoch}$	195	194	198	193	194
Test Set	Area 6	$Value$	45.08	50.92	56.32	55.87	52.30
		$n_{epoch}$	174	41	86	131	161

and

Table 5. Comparisons of deep learning models in terms of best segmentation accuracy. Please note that in the table (a) each row shows the $mIoU$ value for each class and the last row shows the $CmIoU$, which is the average of all the $mIoU$ per class across all classes for each model and the error of it in percentage values, denoted as $ϵ$. Also in the same format of average $\pm ϵ$, we show the per object average and the standard error of the mean. In table (b), we show the best $mIoU$ per Area in each row and, similarly as in table (a), the models’ and Areas’ average and their errors. We use dark grey and light grey cell colors to denote the best and the second-best score in each row.

(a) ShapeNet-part Dataset.
	PointNet	PointNet++	KPConv	PPNet	RSConv	Object Avg ± $ϵ$
Airplane	82.55	82.63	81.90	82.36	83.23	82.53 ± 0.58
Bag	80.22	81.79	82.77	81.35	83.73	81.97 ± 1.64
Cap	76.03	85.83	83.85	82.64	83.47	82.36 ± 4.53
Car	75.91	77.99	79.15	79.84	79.03	78.39 ± 1.96
Chair	90.21	90.55	90.46	90.69	90.40	90.46 ± 0.20
Earphone	68.80	79.34	72.36	76.69	73.65	74.17 ± 5.45
Guitar	91.50	91.27	91.87	91.58	91.87	91.62 ± 0.28
Knife	87.14	85.23	87.22	86.95	85.31	86.36 ± 1.17
Lamp	80.92	83.11	80.88	80.73	83.90	81.91 ± 1.81
Laptop	95.78	95.32	95.50	95.48	95.47	95.51 ± 0.18
Motorbike	61.32	70.97	74.27	74.77	74.98	71.26 ± 8.13
Mug	91.91	94.22	95.94	95.40	95.34	94.56 ± 1.70
Pistol	79.73	81.99	81.93	82.58	83.90	82.03 ± 1.84
Rocket	46.34	61.56	63.50	65.34	61.71	59.69 ± 12.76
Table	81.68	81.26	78.89	77.65	81.59	80.21 ± 2.29
$\mathit{CmIoU}\pm ϵ$	79.03 ± 15.82	82.50 ± 10.37	82.39 ± 10.42	82.50 ± 9.75	82.73 ± 10.44	∅
(b) S3DIS Dataset.
	PointNet	PointNet++	KPConv	PPNet	RSConv	Area Avg$\pm ϵ$
Area 1	60.64	66.62	69.21	70.89	68.00	67.07 ± 5.85
Area 2	34.41	42.28	45.38	45.24	47.34	42.93 ± 11.86
Area 3	44.52	50.28	57.43	57.55	53.41	52.64 ± 10.37
Area 4	62.49	69.73	72.64	75.00	71.98	70.37 ± 6.80
Area 5	69.93	74.99	76.51	77.35	75.68	74.89 ± 3.89
Area 6	45.08	50.92	56.32	55.87	52.30	52.10 ± 8.73
Model Avg ± $ϵ$	52.84 ± 25.60	59.14 ± 22.05	62.91 ± 18.81	63.65 ± 19.94	61.45 ± 19.31	∅

.

Initially, Table 4 depicts the recorded measurements related to segmentation accuracy (described in Section 3.2) of the learning process. In training, validation, and test sets, we show the best achieved $CmIoU$ and $ImIoU$ metrics. We also denote the exact number of epochs ($n_{epoch}$), where the best metric is recorded. In the case of the S3DIS dataset, we display the $ImIoU$ metric in the training and test set, as the $CmIoU$ metric does not apply and there is no validation set. To clarify, we do not analyze the inner class labels of S3DIS, as explained in Section 4.2. For this, per-class metrics such as $CmIoU$ that can be applied in the ShapeNet-part dataset, do not apply in the analysis of S3DIS in this work.

In the results using the ShapeNet-part dataset, we observe that RSConv is the best method in test data achieving an $ImIoU$ score of 85.47 and a $CmIoU$ of 82.73. PointNet++ is second in terms of $ImIoU$ and $CmIoU$ metrics, achieving scores of 84.93 and 82.50 respectively. Note that PPNet achieves also the same $CmIoU$ metric of 82.50 as PointNet++. In addition, PPNet reaches the highest performance in learning-related metrics in the training set with 92.37 in $ImIoU$ and 92.89 in $CmIoU$. However, its poor performance in the test set may indicate overfitting issues.

In the S3DIS dataset, we observe that in Areas 1, 3, 4, and 5 PPNet is first while KPConv is second in the test data. In Area 6 we can see that KSConv surpasses PPNet with a $ImIoU$ score equal to 56.32 against 55.87. It is worth mentioning, that in the hardest to segment Area, Area 2, RSConv is the winner with $ImIoU=47.34$, while KPConv takes the second place with an $ImIoU=45.38$. Similarly, as in the ShapeNet-part dataset, PPNet has the highest performance in the training set in all Areas. However, by observing some poor performance cases in the test set, for example in Area 3 or Area 2, we may have overfitting issues or these Areas are hard to learn.

To analyze in-depth the segmentation behavior of the models, in Table 5a,b, we present in-depth results with ShapeNet-part and S3DIS datasets, respectively.

Regarding the results with ShapeNet-part, we report the segmentation accuracy per class ($CmIoU$) in the epoch where the best $CmIoU$ is recorded for each model. It seems that all the models perform better in different classes of point cloud objects. By observing the table, we can identify that there is no perfect rule for dividing the models according to their accuracy result in each class. For instance, RSConv outperforms the other models in classes Airplane and Bag but is third or fourth in ranking in other classes such as Car or Chair. Additionally, PointNet seems to deal great with Laptop and Table labeled point clouds, but can not deal effectively with the majority of the others. In addition, it is interesting that, for example, in class Cap with 39 samples PointNet++ is the winner, while on Rocket with 46 samples the winner is PPNet and in Bag with 54 samples the winner is RSConv.

Regarding the results with S3DIS, we report the best achieved $ImIoU$ per Area. We can see that KPConv, PPNet, and RSConv are ahead of PointNet and PointNet++ in all S3DIS Areas. We can not decide on an all-around winning model for all the Areas, as PPNet is first in Areas 1, 3, 4, and 5, but in Area 2 and Area 6 the winners are RSConv and KPConv, respectively. Thus, we highlight the Observation 1.

Observation 1.

In terms of accuracy, there is not a clearly winning model in all classes of point cloud objects in the ShapeNet-part. Additionally, it seems that there is not a clear winner in classes where the point cloud samples are limited. The worst model is PointNet, which incorporates only Rotation and Permutation invariance properties. The same insights are also observed in scene segmentation (S3DIS dataset), as there is not an absolute winner in all Areas and PointNet is the least accurate model. Finally, in both segmentation tasks, Convolution-based models obtain better results, both in training and testing.

4.3.2. Efficiency

In this section, we explore the segmentation efficiency of the selected models by analyzing the results in

Table 6. Comparison of the efficiency of the utilized deep learning models in 200 epochs. Time values are shown in decimal hours (h). In table (a) we show the results utilizing the ShapeNet-part dataset and in tables (b–g) we show the results in all Areas of S3DIS dataset. Please note that in S3DIS, tables (b–g), the $CmIoU$ values are missing, because such a performance metric is not applied in this dataset. We use dark grey and light grey cell colors to denote the best and the second best score per metric respectively.

(a) ShapeNet-part dataset.
Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{CmIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$
		$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$	$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$
PointNet	5.55	4.77	170	4.99	178	33.7
PointNet++	4.55	2.03	88	3.36	146	36.3
KPConv	23.01	6.21	53	21.96	189	60.4
PPNet	29.28	24.71	167	22.33	151	89.0
RSConv	12.06	4.35	71	11.81	194	55.5
(b) Area 1—S3DIS dataset.					(c) Area 2—S3DIS dataset.
Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$	Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$
		$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$				$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$
PointNet	3.98	2.80	140	31.8	PointNet	3.94	2.59	131	33.8
PointNet++	3.37	2.81	166	32.8	PointNet++	3.24	1.20	74	32.7
KPConv	17.34	16.21	186	46.8	KPConv	16.91	5.44	64	53.6
PPNet	22.50	19.11	169	77.3	PPNet	21.57	4.12	38	89.0
RSConv	8.89	5.54	124	53.1	RSConv	8.93	1.17	26	54.8
(d) Area 3—S3DIS dataset.					(e) Area 4—S3DIS dataset.
Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$	Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$
		$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$				$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$
PointNet	4.08	3.75	183	30.2	PointNet	4.29	3.10	144	29.8
PointNet++	3.38	1.89	111	32.9	PointNet++	3.54	2.31	130	34.2
KPConv	17.73	16.04	180	46.4	KPConv	18.75	6.60	70	43.0
PPNet	22.57	19.85	175	75.7	PPNet	24.25	16.57	136	94.0
RSConv	9.07	3.65	80	52.1	RSConv	9.61	5.75	119	51.8
Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$	Method	${\mathit{t}}_{\mathit{total}}\left(\mathit{h}\right)$	${\mathit{ImIoU}}_{\mathit{time}\left(\mathit{h}\right)}^{\mathit{best}}$		${\mathit{GPU}}_{\mathit{mem}}(\%)$
		$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$				$\mathit{Value}$	${\mathit{n}}_{\mathit{epoch}}$
PointNet	4.05	3.46	170	31.3	PointNet	3.75	3.28	174	30.6
PointNet++	3.32	3.09	185	34.1	PointNet++	3.23	0.67	41	33.3
KPConv	17.57	13.95	158	48.6	KPConv	15.66	6.77	86	48.3
PPNet	22.33	16.05	143	77.1	PPNet	20.10	13.23	131	80.5
RSConv	8.92	4.03	90	53.2	RSConv	8.22	6.65	161	52.4

.

In Table 6, we display (i) the time spent (in decimal hours) to complete the whole learning process of training, validation, and testing as $t_{total}\left(h\right)$, (ii) the time spent to achieve the best performance in relation to $CmIoU$ and $ImIoU$ metrics in the test data as $CmIo{U}_{time\left(h\right)}^{best}$, $ImIo{U}_{time\left(h\right)}^{best}$ respectively and (iii) the number of epoch ($n_{epoch}$) that corresponds to the exact time measurement. Additionally, we display (iv) the average GPU memory allocation in percentage in the whole learning process as $GP{U}_{mem}$. Please note that the preliminaries of the aforementioned metrics are detailed in Section 3.2.2. In S3DIS Areas, we report only the $ImIoU$ as the $CmIoU$ does not apply, as stated earlier.

Regarding the results in ShapeNet-part, an interesting observation is that PointNet++ is the fastest neural network with a total run time ($t_{total}$) of 4.55 h, while being the second best in accuracy, as shown in Table 4. It also achieves its peak performance in test data faster than all its competitors, i.e., $ImIo{U}_{time\left(h\right)}^{best}=2.03$ and $CmIo{U}_{time\left(h\right)}^{best}=3.36$ h. RSConv and PointNet are second in $ImIo{U}_{time\left(h\right)}^{best}$ and $CmIo{U}_{time\left(h\right)}^{best}$ respectively. Additionally, KPConv uses the least amount of epochs to achieve the best $ImIoU$ value in test data, i.e., $n_{epochs}=53$. Regarding the best score in $CmIoU$, PointNet++ uses $n_{epochs}=146$ while PPNet follows with an almost identical number of epochs to achieve its best $CmIoU$ score, $n_{epochs}=151$.

In terms of average GPU memory usage, PointNet finishes in the first place with 33.7% although the second one, PointNet++, has approximately the same GPU memory usage with a value of 36.3%. Additionally, PPNet utilizes 89% of total GPU memory while needing about 29.28 h of time for its computations, appearing to be the least efficient in terms of memory and time spent. It is worth noticing that the differences in time efficiency across the models are great, wherein on one hand we observe PointNet and PointNet++ models having $t_{total}=5.55$ and $t_{total}=4.55$ and on the other hand KPConv and PPNet having $t_{total}=23.01$ and $t_{total}=29.28$ respectively. Similarly, in average GPU memory allocation, we notice PointNet and PointNet++ models having $GP{U}_{mem}=33.7$ and $GP{U}_{mem}=36.3$, and on the other hand KPConv and PPNet having $GP{U}_{mem}=60.4$ and $GP{U}_{mem}=89$ respectively.

Regarding the results in S3DIS Areas, we observe that PointNet++ is the fastest neural network in ($t_{total}$), in all Areas of S3DIS, similarly as in ShapeNet-part case. However, in Area 1, PointNet achieves its peak performance $ImIo{U}_{time\left(h\right)}^{best}=2.80$ faster than the others. It is noteworthy that in Area 2, RSConv not only achieves the best accuracy of $ImIoU=47.34$ (Table 4) but also is faster than the other models in $ImIo{U}_{time\left(h\right)}^{best}=1.17$. Regarding the average GPU memory usage, PointNet is the winner in almost all Areas except Area 2 where PointNet++ is first. It is clear that both PointNet and PointNet++ use fewer memory resources than the others, while PPNet requires the most memory resources almost in all Areas. These remarks lead us to Observation 2.

Observation 2.

Time and memory efficiency varies greatly across different models. There is not a clearly winning model concerning efficiency in time and memory allocation. Additionally, it seems that neural networks that utilize Point-wise MLP-based operations are the ones that have the lowest time and GPU memory consumption.

4.3.3. Robustness

In this section, we analyze the results presented in Table 5 and

Table 7. Comparison of deep learning models in terms of $mIoU$ per class in the whole learning procedure (averaged over 200 epochs). In table (a) we show the results in the ShapeNet-part dataset and in the table (b) we display the results in the S3DIS dataset. We use dark and light grey colors to denote the best and the second-best model. Please note that the last row of both tables, entitled "Ranking", refers to the ranking mechanism described in Section 3.2.3.

(a) ShapeNet-part dataset.
Class	PointNet	PointNet++	KPConv	PPNet	RSConv
	$\mu \pm ϵ$	$\mu \pm ϵ$	$\mu \pm ϵ$	$\mu \pm ϵ$	$\mu \pm ϵ$
Airplane	79.88 ± 4.12	81.59 ± 2.27	81.81 ± 2.21	81.90 ± 1.57	82.48 ± 1.82
Bag	71.44 ± 14.50	79.00 ± 6.21	81.24 ± 3.00	80.39 ± 3.73	80.60 ± 4.51
Cap	75.57 ± 5.44	84.38 ± 4.59	83.98 ± 2.65	81.74 ± 2.14	82.60 ± 2.50
Car	71.16 ± 8.06	76.81 ± 4.87	77.43 ± 3.48	78.65 ± 2.91	77.95 ± 2.86
Chair	88.71 ± 1.88	90.21 ± 1.23	90.19 ± 0.69	90.30 ± 0.91	90.50 ± 0.72
Earphone	64.28 ± 9.35	73.72 ± 5.47	68.64 ± 4.84	74.46 ± 4.46	72.76 ± 3.55
Guitar	88.18 ± 5.09	91.05 ± 1.44	90.85 ± 1.55	90.97 ± 1.59	91.50 ± 0.83
Knife	84.07 ± 2.96	84.34 ± 2.87	86.42 ± 2.06	86.01 ± 2.12	85.45 ± 1.31
Lamp	78.99 ± 3.38	82.68 ± 1.87	80.72 ± 1.58	80.14 ± 1.67	83.35 ± 1.22
Laptop	94.97 ± 0.90	95.66 ± 0.31	95.44 ± 0.22	95.64 ± 0.21	95.45 ± 0.33
Motorbike	51.63 ± 21.54	66.27 ± 15.08	70.04 ± 9.70	71.79 ± 7.79	70.97 ± 11.51
Mug	87.11 ± 9.81	92.76 ± 4.33	94.39 ± 1.77	94.98 ± 1.29	94.35 ± 1.88
Pistol	76.30 ± 7.34	79.66 ± 4.66	80.26 ± 3.13	81.09 ± 1.98	82.58 ± 1.92
Rocket	43.40 ± 17.26	57.86 ± 10.22	60.11 ± 7.10	59.91 ± 6.86	59.26 ± 7.26
Skateboard	68.67 ± 6.47	74.63 ± 4.11	75.53 ± 2.26	75.48 ± 2.46	75.19 ± 2.59
Table	80.86 ± 2.11	81.21 ± 1.29	78.51 ± 1.81	77.78 ± 1.56	82.09 ± 0.86
Ranking	4.88	3.13	2.56	2.31	2.13
(b) S3DIS dataset.
Area	PointNet	PointNet++	KPConv	PPNet	RSConv
	$\mu \pm ϵ$	$\mu \pm ϵ$	$\mu \pm ϵ$	$\mu \pm ϵ$	$\mu \pm ϵ$
1	56.49 ± 6.42	64.39 ± 4.52	66.85 ± 4.03	68.06 ± 3.96	66.11 ± 3.42
2	31.78 ± 4.49	39.17 ± 3.98	42.27 ± 3.98	41.75 ± 3.36	43.21 ± 2.89
3	40.93 ± 6.69	48.12 ± 3.85	54.77 ± 5.16	55.63 ± 3.71	51.45 ± 3.56
4	59.12 ± 6.84	67.29 ± 4.47	69.89 ± 3.93	72.25 ± 4.08	68.92 ± 3.66
5	64.77 ± 8.42	72.09 ± 4.63	73.77 ± 4.70	74.85 ± 4.13	73.35 ± 3.93
6	41.28 ± 6.77	48.76 ± 2.97	54.61 ± 3.32	53.83 ± 2.92	51.10 ± 2.53
Ranking	5.00	4.00	1.83	1.50	2.67

to investigate the segmentation robustness of the selected models.

In order to further clarify the robustness of each deep learning model in each class we denote the results in $\mu \pm ϵ$ format. Regarding the robustness-related results in the ShapeNet-part dataset, in the last row of Table 5(a), we display the results of $mIoU$ metric for each class that correspond to the best epoch outcome of $CmIoU$ of each model. Additionally, we report the average accuracy obtained in each object. Such information is useful to detect the most difficult and the easiest objects to learn. In the same notion, in Table 5(b), in the results on the S3DIS dataset, we report the best achieved $mIoU$ per Area and also the model performance averages. We also report the average per Area in order to justify the learning difficulty of each Area.

In ShapeNet-part, PPNet has the lowest error ($ϵ=9.75$) of the mean ($\mu =82.50$), while the mean performance of 82.50 is almost identical to the RSConv, which achieves 82.73 with an error of $ϵ=10.44$. Please note that in the hardest classes to learn, i.e., the ones with the lowest achieved accuracy and highest error, such as "Rocket" or "Motorbike" the winning models are KPConv and RSConv respectively, both of them being based on convolutional operations.

On the other hand, in S3DIS, PPNet achieves the best average performance in all Areas, with a model average of $63.65\pm 19.94(\%)$, while KPConv is second with an average of $62.91\pm 18.81(\%)$. Additionally, it can be observed that the hardest Areas to learn are Areas 2, 3, and 6, as all the models achieved significantly lower segmentation accuracy than in Areas 1, 4, and 5. Similarly, as in ShapeNet-part results, the winning models in the hardest cases are based on convolutional operations. Following, we highlight another remark in Observation 3.

Observation 3.

In the "hardest" to learn classes (part segmentation) or areas (scene segmentation) the winning models are the Convolution-based ones that incorporate Local Aggregation operations focusing on the local features of the 3D point cloud. Additionally, in some classes (e.g., Earphone) in part segmentation, the Point wise MLP-based models achieve high mean accuracy but they tend to have higher errors than the others.

Furthermore, in Table 7a, in the ShapeNet-part dataset, we report the average scores of $mIoU$ per class that are achieved by each neural network in the testing phase of all 200 epochs. It can be observed that highly accurate models in specific classes have higher error ($ϵ$) than the others. For instance, in class Cap, PointNet++ has the highest average accuracy of $84.38$ however its error of the mean seems to be higher than the others $ϵ=4.59$. On the other hand, PPNet has a lower accuracy score of $81.74$ but the error ($ϵ=2.14$) is approximately half the one of PointNet++.

Regarding the S3DIS results in Table 7b, we report the average scores of $mIoU$ in all six Areas, similarly as in ShapeNet-part results. In Area 2, RSConv has the best mean accuracy and also the lowest error ($43.21\pm 2.89$). KPConv has the best segmentation accuracy in Area 6, but its error is higher than the others. Moreover, PPNet achieves the best mean segmentation accuracy in Areas 1, 3, 4, and 5, but its error of the mean in some cases, such as Area 4 is higher than the one in KPConv or RSConv.

Moreover, we graphically represent the $\mu \pm ϵ$ of $IoU$ in each class of ShapeNet-part and in each Area of S3DIS in all testing epochs in Figure 4. In ShapeNet-part, the most accurate method, RSConv, shows also greater robustness than the most efficient PointNet++ model. It is interesting how the models perform in "ill" classes such as the Motorbike and Rocket. In such classes, we observe great differences among the models’ performance, although PPNet, KPConv, and RSConv achieve approximately the same segmentation accuracy and robustness. This can be also justified by Table 7, where in Rocket class the former three achieve approximately $60\pm 7$ of $mIoU$. On the other hand, in the same class of Rocket, PointNet and PointNet++ seem to be worse with the first one being the worst reporting a $43.40\pm 17.26$.

In S3DIS, PointNet appears to be the least accurate model since it has the lowest segmentation accuracy and its error is the highest. Observing the error bars, we can say that in some occasions, such as in Area 5, the error is more than twice as high as in other models. Furthermore, we observe that the best model, PPNet, shows also good robustness. In Area 3, we see a great range of accuracy values of all the models combined ranging from approximately 35% to 60%. We can also visually identify that Areas 2, 3, and 6 are hard Areas to learn.

In addition, in order to provide a rigorous statistical evaluation in terms of per-class robustness in test data, first we use the Friedman statistical test [40], as described in Section 3.2.3. We apply the Friedman test in our experimental setup, where in the case of ShapeNet-part we have $N=16$ data classes and $n_{models}=5$ different deep learning models, and in the case of S3DIS, we have $N=6$ (Areas) and $n_{models}=5$.

Regarding the ShapeNet-part case, the Friedman test statistic $F_F$ follows the F distribution with $(5-1)=4$ and $(5-1)·(16-1)=60$ degrees of freedom. The calculated Friedman test statistic is equal to $F_F=14.77$, according to Equations (6) and (7). Hence, at an $\alpha =0.05$ of statistical significance, the critical value is 2.52. Next, we observe that $14.77>2.52$, so we have enough evidence to reject the null hypothesis $H_0$, as described in Section 3.2.3. Alternatively, at an alpha level of statistical significance $\alpha =0.05$ the $p_{value}=0$, implies that we can reject the null hypothesis. Table 7 shows the ranking of models according to the aforementioned test.

Regarding the S3DIS case, the Friedman test statistic $F_F$ follows the F distribution with $(5-1)=4$ and $(5-1)·(6-1)=20$ degrees of freedom. The Friedman test statistic is equal to $F_F=34.09$. At an $\alpha =0.05$ of statistical significance, the critical value is $2.86$ and by observing that $34.09>2.86$, we can safely reject the null hypothesis $H_0$.

Once we have successfully rejected the null hypothesis, the Nemenyi test [40] is applied to check the presence of statistically significant differences among the models. Recall that the two models are statistically significant if their corresponding average ranks differ by at least the critical difference value ($CD$), described in Section 3.2.3. In the case of ShapeNet-part, the critical value of the two-tailed Nemenyi test (Equation (8)) that corresponds to 95% statistical significance, i.e., $\alpha =0.05$, having $n_{models}=5$ and $N=16$ is equal to $q_{0.05}=2.728$. Thus, the calculated critical difference value is $CD=1.525$ and for any two pairs of models whose rank difference is higher than $CD=1.525$, we can infer with a statistical confidence of 95% that a significant difference exists among them.

In the case of S3DIS, the aforementioned critical value at an $\alpha =0.05$ while $n_{models}=5$ and $N=6$ is equal to $q_{0.05}=2.728$. The calculated critical difference value is $CD=2.49$ and we can infer with a statistical confidence of 95% that a significant difference exists among them.

Figure 5 portrays the Nemenyi statistical test of models. In the graph, the bullets represent the mean ranks of each model and the vertical lines indicate the critical difference. Hence, to clarify, the two methods are significantly different if their lines are not overlapping. In ShapeNet-part results, the RSConv model seems to be the winner across all models although, statistically, we can only say that the PointNet model is significantly worst that its competitors. Additionally, PPNet, KPConv, and RSConv perform almost equally according to the Nemenyi test.

By observing the Nemenyi test of S3DIS in Figure 5b, although the PPNet model appears to be the winning model, we can only justify with statistical significance that PointNet is the worst model and PPNet is better than PointNet and PointNet++ models. Having analyzed our results, we report our Observation 4.

Observation 4.

Apart from accuracy and efficiency, robustness is also a crucial concern for effective model performance evaluation. There is a great variety of different errors of the mean (ϵ) $mIoU$ values and a global robustness comparison rule among the models can not be easily identified. Basically, Convolution-based models that incorporate Adaptive Weight-based or Position Pooling aggregation operators seem to be the winners in the statistical ranking, i.e., RSConv in part segmentation (ShapeNet-part) and PPNet in scene segmentation (S3DIS).

4.3.4. Generalized Metrics

In this section, we provide insights into the generalized performance of the utilized segmentation models by analyzing the results in

Table 8. Comparison of deep learning models in terms of generalized performance evaluation based on three distinct selections of ${\alpha }_1$, ${\beta }_1$ parameters. Please note that ${\alpha }_1=0.2$ and ${\beta }_1=0.2$ portray an efficiency-biased evaluation, ${\alpha }_1=0.5$ and ${\beta }_1=0.5$ a balanced evaluation between accuracy and efficiency, and ${\alpha }_1=0.9$ and ${\beta }_1=0.9$ an accuracy biased evaluation. Please remind that ${\alpha }_2={\alpha }_3={\alpha }_4=\frac{1-{\alpha }_1}{3}$ and ${\beta }_2={\beta }_3={\beta }_4=\frac{1-{\beta }_1}{3}$. Table (a) shows the results in the ShapeNet-part dataset and tables (b)–(g) the results in all Areas of S3DIS. It is worth noticing that $F_{CmIoU}^R$ and $F_{general}^R$ do not apply in the S3DIS dataset. With dark grey, we denote the best score, and with light grey the second best.

(a) ShapeNet-part dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{CmIoU}^R$	0.52	0.88	0.61	0.44	0.81
	$F_{ImIoU}^R$	0.57	0.82	0.47	0.25	0.81
	$F_{general}^R$	0.55	0.85	0.54	0.34	0.81
${\beta }_1=0.5$, ${\alpha }_1=0.5$	$F_{CmIoU}^R$	0.33	0.90	0.72	0.62	0.88
	$F_{ImIoU}^R$	0.44	0.76	0.38	0.16	0.88
	$F_{general}^R$	0.38	0.83	0.55	0.39	0.88
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{CmIoU}^R$	0.07	0.93	0.87	0.88	0.98
	$F_{ImIoU}^R$	0.27	0.68	0.25	0.03	0.98
	$F_{general}^R$	0.17	0.81	0.56	0.45	0.98
(b) Area 1—S3DIS dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{ImIoU}^R$	0.52	0.71	0.62	0.47	0.61
${\beta }_1=0.5$, ${\alpha }_1=0.5$	$F_{ImIoU}^R$	0.33	0.66	0.70	0.67	0.65
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{ImIoU}^R$	0.07	0.60	0.81	0.93	0.70
(c) Area 2—S3DIS dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{ImIoU}^R$	0.52	0.72	0.61	0.43	0.68
${\beta }_1=0.5$, ${\alpha }_1=0.5$	$F_{ImIoU}^R$	0.32	0.68	0.70	0.59	0.80
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{ImIoU}^R$	0.06	0.62	0.82	0.79	0.96
(d) Area 3—S3DIS dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{ImIoU}^R$	0.52	0.67	0.64	0.47	0.60
${\beta }_1=0.5$, ${\alpha }_1=0.5$	$F_{ImIoU}^R$	0.33	0.59	0.77	0.67	0.63
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{ImIoU}^R$	0.07	0.47	0.95	0.93	0.67
(e) Area 4—S3DIS dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{ImIoU}^R$	0.52	0.70	0.65	0.47	0.65
${\beta }_1=0.5$, ${\alpha }_1=0.5$	$F_{ImIoU}^R$	0.33	0.65	0.71	0.67	0.69
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{ImIoU}^R$	0.07	0.59	0.79	0.93	0.74
(f) Area 5—S3DIS dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{ImIoU}^R$	0.52	0.72	0.61	0.47	0.62
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{ImIoU}^R$	0.07	0.69	0.85	0.93	0.76
(g) Area 6—S3DIS dataset.
Scenario	Metric	PointNet	PointNet++	KPConv	PPNet	RSConv
${\beta }_1=0.2$, ${\alpha }_1=0.2$	$F_{ImIoU}^R$	0.52	0.69	0.64	0.46	0.60
${\beta }_1=0.5$, ${\alpha }_1=0.5$	$F_{ImIoU}^R$	0.33	0.63	0.78	0.65	0.61
${\beta }_1=0.9$, ${\alpha }_1=0.9$	$F_{ImIoU}^R$	0.07	0.54	0.96	0.90	0.64

.

In Table 8, we evaluate the models concerning the proposed generalized metrics (see Section 3.2.4). We display three different cases that may represent the needs of the final user. Please remind that we use the following parameter rules in the Equations (9) and (10): ${\alpha }_2={\alpha }_3={\alpha }_4=\frac{1-{\alpha }_1}{3}$ and ${\beta }_2={\beta }_3={\beta }_4=\frac{1-{\beta }_1}{3}$ to promote accurate models but also balanced in terms of efficiency and robustness by assigning equal weights to the efficiency and robustness terms of the Equations.

In the first case of ShapeNet-part results, we select values of ${\alpha }_1=0.2$ and ${\beta }_1=0.2$, which indicate that the model evaluation process is biased towards the efficiency and robustness of the models. PointNet++ is first in $F_{CmIoU}^R$ with a value of 0.88, while RSConv is second with a value of 0.81. In $F_{ImIoU}^R$, PointNet++ is first again with a value of 0.82, while RSConv is second with a value of 0.81. In the generalized metric $F_{general}^R$, we observe similar behavior as PointNet++ is the winner. In the second case, where ${\alpha }_1=0.5$ and ${\beta }_1=0.5$, we portray a balanced approach, giving the same weight in segmentation accuracy, efficiency, and robustness of each model. In this case, RSConv is first in $F_{ImIoU}^R$ with a value of 0.88, while PointNet++ obtains the best value in $F_{CmIoU}^R$ with 0.90. Additionally, RSConv outperforms its competitors in the $F_{general}^R$ metric. Finally, the third case, where ${\alpha }_1=0.9$ and ${\beta }_1=0.9$, displays a segmentation accuracy biased model selection process. Here, RSConv is the winner in all three metrics.

Please note that in all of our portrayed scenarios we use ${\alpha }_1={\beta }_1$ because we basically want the models to be evaluated in their ability to produce uniformly good results not only in all point cloud instances but also in all classes. As explained in Section 3.2.1, in multi-class 3D point cloud segmentation task, we seek a model that has equally high $CmIoU$ and $ImIoU$ ($CmIoU\approx ImIoU$).

Regarding the generalized metrics in S3DIS, we select the same values of ${\alpha }_1$ and ${\beta }_1$ in the same scenarios in order to uniformly analyze the models. However, the metrics related to $CmIoU$ can not be applied in this dataset. As a result, we compute only the $F_{ImIoU}^R$ in all the scenarios. In the first scenario of ${\alpha }_1=0.2$ and ${\beta }_1=0.2$, we observe approximately the same behavior in all Areas, as PointNet++ achieves the best result. In Areas 2 and 5 RSConv is second, while in Areas 1, 3, and 6 KPConv is second. In Area 4, we have a tie between RSConv and KPConv with $F_{ImIoU}^R=0.65$. In the balanced scenario where ${\alpha }_1=0.5$ and ${\beta }_1=0.5$, in all Areas, the KPConv model is first, except Area 2, where RSConv is the winner. In Areas 1, 3 and 6 PPNet is second with values of 0.67, 0.67, and 0.65 respectively. In the last scenario, we can visually identify three performance clusters, the first one includes Areas 1, 4, and 5, where we observe similar behavior of the models as PPNet is first with $F_{ImIoU}^R=0.93$ while KPConv achieves the second best values. The second cluster includes Areas 3 and 6 where KPConv and PPNet have the first and second-best scores respectively. Finally, the third performance cluster includes Area 2, where interestingly RSConv and KPConv are the two best ones. It is worth noticing that Area 2 is the “hardest” Area to learn and RSConv is the winner in both balanced and accuracy-biased evaluation scenarios. Additionally, in all scenarios of all Areas of the S3DIS dataset, the fundamental architecture PointNet holds the last position which is clearly indicating that advances have been made in the trade-off of models between accuracy, efficiency, and robustness. The analysis of the results yields Observation 5.

Observation 5.

The deployment of generalized performance evaluation metrics facilitates model selection to a great extent. Such metrics are able to easily highlight the differences among models concerning accuracy, efficiency, and robustness. It is interesting that in all selected scenarios of ${\alpha }_1$ and ${\beta }_1$ values, in part segmentation, the winning models (PointNet++ and RSConv) are the ones that incorporate all the invariance properties (either weak or strong), namely Rotation, Permutation, Size and Density. In scene segmentation, utilizing Convolution-based models with Local Aggregation operators accompanied by an assortment of invariance properties (either weak or strong) is important. It seems that it is advantageous to combine invariance properties, allowing the network to select the invariance it needs.

4.3.5. Relation between Design and Experimental Properties

To sum up, in this section, we emphasize the relation between the design and experimental properties of the selected models in order to pave the way toward an effective 3D point cloud segmentation model selection. We present our results in

Table 9. Model comparisons according to their design and experimental properties. In Rotation, Size, and Density, the ⋆ and ▿ and denote strong or weak invariance to such transformations respectively. In the Experimental Properties, the ranking numbers in black color refer to the results using the ShapeNet-part dataset, while the numbers in blue color refer to the results of the S3DIS dataset. Please note that the up-script number (#) in the blue ranking format ($numbe{r}^{(\#)}$) denotes the number of Areas, where the model achieved either 1st or 2nd position.

Method	Design Properties													Experimental Properties
	Agg Level		Agg Type				NN Method		Invariance				Rest	Accuracy		Efficiency		Robustness	Gen Performance
	Local	Global	Point-wise	Pseudo Grid	Adaptive Weight	Position Pooling	Convolution	MLP	Rotation	Permutation	Size	Density	Parameters	Per-Instance Accuracy	Per-Class Accuracy	Time Efficiency	GPU Memory Efficiency	Robustness	Per-Class ${\mathit{F}}^{\mathit{R}}$ (${\mathsf{\alpha }}_{\mathbf{1}}={\mathsf{\beta }}_{\mathbf{1}}=\mathbf{0.5}$)	Per-Instance ${\mathit{F}}^{\mathit{R}}$ (${\mathsf{\alpha }}_{\mathbf{1}}={\mathsf{\beta }}_{\mathbf{1}}=\mathbf{0.5}$)	Generalized ${\mathit{F}}^{\mathit{R}}$ (${\mathsf{\alpha }}_{\mathbf{1}}={\mathsf{\beta }}_{\mathbf{1}}=\mathbf{0.5}$)
PointNet		⋆	⋆					⋆	▿	⋆			3.5 M			2, $2^{\left(6\right)}$	1, $1^{\left(5\right)}$, $2^{\left(1\right)}$
PointNet++	⋆		⋆					⋆	▿	⋆	⋆	▿	1.4 M	2	2	1, $1^{\left(6\right)}$	2, $1^{\left(1\right)}$, $2^{\left(5\right)}$		1	2	2
KPConv	⋆			⋆			⋆		⋆	⋆	⋆	▿	14.2 M	$1^{\left(1\right)}$, $2^{\left(5\right)}$				2		$1^{\left(5\right)}$, $2^{\left(1\right)}$
PPNet	⋆					⋆	⋆		▿	⋆	⋆	▿	18.5 M	$1^{\left(4\right)}$, $2^{\left(1\right)}$	2			2, 1		$2^{\left(3\right)}$
RSConv	⋆				⋆		⋆		⋆	⋆	⋆	⋆	3.5 M	1, $1^{\left(1\right)}$	1			1	2	1, $1^{\left(1\right)}$, $2^{\left(2\right)}$	1

, where the ⋆ in design properties denotes the models that utilize this property. Concerning invariance properties, and specifically in transformation-related ones (rotation, size, density), we assign ⋆ to the models that according to the literature are highly robust to such transformations, or ▿ to the models where their invariance to transformations is considered weak. In experimental properties, the numbering (1, 2) distinguishes the models that achieve the two highest scores in each property, i.e., the two best ones. Please note that in case of a tie both models are getting the same number of rankings.

By focusing the learning process on the local features of the point cloud object, using Local Aggregation operators as described in Section 3.1, we expect a model to have higher accuracy and greater robustness than a model that uses only Global Aggregation operators, but less time and memory efficiency, because of the use of a greater amount of computations. Indeed, we observe that focusing on the Global Features of a point cloud is closely related to time efficiency and GPU-memory efficiency in both part segmentation and scene segmentation, e.g., PointNet’s performance, but there is a lack of segmentation accuracy and robustness. By design, models that focus on the local features of a point cloud object capture better the geometrical topology of the points, leading to higher segmentation accuracy. For instance, RSConv focuses on the Local Features of a point cloud and captures well the geometrical topology of its points, as explained in Section 3.3, resulting in a high segmentation accuracy value, in both part segmentation and scene segmentation, as shown in Table 4 and Table 5. High performance in accuracy is also observed in PPNet and KPConv models, especially in scene segmentation. However, in part segmentation, we do not observe this behavior of RSConv in all classes of the ShapeNet-part dataset, or in classes where the point cloud samples are limited, as detailed in Observation 1. Additionally, we observe that the worst model in terms of accuracy in both part segmentation and scene segmentation, PointNet, uses only the Rotation and Permutation invariance properties and focuses on the Global Features of the input point clouds.

Convolutional operations often produce more accurate results although there are cases where Point-wise MLPs outperform them. However, Point-wise MLP-based models use shared MLP units to extract point features, which are efficient and if they are accompanied by random point sampling can be highly efficient in terms of memory and computations [9,47]. Convolution-based models, while, generally, being inefficient in terms of memory and time compared to the Point-wise MLP-based models, try to improve efficiency by splitting the convolution into multiple smaller highly efficient computations, such as matrix multiplications paired with low dimension convolutions [9]. In this work, we justify such behavior of the Convolutional-based models compared to the Point-wise MLP-based ones, as depicted in Table 9. Thus, convolutions do not correspond to time or memory efficiency and the Point-wise MLP-based models appear to be the ones that have the lowest time and GPU memory consumption on average, as explained in Observation 2.

Moreover, in the "hardest" to learn classes in part segmentation or areas in scene segmentation the winning models are the Convolution-based ones by focusing on the Local Features of the point cloud, as stated in Observation 3. Additionally, in some classes (Earphone) in part segmentation Point-wise MLP-based models can achieve high mean accuracy but they tend to have higher errors than the others.

In terms of robustness, Convolution-based neural networks that incorporate Adaptive Weight-based or Position Pooling aggregation appear to be the winners in robustness statistical ranking, while Pseudo Grid operations are following in most of the cases, as shown in Observation 4. Nevertheless, it is worth noticing that paying attention in the learning process on the local features of the point cloud using either Convolution-based or Point-wise MLP-based model often leads to greater accuracy and robustness, while greatly capturing the points topology, as shown in Table 9. Summarizing, the best results in accuracy and robustness in part segmentation and scene segmentation are recorded in models that focus on the local features of the point cloud while being Convolution-based and using Adaptive Weight-based or Position Pooling local aggregation operators.

Additionally, in Table 9, we detail the number of parameters of each model. We observe that the low number of parameters is related to efficiency but also to segmentation accuracy and robustness. Thus, the correct utilization of parameters and the architectural design of the network plays a significant role. For instance, PointNet++ and RSConv use approximately 1.4 and 3.4 million parameters respectively, while being two of the best in segmentation accuracy and robustness ranking in part segmentation. However, in scene segmentation tasks it seems that the high number of parameters is strongly correlated with high accuracy and robustness but not efficiency.

Finally, the use of generalized experimental metrics aids the interpretation of all these crucial evaluation dimensions, i.e., accuracy, efficiency, robustness. Additionally, it emphasizes the trade-off among them across various models and their design properties. For example, in a balanced model evaluation scenario among accuracy, efficiency and robustness (${\alpha }_1={\beta }_1=0.5$), the winning models in $F_{CmIoU}^R$, $F_{ImIoU}^R$ and $F_{general}^R$ are the ones that are highly accurate, efficient and robust, as shown in Table 9, and, clearly highlighted in Observation 5.

Some further remarks in part segmentation, i.e., ShapeNet-part data, could be that high scores in the aforementioned experimental properties correspond to models (PointNet++ and RSConv) that mainly (i) focus on the Local Features of the point cloud and have the ability to capture the topology of the points, (ii) incorporate all the invariance properties (either weak or strong invariance), namely Rotation, Permutation, Size and Density, and (iii) use a low amount of parameters compared to others, although they come from two distinct families of deep learning architectures. For instance, PointNet++ is mainly a Point-wise MLP-based model and RSConv is a Convolution-based neural network that uses Adaptive Weight-based local aggregation operations.

In addition, further remarks in scene segmentation, i.e., S3DIS data, could be that high $F_{ImIoU}^R$ scores correspond to models that (i) focus on the Local Features of the point cloud and (ii) incorporate the majority of invariance properties. It seems that it is advantageous to combine invariance properties, allowing the network to select the invariance it needs. Additionally, all the best models in scene segmentation utilize convolutional operations and use Pseudo Grid or Adaptive Weight or Position Pooling local aggregation type. Without the loss of generality, we can say that local aggregation operators, when properly calibrated, may yield comparable performance, as shown in [14].

5. Discussion & Limitations

Our experimental findings reveal certain differences compared to the current literature. The majority of the studies show only the best-achieved accuracy of the models [9]. Instead, we not only show the best-achieved accuracy but also show the average and the standard deviation (as a percentage error of the mean) of the measurements. It is important to show experimental results in a format of $\mu \pm ϵ$, in order to justify rigorous evaluation, as it is normal in different runs to achieve slightly different "best" results. Additionally, while Zhang et al. [27] show that the forward time of PointNet is less than PointNet++’s time, we found out that the total run time of PointNet++ is way less than PointNet’s time. This can be justified to a certain extent by the fact that PointNet++ utilizes approximately 2.5 times fewer parameters than PointNet, even though it is a more complex structure than PointNet.

Regarding the limitations of this study, first, as there is a plethora of new neural networks, we choose to investigate the widely used and most characteristic ones. For instance, we do not include graph neural networks, although they are highly accurate in downstream tasks [48,49]. Thus, an all-around performance evaluation of graph-based neural networks in 3D point cloud segmentation will be addressed in future research. Second, although, we conduct our experiments in part segmentation and indoor segmentation tasks, it is interesting to explore also outdoor segmentation datasets, e.g., Semantic3D [50]. Third, in this study, we assign the invariance properties to the models from the current literature.

To open the discussion for future research, we include our further findings concerning invariance properties. In fact, permutation invariance can be incorporated quite easily into a point-based neural network, for example, by using symmetric pooling operations [11,12]. On the other hand, size, density, and rotation transformations are properties that should be rigorously evaluated. Strict invariance is tough to achieve and if so it needs to be mathematically proven. The term "strict" denotes the situation in which the equality in Equation (1) holds. Thus, in this manuscript, we refer to transformation invariant properties denoting the robustness (strong or weak) of a model to input size, scale, density changes, and arbitrary rotations, and we utilize the terms strong and weak invariance, as explained in Section 3.1. By no means, does Table 9 show strict transformation invariance properties of the models. For instance, the majority of the networks are not strictly invariant to arbitrary rotations [51], as such invariance property is often overlooked [52]. While data augmentation techniques can be used to enhance the model’s robustness to rotations in specific datasets [53], the projection of the point clouds to a high dimensional canonical space [54] or rotation-invariant convolutions [52] are two approaches that seem capable of achieving strict rotation invariance. Moreover, size invariance is also relative and strongly depends on the amount of sizing/scaling [55]. For these reasons, we have considered that the validation of the invariance properties deserves special attention and will be addressed in depth in future research.

6. Conclusions

The majority of segmentation models on 3D point clouds focus on segmentation accuracy, especially on $mIoU$ and variants of it, $CmIoU$ and $ImIoU$. However, there is little attention on analyzing efficiency, robustness, and other potential evaluation dimensions in relation to the models’ design properties. Consequently, there is an imperative need in the literature for a deep and fine-graded analysis of segmentation models on 3D point cloud objects in order to be useful in practice in part segmentation and scene segmentation tasks.

This article presents experimental findings and aims to deeply analyze segmentation models on 3D point clouds in different performance dimensions, namely accuracy, efficiency, and robustness, and relate them with the models’ inner design characteristics. Specifically, we study the inner design and experimental properties of five representative neural networks, PointNet, PointNet++, KPConv, PPNet, and RSConv, and evaluate them in widely used segmentation datasets, namely ShapeNet-part (part segmentation) and S3DIS (scene segmentation).

Our main results relate the design properties of the models with significant experimental properties, aiming to find a correspondence between them. This particular information is crucial for designing novel neural network models and is also useful for any individual applying the current state-of-the-art models. It also facilitates the decision-making of model selection from the wide range of existing models.

We show that Convolution-based models that incorporate local aggregation operations obtain better results in both part and scene segmentation than the Point-wise MLP-based ones, and they also achieve superior performance in the “hardest” classes to learn. However, Point-wise MLP-based models have the lowest time and GPU memory consumption. Additionally, Convolution-based models that incorporate Adaptive Weight-based or Position Pooling local aggregation operators are the most robust ones according to the employed Friedman–Nemenyi statistical ranking. By further relating the model invariance properties with the proposed generalized metrics $F_{CmIoU}^R$, $F_{ImIoU}^R$ and $F_{general}^R$, in both part and scene segmentation, the winning models are the ones that incorporate all the invariance properties (either weak or strong), namely Rotation, Permutation, Size, and Density. It seems that it is advantageous to combine invariance properties, allowing the network to select the invariance it needs. Finally, in a balanced model evaluation scenario among accuracy, efficiency and robustness, the winning models in the proposed generalized metrics are the ones that are highly accurate, efficient and robust.

To sum up, an all-around performance evaluation of 3D point cloud segmentation models should be the de facto standard. The new upcoming neural network models in the field should not only be evaluated on their accuracy but also their efficiency and robustness. Additionally, local aggregation operator types should be studied further to better assess their efficacy in different network architectures. Finally, as we could not find extensive research on invariance properties, we believe that the experimental evaluation and validation of invariance properties in 3D point cloud learning is a research area with high potential to explore.