Younger: The First Dataset for Artificial Intelligence-Generated Neural Network Architecture

## Abstract

Abstract Designing and optimizing neural network architectures typically requires extensive expertise, starting with handcrafted designs and then manual or automated refinement. This dependency presents a significant barrier to rapid innovation. Recognizing the complexity of automatically generating neural network architecture from scratch, we introduce Younger, a pioneering dataset to advance this ambitious goal. Derived from over 174K real-world models across more than 30 tasks from various public model hubs, Younger includes 7,629 unique architectures, and each is represented as a directed acyclic graph with detailed operator-level information. The dataset facilitates two primary design paradigms: global, for creating complete architectures from scratch, and local, for detailed architecture component refinement. By establishing these capabilities, Younger contributes to a new frontier, Artificial Intelligence-Generated Neural Network Architecture (AIGNNA). Our experiments explore the potential and effectiveness of Younger for automated architecture generation and, as a secondary benefit, demonstrate that Younger can serve as a benchmark dataset, advancing the development of graph neural networks. We release the dataset 1 1 1 Younger Dataset: https://datasets.yangs.cloud/younger and code 2 2 2 Source Code: https://github.com/Jason-Young-AI/Younger publicly to lower the entry barriers and encourage further research in this challenging area.

## 1 Introduction

The proliferation of large language models like ChatGPT [] has decisively demonstrated the critical importance of large-scale data collection and innovative neural network architecture design in advancing Artificial Intelligence (AI) [, ]. Mainstream models have shifted from architectures predominantly based on RNNs or CNNs to those employing the Transformer [], consistently delivering superior performance across various tasks [, ]. This shift illustrates the significant impact of architectural innovations. It compels us to investigate Artificial Intelligence-Generated Neural Network Architecture (AIGNNA), a concept we introduce for the autonomous generation of neural architectures from scratch, as shown in Figure [2](#S4.F2).

Designing and optimizing neural network architectures requires profound domain expertise, meticulous manual construction, and continuous refinement. Such demands underscore the challenges in achieving rapid and automated generation of efficient neural network architectures. While Neural Architecture Search (NAS) has achieved significant success in automating the optimization and search of neural network architectures [, , ], it still heavily relies on human expertise for designing the initial overall network topology or macro-architecture [, , ]. This reliance restricts the diversity and innovation of neural network architectures.

To overcome the reliance on human expertise and foster the automated generation of diverse and innovative neural architectures, we introduce Younger, a pioneering dataset that encapsulates extensive prior knowledge about neural network architecture. Derived from approximately 174K real-world models across more than 30 tasks from various public model repositories, as listed in Table [3](#S3.T3), Younger includes 7,629 distinct neural network architectures, each represented as a directed acyclic graph (DAG) with detailed operator-level information. Specifically, all models are converted into the Open Neural Network Exchange (ONNX) format [], an open format designed to represent neural network models, ensuring the standardization of architecture and framework independence. To ensure model uniqueness and address privacy and safety concerns, we developed a tool that converts ONNX models into DAGs while preserving architectural integrity. Parameter values are excluded to ensure privacy and safety. In these DAGs, nodes represent ONNX operators, recording detailed configurations and hyperparameters, while edges represent the data flow between operators.

Activated by the Younger, we introduce two paradigms for AIGNNA, characterized by escalating complexity, as shown in Figure [2](#S4.F2): 1) Local: This paradigm focuses on fine-tuning and optimizing components of pre-existing or pre-generated neural network architectures. Within the paradigm, the challenge intensifies from determining data flows between operators to select the most suitable operator type for the given architecture. Due to the large number of operator types, the selection and integration of operators present a higher level of difficulty. 2) Global: This more demanding paradigm entails generating entire neural network architectures from scratch with no restrictions, epitomizing an end-to-end automation challenge that requires building a complete and functional architecture starting from zero.

We conducted experiments to validate the Younger’s potential and effectiveness for Artificial Intelligence-Generated Neural Network Architecture. Initially, we performed statistical analyses at three different levels of granularity: operator level, component level, and architecture level, demonstrating that the dataset contains sufficiently rich prior knowledge. Subsequently, we explored the practical application of the local and global paradigms, proving the dataset’s feasibility in real-world scenarios. Furthermore, our experiments revealed that due to the representation of architecture as DAG, Younger’s unique graph structural characteristics make it a promising benchmark dataset in advancing research in Graph Neural Networks (GNN).

As the name of our dataset, ‘Younger,’ implies, we have made the dataset publicly available online to keep it perpetually young and to lower the barriers to entry for research, thus fostering development in the field. To promote the democratization of research, we also provide a platform that allows researchers worldwide to upload their models. Our platform can automatically convert the uploaded models into DAG format and integrate them into the next release of Younger.

## 2 Related Work

### 2.1 Artificial Intelligence-Generated Neural Network Architecture

The design and optimization of neural network architectures have historically been labor-intensive tasks, relying heavily on the intuition and expertise of human researchers. This process has evolved from manual designs, exemplified by early architectures such as AlexNet[], ResNet [], LSTM [], and Transformer [], to more automated methods employing neural architecture search (NAS) like NASNet [] and DARTS [].

Early architecture designs, while innovative, were constrained by their reliance on expert knowledge and extensive experience. Despite the effectiveness of these manually designed architectures, they needed more agility and speed in an era characterized by rapid data growth and increasingly diverse application domains. This temporal inefficiency made it challenging to quickly develop tailored neural network solutions that could adapt to and capitalize on emerging opportunities across varied fields.

The advent of NAS marked a significant shift towards automation, aimed at enhancing the efficiency and adaptability of the design process. NAS frameworks like DARTS [] and benchmarks such as NAS-Bench-101 [] and NATS-Bench [] introduced methodologies that automate the exploration of predefined search spaces (macro-architectures) and the selection of optimal cells (building blocks or micro-architectures) [, , , , , , ]. However, the potential for innovation in NAS is constrained by the limitations of predefined macro-architectures and a restricted selection of operators, which stifles the exploration of new architectural designs.

**Table 1: The difference between Younger and NAS-related datasets. Younger does not restrict macro- or micro-architectures, it contains rich real-world architectures.**
| Dataset | #architectures | #op-types | #tasks |  |  |
| --- | --- | --- | --- | --- | --- |
| unrestricted- | macro- | micro- |  |  |  |
| NAS-Bench-101 [] | - | 1 | 423K | 3 (Desc.) | 1 (Image) |
| NAS-Bench-201 [] | - | 1 | 15K | 5 (Desc.) | 1 (Image) |
| NAS-Bench-NLP [] | - | 1 | 14K | 6 (Desc.) | 1 (Text) |
| NAS-Bench-ASR [] | - | 1 | 8K | 6 (Desc.) | 1 (Audio) |
| DeepNets-1M [] | - | 1 | 1M | 15 (Desc.) | 1 (Image) |
| Younger | 7.4K | - | - | 193 (ONNX) | 31 (Unlimited) |

The Younger dataset and the associated AIGNNA methodology propose a revolutionary departure from these constraints. By eliminating the need for predefined macro-architectures, Younger allows for a more explorative approach to architecture design, supporting various operator types and data flow configurations, as seen in Table [1](#S2.T1). This flexibility facilitates the generation of innovative, customized architectures better suited to specific applications and more adaptable to emerging challenges in neural network design.

### 2.2 Benchmarking Graph Neural Network

Graph neural networks (GNNs) have gained prominence due to their effectiveness in processing data represented in graph formats, applicable across various domains such as social network analysis, recommendation systems, and molecular chemistry. Standard benchmark datasets for GNN research include citation networks like Cora, CiteSeer, and PubMed [], as well as molecular datasets such as QM9 [] and ZINC []. These datasets primarily represent graphs with relatively simple and static structures.

**Table 2: The difference between Younger and GNN-related datasets. Younger has the highest number of node types and is more balanced than other datasets regarding the number of nodes, edges, and graphs.**
| Dataset | #graphs | #nodes | #edges | #node-types |
| --- | --- | --- | --- | --- |
| Cora [] | 1 | 2,708 | 10,556 | - |
| CiteSeer [] | 1 | 3,327 | 9,104 | - |
| PubMed [] | 1 | 19,717 | 88,648 | - |
| ZINC [] | 49,456 | $\sim$23.2 | $\sim$49.8 | 10 |
| QM9 [] | 130,831 | $\sim$18.0 | $\sim$37.3 | 5 |
| Younger | 7,629 | $\sim$1,658 | $\sim$2,113 | 184 |

Due to the inherent nature of the directed acyclic graph of the data items in Younger, it can naturally be used as a benchmark data set for graph neural network-related research. As shown in Table [2](#S2.T2), Younger introduces a new dimension to GNN benchmarking by providing a dataset of diverse, complex directed acyclic graphs (DAGs) ranging dramatically in scale and complexity. This variability presents new challenges and opportunities for GNN research, particularly in testing the scalability, robustness, and generalizability of GNN algorithms. Each graph within Younger can be studied as homogeneous or heterogeneous, depending on the specific research focus or application, providing a versatile platform for advancing GNN methodologies. Homogeneous or heterogeneous considerations are discussed in Section [5](#S5).

Developing the Younger dataset and the AIGNNA methodology significantly advances neural network architecture design and GNN benchmarking. By providing paradigms that support extensive customization and innovation, Younger facilitates a deeper exploration of neural architectures and offers a robust benchmarking tool for GNN research. This approach challenges existing approaches and paves the way for future neural network design developments.

## 3 Dataset Construction

Collecting real-world neural network architectures is complicated and requires in-depth knowledge of deep learning frameworks, particularly ONNX [], as well as significant human effort, computing power, and network resources. This can be prohibitive for many researchers. To provide broad support for AIGNNA and lower the entry barriers for researchers, we provide a series of neural network architecture collection and processing tools to avoid the labor costs required for data collection. Using these tools, we constructed the initial version of Younger, with resource consumption detailed in the Appendix.
Our dataset construction process mainly includes four parts: retrieving neural network models, converting models to ONNX, extracting DAGs from ONNX, and filtering out unique DAGs. Figure [1](#S3.F1) shows the overall processing pipeline. The specific process is as follows:

Figure: Figure 1: Overview of the construction pipeline. Models are retrieved from Hugging Face Hub, ONNX Model Zoo, PyTorch Hub, and Kaggle Models. Then, all retrieved models are converted to ONNX and extracted to be DAGs.
Refer to caption: /html/2406.15132/assets/x1.png

Retrieving Neural Network Models:
We constructed Younger using four well-known neural network models from four publicly available neural network model repositories. Specifical, four well-known open-source neural network model repositories are chosen to obtain a sufficiently diverse range of neural network models: Kaggle Models(^3^33Kaggle Models: [https://www.kaggle.com/models](https://www.kaggle.com/models)), PyTorch Hub(^4^44PyTorch Hub: [https://pytorch.org/hub/](https://pytorch.org/hub/)), ONNX Model Zoo(^5^55ONNX Model Zoo: [https://onnx.ai/models/](https://onnx.ai/models/)), and Hugging Face Hub(^6^66Hugging Face Hub: [https://huggingface.co/models](https://huggingface.co/models)). These repositories cover over 30 types of deep learning tasks and include models based on various deep learning frameworks such as PyTorch [] and TensorFlow [], see Appendix for details. It ensures the diversity of sources for deep learning models to a certain extent. Given the rapid growth rate of the Hugging Face Hub, we have provided a series of automated model acquisition tools to support Younger’s rapid version iteration and maintain timeliness. In addition, although the update frequency of the other three model libraries is slow, we have also developed corresponding tools to achieve automation. Table [3](#S3.T3) shows detailed information about the model hubs.

Converting Models to ONNX:
Different deep learning frameworks define different operators. Without a unified representation, issues such as increased dataset usage costs and reduced efficiency in architecture design may arise. Therefore, we adopt Open Neural Network Exchange (ONNX) as the unified representation format for the model. ONNX defines machine learning models by providing a standard set of operators, allowing different deep learning frameworks (such as PyTorch, TensorFlow, etc.) to use the same operators for model exchange and deployment.
Another benefit of using ONNX as a unified representation is that it significantly reduces the number of operator types, greatly lowering the cost of representing neural network architectures. For instance, while PyTorch has defined approximately 2000+ different operators, with ONNX, only about 200 standard operators are required.
We use several open-source tools for conversion, such as optimum(^7^77Optimum: [https://github.com/huggingface/optimum](https://github.com/huggingface/optimum)) and tf2onnx(^8^88tf2onnx: [https://github.com/onnx/tensorflow-onnx](https://github.com/onnx/tensorflow-onnx)); see Appendix for details.

Extracting DAGs From ONNX:
To protect parameter information and avoid security and privacy issues, all parameter information must be removed from the ONNX model. In addition, compared to DAGs, ONNX models defined in the Protocol Buffers(^9^99Protocol Buffers [https://protobuf.dev/](https://protobuf.dev/)) format are less suitable for direct reading and processing by various data analysis and processing tools like graph studying tools(e.g., NetworkX []) and deep learning frameworks (e.g., PyTorch Geometric []). Consequently, we have developed a tool for transforming the ONNX models into directed acyclic graphs. This tool allows model owners to provide their architecture design without leaking parameter information, helping enrich the construction and development of open-source Younger.

Specifically, we store each operator in a neural network architecture in the nodes of the DAG and record detailed information such as the operator type and operator attribute definitions. We use directed edges to represent the data flows within the neural network architecture and meticulously document each node’s data inflow and outflow order. We utilize the open-source graph library NetworkX to represent the DAGs.

Filtering the Dataset:
There are many isomorphic neural network architectures in public model hubs, so it is necessary to filter the isomorphic architectures to ensure the uniqueness of each architecture in the dataset. We use the Weisfeiler Lehman (WL) [] graph hash algorithm to compute the extracted DAGs and identify heterogeneous architectures. The WL algorithm has the same calculation result for isomorphic graphs and firmly guarantees that heterogeneous graphs have different hashes. We use operator type and operator attributes represented in nodes as the iteration objects of the WL hash algorithm, ensuring the heterogeneity of all architectures in the dataset in terms of hyperparameters and operator types. After filtering, we obtained 7629 heterogeneous neural network architectures from 174K real-world models.

**Table 3: Statistical information during the construction process of Younger. This includes the number of retrievable models from four publicly available model hubs, the number of models that are ONNX convertable, the number of models that have been successfully retrieved, the number of models that have been successfully converted to ONNX, and the number of heterogeneous DAGs that are filtered.**
| Public Model Hubs | Retrievable | Convertable | Retrieved | Converted | Filtered |
| --- | --- | --- | --- | --- | --- |
| Hugging Face Hub | 691K | 325K | 143.5K | 96K | - |
| ONNX Model Zoo | 12K | 12K | 12K | 74K |  |
| PyTorch Hub | N/A | 121 | 121 | 121 |  |
| Kaggle Models | 5K | 4K | 4K | 4K |  |
| Total | 743.5K | 341K | 159.5K | 174K | 7629 |

When the first version of Younger started construction, there were 743.5K publicly available models, of which 341K models could be converted to ONNX format. As of the release of the first version of Younger, we have extracted 174K models for processing. It can be seen that even though the base of deep learning models is large and the growth pace is fast, the actual effective and heterogeneous neural network architecture is less than 1% of the total number of models. Please take a look at Table 1 for details.
The notably low proportion of heterogeneous neural network architectures reveals that current neural network design methods, both manual and NAS-based, have a limited impact on architectural innovation. This underscores Younger’s importance in offering new design approaches for AIGNNA and its critical role in advancing neural network architecture innovation.

## 4 Paradigms for AI-Generated Neural Network Architecture (AIGNNA)

To advance the development of AIGNNA based on the Younger dataset, we introduce two paradigms for neural network architecture design, each tailored to different real-world application scenarios. Figure [2](#S4.F2) provides an intuitive visualization of two paradigms.

Figure: Figure 2: Paradigms of the AIGNNA. From left to right are operator design for the local paradigm, data flow design for the local paradigm, and global architecture design for the global paradigm.
Refer to caption: /html/2406.15132/assets/x2.png

### 4.1 Local: Architecture Refinement In Detail

The local paradigm addresses the need to fine-tune specific aspects of existing neural network architectures. This approach is divided into operator and data flow designs, as shown in Figure [2](#S4.F2). Operator Design involves determining the most suitable type of operator for a given node based on local or global architectural information, as illustrated in the leftward of Figure [2](#S4.F2). This design assesses potential replacements for current operators and suggests appropriate operators for new nodes based on neighboring structural information.

The second type, data flow design, evaluates the existence of data flows between operators. This fine-tuning method determines whether a directed edge representing data flow should connect any two nodes, utilizing insights from local and global architectural contexts.

The challenge in local paradigms arises from the vast diversity of operators and the binary nature of data flow decisions (existing or not). To assess the efficacy of this paradigm, we employ five different graph neural networks as baselines, focusing on operator and data flow design. It will be seen that operator design is more challenging than data flow design. See Section 1 for more details.

### 4.2 Global: Architecture Design From Scratch

Designing neural network architectures from scratch is an open and complex challenge. Unlike neural architecture search, which limits the search space to a predefined macro-architecture while optimizing micro-architectural elements for specific performances, the global paradigm seeks to generate comprehensive neural network architectures incorporating detailed operator-level elements from the ground up.

As shown in the rightward flowchart of Figure [2](#S4.F2), this generative process is conditioned on specific properties, denoted by $z$ in Figure [2](#S4.F2), such as a noise that represents the architecture’s intended application or required characteristics. Moreover, the architecture’s design objectives are defined by the goals it needs to achieve. Importantly, global paradigms can also iteratively leverage local paradigms to progressively achieve their comprehensive design objectives.
To explore the potential and feasibility of the global paradigm, we implement a robust baseline for validation.

## 5 Experiments

We conduct two parts of experiments: one to analyze the Younger statistics information and the other to apply the paradigms.

Homogeneous or Heterogeneous?
Different operator types possess varying quantities and varieties of attributes. For instance, a Convolution (Conv) operator includes attributes such as dilations, kernel shape, and strides, whereas a Batch Normalization operator features attributes like epsilon and momentum. This diversity complicates the treatment of these operator types within a DAG. Consequently, it presents an exciting challenge: Should researchers treat these graphs as homogeneous or heterogeneous?

The simplest way is to treat the graphs as homogeneous, which means that all nodes are considered to be of the same type, namely ‘operator.’
When a graph is considered heterogeneous, all nodes are viewed as operators of different types, exhibiting heterogeneity in operator types. However, the diversity of operator types increases the complexity of analyzing and designing neural network architectures, especially from the perspective of heterogeneous graphs.

To succinctly demonstrate Younger’s effectiveness in AIGNNA, we treat all architectures in Younger as homogeneous graphs to avoid introducing more variables and affecting the experimental analysis. We leave the task of treating architectures in Younger as heterogeneous graphs as future work.

Experimental Setup:
Since the nodes in Younger’s DAGs store discrete information, such as operator types and integer attributes, it is difficult for us to process the node features of the DAGs using traditional approaches. For simplicity, we consider the operator types to be discrete features of nodes. We use two configurations: 1) Regardless of whether the operator attribute configuration is consistent, we treat the same operator type as the same type of feature, which minimizes the number of node features to the size of the ONNX operator set, denoted as ‘Operator w/o Attributes.’ 2) For operators of the same type with different attribute configurations, they are considered as different class features, which leads to a sharp increase in the number of node features and further makes learning on the dataset more challenging, denoted as ‘Operator w/ Attributes.’ We will see the specific effects of these two configurations in experiments.

### 5.1 Statistical Analysis

We conduct statistical analysis from two perspectives: 1) analyzes lower-dimension statistical information, such as the distribution of the number of nodes in each graph and the operator distribution in Younger. 2) analyzes high-dimension statistical information, including the distribution of three different level granularity: operator, subgraph, and graph.

Low-Dimensional Statistical Information:
We compare the statistics between Younger and conventional graph datasets. From Table [2](#S2.T2) and Figure [3](#S5.F3)(a), Younger contains the most extensive distribution of the number of nodes in the graph, ranging from graphs containing only a dozen nodes to graphs containing hundreds of thousands of nodes. In addition, Younger also contains enough graphs compared to most graph datasets, which makes it further challenging to conduct GNNs on Younger.

Figure: Figure 3: Distribution of #nodes and #edges and top 30 ONNX operators. (a) The distribution of the number of graph nodes and edges in Younger; (b) The top 30 ONNX operators have the highest frequency in Younger.
Refer to caption: /html/2406.15132/assets/x3.png

Figure [3](#S5.F3)(b) shows Younger’s top 30 operators with the highest frequency. The dataset has a great diversity of operator types, including tensor deformations (e.g., Unsequeeze, Reshape), arithmetic operations (e.g., Add, Conv, MatMul), logical operations (e.g., Equal), and quantization (e.g., DynamicQuantizeLinear).

High-Dimensional Statistical Information
Due to the nonlinear nature of the graph, we use embedding to study the distribution properties of architectures in Younger. Specifically, the GCN network trained in subsection [5.2.1](#S5.SS2.SSS1) for operator design is used to obtain the specific embeddings.
In Figure [7](#S5.F7) and [7](#S5.F7), orange dots represent the operators that appear in Younger’s top 500 frequencies. After training, GCN gradually extracts the high-frequency operators from the original distribution and aggregates them. This reveals that learning the distribution of long-tailed operators in the dataset is a highly challenging problem; see Appendix [D](#A4) for more details.

Figure: Figure 4: Node embeddings before training
Refer to caption: /html/2406.15132/assets/x4.png

### 5.2 Practical Applications

We conducted experiments on the Younger dataset for global and local paradigms to verify the feasibility and effectiveness of our proposed two paradigms for AIGNNA. The experiment indicates that exploring AIGNNA based on Younger is feasible, and it demonstrates Younger’s potential as a benchmark dataset for graph neural networks.

#### 5.2.1 Local Paradigm

Data Flow Design:
We use GCN, GAT, and GraphSAGE under the data flow design paradigm to verify the effectiveness of neural architecture refinement on Younger. The results are shown in Table [4](#S5.T4).
All models have achieved good performance on the Younger dataset, which proves that existing graph neural networks are more suitable for predicting data flows in neural network architectures.
Additionally, it can be seen that almost all models perform better without attributes because reducing the number of node features on the graph makes learning them easier.

**Table 4: Local paradigm: data flow design. Bold values represent the best-performing results.**
| Model | Operator w/ Attributes | Operator w/o Attributes |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| AUC$\uparrow$ | F1$\uparrow$ | AP$\uparrow$ | AUC$\uparrow$ | F1$\uparrow$ | AP$\uparrow$ |  |
| GCN [] | 0.9922 | 0.7881 | 0.9913 | 0.9938 | 0.7791 | 0.9929 |
| GAT [] | 0.8997 | 0.8079 | 0.8720 | 0.9094 | 0.7964 | 0.8901 |
| SAGE [] | 0.9169 | 0.8033 | 0.8940 | 0.9252 | 0.8002 | 0.9026 |

Operator Design:
We use five different baselines for ten experiments under the operator design paradigm, as shown in Table [5](#S5.T5). Despite the high accuracy achieved by all baselines, the F1 score, Precision, and Recall remain low. This is primarily attributed to the complex graph structures in Younger, which are characterized by many operator types. Among these, multiple kinds of operators infrequently occur, posing challenges to achieving robust multi-classification performance. In experiments w/o attributes, we observed higher values for F1, Precision, and Recall compared to scenarios w/ attributes. This finding further substantiates the inherent complexity of the dataset and its impact on classification performance.

**Table 5: Local paradigm: operator design. Bold values represent the best-performing results. ‘Prec.’ in the header represents Precision.**
| Model | Operator w/ Attributes | Operator w/o Attributes |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ACC$\uparrow$ | F1$\uparrow$ | Prec.$\uparrow$ | Recall$\uparrow$ | ACC$\uparrow$ | F1$\uparrow$ | Prec.$\uparrow$ | Recall$\uparrow$ |  |
| GCN [] | 0.8684 | 0.1451 | 0.1713 | 0.1466 | 0.8360 | 0.2987 | 0.3657 | 0.2788 |
| GAT [] | OOM | OOM | OOM | OOM | 0.7139 | 0.2022 | 0.2532 | 0.2039 |
| GAE [] | 0.9016 | 0.0537 | 0.0728 | 0.0513 | 0.9073 | 0.1745 | 0.2036 | 0.1700 |
| VGAE [] | 0.8243 | 0.0716 | 0.0891 | 0.0707 | 0.9137 | 0.2207 | 0.2654 | 0.2132 |
| SAGE [] | 0.8984 | 0.2028 | 0.2383 | 0.1996 | 0.9250 | 0.3646 | 0.4323 | 0.3532 |

#### 5.2.2 Global Paradigm

In the global paradigm, we adopted the graph generation model DiGress, which uses a diffusion model to generate a graph. Due to the restriction of the computing resources and the maximum number of nodes in a graph of Younger reaching hundreds of thousands, we only selected architectures with node counts in the range $[1,300]$ for training.

The DiGress we used achieved a negative log-likelihood of at least 345.4988 on the test set. Global Paradigm is a highly challenging task, so we will continue to research it in the future.

## 6 Conclusion and Future Work

This article presents Younger, a dataset of neural network architectures extracted from real-world models across various public model repositories.
Based on this dataset, we propose a new challenging field: Artificial Intelligence-Generated Neural Network Architecture (AIGNNA).
We propose two new challenges regarding neural network architecture design in this field: the Global Design Paradigm and the Local Design Paradigm. Through experiments, we have preliminarily verified the potential and effectiveness of Younger’s neural architecture design in the new field. And call on more researchers to join this research direction.

## Appendix A Datasheet

### A.1 Motivation

- •
For what purpose was the dataset created? Was there a specific task in mind? Was there a specific gap that needed to be filled? Please provide a description.
–
The creation of Younger aims to enable fully automated neural network architecture design and optimization, a novel domain we introduce in the paper as AIGNNA. Previous efforts in neural network architecture design and optimization have primarily relied on manually designed initial macro-architectures, followed by a search for micro-architectures within a constrained space. This approach has led to a need for more innovation and diversity in AIGNNA. The introduction of Younger addresses this deficiency. On the one hand, it enables granular (operator-level) automatic architecture design; on the other hand, as a dataset with graph structural properties, Younger can also serve as a benchmark dataset to further advance the development of graph neural networks, as demonstrated by the experiments described in the main text.
- •
Who created the dataset (e.g., which team, research group) and on behalf of which entity (e.g., company, institution, organization)?
–
This dataset is presented by the author of the paper and BenchCouncil (The International Open Benchmark Council), a non-profit international organization dedicated to benchmarks and evaluations.
- •
Who funded the creation of the dataset? If there is an associated grant, please provide the name of the grantor and the grant name and number.
–
Supported by the Innovation Funding of ICT, CAS under Grant No. E461070.
- •
Any other comments?
–
No.

### A.2 Composition

- •
What do the instances that comprise the dataset
represent (e.g., documents, photos, people, countries)? Are there
multiple types of instances (e.g., movies, users, and ratings;
people and interactions between them; nodes and edges)? Please
provide a description.
–
Younger contains 7629 completely different neural network architectures (instances). Each instance is a neural network architecture from the real world, represented by a directed acyclic graph, where each node records detailed ONNX operator configurations and edges record data flow between operators. In the paper, we will discuss in detail how to view node features, that is, whether the neural network architecture should be viewed as heterogeneous or homogeneous, as detailed in Section [5](#S5). The operator type is in the set of operators specified by ONNX. Currently, the latest version of ONNX is 22, supporting 193 different operators. This dataset presently includes 184 of these operators.
- •
How many instances are there in total (of each type, if appropriate)?
–
In Younger, 7629 neural network architectures were extracted from 174K real-world model species. Furthermore, Younger contains approximately 12.6M nodes and 16.1M edges.
- •
Does the dataset contain all possible instances or is it
a sample (not necessarily random) of instances from a larger set?
If the dataset is a sample, then what is the larger set? Is the
sample representative of the larger set (e.g., geographic coverage)?
If so, please describe how this representativeness was
validated/verified. If it is not representative of the larger set,
please describe why not (e.g., to cover a more diverse range of
instances, because instances were withheld or unavailable).
–
As stated in Section [5](#S5) of the paper, the dataset was extracted from four well-known publicly available model libraries containing 743.5K models covering over 30 different task types. Due to the inability of at least half of the models to automatically convert to ONNX types, Younger’s current version can only partially cover part of the real-world space. To promote the development of datasets, this work provides an online ONNX model submission platform and ONNX to DAG conversion tools to facilitate global collaborative construction.
–
In addition, experiments have shown that our dataset covers many mainstream architectures, so it has a certain degree of completeness.
- •
What data does each instance consist of? “Raw” data
(e.g., unprocessed text or images) or features? In either case,
please provide a description.
–
The dataset consists of three main versions. 1, the complete version includes the architecture corresponding to all unfiltered accurate models and records the source of the original model, including its model library and model ID. The model’s parameter values are not recorded to ensure data security and privacy. 2. Filter versions, including all heterogeneous model architectures, to remove duplicate versions of the complete version. 3. According to specific experimental requirements, the split version has performed a certain proportion of segmentation and processing on the dataset, as described in Section [D](#A4)
- •
Is there a label or target associated with each
instance? If so, please provide a description.
–
Each instance in the dataset contains information about operators and data flows, which can be used as labels in various AIGNNA paradigms according to the specific needs of researchers.
- •
Is any information missing from individual instances?
If so, please provide a description, explaining why this information
is missing (e.g., because it was unavailable). This does not include
intentionally removed information, but might include, e.g., redacted
text.
–
No.
- •
Are relationships between individual instances made
explicit (e.g., users’ movie ratings, social network links)? If
so, please describe how these relationships are made explicit.
–
No.
- •
Are there recommended data splits (e.g., training,
development/validation, testing)? If so, please provide a
description of these splits, explaining the rationale behind them.
–
Yes. We performed dataset splitting and processing under two Local Paradigms of the AIGNNA: Local Operator Design and Local Data Flow Design. We only provide a suggested splitting and processing method, and users can make changes according to specific needs. Specifically, to verify the feasibility of the local paradigm, we processed and segmented the dataset according to different application scenarios. For Local Operator Design, we performed community detection on each architecture, removed duplicate communities, and then marked the boundary nodes of the communities as targets for predicting operator types; the communities are split into train, valid, and test. For Local Data Flow Design, we divided the entire dataset into train, valid, and test and then performed negative edge sampling on each architecture. See Section [D](#A4) for details.
- •
Are there any errors, sources of noise, or redundancies
in the dataset? If so, please provide a description.
–
No.
- •
Is the dataset self-contained, or does it link to or
otherwise rely on external resources (e.g., websites, tweets,
other datasets)? If it links to or relies on external resources,
a) are there guarantees that they will exist, and remain constant,
over time; b) are there official archival versions of the complete
dataset (i.e., including the external resources as they existed at
the time the dataset was created); c) are there any restrictions
(e.g., licenses, fees) associated with any of the external
resources that might apply to a dataset consumer? Please provide
descriptions of all external resources and any restrictions
associated with them, as well as links or other access points, as
appropriate.
–
Younger is independent of external resources and will continue to become abundant over time. When releasing a newer dataset, we retain the older version and expand new architectures in the latest version to ensure data compatibility and persistence.
- •
Does the dataset contain data that might be considered
confidential (e.g., data that is protected by legal privilege or
by doctor–patient confidentiality, data that includes the content
of individuals’ non-public communications)? If so, please provide
a description.
–
No.
- •
Does the dataset contain data that, if viewed directly,
might be offensive, insulting, threatening, or might otherwise
cause anxiety? If so, please describe why.
–
No.

### A.3 Collection Process

- •
How was the data associated with each instance
acquired? Was the data directly observable (e.g., raw text, movie
ratings), reported by subjects (e.g., survey responses), or
indirectly inferred/derived from other data (e.g., part-of-speech
tags, model-based guesses for age or language)? If the data was reported
by subjects or indirectly inferred/derived from other data, was the
data validated/verified? If so, please describe how.
–
We pull open-source models from public model hubs and convert them to ONNX format. Using self-developed tools, we extract the directed acyclic graphs contained in the ONNX format model without exposing the model parameter values while ensuring the invariance of the model architecture. Therefore, these instances cannot be directly observed, but according to the ONNX specification, our extraction tool can guarantee the accuracy of the conversion results, and manual testing is carried out through random sampling to ensure the accuracy of the data. See Section [3](#S3) for details.
- •
What mechanisms or procedures were used to collect the
data (e.g., hardware apparatuses or sensors, manual human
curation, software programs, software APIs)? How were these
mechanisms or procedures validated?
–
In obtaining the original model, we called their official open-source API interfaces to integrate model information for different public model libraries and then automated the acquisition of specific models. For detailed acquisition methods, please refer to the source code instructions.
–
Then, we convert the models to ONNX format based on different model types. Specifically, we use the open-source Optim tool to convert the models in the Hugging Face Hub to ONNX, the open-source tf2onnx tool to convert the TensorFlow format models to ONNX, and the PyTorch built-in open-source conversion tool to convert the PyTorch format models to ONNX.
–
Finally, we used a self-developed DAG extraction tool to extract the DAGs contained in the ONNX model.
–
All the data processing work above was carried out using CPUs. We used twenty CPU servers to process the model and then manually sampled and checked the processed data to ensure the correctness of the entire process.
- •
If the dataset is a sample from a larger set, what was
the sampling strategy (e.g., deterministic, probabilistic with
specific sampling probabilities)?
–
The dataset was collected from multiple publicly available model libraries, and the selection of publicly available model libraries followed the model’s reputation. Therefore, four well-known model libraries were selected, including Hugging Face Hub, Kaggle, ONNX Model Zoo, and PyTorch Hub.
–
Our collection strategy is to enumerate as many models as possible that can be converted to ONNX format to cover the entire real-world space.
- •
Who was involved in the data collection process (e.g.,
students, crowdworkers, contractors) and how were they compensated
(e.g., how much were crowdworkers paid)?
–
No crowdsourcing personnel participated in this work; only the authors of this paper collected and processed the data, and the work was carried out free of charge.
- •
Over what timeframe was the data collected? Does this
timeframe match the creation timeframe of the data associated with
the instances (e.g., recent crawl of old news articles)? If not,
please describe the timeframe in which the data associated with the
instances was created.
–
All of Younger’s instances were created between April and May 2024, but the time of the raw model data it extracted from may be traced back to earlier times. During Younger’s creation period, the number of models in many model zoos, especially the Hugging Face Hub, is still increasing.
- •
Were any ethical review processes conducted (e.g., by an
institutional review board)? If so, please provide a description
of these review processes, including the outcomes, as well as a link
or other access point to any supporting documentation.
–
No. Because Younger does not involve ethical review issues.

### A.4 Preprocessing/cleaning/labeling

- •
Was any preprocessing/cleaning/labeling of the data done
(e.g., discretization or bucketing, tokenization, part-of-speech
tagging, SIFT feature extraction, removal of instances, processing
of missing values)? If so, please provide a description. If not,
you may skip the remaining questions in this section.
–
Younger converts all operators from different versions to the latest ONNX version to ensure consistency in the architecture version.
- •
Was the “raw” data saved in addition to the preprocessed/cleaned/labeled data (e.g., to support unanticipated future uses)? If so, please provide a link or other access point to the “raw” data.
–
Younger provides the architecture of all the original models of the dataset, located at [https://datasets.yangs.cloud/younger/](https://datasets.yangs.cloud/younger/).
- •
Is the software that was used to preprocess/clean/label the data available? If so, please provide a link or other access point.
–
The tool for converting different versions of operators to the same version is detailed in the source code description.
- •
Any other comments?
–
No.

### A.5 Uses

- •
Has the dataset been used for any tasks already? If so, please provide a description.
–
Before this paper proposed the concept of AIGNNA, Younger had not yet been applied to any task.
- •
Is there a repository that links to any or all papers or systems that use the dataset? If so, please provide a link or other access point.
–
No. However, all tasks and experiments using Younger in this article are open-source. They are at this link: [https://github.com/Jason-Young-AI/Younger.](https://github.com/Jason-Young-AI/Younger.)
- •
What (other) tasks could the dataset be used for?
–
On the one hand, Younger supports extensive research on AIGNNA-related tasks, including but not limited to the Local and Global paradigms. The authenticity of Younger’s data composition provides possibilities and new opportunities for the automated generation of neural network architectures from scratch. On the other hand, Younger’s inherent graph structure properties and unique and rich statistical features naturally support graph neural network research. It can also be used as a benchmark dataset.
- •
Is there anything about the composition of the dataset or the way it was collected and preprocessed/cleaned/labeled that might impact future uses? For example, is there anything that a dataset consumer might need to know to avoid uses that could result in unfair treatment of individuals or groups (e.g., stereotyping, quality of service issues) or other risks or harms (e.g., legal risks, financial harms)? If so, please provide a description. Is there anything a dataset consumer could do to mitigate these risks or harms?
–
Younger excludes all model parameter values and is only related to the model architecture, so it will not bring any related issues.
- •
Are there tasks for which the dataset should not be used? If so, please provide a description.
–
No.
- •
Any other comments?
–
No.

### A.6 Distribution

- •
Will the dataset be distributed to third parties outside of the entity (e.g., company, institution, organization) on behalf of which the dataset was created? If so, please provide a description.
–
Yes, Younger will be open source.
- •
How will the dataset will be distributed (e.g., tarball on website, API, GitHub)? Does the dataset have a digital object identifier (DOI)?
–
We will distribute datasets for Younger at three levels, including 1. Complete version. 2. Filter version. 3. Split version. All data can be found on the official website [https://datasets.yangs.cloud/younger](https://datasets.yangs.cloud/younger). The retrieval methods include online browsing for on-demand downloads, tarball compression, and API retrieval. We will provide Digital Object Identifiers shortly.
- •
When will the dataset be distributed?
–
The initial version of Younger will be released before 31/06/2024 and will be continuously updated in the future to improve information related to the datasets.
- •
Will the dataset be distributed under a copyright or other intellectual property (IP) license, and/or under applicable terms of use (ToU)? If so, please describe this license and/or ToU, and provide a link or other access point to, or otherwise reproduce, any relevant licensing terms or ToU, as well as any fees associated with these restrictions.
–
[CC BY-NC-ND 4.0](https://creativecommons.org/licenses/by-nc-nd/4.0/)
- •
Have any third parties imposed IP-based or other restrictions on the data associated with the instances? If so, please describe these restrictions, and provide a link or other access point to, or otherwise reproduce, any relevant licensing terms, as well as any fees associated with these restrictions.
–
The author of the paper and BenchCouncil retain ownership of the dataset and distribute it under CC BY-NC-ND 4.0.
–
The copyright related to the design of the model architecture in the dataset belongs to the creator of the model architecture, and BenchCouncil and the author of the paper are not responsible for this.
- •
Do any export controls or other regulatory restrictions apply to the dataset or to individual instances? If so, please describe these restrictions, and provide a link or other access point to, or otherwise reproduce, any supporting documentation.
–
No.
- •
Any other comments?
–
No.

### A.7 Maintenance

- •
Who will be supporting/hosting/maintaining the dataset?
–
The authors and BenchCouncil will support, host, and maintain Younger.
- •
How can the owner/curator/manager of the dataset be contacted (e.g., email address)?
–
Please contact the first author or BenchCouncil’s main office staff via email address [benchcouncil@gmail.com](benchcouncil@gmail.com).
–
Or through the website[https://datasets.yangs.cloud/younger/contacts/](https://datasets.yangs.cloud/younger/contacts/), contact us.
- •
Is there an erratum? If so, please provide a link or other access point.
–
Our initial version did not have an erratum, but we will release the errata in subsequent versions and publish it at the following address [https://datasets.yangs.cloud/younger/errata](https://datasets.yangs.cloud/younger/errata).
- •
Will the dataset be updated (e.g., to correct labeling
errors, add new instances, delete instances)? If so, please
describe how often, by whom, and how updates will be communicated to
dataset consumers (e.g., mailing list, GitHub)?
–
Younger will be updated periodically, including adding new model architectures, removing outdated architectures, and correcting possible dataset errors. We will choose whether to update the dataset version based on whether there is a significant statistical difference between the data changes and the previous version. We hope every researcher who obtains data can fill out a nonmandatory survey questionnaire and provide a contact email. Therefore, updating notifications about Younger can be controlled through email, dataset websites, and the Younger code repository.
- •
If the dataset relates to people, are there applicable
limits on the retention of the data associated with the instances
(e.g., were the individuals in question told that their data would
be retained for a fixed period of time and then deleted)? If so,
please describe these limits and explain how they will be
enforced.
–
No.
- •
Will older versions of the dataset continue to be
supported/hosted/maintained? If so, please describe how. If not,
please describe how its obsolescence will be communicated to dataset
consumers.
–
The old dataset version will continue to be supported/hosted/maintained, and all changes and maintenance of the different dataset versions will happen on the dataset’s official website.
- •
If others want to extend/augment/build on/contribute to
the dataset, is there a mechanism for them to do so? If so,
please provide a description. Will these contributions be
validated/verified? If so, please describe how. If not, why not? Is
there a process for communicating/distributing these contributions
to dataset consumers? If so, please provide a description.
–
We support all researchers worldwide in contributing to the dataset. Still, we only support researchers submitting neural architecture models on Younger’s official website to extend/augment/build on/contribute to the dataset. The neural architecture submitter will receive real-time feedback to verify whether the new architecture they submit contributes to the existing dataset.
–
In addition, we support researchers’ private expansion of datasets to meet specific scientific research needs. Still, we do not support redistributing the modified datasets under this situation to avoid potential adverse consequences for society.
- •
Any other comments?
–
No.

## Appendix B Dataset Maintenance

### B.1 Dataset Series

Although the Younger used in this article only includes 7629 different architectures, we will still release some other series related to Younger, which are differentiated based on several critical stages of Younger’s entire lifecycle to meet the various needs of researchers. The specific situation is as follows:

#### B.1.1 The Complete Series

Once all DAGs corresponding to neural network architectures are extracted from their corresponding models, they will be immediately added to the ‘Complete’ series. Each DAG in this series of datasets will be saved in a ‘Dataset’ class defined by us and persisted using the ‘Instance’ class defined by us. These instances will record the public model repository to which their original models belong and their corresponding model IDs. Over time, some owners may update or delete their models. We will regularly scan existing instances and update the dataset accordingly.

#### B.1.2 The Filter Series

Once the ‘Complete’ series is created, we will filter it by removing isomorphic DAGs (architectures), and the deduplicated results will be published as the ‘Filter’ series. Specifically, we use the Weisfeiler Lehman (WL) Hash algorithm [] to identify isomorphic architectures. The WL Hash algorithm iteratively hashes and aggregates the operator information of neighboring nodes of each node in the DAG to obtain the hash value of the DAG. The WL Hash algorithm ensures that isomorphic DAGs have the same hash value and strong guarantees that the hash values of non-isomorphic DAGs have significant differences. Therefore, the accuracy of the filtering results can be guaranteed.

Section [5](#S5) of the paper describes two configurations of operator information for nodes when using the WL hash algorithm: ‘Operator w/Attributes’ and ‘Operator w/o Attributes.’ Therefore, we will publish the ‘Filter’ series separately for these two types.

#### B.1.3 The Split Series

To facilitate researchers’ reproducing all the experiments in this paper and related AIGNNA research, we have provided corresponding segmented datasets for the two paradigms of AIGNNA based on the ‘Filter’ series dataset, which we refer to as the ‘Split’ series. For details, please look at the ‘Dataset Splits’ subsection of Appendix [D](#A4) for each paradigm. We also publish the ‘Split’ series separately for the ‘Operator w/Attributes’ and ‘Operator w/o Attributes’ types, the same as ‘Filter.’

### B.2 Dataset Versioning

All versions of the series of datasets will be released follow Semantic Versioning 2.0.0 (^10^1010Semantic Versioning 2.0.0 [https://semver.org/spec/v2.0.0.html](https://semver.org/spec/v2.0.0.html)). We will provide detailed version control specifications on the dataset’s official website in the future, which will be briefly introduced here, given version number MAJOR MINOR.PATCH: When entries in the dataset need to be revised, the version number will increase to PATCH. When there is a significant change in the statistical characteristics of the dataset, the MINOR version will be increased. The MAJOR version number will be added when the dataset undergoes overall changes due to special reasons such as format or settings.

## Appendix C Access and Contribute to Younger

### C.1 Official Websites

To involve researchers worldwide in AIGNNA research, we have established an official website (^11^1111Official Website [https://datasets.yangs.cloud/younger](https://datasets.yangs.cloud/younger)) for Younger, which provides functions such as querying, downloading, and contributing to datasets. The website also offers this paper’s experimental code and code for dataset construction to support researchers in building private datasets. It includes the following main functions:

#### C.1.1 Dataset

Firstly, we provide the ability to select versions for downloading three different series of datasets. Secondly, we support researchers in uploading models in ONNX format, or that can be converted to ONNX format, thereby expanding Younger. Considering the issue of model privacy, we provide an offline architecture extraction tool to ensure that researchers can extract the DAG of the neural network architecture without leaking parameters and then upload the DAG through our official website. Finally, we also support online browsing, querying all neural network architectures in Younger, and generating subsets of data for on-demand selection and downloading.

#### C.1.2 Code

We open source all the source code used to build the dataset on our official website (^12^1212Source Code on Official Website [https://datasets.yangs.cloud/younger/code](https://datasets.yangs.cloud/younger/code)) and GitHub (^13^1313Source Code on GitHub [https://github.com/Jason-Young-AI/Younger](https://github.com/Jason-Young-AI/Younger)).
In addition, we also provide the source code for all the experiments involved in this paper to facilitate subsequent research, especially AIGNNA.
For information on how to use the code, please refer to the official documentation or the GitHub homepage.

### C.2 LICENSE

Our dataset adopts the [CC BY-NC-ND 4.0](https://creativecommons.org/licenses/by-nc-nd/4.0/) license. Before using it, please carefully read the detailed statement in the license agreement.
In addition, since our dataset is obtained from various open-source model repositories and then extracted architectures.
So, if any architecture data items violate the license declared by the model provider, please contact us, and we will cancel the publication of the relevant architecture.

## Appendix D Experimental Details

This section offers a more detailed examination of the experiments discussed in the main paper. Specifically, it addresses five critical components: Local Data Flow Design and Local Operator Design within the Local Paradigm and Node, Subgraph, and Graph Embedding in the context of Statistical Analysis. It offers a comprehensive introduction and discussion of dataset splits, training details, model selection, results, and analytical insights.

### D.1 Local Data Flow Design

#### D.1.1 Dataset Splits

Before splitting the dataset, we removed graphs with nodes or edges less than one from the ‘Filter’ dataset. Subsequently, the dataset was divided into training, validation, and test sets in a ratio of 8:1:1 with a random seed to be set as 1234. To better meet the need for local data flow design, we removed graphs in the validation set and test set with operator type not appearing in the training set to maintain training performance. Ultimately, there were 5994, 690, and 685 unique architectures in training, validation, and test sets for node features denoted as ‘Operator w/ Attributes.’ For node features denoted as ‘Operator w/o Attributes,’ there were 5612, 639, and 648 unique architectures in training, validation, and test sets, respectively.

#### D.1.2 Baseline Model Configuration

The architectures of three baseline models represented by topological diagrams under the local data flow design paradigm are shown in Figure [8](#A4.F8) and Table [6](#A4.T6) indicates the number of parameters. It is worth mentioning that the outputs of multi-head attention of GAT are averaged instead of concatenated.

**Table 6: Number of Parameters of Local Data Flow Design Baseline Models.**
| Model | Operator w/ Attributes | Operator w/o Attributes |
| --- | --- | --- |
| Number of Parameters | Number of Parameters |  |
| GCN | 5,360,384 | 849,664 |
| GAT | 9,960,192 | 5,449,472 |
| SAGE | 6,015,744 | 1,505,024 |

Figure: Figure 8: Topological diagram of three baseline models: GCN, GAT, and SAGE .
Refer to caption: /html/2406.15132/assets/x8.png

#### D.1.3 Training Configuration

In this version, we set the random seed to 12345 and chose Adam as the optimizer for the local data flow design training process. Other hyperparameters were set as shown in Table [7](#A4.T7).
The experiments for local operator design were conducted on a server running Ubuntu 22.04.1 LTS. It has four identical A800-80GB GPUs and an Intel(R) Xeon(R) Gold 6348 CPU @ 2.60GHz with 112 cores. All the baseline models for data flow design were trained on four identical A800-80GB GPUs.

**Table 7: Training Details of Local Data Flow Design. ‘LR,’ ‘WD,’ and ‘BS’ in the header represent Learning Rate, Weight Decay, and Batch Size, respectively**
| Model | Operator w/ Attributes | Operator w/o Attributes |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| LR | WD | BS | LR | WD | BS |  |
| GCN [] | 1e-4 | 5e-5 | 1 | 1e-4 | 5e-5 | 1 |
| GAT [] | 1e-4 | 5e-5 | 1 | 1e-4 | 5e-5 | 1 |
| SAGE [] | 1e-4 | 5e-5 | 1 | 1e-4 | 5e-5 | 1 |

#### D.1.4 Metrics

Area under the Receiver Operating Characteristic Curve (AUC):

$$ $\text{TPR}=\frac{\text{TP}}{\text{TP}+\text{FN}},$ (1) $$

$$ $\text{FPR}=\frac{\text{FP}}{\text{FP}+\text{TN}}.$ (2) $$

For the Receiver Operating Characteristic (ROC) Curve, the Y axis represents the true positive rate (TPR) while the X axis represents the false positive rate (FPR).
A value of AUC close to 1 represents a better classification prediction performance.

F1 Score (F1):

$$ $\text{F1}=\frac{2\cdot\text{TP}}{2\cdot\text{TP}+\text{FP}+\text{FN}},$ (3) $$

where TP, FP, and FN represent the number of true positives, false positives, and false negatives, respectively.

Average Precision (AP):

$$ $\text{AP}=\sum_{n=1}^{N}(R_{n}-R_{n-1})P_{n},$ (4) $$

where $R$ and $P$ represent the precision and recall, while $n$ denotes the $n$th threshold.

#### D.1.5 Checkpoint Selection

We chose checkpoints to test the performance of baseline models based on the weighted average of all the metrics reported during validation. The weighted averages of AUC, F1, and AP were calculated to measure the performance of baseline models. In this version, all weights are set to be the same.

#### D.1.6 Results and Analysis

We set up our configuration as stated in Section [D.1.3](#A4.SS1.SSS3) and used GCN, GAT, and GraphSAGE for six experiments under the data flow design paradigm on Younger. As shown in Table [8](#A4.T8), these three baseline models perform well on all metrics. It is worth noting that GCN outperforms other models in all metrics except F1 Score, regardless of whether the operators have attributes.

**Table 8: Local paradigm: data flow design. Bold values represent the best-performing results.**
| Model | Operator w/ Attributes | Operator w/o Attributes |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| AUC$\uparrow$ | F1$\uparrow$ | AP$\uparrow$ | AUC$\uparrow$ | F1$\uparrow$ | AP$\uparrow$ |  |
| GCN [] | 0.9933 | 0.7893 | 0.9924 | 0.9949 | 0.7907 | 0.9942 |
| GAT [] | 0.9195 | 0.8023 | 0.8974 | 0.9133 | 0.7960 | 0.8937 |
| SAGE [] | 0.9702 | 0.8005 | 0.9682 | 0.8991 | 0.8053 | 0.8591 |

### D.2 Local Operator Design

#### D.2.1 Dataset Splits

Due to the lack of relevant research on extracting building blocks for neural network architecture. Therefore, we performed community detection on all DAGs (Neural Network Architecture) in the ‘Filter’ dataset to extract the building blocks of the neural network architecture. Through community detection, we can identify the closely connected node sets in the graph to help identify subsets of nodes with specific correlations or functional associations. Although there is no evidence to suggest that the subgraphs extracted by community detection are effective building blocks for neural network architecture, in this paper, it is reasonable to use this method to extract subgraphs for preliminary validation to test the feasibility of Local Operator Design.

We adopt the Clauset Newman Moore Grey modularity maximization method [] as the community detection algorithm and set it to detect at least one community, the DAG itself.
For each community, we simultaneously query its node boundary and label it as the node to be predicted. The community and node boundary form a new subgraph, and the definition of node boundary is shown in Formula [5](#A4.E5).

$$ $\mathcal{B}=\{v|v\in\mathcal{D}-\mathcal{C},u\in\mathcal{C},(u,v)\in\mathcal{E}\},$ (5) $$

where $\mathcal{D}$, $\mathcal{C}$, and $\mathcal{E}$ represent the node set of DAG and the node set of community and edge set of DAG, respectively, and $(u,v)$ indicates two directed edges $<u,v>$ and $<v,u>$.

Finally, we will deduplicate the subgraphs formed by all community and node boundary pairs, i.e., remove isomorphic subgraphs. Finally, 38,803 and 29,581 non-isomorphic subgraphs were obtained under the configurations of ‘Operator w/ Attributes’ and ‘Operator w/o Attributes’, respectively.
To obtain the final training, validation, and test sets, we split all non-isomorphic subgraphs in an 8:1:1 ratio. Specifically, under the ‘Operator w/ Attribute’ configuration, the training, validation, and testing sets contain 31,282, 3,769, and 3,752 subgraphs, respectively, while under the ‘Operator w/o Attribute’ configuration, they include 23,775, 2,907 and 2,899 subgraphs, respectively.

#### D.2.2 Baseline Model Configuration

The architectures of baseline models represented by topological diagrams under the local operator design paradigm are shown in Figure [9](#A4.F9) and Table [9](#A4.T9) indicates the number of parameters.
For experiments with GAE and VGAE under the local operator design paradigm, we first pre-trained the encoders of GAE and VGAE, then trained the linear layers for classification using the output from encoders. For GAT, the outputs of multi-head attention of GAT are averaged instead of concatenated.

**Table 9: Number of Parameters of Local Operator Design Baseline Models.**
| Model | Operator w/ Attributes | Operator w/o Attributes |
| --- | --- | --- |
| Number of Parameters | Number of Parameters |  |
| GCN | 7,301,433 | 809,145 |
| GAT | 26,852,041 | 5,153,353 |
| SAGE | 10,083,129 | 1,428,153 |
| GAE-Encoder | 6,089,216 | 1,763,840 |
| GAE-Classification | 2,261,817 | 94,905 |
| VGAE-Encoder | 6,614,016 | 2,288,640 |
| VGAE-Classification | 2,261,817 | 94,905 |

Figure: Figure 9: Topological diagram of five baseline models: GCN, GAT, SAGE, GAE, and VGAE .
Refer to caption: /html/2406.15132/assets/x9.png

#### D.2.3 Training Configuration

In this version, we set the random seed to 12345 and chose Adam as the optimizer for the local operator design training process. Other hyperparameters were set as shown in the Table [10](#A4.T10).
The experiments for local operator design were conducted on a server running Ubuntu 22.04.1 LTS. It has four identical A800-80GB GPUs and an Intel(R) Xeon(R) Gold 6348 CPU @ 2.60GHz with 112 cores. GAT, GCN, and SAGE were trained on four A800-80GB GPUs, while GAE and VGAE were trained on one A800-80GB GPU.

**Table 10: Training Details of Local Operator Design. ‘LR,’ ‘WD,’ and ‘BS’ in the header represent Learning Rate, Weight Decay, and Batch Size, respectively.**
| Model | Operator w/ Attributes | Operator w/o Attributes |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| LR | WD | BS | LR | WD | BS |  |
| GCN [] | 1e-3 | 5e-5 | 512 | 1e-3 | 5e-5 | 512 |
| GAT [] | OOM | OOM | OOM | 1e-3 | 5e-5 | 512 |
| SAGE [] | 1e-3 | 5e-5 | 512 | 1e-3 | 5e-5 | 512 |
| GAE-Encoder [] | 1e-4 | 5e-5 | 512 | 1e-4 | 5e-5 | 512 |
| GAE-Classification [] | 1e-3 | 5e-4 | 512 | 1e-3 | 5e-4 | 512 |
| VGAE-Encoder [] | 1e-4 | 5e-5 | 512 | 1e-4 | 5e-5 | 512 |
| VGAE-Classification [] | 1e-3 | 5e-4 | 512 | 1e-3 | 5e-4 | 512 |

#### D.2.4 Metrics

Accuracy (ACC): The ratio of correctly predicted instances to the total instances.

F1 Score (F1):

$$ $\text{F1}=\frac{2\cdot\text{TP}}{2\cdot\text{TP}+\text{FP}+\text{FN}},$ (6) $$

where TP, FP, and FN represent the number of true positives, false positives, and false negatives, respectively.

Precision (Prec):

$$ $\text{Precision}=\frac{\text{TP}}{\text{TP}+\text{FP}},$ (7) $$

where TP and FP represent the number of true positives and false positives.

Recall:

$$ $\text{Recall}=\frac{\text{TP}}{\text{TP}+\text{FN}},$ (8) $$

where TP and FN represent the number of true positives and false negatives.

#### D.2.5 Checkpoint Selection

We chose checkpoints to test the performance of baseline models based on the weighted average of ACC, F1 Score, Precision, and Recall reported during validation. In this version, all weights are set to be the same. For the encoder of GAE and VGAE, we chose the checkpoint on training step 4000, whose training loss remained stable.

#### D.2.6 Results and Analysis

We set configuration as stated in Section [D.2.3](#A4.SS2.SSS3). Baseline models, including GCN, GAT, GAE, VGAE, and SAGE, were used under the operator design paradigm. As shown in Table [11](#A4.T11), all baseline models achieve high accuracy but perform poorly in other metrics. The reason can be attributed to the complexity of Younger and further to the complexity of the neural network architectures in the real world. Another reason is that some typical types of operators appear more frequently while others appear less frequently, causing the model to be biased toward predicting the majority of operators. It can be seen that all baseline models in experiments w/o attributes achieve higher F1, Precision, and Recall compared to those in experiments w/ attributes. This indicates that reducing the variety of operators and making their distribution more uniform can improve the multi-classification performance. In addition, among these baseline models, SAGE performs excellently on almost all metrics. Notice that GAT lacks experiments with Operator w/ Attributes due to excessively large parameter counts as shown in Table [9](#A4.T9), resulting in out-of-memory issues during execution.

**Table 11: Local paradigm: operator design. Bold values represent the best-performing results. ‘Prec.’ in the header represents Precision.**
| Model | Operator w/ Attributes | Operator w/o Attributes |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ACC$\uparrow$ | F1$\uparrow$ | Prec.$\uparrow$ | Recall$\uparrow$ | ACC$\uparrow$ | F1$\uparrow$ | Prec.$\uparrow$ | Recall$\uparrow$ |  |
| GCN [] | 0.7454 | 0.1294 | 0.1666 | 0.1323 | 0.7627 | 0.2988 | 0.3750 | 0.2941 |
| GAT [] | OOM | OOM | OOM | OOM | 0.7163 | 0.2007 | 0.2519 | 0.1979 |
| GAE [] | 0.8173 | 0.0484 | 0.0658 | 0.0467 | 0.8179 | 0.1514 | 0.1815 | 0.1438 |
| VGAE [] | 0.8224 | 0.0724 | 0.0924 | 0.0712 | 0.8243 | 0.1969 | 0.2500 | 0.1881 |
| SAGE [] | 0.8049 | 0.1927 | 0.2385 | 0.1878 | 0.9238 | 0.3477 | 0.4144 | 0.3375 |

### D.3 Node Embedding

#### D.3.1 Checkpoint Selection

To better illustrate the distribution of operators in Younger in high-dimensional space, we selected checkpoints of baseline models according to the method from section [D.2.5](#A4.SS2.SSS5) and then extracted the embeddings of operators with attributes and those without attributes from node embedding layer of baseline models. Due to the problem about memory overflow, the visualization of ‘Operator w/o Attributes’ about GAT is not presented. To compare the training effectiveness, we also extracted the embeddings from the initial node embedding layer without loading any checkpoints.

#### D.3.2 Visualization

Figure [11](#A4.F11)-[13](#A4.F13) show the t-SNE visualization results of node embeddings before and after training from GCN and SAGE with node features denoted as ‘Operator w/ Attributes.’ The orange points represent Younger’s top 500 most frequently occurring operators. It can be observed that before training, the distribution of node embeddings is relatively concentrated and chaotic. After training, the distribution of embeddings representing high-frequency nodes selected and other low-frequency nodes from Younger was well distinguished. This indicates an uneven distribution of node quantities among different types, which introduces bias into the learning process of baseline models.

Figure: Figure 10: Node embeddings before training (GCN - Operator w/ Attributes)
Refer to caption: /html/2406.15132/assets/x10.png

Figure: Figure 12: Node embeddings before training (SAGE - Operator w/ Attributes)
Refer to caption: /html/2406.15132/assets/x12.png

Figure [15](#A4.F15)-[19](#A4.F19) show the t-SNE visualization results of node embeddings before and after training from GCN, GAT, and SAGE with node features denoted as ‘Operator w/ Attributes.’ The orange points represent Younger’s top 20 most frequently occurring operators. It can be seen that the distribution of node embeddings is relatively concentrated before training, while the distribution of all embeddings is uniform after training. This result indicates baseline models learned the features of different nodes well.

Figure: Figure 14: Node embeddings before training (GCN - Operator w/o Attributes)
Refer to caption: /html/2406.15132/assets/x14.png

Figure: Figure 16: Node embeddings before training (GAT - Operator w/o Attributes)
Refer to caption: /html/2406.15132/assets/x16.png

Figure: Figure 18: Node embeddings before training (SAGE - Operator w/o Attributes)
Refer to caption: /html/2406.15132/assets/x18.png

Figure: Figure 20: Subgraph embeddings (GCN - Operator w/ Attributes)
Refer to caption: /html/2406.15132/assets/x20.png

Figure: Figure 22: Subgraph embeddings (SAGE - Operator w/ Attributes)
Refer to caption: /html/2406.15132/assets/x22.png

Figure: Figure 24: Subgraph embeddings (GAT - Operator w/o Attributes)
Refer to caption: /html/2406.15132/assets/x24.png

Figure: Figure 25: Graph embeddings (GCN - Operator w/ Attributes)
Refer to caption: /html/2406.15132/assets/x25.png

Figure: Figure 27: Graph embeddings (SAGE - Operator w/ Attributes)
Refer to caption: /html/2406.15132/assets/x27.png

Figure: Figure 29: Graph embeddings (SAGE - Operator w/o Attributes)
Refer to caption: /html/2406.15132/assets/x29.png

### D.4 Subgraph Embedding

#### D.4.1 Checkpoint Selection

To better illustrate the distribution of subgraphs in Younger in high-dimensional space, we selected checkpoints of baseline models according to the method from Section [D.2.5](#A4.SS2.SSS5). Then, we calculated the embeddings of these subgraphs using operators with attributes and those without attributes.

#### D.4.2 Visualization

Figure [21](#A4.F21)-[24](#A4.F24.1) show the t-SNE visualization results of all subgraph embeddings under the GCN, GAT, and SAGE models. Due to memory overflow in ‘Operator w/ Attributes’ of GAT, we only present the visualization of ‘Operator w/o Attributes’ about GAT. As can be seen, all three models have distinguished the embeddings of subgraphs well, but due to data bias, node embeddings were not learned particularly well. Therefore, the models only distinguished the embeddings of subgraphs well in a part of the spatial distribution (the boundary of the space).
In addition, compared to ‘Operator w/o Attributes,’ ‘Operator w/ Attributes’ has a finer granularity in distinguishing subgraph embeddings, i.e., different clusters occupy less space.

### D.5 Graph Embedding

#### D.5.1 Obtaining Method

We obtain the graph embeddings by averaging the embeddings of all subgraphs in each DAG.
Therefore, each baseline model can generate two types of graph embeddings: ‘Operator w/Attributes’ and ‘Operator w/o Attributes.’
However, due to memory overflow in ‘Operator w/ Attributes’ of GAT, we only present the visualization of ‘Operator w/o Attributes’ about GAT.

#### D.5.2 Visualization

Figure [26](#A4.F26)-[29](#A4.F29.1) show the t-SNE visualization results of all graph embeddings under the GCN, GAT, and SAGE models.
We mark the embeddings of several commonly used models in figures in different colors. Several architectures have shown almost similar results. It can be seen that, on the one hand, the embeddings of DAGs based on the same architecture are very close or even overlap in the graph; for example, there are many points of the RoBERTa [] and ViT [] architectures, which are Transformer-based [] architectures, that are close in distance or overlap. On the other hand, it can be seen that the Younger dataset covers multiple common architectures well, indicating that Younger covers most of the neural network architectures in the real world.
In addition, the same architecture has multiple points of the same color in the figures, indicating that the dataset contains various variants of this type of architecture.

## Appendix E Author Contributions

- •
Zhengxin Yang: He led the project and proposed its idea. He independently implemented the project’s code, including the dataset’s construction code, the primary framework for application experiments, and statistical analysis.
- •
Jianfeng Zhan: Proposed the concept of AIGNNA, participated in the entire project discussion, provided constructive suggestions, and provided guidance and supervision.
- •
Wanling Gao: Participated in the discussion of the entire project, helped improve the idea of dataset application orientation, and provided constructive suggestions for application experiments.
- •
Luzhou Peng: Participated in the debugging process of the code and jointly implemented a portion of the experimental code with Zhengxin Yang. He independently implemented some statistical analysis experimental code and partially participated in project discussions.
- •
Yunyou Huang: He partially participated in project discussions and provided annotations on performance metric values, although Younger did not include this.
- •
Fei Tang: Participated in discussions on the initial ideas of the project.

## Checklist

- 1.
For all authors…
(a)
Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
[Yes]
(b)
Did you describe the limitations of your work?
[Yes] In Section [5](#S5)
(c)
Did you discuss any potential negative societal impacts of your work?
[N/A]
(d)
Have you read the ethics review guidelines and ensured that your paper conforms to them?
[Yes]
- 2.
If you are including theoretical results…
(a)
Did you state the full set of assumptions of all theoretical results?
[N/A]
(b)
Did you include complete proofs of all theoretical results?
[N/A]
- 3.
If you ran experiments (e.g. for benchmarks)…
(a)
Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
[Yes] See Appendix [D](#A4)
(b)
Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
[Yes] See Appendix [D](#A4)
(c)
Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
[N/A]
(d)
Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
[Yes] See Appendix [D](#A4)
- 4.
If you are using existing assets (e.g., code, data, models) or curating/releasing new assets…
(a)
If your work uses existing assets, did you cite the creators?
[Yes] We provide citations for all resources and baselines
(b)
Did you mention the license of the assets?
[Yes] See Appendix [C.2](#A3.SS2)
(c)
Did you include any new assets either in the supplemental material or as a URL?
[N/A]
(d)
Did you discuss whether and how consent was obtained from people whose data you’re using/curating?
[N/A]
(e)
Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?
[N/A]
- 5.
If you used crowdsourcing or conducted research with human subjects…
(a)
Did you include the full text of instructions given to participants and screenshots, if applicable?
[N/A]
(b)
Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
[N/A]
(c)
Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
[N/A]

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: See above.
soundness: 3
strengths: The study is highly relevant and timely for NAS-related fields, with the potential to generate a high impact on the community.  

The effort invested in this work seems quite substantial.

The writing and the presentation are clear and easy to follow.
summary: This study produced a dataset of 7k unique models, Younger, from 174k publicly available models and 30 tasks. After processing and filtering, architectures are stored as acyclic graphs based on ONNX definitions.  The study aims to automate architecture generation and refinement.  It offers a range of statistical analyses to illustrate the diversity of Younger.  Several experiments are also included to show the potential of Younger, especially as a benchmark for GNN.
weaknesses: The goal of this study is quite ambitious, allowing people to search for good architectures using Younger for a wide range of tasks.  The experimental section shall match that ambition, e.g. demonstrating the applicability and benefits of Younger on a wide range of tasks.  This would help illustrate the practical application of the dataset.
* Provide a concrete example, or case study showing how Younger could be used for a specific task like CIFAR-10 classification and ImageNet classification.
* Other possible cases can be performing time series prediction
* Or creating generative models.
* Or multimodal models for a specific task e.g. text-to-video or description or caption generation task.

---

Also the paper claims Younger is advantageous in comparison with benchmarks like DARTS, NAS-Bench-201.  Other than the difference between them, as shown in Table 1, how would they compare in a specific task, e.g. using different sets for the same task?  The study should show Younger's advantages clearly, e.g. leading to better performance, reducing search costs etc.
* Conduct a comparative experiment using Younger and a benchmark like NAS-Bench-201 on a common task, measuring metrics like search efficiency and final model performance.

---
  
Clearly state whether AIGNNA is a novel term introduced in this paper.  If not, provide the appropriate citation.

---

The code and the dataset link cannot be found in the submission.
* Provide direct links to the code repository and dataset, perhaps in a dedicated "Resources" section.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: Please see the weaknesses. Overall, this paper is interesting and the proposed YOUNGER dataset seems to be useful in several directions. Giving all these, I’d like to recommend the score 6 temporarily.
soundness: 3
strengths: 1) Constructing the dataset for neural architectures in the AI-generated manner is novel and interesting. 
2) The paper is nicely written and well organized. The details for the dataset and construction processes are clearly presented. 
3) The AI-generated architectures in different types are very helpful to several research directions.
summary: This paper presents a novel dataset for AI-generated neural network architectures. Specifically, the construction process contains four core steps, i.e., retrieving NN models, converting the models to ONNX format, extracting DAGs from the ONNX models, and filtering out isomorphic DAGs to ensure the uniqueness of the architectures. Some experimental results support the statistical analysis and present some distributions of the whole dataset.
weaknesses: 1) More details in terms of the use of the proposed YOUNGER dataset are expected. For example, it is possible to provide at least one case using the YOUNGER dataset, such as performing some NAS algorithms to search for architectures in this dataset? 
2) The experimental results are mainly focus on GNNs. However, it seems that there can be other types of architectures contained by YOUNGER. Could the authors provide additional experimental results in terms of other types of architectures beyond GNNs?
3) More details for the distribution of the performance of architectures are needed.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: in the paper it is stated in line 284 that "less than 1% of these models represent heterogeneous and effective architectures. This notably low proportion of heterogeneous architectures highlights the limitations of current neural network design methods, both manual and NAS-based, in fostering architectural innovation".   

How did the author decide whether an architecture is heterogeneous?  and what does it mean by effective architecture?   In addition, all architectures are from online sources should be mostly manually built right?    It is really surprising that out of all models available online, less than 1% are really valid.
soundness: 3
strengths: 1. The paper presents a good contribution to the community by offering a dataset that can potentially faciliate the research in the neural architecture search field.

2. The dataset published can overcome challenges of previous related datasets in terms of operator scope and scale.
summary: The paper presents a dataset for neural network architectures extracted from public model sources. Then convert these models to intermediate representation operators for further research purpose.  The dataset incorporates richer operator than existing neural architecture datasets, to facilitate more research in the field.
weaknesses: One complaint I have regarding this dataset comparing with existing NASbench dataset is that the proposed dataset doesn't seem to have the associated training performance on a standardized dataset.  In comparison, the NASbench dataset is evaluated on a standard task (Cifar10) on different settings.  Because of this, user can only perform unsupervised analysis like shown in figure 3-6.

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 1
questions: Section 4.3.2: different tasks have different evaluation metrics and ranges for different datasets [9], so how do you handle that?
Section 4.3.3: Can you provide more information on exactly what this is, in terms of framing it through citations and potential tables/figures presenting the results? That would be a better use of page real estate than Figs 2-6 which are more appendix details.

References:

[1] Liu, Yuqiao, et al. "Bridge the gap between architecture spaces via a cross-domain predictor." Advances in Neural Information Processing Systems 35 (2022): 13355-13366.

[2] Mills, Keith G., et al. "Gennape: Towards generalized neural architecture performance estimators." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 37. No. 8. 2023.

[3] Yang, Yichen, et al. "Equality saturation for tensor graph superoptimization." Proceedings of Machine Learning and Systems 3 (2021): 255-268.

[4] Zhang, Chenhao, et al. "Towards better generalization for neural network-based sat solvers." Pacific-Asia Conference on Knowledge Discovery and Data Mining. Cham: Springer International Publishing, 2022.

[5] Mills, Keith G., et al. "Building Optimal Neural Architectures using Interpretable Knowledge." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2024.

[6] Schrodi, Simon, et al. "Construction of hierarchical neural architecture search spaces based on context-free grammars." Advances in Neural Information Processing Systems 36 (2024).

[7] Salameh, Mohammad, et al. "AutoGO: automated computation graph optimization for neural network evolution." Advances in Neural Information Processing Systems 36 (2024).

[8] White, Colin, et al. "How powerful are performance predictors in neural architecture search?." Advances in Neural Information Processing Systems 34 (2021): 28454-28469.

[9] Mills, Keith G., et al. "Aio-p: Expanding neural performance predictors beyond image classification." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 37. No. 8. 2023.
soundness: 2
strengths: Strengths:
- The dataset consists of many diverse architectures from different tasks.
- Breaking the confines of predefined search spaces is a good step forward for NAS.
summary: This manuscript proposes Younger, a dataset comprising of neural network ONNX graph representations collected from various online repositories. Each ONNX graph is annotated with some kind of task performance. The goal of Younger is to fuel Artificial Intelligence-Generated Neural Network Architecture (AIGNNA) generation, in order to break the confines of pre-established search spaces. The manuscript consists of tables and figures tabulating/illustrating features of the Younger dataset, as well as some limited experiments on AIGNNA Exploration.
weaknesses: Weaknesses:
- Primary weakness of this paper is that its key contribution is not novel at all. While it is true that predefined search spaces pose a large problem for NAS, there are existing works that break the confines of predefined search spaces, enabling generalizable prediction across different micro, cell-based NAS search spaces [1] and even between micro and macro search spaces [2], using ONNX as the generalizable representation [3, 4, 5] or otherwise. This paper does not seem to recognize such existing works.
- AIGNNA in Section 4.3, the authors illustration is flawed for Fig. 7 left. You would not have a choice between 'Add' and 'ReLU' since ReLU is an activation applied to one single input, while 'Add' combines several inputs into one. A better choice would be to ask 'ReLU' or 'SiLU' or 'Add' vs. 'Concat'. Here still, there is existing work on generating new architectures outside of pre-existing search spaces [6, 7]. 
- Experimental results in Section 4.3.2 is not very convincing as you are focusing on testing different GNN designs (which govern the message passing rule, not necessarily graph feature design), while there are numerous neural predictors in the literature [8] which are better compared to. Also, ACC, F1, Prec. and Recall are generally not evaluation metrics for neural predictors; rather, rank correlation (Kendall's Tau or Spearman Rho) and regression error (L1) are more common [8]. 
- Overall presentation in the paper is very lacking. Table and Figure captions are too short and do not adequately convey enough information, while most figures (2 - 6) should be re-tweaked with larger fonts.