Tracing Hyperparameter Dependencies for Model Parsing via Learnable Graph Pooling Network

Authors: xiao  guo
vishal  asnani
sijia  liu
xiaoming  liu
params  num
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-15 07:45:41

Abstract: \textit{Model Parsing} defines the task of predicting hyperparameters of the generative model (GM), given a GM-generated image as the input. 
Since a diverse set of hyperparameters is jointly employed by the generative model, and dependencies often exist among them, it is crucial to learn these hyperparameter dependencies for improving the model parsing performance. 
To explore such important dependencies, we propose a novel model parsing method called Learnable Graph Pooling Network (LGPN), in which we formulate model parsing as a graph node classification problem, using graph nodes and edges to represent hyperparameters and their dependencies, respectively. 
Furthermore, LGPN incorporates a learnable pooling-unpooling mechanism tailored to model parsing, which adaptively learns hyperparameter dependencies of GMs used to generate the input image. 
Also, we introduce a Generation Trace Capturing Network (GTC) that can efficiently identify generation traces of input images, enhancing the understanding of generated images' provenances.
Empirically, we achieve state-of-the-art performance in model parsing and its extended applications, showing the superiority of the proposed LGPN.

Main paper: 
 introduction: 
 Generative Models (GMs) [22, 73, 11, 44, 33, 60, 32, 34, 50] , e.g., Generative Adversarial Networks (GANs), Variational Autoencoder (VAEs), and Diffusion Models (DMs), have gained significant attention, offering remarkable capabilities in generating visually compelling images. However, the proliferation of such Artificial Intelligence Generated Content (AIGC) can inadvertently propagate inaccurate or biased information. To mitigate such negative impact, various image forensics [52] methods have been proposed [62, 54, 20, 6, 24, 64, 31, 76, 56, 71, 1] . Alongside these defensive efforts, the recent work [2] defines a novel research topic called "model parsing", which predicts 37 GM hyperparameters using the generated image as the input, as detailed in Fig. 1a .Model parsing requires analyzing GM hyperparameters and gaining insights into origins of generated images, which facilitate defenders to develop effective countermeasures. For example, one can reasonably determine if there exists coordinated attacks [2] -two images are generated from the same GM that is unseen during the training, using predicted hyperparameters from the model parsing algorithm. In light of this, the previous method [2] introduces a clustering-based approach that achieves effective model parsing performance. However, this approach neglects the learning of hyperparameter dependencies. For instance, an inherent dependency exists between GM's layer number and parameter number, as GM's layer number is positively proportional to its parameter number. A similar proportional relationship exists between the number of convolutional layers and convolutional filters. In contrast, the use of the L1 loss is negatively correlated with the use of the L2 loss, as GMs typically do not employ both losses as objective functions simultaneously. We believe the neglect of such dependencies might cause a suboptimized performance. Therefore, in this work, we propose to use graph nodes and edges to explicitly represent hyperparameters and their dependencies, respectively, and then propose a model parsing algorithm that utilizes the effectiveness of Graph Convolution Network (GCN) [35, 61, 18, 51] to capture dependencies among graph nodes.Specifically, we first use training samples in the RED dataset [2] to construct a directed graph (Fig. 1b ).The directed graph, based on the label co-occurrence pattern, illustrates the fundamental correlation between different categories and helps prior GCN-based methods achieve remarkable performances in various applications [10, 7, 68, 46, 16, 58] . In this work, this directed graph is tailored to the model parsing -we define discrete-value and continuous-value graph nodes to represent hyperparameters, shown in Fig. 1c . Then, we use this graph to formulate model parsing as a graph node classification problem, in which the discrete-value graph node feature decides if a given hyperparameter is used in the given GM, and the continuous-value node feature decides which range the hyperparameter resides. This formulation helps obtain effective representations of hyperparameters and dependencies among them for the model parsing task, detailed in Sec. 3.1.To this end, we propose a novel model parsing framework called Learnable Graph Pooling Network (LGPN), which contains a Generation Trace Capturing Network (GTC) and a GCN refinement block (Fig. 2 ). Our GTC differs from neural network backbones used in State-of-The-Art (SoTA) forgery detection methods [62, 74, 63, 4, 63] , using down-sampling operations (e.g., pooling) gradually reduce the learned feature map resolution during the forward propagation. This down-sampling can cause the loss of already subtle generation traces left by GMs. Instead, our GTC leverages a high-resolution representation that largely preserves generation traces throughout the forward propagation (Sec. 3.2.1) . Therefore, the learned image representation from the GTC deduces crucial information (i.e., generation trace) of used GMs and benefits model parsing. Subsequently, this representation is transformed into a set of graph node features, along with the pre-defined directed graph, which are fed to the GCN refinement block. The GCN refinement block contains trainable pooling layers that progressively convert the correlation graph into a series of coarsened graphs by merging original graph nodes into supernodes. Then, the graph convolution is conducted to aggregate node features at all levels of graphs, and trainable unpooling layers are employed to restore supernodes to their corresponding children nodes. This learnable pooling-unpooling mechanism helpsLGPN generalize to parsing hyperparameters in unseen GMs and improves the GCN representation learning. In summary, our contributions are:⋄ We innovatively formulate model parsing as a graph node classification problem, using a directed graph to help capture hyperparameter dependencies for better model parsing performance.⋄ A learnable pooling-unpooling mechanism is introduced with GCN to enhance representation learning in model parsing and its generalization ability.⋄ We propose a Generation Trace Capturing Network (GTC) that utilizes high-resolution representations to capture generation traces, facilitating a deeper understanding of the image's provenance. ⋄ Extensive empirical results demonstrate the SoTA performance of the proposed LGPN in model parsing and identifying coordinated attacks. Additionally, the GTC's effectiveness is validated through CNN-generated image detection and image attribution tasks.! ! ! " ! ! #$! … " # % " % #$! … % ! ! GCN Refinement BlockModel Parsing 
related works: 
 Model Parsing Previous model parsing works [59, 30, 17, 3, 47] require prior knowledge of machine learning models and their inputs to predict model hyperparameters, and such predictions are primarily limited to architecture-related hyperparameters [17, 47] . In contrast, Asnani et al. [2] recently propose a technique to estimate 37 pre-defined hyperparameters covering loss functions and architectures by only leveraging generated images as inputs. Specifically, this work [2] designs FEN-PN that uses a clustering-based approach to estimate the mean and standard deviation of hyperparameters for network architecture and loss function types. Then, FEN-PN uses a fingerprint estimation network that is trained with four constraints to estimate the fingerprint for each image. These fingerprints are employed to predict hyperparameters. However, FEN-PN overlooks dependencies among hyperparameters, which cannot be adequately captured by the estimated mean and standard deviation. In contrast, we propose LGPN, using GCN to model dependencies among different hyperparameters, improving overall model parsing performance.Graph Convolution Neural Network (GCN) shows effectiveness in encoding dependencies among different graph nodes [35, 61, 18, 26, 28] , and in the computer vision community, directed graphs based on label co-occurrence patterns are used with GCN in tasks such as multi-label image recognition [10, 7, 68] , semantic segmentation [9, 29, 41, 16] , and person ReID and action localization [46, 65, 8, 58] . These works rely on original graph structures, whereas our method uses a pooling algorithm to modify this graph structure, which can benefit GCN's representation learning. Also, our GCN refinement block differs from Graph U-Net [19] in that it reduces the graph size by removing certain nodes. However, we formulate model parsing as a graph node classification task, where each node represents a specific hyperparameter, meaning no nodes should be discarded.Learning Image Generation Traces GMs leave particular traces in their generated images [43, 12] , which can be visual artifacts [72, 4] or through evident peaks in the frequency domain [74, 62] . These traces serve as important clues for image forensic tasks such as detection [12, 74, 62] , attribution [70, 49] and model parsing [2, 66, 67, 21] . Current methods [62, 74, 63, 4, 63, 57] use backbones like ResNet and XceptionNet that have high generalization abilities, and vision-language foundation models [55, 75, 23] also show effectiveness in detecting unseen forgeries. However, these prior methods often use backbones that rely on downsampling operations, such as convolutions with large strides and pooling, which capture global semantics but discard high-frequency details that contain critical generation traces. In contrast, we propose a Generation Trace Capturing network that mainly operates on a high-resolution representation for capturing such generation traces. Its effectiveness is shown in our experiment by comparing against recent detection methods that use pre-trained CLIP features [48] and the novel representation [63] , and competitive image attribution methods.  
method: 
 In this section, we first revisit some fundamental preliminaries in Sec. This section provides the problem statement of model parsing and its formulation as a graph node classification task with the Graph Convolutional Network (GCN).Revisiting Model Parsing Given an input image I ∈ R 3×W ×H generated by a GM (i.e., G), the model parsing algorithm generates three vectors (y d ∈ R 18 , y c ∈ R 9 , and y l ∈ R 10 ) as predictions of G different hyperparameters used in the G. Specifically, defined by the previous work [2] , these predictable G hyperparameters include discrete and continuous architecture hyperparameters, as well as loss functions, which are denoted as y d , y c , and y l , respectively. For y d and y l , each element is a binary value representing if the corresponding feature is used or not. Each element of y c is the value of certain continuous architecture hyperparameters, such as the layer number and parameter number. As these hyperparameters are in different ranges, we normalize them into [0, 1], same as the previous work [2] . Predicting y d and y l is a classification task while the regression is used for y c . Detailed definitions are in Tab. 4, 5, and 6 of the Supplementary. We augment the previous model parsing dataset (e.g., RED116 [2] ) with different diffusion models such as DDPM [27] , ADM [15] and Stable Diffusions [50] , increasing the spectrum of GMs. Also, we add real images on which these GMs are trained into the dataset. In the end, we collect 140 GMs in total and denote such a collection as the RED140 dataset. Details are in the Supplementary Sec. D.We design a graph structure of model parsing, where graph nodes and edges represent hyperparameters and their dependencies, respectively. We first use conditional probability P (L j |L i ) to denote the probability of hyperparameter L j occurrence when hyperparameter L i appears. We count the occurrence of such pairs in the RED140 to construct the matrix G ∈ R C×C , where C and G ij denotes the number of graph nodes and the conditional probability of P (L j |L i ), respectively. Next, we apply a fixed threshold τ to remove edges with low correlations in G and then obtain a directed graph, denoted as A ∈ R C×C , where A ij indicates if there exists an edge between node i and j.Specifically, as depicted in Fig. 1c EQUATIONwhere h l i represents the i-th node feature in graph A. W l and b l are weight and bias terms.In this section, we detail the Generation Trace Capturing Network (GTC) and GCN refinement block-two major components used in the proposed LGPN, as depicted in Fig. 2 .As shown in Fig. 3 , GTC uses one branch (i.e., ResNet branch) to propagate the original image information. Meanwhile, the other branch, denoted as high-res branch, harnesses the high-resolution representation that helps detect high-frequency generation artifacts stemming from various GMs. More formally, three separate 2D convolution layers with different kernel sizes (e.g., 3 × 3, 5 × 5 and 7 × 7) are utilized to extract feature maps of I. We concatenate these feature maps and feed them to the fusion layer -the 1 × 1 convolution for the channel dimension reduction. Then, we obtain the feature map F h ∈ R D×W ×H , with the same resolution as I. After that, we proceed F h to a dual-branch backbone. Specifically, we upsample intermediate features output from each ResNet block and incorporate them into the high-res branch, as depicted in Fig. 3 . The high-res branch also has four different convolution blocks (e.g., Φ b with b ∈ {1 . . . 4}), which do not employ down-sampling operations, such as the 2D convolution with large strides or pooling layers. Then, intermediate feature maps throughout the high-res branch possess the same resolution as F h .The ResNet branch and high-res branch output feature maps are concatenated and then passed through an AVGPOOL layer. Then, we obtain the final learned representation, f ∈ R D , that captures generation artifacts of the input image I. Subsuqently, we learn C independent linear layers, i.e., Θ = {θ C-1 i=0 } to transform f into a set of graph node features H = {h 0 , h 1 , ..., h (C-1) }, where H ∈ R C×D and h i ∈ R 1×D (i ∈ {0, 1, ..., C -1}). We use H to denote graph node features of the directed graph (i.e., graph topology) A ∈ R C×C .The GCN refinement block has a learnable pooling-unpooling mechanism that progressively coarsens the original graph A 0 into a series of coarsened graphs, i.e., A 1 , A 2 ...A n , and graph convolution is conducted on graphs at all different levels. Specifically, such a pooling operation is achieved by merging graph nodes, namely, via a learned matching matrix M. Also, correlation matrices of different graphs, denoted as A l2 , which are learned using MLP layers, which are also influenced by the GM responsible for generating the input image. This further emphasizes the significant impact of GM on the correlation graph generation process.Learnable Graph Pooling Layer First, A l ∈ R m×m and A l+1 ∈ R n×n denote directed graphs at l th and l + 1 th layers, with m and n (m ≥ n) graph nodes, respectively. An assignment matrix M l ∈ R m×n converts A l to A l+1 as:EQUATIONAlso, we use H l ∈ R m×D and H l+1 ∈ R n×D to denote graph node features of A l and A l+1 , respectively. Therefore, we can use M l to perform the graph node aggregation operation via:EQUATIONFor simplicity, we use f GCN to denote the mapping function imposed by a GCN block that has multiple GCN layers. Assuming the q-th and l-th graph layer are the first and last layer of the GCN block, then we have:EQUATION) Ideally, the learnable pooling operation should be dependent on the learned representation of the input image, and such representation is converted into H l . Therefore, we employ a trainable weight W m to transform H l into the assignment matrix M l :EQUATION)where α is set as 1e9. Values of the resultant M l are approximately equal to 0 or 1. It is worth noting that prior works [39, 40] also adopt techniques similar to Eq. 5 for making the thresholding operation differentiable. ! !" # = ! ! " (! ! " ) # A B C1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 Learnable Unpooling Layer We perform the graph unpooling operation that progressively restores pooled graphs to the graph at the original resolution for the graph node classification task. As shown in Fig. 2 , to avoid confusion, we use H and V to represent the graph node feature on the pooling and unpooling branches, respectively. The correlation matrix on the unpooling branch is denoted by A ′ ,! !" # = ! ! " (! ! " ) #EQUATIONwhere A ′ l and A ′ l-1 are the l th and l -1 th layers in the unpooling branch, respectively. Finally, we use the refined feature V for model parsing.Discussion This learnable pooling-unpooling mechanism offers three distinct advantages. First, each supernode in the coarsened graph serves as the combination of features from its children nodes, and graph convolutions on supernodes have a large receptive field for aggregating features. Secondly, the learnable correlation models hyperparameter dependencies dynamically based on generation artifacts of input image features (e.g., f ). Lastly, learned correlation graphs A vary across different levels, helping address the over-smoothing issue commonly encountered in GCN learning [38, 45, 5] .We jointly train our method with three objective functions. Graph node classification loss (e.g., L graph ) encourages each graph node feature to predict the corresponding hyperparameter label. Artifacts isolation loss (e.g., L iso ) helps the LGPN only parse the hyperparameters for generated images, and hyperparameter hierarchy constraints (e.g., L hier ) imposes hierarchical constraints among different hyperparameters while stabilizing the training.Training Samples We denote a training sample as {I, y}, in which y = {y d , y c , y l } = {y 0 , y 1 , ..., y (C-1) } is annotations of C graph nodes for G parsed hyperparameters as introduced in Sec. 3.1. Specifically, y c is assigned as 1 if the sample has c-th hyperparameter and 0 otherwise, where c ∈ {0, 1, ..., C -1}. Details are in Supplementary Sec. B.Graph Node Classification Loss Given the image I, we convert the refined feature V into the predicted score vector, denoted as s = {s 0 , s 1 , ..., s (C-1) }. We employ the sigmoid activation to retrieve the probability vector p = {p 0 , p 1 , ..., p (C-1) }, namely, p c = SIGMOID(s c ). Then, we have:EQUATIONHyperparameter Hierarchy Prediction Fig. 4 shows that different hyperparameters can be grouped, so we define the hyperparameter hierarchy assignment M s to reflect this inherent nature. More details of such the assignment are in Supplementary Sec. A. Suppose, at the l th layer, we minimize the L 2 norm of the difference between the predicted matching matrix M l and M s l , EQUATIONWe denote the image-level binary label as y img and use p img as the probability that I is a generated image. Then we have:EQUATIONIn summary, our joint training loss function can be written asL all = λ 1 L graph + λ 2 L hier + λ 3 L iso ,where λ 1 and λ 2 equal 0 when I is real.Inference As Fig. 4b , we use the discrete-value graph node feature to perform the binary classification to decide the presence of given hyperparameters. For the continuous architecture hyperparameter, we first concatenate n corresponding node feature and train a linear layer to regress it to the estimated value. Empirically, we set n as 3 and show this concatenated feature improves the robustness in predicting the continuous value (see Supplementary Tab. 7). 
model parsing: 
 Setup Our experiment utilizes RED140 dataset. In RED140, each GM contains 1, 000 images, resulting in a total of 140, 000 generated images that encompass a wide range of semantics, including objects, handwritten digits, and human faces. Also, RED140 has real images on which these GMs are trained, such as CelebA [42] , MNIST [14] , CIFAR10 [36] , ImageNet [13] , facades [77] , edges2shoes [77] and, apple2oranges [77] . We follow the protocol of [2] contains more images from diffusion models than RED116. The complete performance comparison on RED116 is reported in Tab. 5c. Lastly, we replace MLP with the GCN refinement block, which is the full model of LGPN (line #6) and performs better on all metrics, demonstrating that the GCN refinement block indeed refines graph node features and makes a more effective model parsing head than MLP layers.Hyperparameter Dependency Capturing Tab. 2a reports model parsing performance using different GCN variants as the model parsing head. Overall, the proposed GCN refinement block, which refines graph node features to better capture hyperparameter dependencies, helps achieve the best model parsing performance. By comparing lines #1 and #2, we conclude that replacing MLP layers with the GCN refinement benefits the model parsing task. After all, GCN leverages structural information of the pre-defined graph, improving the learning of correlations among different hyperparameters. Next, we use Graph attention networks [61] (Att-GCN) at line #3, which employs the attention mechanism to update the graph node feature. As a result, Att-GCN achieves 1.1% higher F1 than stacked GCN (e.g., line #2) on predicting discrete architecture parameters. Lastly, line #4 uses Graph U-Net [19] , which has a similar pooling-unpooling mechanism to our GCN refinement block, but its pooling operation discards graph nodes in the previous layer for forming a smaller graph. Using the Graph U-Net as the model parsing head produces the worse performance on discrete architecture hyperparameters -4.3% lower than Att-GCN (#3). We believe this is because dropping graph nodes is not optimal for model parsing, in which all graph nodes represent corresponding hyperparameters and are important for the final performance. In contrast, LGPN merges children nodes into the supernode, so all node information in the previous layer remains in the smaller pooled graph, helping achieve the best performance on discrete hyperparameters in Tab. 2a. On the other hand, continuous hyperparameter prediction can also benefit from the GCN refinement block. In Tab. 2b, LGPN shows L1 errors of 0.147 and 0.081 on Layers Num. and Param. Num. respectively, whereas the model with MLP layers only achieves 0.149 and 0.148, respectively. This is because the GCN refinement learns the dependency between Param. Num. and Layer Num., which aligns with the observation that models with more layers typically have more parameters. Therefore, modeling such dependencies ultimately decreases the L1 error in Param. Num. prediction. Likewise, when predicting Conv. Layer Num. and Filters Num., the GCN refinement achieves 0.137 and 0.149 L1 error, whereas GTC with MLP layers have 0.151 and 0.161 L1 error.GM-dependent Graph Fig. 5a shows that learned correlation graphs (A ′ 0 ) from image pairs exhibit significant similarity when both images belong to the same unseen GM. This result demonstrates that our correlation graph largely depends on the GM instead of image contents, given that we have Method Acc. AUC Pd@5% HiFi-Net [24] 72 different contents (e.g., human face and objects) in unseen GMs from each test. In addition, we empirically observe our method remains robust when using different thresholds to construct the graph, which is detailed in the Supplementary Tab. 9. However, the performance declines more when the threshold increases to 0.65, which causes the correlation graph to have very sparse connectivities, hindering the learning of hyperparameter dependencies.Objective Functions Analysis Fig. 5b shows the ablation of different training objective functions introduced in Sec. 3.3. Line #1 only optimizes the LGPN with L grpah , producing results comparable to simply stacking GCN with the attention mechanism (e.g., line #3 in Tab. 2a). Lines #2 and #3 show contributions from L iso and L hier , which improve the performance by 1.1% and 2.0% than only using L grpah , on predicting discrete architecture hyperparameters, respectively. This is because L iso and L hier make the LGPN concentrate on learning generation traces from generated images and impose the hierarchical constraints, respectively. RED116 Results Fig. 5c reports that LGPN achieves the best performance on all metrics in RED116 dataset. Interestingly, LGPN obtains 79.5% F1 score on predicting discrete architecture hyperparameters in RED140 (Tab. 1), whereas only 74.3% in RED116, which does not contain diffusion model generated images. We believe this is because all diffusion models share similar architectures, and such similarities make the prediction of their architecture hyperparameters easier.We evaluate the proposed LGPN on coordinated attacks detection [2] , which aims to classify whether two fake images are generated from the same GM or not. This is achieved by computing the cosine similarity between predicted hyperparameters from given images. Specifically, we evaluate coordinated attack detection on RED140 in a 4-fold cross-validation. In each fold, the train set has 125 GMs, and the test set has 30 GMs where 15 GMs are exclusive (unseen) from the train set and 15 GMs are seen in the train set. We generate 89, 000 training image pairs from train-set GMs for training 1, 000 image pairs for validation. We generate 25, 000 test image pairs from test-set GMs, and the average of the 4 folds is used as the final result. For the measurement, we use accuracy, AUC, and detection probability at a fixed false alarm rate (Pd@FAR) e.g., Pd@5% as metrics. Specifically, aside from FEN-PN [2] , we also compare with the recent work HiFi-Net [24] that show SoTA results in attributing different forgery methods. Specifically, we train HiFi-Net to classify 125 GMs and take learned features from the last fully-connected layer for coordinated attack detection. The performance is reported in Tab. 3a, which demonstrates that our proposed method surpasses both prior works. We observe the HiFi-Net performs much worse on AUC than the model parsing baseline (e.g., GTC w S-GCN) and FEN-PN. Furthermore, Tab. 3b shows the FEN-PN and LGPN perform comparably as HiFi-Net on seen GMs (first two bar charts), yet much better than HiFi-Net when images are generated by unseen GMs (last three bar charts). Lastly, LGPN has a better Pd@5% performance than other methods.To study GTC's ability to identify generation traces, we adopt it for CNN-generated image detection and image attribution. For a fair comparison, no model parsing dataset is used for the pre-training.We append fully-connected layers at the end of GTC to obtain a binary detector that distinguishes CNN-generated images from real ones (detailed in supplementary Average Precision (AP) Accuracy (Acc.) [62] [24][53][48] [57] (a)CelebA LSUN Metric: Acc(%) PRNU [43] 86.61 67.84 Attr. [70] 99.43 98.58 FEN-PN [2] 99 Fig. 8 ). We follow the experiment setup from prior works [62, 48, 57] , which trains the model on images generated by ProGAN [32] , and test it on images generated by 11 unseen forgery methods, using average precision (AP) and accuracy for the measurement. Fig. 6a reports that our method achieves premium detection performance compared to prior methods. The second-best method, NPR [57] , focuses on learning local up-sampling artifacts from pixels, helping detect images from unseen GMs. Instead, GTC's high-resolution representation more effectively exploits both local and global traces left from generation processes, obtaining a better performance.Image Attribution Tab. 6b and Tab. 6c report the image attribution performance in two different protocols. Specifically, we define the protocol 1 based on the previous work [2] , which trains methods on 100, 000 real and 100, 000 images generated from four different GMs (e.g., SNGAN, MMDGAN, CRAMERGAN, and ProGAN), conducting a five-way classification (i.e., 4 GMs and real). In protocol 2, we add two more generative methods (e.g., styleGANv2, styleGANv3), resulting in a more challenging task: a 7-way classification task, classifying whether the image is real samples or generated by which one of 6 GMs. As depicted in Supplementary Fig. 8 , we apply fully-connected layers on the top of GTC, which leverages the final representation of the generation trace for the multi-category classification task, e.g., image attribution. Our proposed method achieves the best image attribution performance on CelebA and competitive results on LSUN, indicating that GTC has a promising ability to capture the generation trace. 
conclusion: 
 In this study, our focus is model parsing, which predicts pre-defined hyperparameters of a GM given an input image. We propose a novel method that incorporates a learnable pooling-unpooling mechanism devised for the model parsing task. This mechanism serves multiple purposes: modeling GM-dependent hyperparameter dependencies, expanding the receptive field of graph convolution, and mitigating the over-smoothing issue in GCN learning. In addition, we provide the Generation Trace Capturing network to capture generation artifacts, which proves effective in two different image forensic applications: CNN-generated image detection and coordinated attacks detection.Limitation We empirically observe two limitations in our proposed method, both of which can be interesting directions for future research. First, while our model parsing approach delivers excellent performance on the RED140 dataset, it is worth exploring its effectiveness on specific GMs that fall outside our dataset scope. This investigation would provide valuable insights into the generalizability of our method to a broader range of GMs. Secondly, we formulate the model parsing task as a closed-set classification problem, which limits its ability to predict undefined hyperparameters, e.g., LeakyReLU. One interesting solution could be adding a few new graph nodes for undefined hyperparameters while keeping original graph nodes -the learned dependency between graph nodes representing ReLU and LeakyReLU should be high.Broader Impact We strongly advocate for the machine learning and computer vision community to actively work towards mitigating potential negative societal implications of research. It is possible that generated face images used in training could leak the identity information of subjects who have not provided consent forms. We shall strive to work on real face imagery whose collection is reviewed by an Institutional Review Board (IRB).In this supplementary, we provide:⋄ Predictable hyperparameters introduction.⋄ Training and implementation details.⋄ Additional results of model parsing and CNN-generated image detection.⋄ The construction of RED140 dataset.⋄ Hyperparameter ground truth and the model parsing performance for each GM 
broader impacts: 
 Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?Answer: [Yes] Justification: We include societal impact contents at the end of our work, following NeurIPS code of ethics. Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)? Answer: [NA] Justification: The dataset consists of digital images, which do not need safeguards. This is not applicable to our work. Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort. 12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected? Answer: [Yes] Justification: Both the RED116 and RED140 datasets used in this work are publicly available and can be used for research purposes. Guidelines:• The answer NA means that the paper does not use existing assets.• The authors should cite the original paper that produced the code package or dataset.• The authors should state which version of the asset is used and, if possible, include a URL. • The name of the license (e.g., CC-BY 4.0) should be included for each asset.• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided. • If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset. • For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. • If this information is not available online, the authors are encouraged to reach out to the asset's creators. 
new assets: 
 Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?Answer: [Yes]Justification: We will release the dataset and code based on the acceptance. They are well-documented.Guidelines:• The answer NA means that the paper does not release new assets.• Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc. • The paper should discuss whether and how consent was obtained from people whose asset is used. • At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file. 
crowdsourcing and research with human subjects: 
 Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?Answer: [NA] Justification: Our work does involve crowdsourcing and human subjects' biometric information.Guidelines:• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. • Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. • According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector. 
institutional review board (irb) approvals or equivalent for research with human subjects: 
 Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?Answer: [No]  
 
 Appendix: We investigate 37 hyperparameters that exhibit the predictability according to Asnani et al. [2] . These hyperparameters are categorized into three groups: (1) Loss Function (Tab. 4), (2) Discrete Architecture Hyperparameters (Tab. 5), (3) Continuous Architecture Hyperparameters (Tab. 6). We report our proposed method performance of parsing hyperparameters in these three groups via Fig. 7a , Fig. 7b , and Fig. 7c , respectively. Moreover, in the main paper's Eq. 8 and Fig. 4a , we employ the assignment hierarchy M s to group different hyperparameters together, which supervises the learning of the matching matrix M. The construction of such the M s is also based on Tab. 4, 5, and 6, which not only define three coarse-level categories, but also fine-grained categories such as pixel-level objective (loss) function (e.g., L1 and MSE) in Tab. 4, and normalization methods (e.g., ReLu and Tanh) as well as nonlinearity functions (e.g., Layer Norm. and Batch Norm.) in Tab. 5.Training Details Given the directed graph A ∈ R C×C , which contains C graph nodes. We empirically set C as 55, as mentioned in the main paper Sec. 3.3. In the training, LGPN takes the given image I and output the refined feature V ∈ R 55×D , which contains learned features for each graph node, namely, V = {v 0 , v 1 , ..., v 54 }. As a matter of fact, we can view V as three separate sections: V l = {v 0 , v 1 , ..., v 9 }, V d = {v 10 , v 11 , ..., v 27 }, and V c = {v 28 , v 29 , ..., v 54 }, which denote learned features for graph nodes of 10 loss functions (e.g., L1 and MSE), 18 discrete architecture hyperparameter (e.g., Batch Norm. and ReLU), and 9 continuous architecture hyperparameter (i.e., Parameter Num.), respectively. Note V c represents learned features of 9 continuous architecture hyperparameters because each continuous hyperparameter is represented by 3 graph nodes, as illustrated in Fig. 1c of the main paper. Furthermore, via Eq. 7 in the main paper, we use V to obtain the corresponding probability score p = {p 0 , p 1 , ..., p 54 } for each graph node. Similar to V, this p can be viewed as three sections: p l ∈ R 10 , p d ∈ R 18 and p c ∈ R 27 for loss functions, discrete architecture hyperparameters, continuous architecture hyperparameters, respectively. In the end, we use p to help optimize LGPN via the graph node classification loss (Eq. 7). After the training converges, we further apply individual fully connected layers on the top of frozen learned features of continuous architecture hyperparameters (e.g., V c ). via minimizing the L 1 distance between predicted and ground truth value.In the inference (the main paper Fig. 4b ), for loss function and discrete architecture hyperparameters, we use output probabilities (e.g., p l and p d ) of discrete value graph nodes, for the binary "used v.s. not" classification. For the continuous architecture hyperparameters, we first concatenate learned features of corresponding graph nodes. We utilize such a concatenated feature with pre-trained, fully connected layers to estimate the continuous hyperparameter value.Model Parsing Implementation Details Denote the output feature from the Generation Trace Capturing Network as f ∈ R 2048 . To transform f into a set of features H = {h 0 , h 1 , ..., h 54 } for the 55 graph nodes, 55 independent linear layers (Θ) are employed. Each feature h i is of dimension R 512 . The H is fed to the GCN refinement block, which contains 5 GCN blocks, each of which has 2 stacked GCN layers. In other words, the GCN refinement block has 10 layers in total. We use the correlation graph A ∈ R 55×55 (Fig. 10 ) to capture the hyperparameter dependency and during the training the LGPN pools A into A 1 ∈ R 18×18 and A 2 ∈ R 6×6 as the Fig. 2 of the main paper. The LGPN is implemented using the PyTorch framework. During training, a learning rate of 3e-2 is used.The training is performed with a batch size of 400, where 200 images are generated by various GMs and 200 images are real. Implementation Details for Detection and Attributions We validate GTC's effectiveness in capturing the generation trace in Fig. 6 . Specifically, Fig. 8 shows the detailed implementation. We employ FC layers to convert output feature f ∈ R 2048 to f det. ∈ R 2 and f att. ∈ R 5 for CNN-generated image detection and image attribution respectively.We report detailed performance on RED116 via Tab. 8, demonstrating that our proposed LGPN achieves the best performance on both datasets. Also, in Fig. 5a the correlation graph similarities among different GMs in the first test set. In this section, we offer a similar visualization (e.g., Fig. 9 of the supplementary) for other test sets. In the main paper's Sec 3.3, we use n graph nodes for each continuous hyperparameter and n is set as 3. Tab. 7 shows the advantage of choice, which shows the lowest L 1 regression error is achieved when n is 3. The real-image category contains many real-image datasets that GMs are trained on [33, 32, 13, 69, 25, 36, 37] . (c) The GM has various image resolutions.In this section, we provide an overview of the RED140 dataset, which is used for both model parsing and coordinated attack detection. Note that, for the experiment reported in Tab. ?? of the supplementary, we follow the test sets defined in RED116 [2] . When we construct RED140, we use images from ImageNet, FFHQ, CelebHQ, CIFAR10, and LSUN as the real-images category of RED140. We exclude GM that is not trained in the real-image category of RED140. In addition, both RED116 and RED140 contain various image content and resolution, and the details about RED140 are uncovered in Fig. 12 of the supplementary. For test sets (Tab. 12 of the supplementary), we follow the dataset partition of RED116, excluding the GMs that are trained on real images, which RED140 does have. For example, JFT-300M is used to train BigGAN, so we remove BIGGAN_128, BIGGAN_256 and BIGGAN_512 in the first, second, and third test sets.In this section, we report the ground truth vector of different hyperparameters of each GM contained in the RED140. Specifically, Tab. 13 and Tab. 14 report the loss function ground truth vector for each GM. Tab. 15 and Tab. 16 report the discrete architecture hyperparameter ground truth for each GM. Tab. 17 and Tab. 18 report the continuous architecture hyperparameter ground truth for each GM. The detailed model parsing performance on each GM is reported in the supplementary's Fig. 11 .Table 13 : Ground truth Loss Function feature vector used for prediction of loss type for all GMs. The loss function ground truth is in (Tab. 4).EQUATIONTable 14 : Ground truth Loss Function feature vector used for prediction of loss type for all GMs. The loss function ground truth is in (Tab. 4). Justification: We discuss the potential harms and societal impact at the end of our work, following NeurIPS code of ethics.GM L 1 L 2 MSE MMD LS WGAN KL Adversarial Hinge CE IDDPM_32 0 0 1 0 0 0 0 0 0 0 IDDPM_64 0 0 1 0 0 0 0 0 0 0 IDDPM_256 0 0 1 0 0 0 0 0 0 0 ILVER_256 0 0 1 0 0 0 0 0 0 0 Image_GPT 0 0 0 0 0 0 0 0 0 1 INFOGAN 0 0 1 0 1 0 0 0 0 1 LAPGAN 0 0 0 0 1 0 0 0 0 0 LDM 0 0 1 0 0 0 0 0 0 0 LDM_CON 0 0 1 0 0 1 0 0 0 0 Lmconv 0 0 0 0 0 0 0 0 0 1 LOGAN 1 1 0 0 0 0 0 1 0 0 LSGAN 0 0 1 0 0 0 0 0 1 0 MADE 0 0 0 0 0 0 0 0 0 1 MAGAN 0 0 1 0 0 0 0 0 0 0 MEMGAN 0 0 0 0 1 0 0 0 0 0 MMD_GAN 1 0 0 1 0 0 0 0 0 0 MRGAN 0 0 1 0 1 0 0 0 0 0 MSG_STYLE_GAN 0 0 0 0 1 0 0 0 0 0 MUNIT 1 0 0 0 1 0 0 0 0 0 NADE 0 0 0 0 0 0 0 0 0 1 OCFGAN 0 0 0 1 0 0 0 0 1 0 PGD 1 1 0 0 0 0 0 0 0 0 PIX2PIX 1 0 0 0 1 0 0 0 0 0 PixelCNN 0 0 0 0 0 0 0 0 0 1 PixelCNN++ 0 0 0 0 0 0 0 0 0 1 PIXELDA 0 0 0 0 1 0 0 0 1 1 PixelSnail 0 0 0 0 0 0 0 0 0 1 PNDM_32 0 0 1 0 0 0 0 0 0 0 PNDM_256 0 0 1 0 0 0 0 0 0 0 PROG_GAN 0 0 0 0 0 1 0 0 1 0 RGAN 0 0 0 0 0 1 0 0 0 0 RSGAN_HALF 0 0 0 0 0 0 0 0 0 1 RSGAN_QUAR 0 0 0 0 0 0 0 0 0 1 RSGAN_REG 0 0 0 0 0 0 0 0 0 1 RSGAN_RES_BOT 0 0 0 0 0 0 0 0 0 1 RSGAN_RES_HALF 0 0 0 0 0 0 0 0 0 1 RSGAN_RES_QUAR 0 0 0 0 0 0 0 0 0 1 RSGAN_RES_REG 0 0 0 0 0 0 0 0 0 1 SAGAN 0 0 0 0 1 0 0 0 0 0 SCOREDIFF_256 0 0 1 0 0 0 0 0 0 0 SDEdit_256 0 0 1 0 0 0 0 0 0 0 SEAN 1 0 0 0 1 0 0 0 0 0 SEMANTIC 0 1 0 0 1 0 0 0 0 0 SGAN 0 0 0 0 1 0 0 0 0 1 SNGAN 0 0 0 0 1 0 0 1 0 0 SOFT_GAN 0 0 0 0 1 0 0 0 0 0 SRFLOW 1 0 0 0 0 0 0 0 0 1 SRRNET 0 1 1 0 1 0 0 0 0 1 STANDARD_VAE 0 0 0 0 0 0 1 0 0 1 STARGAN 1 0 0 0 1 0 0 0 0 1 STARGAN_2 1 0 0 0 1 0 0 0 0 0 STA_DM_15 0 0 1 0 0 0 0 0 0 0 STA_DM_21 0 0 1 0 0 0 0 0 0 0 STA_DM_XL 0 0 1 0 0 0 0 0 0 0 STGAN 1 0 0 0 1 1 0 0 0 0 STYLEGAN 0 1 0 0 0 1 0 0 0 0 STYLEGAN_2 0 1 0 0 1 0 0 0 1 0 STYLEGAN2_ADA 0 1 0 1 1 0 0 0 1 0 SURVAE_FLOW_MAXPOOL 0 0 0 0 0 0 1 0 0 1 SURVAE_FLOW_NONPOOL 0 0 0 0 0 0 1 0 0 1 TPGAN 1 0 0 0 0 1 0 0 0 0 UGAN 0 0 0 0 1 0 0 0 0 0 UNIT 0 0 0 0 1 0 1 0 0 0 VAE_field 0 0 0 0 0 0 1 0 0 1 VAE_flow 0 0 0 0 0 0 1 0 0 1 VAEGAN 1 0 0 0 1 0 1 0 0 0 VDVAE 0 0 0 0 0 0 1 0 0 1 WGAN 0 0 0 0 0 1 0 0 0 0 WGAN_DRA 0 0 1 0 0 1 0 0 0 0 WGAN_WC 0 0 0 0 0 1 0 0 0 0 WGANGP 0 1 0 0 0 1 0 0 0 0 YLG 0 0 0 0 0 1 0 0 0 0Guidelines:• The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.• If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. • The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).We adhere to naming conventions from the previous work[2], as the pie chart of Fig.1b, where AA, AR, and NF represent Adversarial Attack models, Auto-Regressive models, and Normalizing Flow models, respectively.A l-th layer graph has nodes and connectivities (e.g., correlations), and we use A l to denote the l-th layer graph or only its correlations. 


Decision: This paper considers the model parsing task that predicts hyperparameters of the generative models through an input image. Compared to the existing work, this paper considers more generative models in the training set (e.g., diffusion models) and their dependencies via directed graphs. The reviewers recognize the strengths in the following aspects: 1) the considered problem is interesting and novel (Reviewers born, 6bSd, Q98w); 2) the approach is reasonable and practical (Reviewers nGEg, born, 6bSd); and 3) the proposed method is effective in terms of comparison performance (Reviewers nGEg, born, 6bSd, Q98w).

The authors have also addressed a number of concerns raised by the reviewers in the rebuttal and during the discussion period, such as the relationship and difference between the proposed method and the related works, the time cost as the types of hyperparameters increase, how the proposed method aids in the detection of coordinated attacks, the distinction between the two datasets, the sensitivities of hyperparameters, etc. These clarifications and supplementary experimental results should be reflected in the revised version.

All reviewers lean to accept this paper. However, some concerns not fully addressed (e.g., LGPN may not be able to be directly applied to the new task environment raised by Reviewer nGEg) can be further explored to improve the generalization ability.

Reviews: review: paper_summary: paper_summary: This paper solves the model parsing task that requires models to predicting hyperparameters of the generative models (GMs) through one input image. The proposed model LGPN predict hyperparameters and their dependencies via directed graphs. LGPN incorporates a learnable pooling-unpooling mechanism to convert this task as a node classification problem. As stated in paper, LGPN achieves state-of-the-art results in model parsing and some extended applications like coordinate attack detection.
strength_weakness: strength_weakness: 1. The extensibility of LGPN can be limited in some aspects. For example, if a class of generative models that include new activation functions is proposed, LGPN may not be able to be directly applied to the new task environment.
2. Efficiency of the proposed method is an aspect that needs to be discussed. As the types of hyperparameters increase, the time cost of the algorithm may increase as well.
questions: questions: 1.	One concern is about the relation to prior works. The authors can better illustrate the contributions by discussing the relationship and difference between LGPN and the papers [1][2]. The paper [1] uses a meta model to predict model attributes from input data, and the paper [2] regards generative models as distributions of functions and captures model hyperparameters and architectures through the latent vector.
2.	How can we predict the continuous parameters of activation functions like leaky ReLU?
3.	Question about the problem setting. Will using more input images as context improves the accuracy in results?

[1] Oh S J, Schiele B, Fritz M. Towards reverse-engineering black-box neural networks[J]. Explainable AI: interpreting, explaining and visualizing deep learning, 2019: 121-144.

[2] Dupont, Emilien, Yee Whye Teh, and Arnaud Doucet. "Generative models as distributions of functions." arXiv preprint arXiv:2102.04776 (2021).
limitations: limitations: The ability of LGPN to infer input images generated with unseen or undefined model architectures is still unclear. For example, would LGPN predicts the leaky ReLU activation in the test environment if it is not appeared in the training data?
paper_summary: paper_summary: This paper focuses on the problem of model parsing, which aims to analyze the hyperparameters of the model that generates a given image. Different from existing model parsing methods, the proposed Learnable Graph Pooling Network (LGPN) exploits the dependencies among hyperparameters to better perform model parsing. In LGPN, the features are extracted by Generation Trace Capturing Network (GTC), which fuses the outputs of the high-res branch and the ResNet branch to preserve high-frequency generation artifacts. The performance of LGPN is compared with baseline methods and a recently proposed model parsing method on the RED140 dataset. The effectiveness of the proposed method is verified by the experimental results.
strength_weakness: strength_weakness: 1. The effectiveness of GTC can be further verified if different backbones are also compared with GCN refinement as the MP head.
2. It is unclear whether the ground truth of the hyperparameter hierarchy assignment is constructed based on the entire dataset or just the training data.
3. The quality of the paper can be improved if the expressions are polished more carefully, especially in the experimental part.
questions: questions: 1. Is the ground truth of the hyperparameter hierarchy assignment constructed based on the entire dataset or just the training data?
2. It has been shown that the hyperparameter hierarchy prediction loss and artifacts isolation loss is important to the performance. Will the performance of the proposed method drop noticeably if: 1) the hyperparameter hierarchy in the test set differ greatly from the training set; 2) some generated images are mistakenly treated as real images in the training set.
limitations: limitations: The limitations are discussed in the conclusion part. There is no potential negative societal impact.
paper_summary: paper_summary: This paper examines the challenge of predicting the hyperparameters of a generative model from its output, specifically a generated image. The proposed approach introduces a learnable graph pooling technique, framing the problem as a node classification task. Experiments across several tasks demonstrate the effectiveness of this method.
strength_weakness: strength_weakness: -  It remains unclear how the proposed method aids in the detection of coordinated attacks.

- Additional demonstrations or examples of predicted hyperparameters would provide clarity on the effectiveness of the proposed method.
questions: questions: See weakness.
limitations: limitations: The authors have adequately addressed the limitations.
paper_summary: paper_summary: This paper studies the model parsing (MP) task [1], which predicts the hyperparameters of the generative model with a generated image input. The authors propose a Learnable Graph Pooling Network (LGPN) method to explore hyperparameter dependencies in the generative model. The LGPN consists of two core designs: the Generation Trace Capturing Network (GTC) and the learnable pooling-unpooling graph mechanism called the GCN Refinement Block. Extensive experiments validate the effectiveness of the method.
strength_weakness: strength_weakness: Despite the strengths mentioned above, there are some concerns listed as follows:
1. The authors provide a new dataset, RED140, which removes and collects some samples. Please clarify the distinction between these two datasets. Is the ground-truth feature vector for Discrete Architecture hyperparameters newly added to supervise the model training? 
2. The work mainly compares with FEN-PN. [1]. The experimental results on the RED116 dataset in Fig. 5(c) just report the F1 score and L1 error performance. [1] provides more evaluation metrics (P-value, Corr. Coef, Slope, Acc., etc.) and tests more dataset types and GM models, such as continuous type, discrete type, and loss type datasets, as well as face and non-face GMs. These analyses provide more evidence to show the method's generalizability and robustness. By comparison, the proposed method needs more experimental evidence.
3. From Fig. 6 (b), the performance of the proposed method has a slight drop compared with FEN-PN [1]. What happens?
4. In lines 30-32, there is a motivation statement for hyperparameter dependency modeling: ”For instance, an inherent dependency exists between GM’s layer number and parameter number.” The authors do not provide such analysis and discussion in the experiments. The discussion on hyperparameter dependency analyses (what and how dependents?) is insufficient. 
5. About the correlation graph construction (lines 125–126), “we count the occurrence of such pairs in the RED140 to retrieve the matrix G\in R^{C \times C}, where C is the hyperparameter number.” The method approach appears to overuse the dataset information in advance and is unfair when compared to FEN-PN [1].
6. There are some parameters, such as the thresholds to remove relations in the graph or binary classification; how about the sensitivities of these parameters?
questions: questions: Please see the comments in Weakness. I'm willing to change my rating if the authors address my concerns.
limitations: limitations: The authors introduce the performance improvement, but the discussions on hyperparameter dependency analyses (what and how dependents?) and the compatibility on different GM models are insufficient.

Comments: title: The Rebuttal Response to Reviewer Q98w
Thanks to Reviewer nGEg
Thanks to Reviewer 6bSd
Thanks to Reviewer Q98w
Replying to Review after rebuttal
comment: We sincerely thank Reviewer Q98w again for valuable suggestions, and these are our precise answers after diligently examining questions and comments.

>**Q7. "what and how to depend" examples** 

Thank you for this insightful question. **Q5** from the first rebuttal response shows that Tab. 2(b) and Lines 270-274 illustrate the idea of hyperparameter dependency claimed in lines 30-32. Furthermore, these are examples of "what and how to depend":

1. There exists a dependency between _Layer Num._ and _Parameter Num._. In other words, in general, Layer Num. **positively depends** on Parameter Num., and vice versa.
This is because generative models, which have a large Layer Num., very likely also have a large Parameter Num.
Such a dependency (i.e., correlation) is helpful in model parsing, as when our method confidently predicts that the generative model has a large Layer Num., then this generative model can likely have a large Parameter Num. 
As a result, LGPN's GCN refinement block captures this dependency and achieves **0.147** and **0.081 L1 error** on predicting Layer Num. and Param. Num., whereas GTC with MLP layers can only have **0.149** and **0.148 L1 error**, respectively. 

2. There exists a dependency between _Conv. Layer Num._ and _Conv. Filters Num_. (i.e., _Filters Num_ in the Tab. 2(b)).
Apparently, Conv. Layer Num. **positively depends** on Filters Num., and vice versa. For example, generative models with more convolution layers, in theory, have a proportionally large number of convolution filters. 
This dependency can be used in model parsing: when our method has the confident prediction that the generative model has a small number of Conv. Layer Num., then it is likely that this generative model also has a small number of Filters Num.
Such a dependency is captured by the GCN refinement block, which achieves **0.137 and 0.149 L1 error** on predicting Conv. Layer Num. and Filters Num., whereas GTC with MLP layers can only have **0.151 and 0.161 L1 error**, respectively. Performance detailed in Tab.2(b).

3. There is a dependency between L1 and L2 loss functions: the existence of L1 loss function **negatively depends** on the existence of L2 loss function.
It's important to note that the generative model typically doesn't use L1 and L2 loss functions simultaneously, and this correlation (e.g., dependency) is useful in the model parsing task.
Specifically, when our method confidently predicts that the L1 loss function is used by the generative model while finding it difficult to predict if the L2 loss function is used, the model can use the confidence prediction on the L1 loss function as the prior knowledge to decide that L2 loss function is likely not used by the given generative model.
As a result, GTC with GCN refinement block achieves **0.101 and 0.163 higher F1 scores** than GTC with MLP layers on predicting L1 and L2 loss functions, respectively. 

>**Q8. Focus on tracing hyperparameter dependencies** 

As claimed in line 8 and line 34, we use graph nodes to represent hyperparameters, and each graph edge between graph nodes is used to **trace** (or capture) corresponding hyperparameter dependencies. 

One important focus of our work is to learn a graph structure (i.e., $\mathbf{A}^{\prime}_{l}$) with graph edges that **trace hyperparameter dependencies effectively**, helping the representation learning for graph nodes that are used for predicting hyperparameters.
This is demonstrated by our major technical contribution (Sec.3.2.2) --- the GCN refinement block with the graph pooling-unpoling mechanism, which optimizes a trainable graph (e.g., both graph edges and graph nodes are trainable) for better model parsing performance and generalization ability. 
Empirically, as detailed in Fig. 5(a), each generative model has its own specific learned graph structure.

>**Q9. Training and inference costs** 

Thank you for this additional interesting question. Aside from the **Q4** from the response to **Reviewer nGEg**, we use the following Table R.11 to show the inference and training costs compared to FEN-PN [R3] and model variant of GTC with the stacked GCN as the model parsing head.
Specifically, the inference speed is measured by the time cost by a one-forward propagation in the single NVIDIA RTX A6000 GPU with 48G memory. 
As shown by Table R.11, our LGPN is a computationally efficient algorithm. 
This is because our innovative graph pooling design actually largely reduces the graph size via the learned graph pooling mechanism, offering a largely more computationally efficient than prior GCN-based methods [10,7,59].

**Table R.11** Different model parsing methods' inference and training cost. 

|Method|Backbone|Model Parsing Head|GFLOPs(↓)|Inference Speed(↓)|Training Time(↓)|
|-------|--------|-------|------|---------------|-------------|
|FEN-PN|FEN|PN|7.1|101.1 ms|around 1 day|
|baseline|GTC|Stacked GCN|4.8|57.5 ms|around 1 day|
|LGPN|GTC|GCN refinement|4.2|41.5 ms|around 1 day|
Thank the authors for the response. The response have solved all my questions. I would like to maintain my score.
Thank the authors for the response. Tracking hyperparameter dependencies is the core topic of this work, but the reply to the discussion is still insufficient. This work appears to focus on "intergrating hyperparameters" rather than "tracing" the hyperparameter dependencies. The training and inference costs compared to the others should be discussed.
Dear Reviewer nGEg:

Please allow us to sincerely thank you again for reviewing our paper and providing valuable feedback, particularly for recognizing our algorithm's reasonable design, effectiveness, and high generalization ability as strengths. 

Please let us know if our response and additional experiments have properly addressed your concerns. We are more than happy to answer any additional questions during the discussion period. Your feedback will be greatly appreciated!

Best,

Paper14633 Authors
Dear Reviewer 6bSd:

Please allow us to sincerely thank you again for reviewing our paper and the valuable feedback, and in particular for recognizing the strengths of our paper in terms of our interesting research topic and the efficient algorithm. 

Please let us know if our response and additional experiments have properly addressed your concerns. We are more than happy to answer any additional questions during the discussion period. Your feedback will be greatly appreciated!

Best,

Paper14633 Authors
Dear Reviewer Q98w:

Please allow us to sincerely thank you again for reviewing our paper and the valuable feedback, and in particular for recognizing the strengths of our paper in terms of the reasonable algorithm design and high effectiveness.

Please let us know if our response and additional experiments have properly addressed your concerns about the comparative experiment and motivations. We are more than happy to answer any additional questions during the discussion period. Your feedback will be greatly appreciated!

Best,

Paper14633 Authors
Thank you so much for your positive feedback! It encourages us a lot!
Thank the authors for the response. All my questions have been answered clearly.