Hydra-SGG: Hybrid Relation Assignment for One-stage Scene Graph Generation

## Abstract

Abstract DETR introduces a simplified one-stage framework for scene graph generation (SGG). However, DETR-based SGG models face two challenges: i) Sparse supervision , as each image typically contains fewer than 10 relation annotations, while the models employ over 100 relation queries. This sparsity arises because each ground truth relation is assigned to only one single query during training. ii) False negative samples , since one ground truth relation may have multiple queries with similar matching scores. These suboptimally matched queries are simply treated as negative samples, causing the loss of valuable supervisory signals. As a response, we devise Hydra-SGG 1 1 1 Hydra is an abbreviation for “ Hy bri d R elation A ssignment”. The name is chosen because it reflects the multi-branch structure of our model, which resembles the multiple heads of the Hydra in Greek mythology. , a one-stage SGG method that adopts a new Hybrid Relation Assignment. This assignment combines a One-to-One Relation Assignment with a newly introduced IoU-based One-to-Many Relation Assignment. Specifically, each ground truth is assigned to multiple relation queries with high IoU subject-object boxes. This Hybrid Relation Assignment increases the number of positive training samples, alleviating sparse supervision. Moreover, we, for the first time, empirically show that self-attention over relation queries helps reduce duplicated relation predictions. We, therefore, propose Hydra Branch, a parameter-sharing auxiliary decoder without a self-attention layer. This design promotes One-to-Many Relation Assignment by enabling different queries to predict the same relation. Hydra-SGG achieves state-of-the-art performance with 10.6 mR@20 and 16.0 mR@50 on VG150, while only requiring 12 training epochs. It also sets a new state-of-the-art on Open Images V6 and GQA.

## 1 Introduction

Figure: Figure 1: Comparisons with other SGG methods in terms of mR@50 and training epochs on VG150 [].
Refer to caption: x1.png

Scene graph is a data structure that describes the entities (objects) in a scene and the relations between these objects []. Scene graph generation (SGG) has attracted significant research attention [; ; ; ] due to its ability to enhance machines’ semantic comprehension of visual content. It has been widely adopted in various downstream applications, such as robotic vision and interaction [; ; ; ], image synthesis and manipulation [; ; ], visual question answering [; ; ], and video understanding [; ; ; ].

Mainstream SGG methods [; ; ; ; ; ] work in a two-stage fashion. First, an off-the-shelf object detector extracts all entities within an image. Then, the extracted entities are permuted, yielding $N(N\!-\!1)$ entity pairs for $N$ detected entities. These entity pairs are used to predict the relationships between the corresponding entities. However, the two-stage methods face a critical limitation: they predict relations for all entity pairs, even though many pairs do not participate in any relations. This incurs heavy computational overhead and time-consuming inference in complex scenes with numerous entities.

Figure: Figure 2: GT stands for Ground Truth. (a) Previous DETR-based SGG methods such as RelTR [] and SGTR [] match each GT relation with only one query. (b) Our Hybrid Relation Assignment utilizes both One-to-One and One-to-Many assignments, generating more positive samples, and thus accelerating training.
Refer to caption: x2.png

Recently, the inherent simplicity of DETR-based SGG methods has led to an ongoing paradigm shift apart from the two-stage framework. Specifically, a sequence of visual tokens, mapped from the input image, interacts with a predefined set of relation queries in a Transformer decoder for simultaneous object detection and relation prediction. Then, One-to-One set matching (*i.e*., Hungarian matching []) is used to assign ground
truth labels to the predictions (Fig.${}_{\!}$ 2a). This set-prediction framework allows DETR-based SGG models to eliminate hand-designed components, such as Non-Maximum Suppression (NMS), which are commonly used in traditional two-stage methods.

Unfortunately, one significant drawback of DETR-based SGG models is their slow convergence. For instance, one-stage RelTR [] requires 150 training epochs to converge, while a recent two-stage method, PE-Net [], only needs 32 epochs. This drawback can be attributed to the sparse relation supervision induced by Hungarian matching, which assigns each ground truth to only one relation query. The sparsity of relation annotations per image further exacerbates this issue. Taking VG150 [] train as an example, there are, on average, only 5.5 ground truth relation triplets per image []. This means that each image provides a mere 5.5 positive relation queries to optimize the loss functions. In the case of RelTR [], which has 200 predefined relation queries, only $2.75\%$ of these queries are positive samples per optimization step. Consequently, relation queries require more optimization steps to learn due to the limited number of positive samples for training. Furthermore, approximately $50\%$ [] of the plausible but suboptimally matched queries (*i.e*., queries with correct subject-object classification and IoU $>$ 0.6 for both boxes) are simply treated as no-relation due to the One-to-One constraint. This constraint discards valuable supervisory signals by treating suboptimal yet informative queries as negative samples. These queries, while not the best matches for ground truth labels, may capture informative relational cues that could contribute to model learning. Simply assigning these queries as negative samples may introduce false negatives, which in turn leads to label noise and performance degradation [].

To improve the training efficacy and performance of DETR-based SGG models, we introduce Hydra-SGG. The core of Hydra-SGG is Hybrid Relation Assignment (Fig.${}_{\!}$ 2b); it synergizes One-to-One and One-to-Many Relation Assignment strategies, providing over 50% more positive queries per training step than previous arts such as RelTR []. Specifically, an IoU-based One-to-Many Relation Assignment is devised, allowing each ground truth label to be assigned to multiple relation queries with high IoU between their predicted subject-object boxes and the ground truth. Moreover, we provide empirical evidence that removing self-attention in the decoder leads to different queries making duplicate relation predictions. With such insight, we introduce an auxiliary branch, dubbed Hydra Branch, to further enhance One-to-Many Assignment. This branch is a decoder without self-attention layers and shares all other parameters with the original decoder. Hydra Branch encourages the predictions of different queries to converge to the same relation, creating a synergy with the proposed One-to-Many Relation Assignment. This synergistic integration of Hydra Branch and One-to-Many Relation Assignment further improves the overall performance (§3.3).

Hydra-SGG makes three key contributions to the field of SGG: First, the proposed Hybrid Relation Assignment increases both the quality and quantity of positive relation queries. By allowing each ground truth to be assigned to multiple queries based on their IoU scores, Hydra-SGG effectively alleviates the sparse supervision issue. Second, as a one-stage SGG model, Hydra-SGG not only achieves state-of-the-art results on the challenging VG150 [] but also exhibits a remarkably fast convergence rate. It converges faster than existing one-stage SGG counterparts [; ; ] with 10$\times$ fewer training epochs. Third, Hydra Branch does not introduce any architectural modifications or additional parameters. It is only used during training and is dropped in the inference stage, causing no additional computational load or delay in the inference stage.

Extensive experiments on three challenging SGG benchmarks, VG150 [], GQA [], and Open Images V6 [], demonstrate the effectiveness of our proposed method. Notably, Hydra-SGG achieves 16.0 mR@50 on VG150 test in only 12 epochs (Fig.${}_{\!}$ 1), surpassing the previous state-of-the-art one-stage method SGTR [] by +4.0 and two-stage method PE-Net [] by +3.6.

## 2 Related Work

Two-stage SGG. Lu *et al*. [] first proposed SGG task and designed a two-stage pipeline. Later, many SGG models have been built on it, using various techniques such as recurrent neural networks or its variants [; ; ; ], visual translation embedding [; ], graph neural networks [; ; ; ; ], external or internal knowledge integration [; ; ; ; ; ], attention mechanisms [; ; ], and Transformer-based models [; ; ; ; ; ; ].

Despite promising performance, two-stage SGG methods rely heavily on manually designed modules, such as NMS, anchor generation, and entity pairing generation modules. In addition, their designs typically involve separate stages for detection, pairing, and relation classification, resulting in a complicated pipeline that cannot be trained in a fully end-to-end manner. Furthermore, these methods predict dense entity pairs in inference, leading to high time complexity and computational burden. For example, if there are 100 detected entities, approximately 10,000 pairs need to be processed. In contrast, this paper proposes Hydra-SGG, a one-stage SGG method that offers significant advantages over two-stage methods. Hydra-SGG enables end-to-end training and surpasses the performance of two-stage methods.

One-stage SGG. One-stage methods have gained increasing attention for their simplicity and end-to-end training ability. Early works in this line adopt CNN-based one-stage detectors [] or query-based sparse R-CNN [] for direct relationship prediction. Recently, the DETR [] framework significantly advances SGG and Human-Object Interaction [; ; ; ; ; ; ; ; ]. This framework enables end-to-end training by associating ground truth labels with output queries. For instance, SGTR [] uses predicate and entity queries to associate relation features, while RelTR [] employs disentangled queries to extract relation features and directly predict relations. SpeaQ [] designs multiple groups of relation-specific queries to learn relation representations effectively.

DETR-based SGG models eliminate NMS but suffer from slow convergence due to sparse relation supervision, requiring significantly more training epochs than two-stage counterparts (*e.g*., 150 for RelTR [] vs. 32 for PE-Net []). To address this limitation, we propose Hydra-SGG, which introduces a Hybrid Relation Assignment. This method exhibits fast convergence compared to two-stage approaches like PE-Net [] and VETO []. Like other DETR-based SGG models, Hydra-SGG eliminates the need for complicated pipelines or hand-crafted components such as NMS.

DETR for Object Detection. The introduction of DETR by Carion *et al*. [] marks a significant shift away from traditional CNN-based object detection models [; ; ; ; ], adopting an end-to-end trainable approach with a novel application of the Transformer architecture and bipartite matching. While DETR streamlines the detection process, it requires 500 epochs to converge []. This spurs a wave of research that focuses on improving low training efficacy, including enhancing training signal [; ; ; ], the adoption of anchor boxes [; ; ], and the leverage of efficient attention mechanism [; ]. For instance, Co-DETR [] introduces extra groups of object queries and DN-DETR [] utilizes noisy queries to increase positive samples.

In this paper, we present Hydra-SGG, a framework that addresses the sparse relation supervision challenge inherent in DETR-based SGG models. Our method introduces Hybrid Relation Assignment, which significantly increases the number of positive samples per training iteration, effectively mitigating the sparse relation supervision issue and accelerating the model’s convergence.

## 3 Hydra-SGG

§3.1 introduces our baseline model, which employs One-to-One Relation Assignment. Next, §3.2 describes Vanilla Hydra-SGG, which enhances the baseline by introducing a Hybrid Relation Assignment strategy. This strategy combines the standard One-to-One Relation Assignment with our One-to-Many Relation Assignment, bringing more than $50\%$ positive samples to each training step compared to the baseline. Finally, §3.3 details the complete Hydra-SGG model, which includes Hydra Branch, an auxiliary decoder that promotes One-to-Many Relation Assignment.

### 3.1 One-to-One Relation Assignment Baseline

Problem Formulation.
Given an input image, SGG models aim to generate a scene graph in the form of relation triplet: $\langle e_{\text{sub}},\rho,e_{\text{obj}}\rangle$, where each entity $e_{\text{sub}},e_{\text{obj}}\in\mathcal{E}$ is represented by a category label $c\in\mathcal{C}$ (*e.g*., cat, people, car) and a bounding box $b$, and $\rho\in\mathcal{P}$ is a specific relation type (*e.g*., on, have, ride). In this paper, we distinguish between the terms “relation” and “relation triplet”. A relation refers to the interaction or relationship between entities, while a relation triplet represents the complete structure containing the subject $e_{\text{sub}}$, object $e_{\text{obj}}$, and their relation $\rho$.

Baseline Architecture.
Our baseline model is composed of a Backbone, a Encoder, and a RelDecoder (Relation Decoder). The relation queries interact with image tokens extracted from the input image by Backbone and Encoder. The updated queries are processed by box regression heads, entity classification heads, and a relation classification head to obtain the final predictions.

- •
Backbone:
Backbone maps an input image into a feature map that has a ${H\times W\times C}$ dimension, where $H$ and $W$ denote the spatial size of the feature map, while $C$ is the channel dimension (*e.g*., 2048 or 1024).
- •
Encoder:
Encoder captures comprehensive spatial and contextual information across the image. Before feeding the feature map into Encoder, a 1$\times$1 conv layer is employed to reduce the dimension of the feature map. The enhanced image tokens are denoted as ${\bm{F}}\in\mathbb{R}^{HW\times 256}$.
- •
RelDecoder:
In RelDecoder, we introduce relation queries $\bm{Q}_{\text{rel}}\in\mathbb{R}^{N\times 512}$ (), which are formed by concatenating subject queries $\bm{Q}_{\text{sub}}\in\mathbb{R}^{N\times 256}$ and object queries $\bm{Q}_{\text{obj}}\in\mathbb{R}^{N\times 256}$ along the channel dimension (*i.e*., 256). Here $N$ denotes the number of queries. $\texttt{RelDecoder}(\bm{Q}_{\text{sub}},\bm{Q}_{\text{obj}},\bm{F})$ works as follows:
$\displaystyle\tilde{\bm{Q}}_{\text{sub}},\tilde{\bm{Q}}_{\text{obj}}$
$\displaystyle=\texttt{SA}([\bm{Q}_{\text{sub}},\bm{Q}_{\text{obj}}])\in\mathbb
{R}^{2N\times 256},$
(1)
$\displaystyle\bar{\bm{Q}}_{\text{sub}}$
$\displaystyle=\texttt{CA}(\bm{F},\tilde{\bm{Q}}_{\text{sub}})\in\mathbb{R}^{N
\times 256},$
$\displaystyle\bar{\bm{Q}}_{\text{obj}}$
$\displaystyle=\texttt{CA}(\bm{F},\tilde{\bm{Q}}_{\text{obj}})\in\mathbb{R}^{N
\times 256}.$
Specifically, the subject queries $\bm{Q}_{\text{sub}}$ and object queries $\bm{Q}_{\text{obj}}$ first interact in a self-attention layer (SA) to obtain updated queries $\tilde{\bm{Q}}_{\text{sub}}$ and $\tilde{\bm{Q}}_{\text{obj}}$. Subsequently, these updated queries interact with image tokens in cross-attention layers (CA).
The output subject and object queries are fed into independent box regression heads and classification heads, producing box predictions $\bar{b}_{\text{sub}},\bar{b}_{\text{obj}}\in\mathbb{R}^{N\times 4}$ and entity class predictions $\bar{p}_{\text{sub}},\bar{p}_{\text{obj}}\in\mathbb{R}^{N\times|\mathcal{C}|}$, respectively. The relation predictions $\bar{p}_{\text{rel}}\in\mathbb{R}^{N\times|\mathcal{P}|}$ are obtained by a relation prediction head. For example, with 300 relation queries (*i.e*., $N\!=\!300$) and 50 relation classes (*i.e*., $|\mathcal{P}|\!=\!50$), the output dimension of $\bar{p}_{\text{rel}}$ would be $300\times 50$. Finally, the outputs of RelDecoder are combined to generate the predicted relation triplets $\bar{\bm{R}}\!=\!\{\langle(\bar{p}_{\text{sub}},\bar{b}_{\text{sub}}),\bar{p}_
{\text{rel}},(\bar{p}_{\text{obj}},\bar{b}_{\text{obj}})\rangle_{n}\}_{n=1}^{N}$. Note that the $i$-th subject query is concatenated only with the $i$-th object query, and there is no permutation process.
- •
One-to-One Relation Assignment Loss.
In One-to-One Relation Assignment Loss $\mathcal{L}_{\text{o2o}}$ [; ], Hungarian matching (HM) is employed to find the optimal correspondence between the predicted relation triplets $\bar{\bm{R}}$ and the ground truth triplets $\bm{R}$. The loss function can be formulated as:
$\mathcal{L}_{\text{o2o}}=\mathcal{L}_{\texttt{HM}}(\bar{\bm{R}},\bm{R}).
\vspace{+3pt}$
(2)
The classification losses (including entity and relation) and box regression losses are computed between matched predictions and ground truth labels, which is identical with the previous models [; ]. The Hungarian matching hyperparameters are the same as RelTR []. A detailed implementation of the loss function is provided in Appendix. The evaluation of our baseline model is given in §4.3.

Figure: Figure 3: Overall pipeline of Hydra-SGG: For simplicity, FFN inside the Transformer layer are omitted. Hydra-SGG incorporates two Transformer decoders: HydraBranch and RelDecoder. HydraBranch shares its parameters with RelDecoder but removes self-attention layers. Hydra-SGG combines One-to-One and One-to-Many assignments in a synergy, generating more supervision signals.
Refer to caption: x4.png

### 3.2 Vanilla Hybrid Relation Assignment

As mentioned in §1, VG150 [] contains an average of only 5.5 ground truth relation triplets per image in train. Our baseline adopts One-to-One Relation Assignment and only assigns approximately 5 out of 300 relation queries to match the ground truth relation triplets for each image (*i.e*., $N\!=\!300$). This severe sparse supervision reduces the training efficacy, as only about 2% of queries in each training step match with ground truth labels for learning, while the remaining 98% are treated as negative samples. Consequently, the model requires a significantly higher number of training steps to learn effectively, leading to slow convergence.

To enrich the relation supervision signals, we propose a Hybrid Relation Assignment. Specifically, we first devise a One-to-Many Relation Assignment (o2m) and then embed it into the baseline to cooperate with One-to-One Relation Assignment. Given a ground truth triplet $\bm{r}\!=\!\langle(c_{\text{sub}},b_{\text{sub}}),\ c_{\text{rel}},(c_{\text{
obj}},b_{\text{obj}})\rangle\in\bm{R}$ and a predicted triplet $\bar{\bm{r}}=\langle(\bar{p}_{\text{sub}},\ \bar{b}_{\text{sub}}),\ \bar{p}_{
\text{rel}},(\bar{p}_{\text{obj}},\ \bar{b}_{\text{obj}})\rangle\in\bar{\bm{R}}$, the One-to-Many Assignment score $\mathcal{S}_{\texttt{o2m}}$ is calculated by:

$$ $\mathcal{S}_{\texttt{o2m}}(\bm{r},\bar{\bm{r}})=\bar{p}_{\text{sub}}^{[c_{ \text{sub}}]}+\bar{p}_{\text{obj}}^{[c_{\text{obj}}]}+\text{IoU}(b_{\text{sub} },\bar{b}_{\text{sub}})+\text{IoU}(b_{\text{obj}},\bar{b}_{\text{obj}}).$ (3) $$

$\mathcal{S}_{\texttt{o2m}}$ combines the predicted class probabilities and IoU scores for the subject and object bounding boxes. The notations $\bar{p}_{\text{sub}}^{[c_{\text{sub}}]}$ and $\bar{p}_{\text{obj}}^{[c_{\text{obj}}]}$ represent the probabilities of the ground truth classes for the subject and object, respectively. For example, if the ground truth subject class $c_{\text{sub}}$ is 3, we would extract the probability corresponding to class 3 from $\bar{p}_{\text{sub}}$.

Given $M$ ground truth relation triplets and $N$ predicted relation triplets, the final One-to-Many Relation Assignment score matrix, with dimensions $M\!\times\!N$, is computed by applying Eq. 3 to each pair of ground truth and predicted relation triplets. We keep the results with scores greater than a threshold $T$ and select the top 6 queries for each ground truth (see details in §4.3).

The proposed Vanilla Hydra-SGG applies both One-to-One and One-to-Many Relation Assignment strategies to the same set of predicted relation triplets $\bar{\bm{R}}$. These triplets are obtained from the updated queries $\bm{Q}_{\text{rel}}$ after passing through the model. By combining these two assignment strategies, we can formulate the vanilla version loss function as:

$$ $\mathcal{L}_{\text{vanilla}}=\mathcal{L}_{\text{{o2o}}}(\bar{\bm{R}},\bm{R})+ \mathcal{L}_{\text{o2m}}(\bar{\bm{R}},\bm{R}).$ (4) $$

Our Vanilla Hydra-SGG provides richer relation supervision signals compared to the baseline by harmonizing the supervision of two assignment strategies. Specifically, it increases the number of positive samples by 65.5% in VG150 [] train and 58.7% in val (Fig.${}_{\!}$ 4a, b).Vanilla Hydra-SGG significantly improves training efficacy and performance (§4.3).

Figure: Figure 4: (a) presents the average number of positive samples of VG150 train and val for One-to-One and Hybrid Relation Assignment. (b) Percentage increase in positive samples achieved by Hybrid Relation Assignment compared to the One-to-One baseline. (c) ADS on VG150 val. (d)-(e) The visualizations show that for the same group of queries that previously predicted different relations, removing the self-attention layers causes them to make the same predictions. The Q ID column represents the ID for each relation query.
Refer to caption: x5.png

### 3.3 Complete Hydra-SGG

Each RelDecoder layer contains self- and cross-attention layers, and a point-wise feed-forward network (FFN). The self-attention layer enables inter-query interactions [], while cross-attention and FFN do not explicitly support query interactions. Previous studies indicate that self-attention helps inhibit duplicate predictions [; ]. In this work, we further find that the self-attention layer in RelDecoder is crucial to reduce duplicated relation predictions.

We introduce a Diversity Score (DS) to quantify the impact of the self-attention layer on the diversity of relation predictions. Specifically, DS is defined as the number of distinct relation categories predicted by the model for a single image. For example, if the model predicts relations for 5 queries as (sit, sit, on, on, has), DS would be 3, as there are 3 distinct relation categories (sit, on, has). We calculate DS using the trained Vanilla Hydra-SGG model, with and without self-attention in the RelDecoder. Let $\text{DS}_{\text{on}}^{(k)}$ and $\text{DS}_{\text{off}}^{(k)}$ represent the DS for the $k$-th image with self-attention enabled and disabled, respectively. The average DS (ADS) across the dataset is then computed as:

$$ $\displaystyle\text{ADS}_{\text{on}}=\frac{1}{K}\sum\nolimits_{k=1}^{K}\text{DS }_{\text{on}}^{(k)},\quad\text{ADS}_{\text{off}}=\frac{1}{K}\sum\nolimits_{k=1 }^{K}\text{DS}_{\text{off}}^{(k)},$ (5) $$

where $K$ is the total number of images. A higher $\text{ADS}_{\text{on}}$ compared to $\text{ADS}_{\text{off}}$ would indicate that self-attention promotes diverse relation predictions. As shown in Fig.${}_{\!}$ 4c, $\text{ADS}_{\text{off}}$ and $\text{ADS}_{\text{on}}$ of VG150 [] val are 4.6 and 6.6, respectively. Fig.${}_{\!}$ 4d, e illustrate how the self-attention layer enables diverse relation predictions. Without self-attention, queries converge to the same relation. These examples demonstrate self-attention’s role in reducing duplicate relations.

The above findings reveal critical interactions between self-attention and One-to-Many Relation Assignment: i) Conflict with Self-Attention: Applying One-to-Many Relation Assignment strategy to self-attention-updated relation queries in RelDecoder of Vanilla Hydra-SGG causes a mismatch in optimization objectives, as self-attention promotes diversity while One-to-Many Relation Assignment assigns one ground truth to multiple queries. ii) Benefit without Self-Attention: Conversely, removing self-attention leads to more duplicated relation predictions, potentially synergizing with our One-to-Many Relation Assignment.

To address this potential conflict and fully harness the benefits of both the self-attention layers and the One-to-Many Relation Assignment strategy, we propose HydraBranch (Hydra Branch, Fig.${}_{\!}$ 3), an auxiliary decoder that shares parameters with RelDecoder but removes the self-attention layers. This multi-branch architecture decouples the learning objectives: the self-attention layers in the main RelDecoder can focus on promoting diversity in relation predictions, while HydraBranch facilitates One-to-Many Relation Assignment. This separation enables each branch to optimize its specific function without compromising the other.

HydraBranch operates with the main RelDecoder in parallel, processing the same input but without the influence of self-attention layers. Specifically, the initial One-to-Many relation queries $\bm{Q}_{\text{rel}}^{\text{o2m}}$ () are set to $\bm{Q}_{\text{rel}}$ (*i.e*., $\bm{Q}_{\text{rel}}^{\text{o2m}}\!=\!\bm{Q}_{\text{rel}}$) before being sent into HydraBranch. The process of $\texttt{HydraBranch}(\bm{Q}_{\text{sub}}^{\text{o2m}},\bm{Q}_{\text{obj}}^{
\text{o2m}},\bm{F})$ is as follows:

$$ $\displaystyle\begin{aligned} \bar{\bm{Q}}_{\text{sub}}^{\text{o2m}}=\texttt{CA }(\bm{F},\bm{Q}_{\text{sub}}^{\text{o2m}})\in\mathbb{R}^{N\times 256},\quad \bar{\bm{Q}}_{\text{obj}}^{\text{o2m}}=\texttt{CA}(\bm{F},\bm{Q}_{\text{obj}}^ {\text{o2m}})\in\mathbb{R}^{N\times 256}.\end{aligned}$ (6) $$

The One-to-Many predicted relation triplets $\bar{\bm{R}}^{\text{o2m}}\!=\!\{\langle(\bar{p}^{\text{o2m}}_{\text{sub}},\bar
{b}^{\text{o2m}}_{\text{sub}}),\bar{p}^{\text{o2m}}_{\text{rel}},(\bar{p}^{
\text{o2m}}_{\text{obj}},\bar{b}^{\text{o2m}}_{\text{obj}})\rangle_{n}\}_{n=1}
^{N}$ are derived in the same manner as $\bar{\bm{R}}$ and share prediction heads with $\bar{\bm{R}}$. Compared with Eq. 1, subject and object queries do not interact in a self-attention layer before they are sent into subsequent cross-attention layers. We apply One-to-Many Relation Assignment described in Eq. 3 to $\bar{\bm{R}}^{\text{o2m}}$ and ${\bm{R}}$. Hybrid Relation Assignment Loss is then given by:

$$ $\mathcal{L}_{\text{Hydra}}=\mathcal{L}_{\texttt{o2o}}(\bar{\bm{R}},\bm{R})+ \mathcal{L}_{\texttt{o2m}}({\bar{\bm{R}}^{\text{o2m}}},\bm{R}).$ (7) $$

By incorporating HydraBranch, the complete version of Hydra-SGG achieves 10.6 and 16.0 on mR@20 and mR@50, respectively, in just 12 training epochs, further boosting the performance compared to the vanilla version (§4.3). Note that HydraBranch is used only in training and discarded in inference, thus bringing no extra parameters or delay.

## 4 Experiment

### 4.1 Experimental Setup

Datasets. We conduct experiments on three datasets:

- •
Visual Genome (VG150) [; ] contains 150 entity and 50 relation categories. It is split into 57,723 training, 5,000 validation, and 26,446 testing images.
- •
Open Images V6 [] features 288 entity and 30 relation categories, including 126,368 training, 1,813 validation, and 5,322 testing images with relation annotations.
- •
GQA [] encompasses 200 entity and 100 relation types, with a split of 52,623 training, 5,000 validation, and 8,209 testing images annotated for SGG tasks.

Evaluation Metrics.
We focus on the scene graph detection (SGDet) setting on VG150 [], GQA [] and Open Images V6 [] datasets. For VG150 and GQA, we report Recall@$k$ (R@$k$) and mean Recall@$k$ [; ] (mR@$k$) performance, mR@K calculates R@K for each predicate individually, then averages these values. It is important to note that recall metrics are more influenced by dataset bias [], whereas mean recall provides a more holistic evaluation of the model’s performance. For Open Images V6, we follow evaluation protocols []: Recall@50, the weighted mean Average Precision (wmAP) for relationship detection (wmAPrel), and phrase detection (wmAPphr). The overall score, denoted as score${}_{\textit{wtd}}$, is calculated as a weighted average of these metrics: $0.2\times\text{R@50}+0.4\times\text{wmAP}_{rel}+0.4\times\text{wmAP}_{phr}$.

Competitors. Hydra-SGG is compared with methods from two categories. The first category contains two-stage SGG methods, including MOTIFS [], VCTree-TDE [], BGNN [], PE-Net [], IS-GGT [], VETO [], and UniVRD [], CFA [], SHA []. The second consists of one-stage methods including SGTR [], ISG [], RelTR [], DSGG [], SpeaQ [], EGTR [].

Implementation Details.
Following the commonly used settings of DETR-like SGG models [; ], we employ ResNet50 [] as our backbone. We implement various DETR-based techniques in our baseline and proposed models, including anchor boxes, training techniques, and attention mechanisms as used in recent works [; ; ; ]. Our model utilizes the same One-to-One Relation Assignment strategy from RelTR [] and matching hyperparameters. Our model architecture consists of a 6-layer Transformer encoder and a 6-layer Transformer decoder, each with 256 dimensions and 8 attention heads, which is the same as previous studies [; ; ]. The prediction heads are shared for RelDecoder and HydraBranch. All models are trained from scratch using AdamW optimizer with an initial learning rate of 2e-4 and the total batch size is 16. More implementation details, including hyperparameter settings and data preprocessing, are provided in Appendix.

### 4.2 Quantitative Comparison Result

VG150 [] test. Table 1 reports the comparison results on VG150 test. Hydra-SGG demonstrates outstanding performance on challenging SGDet, achieving mR@20 and mR@50 scores of 10.6 and 16.0, respectively, setting a new state-of-the-art. Hydra-SGG achieves this performance with significantly shorter training time, requiring only 12 epochs. This training time is substantially shorter compared to SpeaQ [], EGTR [], and DSGG [], with reductions of 40, 263, and 48 epochs, respectively. Despite the shorter training, Hydra-SGG outperforms these methods by +4.2, +8.1, and +3.0 on the mR@50. Furthermore, it even outperforms the state-of-the-art two-stage model, PE-Net [], by a margin of 3.6 on the mR@50 metric. It is crucial to acknowledge that the backbone model employed by DSGG [] is not disclosed in their paper, and the authors could not provide this information upon request. This raises concerns about the fairness of the comparison, as DSGG [] may use Swin-L [] as the backbone model.

**Table 1: SGDet evaluation on VG150 [] test (§4.2). The methods are categorized into two- and one-stage groups. Epochs marked with ^+ include detector pre-training time on VG150. FPS (Frames Per Second) indicates inference speed. Higher FPS values represent faster inference.**
| Method | Backbone | # Epoch | FPS | # Param (M) | R@20 | R@50 | R@100 | mR@20 | mR@50 | mR@100 |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Two-stage methods |  |  |  |  |  |  |  |  |  |  |  |
| MOTIFS []​​ | ​​[CVPR2018] | ResNeXt101-FPN | - | - | 369.9 | 25.1 | 32.1 | 36.9 | 4.1 | 5.5 | 6.8 |
| VCTree-TDE []​​ | ​​[CVPR2020] | ResNeXt101-FPN | - | - | 361.3 | 14.3 | 19.6 | - | 6.3 | 9.3 | 11.1 |
| BGNN []​​ | ​​[CVPR2021] | ResNeXt101-FPN | - | - | 341.9 | 23.3 | 31.0 | 35.8 | 7.5 | 10.7 | 12.7 |
| PE-Net []​​ | ​​[CVPR2023] | ResNeXt101-FPN | 32^+ | - | - | - | 30.7 | 35.2 | - | 12.4 | 14.5 |
| IS-GGT []​​ | ​​[CVPR2023] | ResNet101 | 70 | - | - | - | - | - | - | 9.1 | 11.3 |
| VETO []​​ | ​​[ICCV2023] | ResNeXt101-FPN | 33^+ | - | - | - | 27.5 | 31.5 | - | 8.1 | 9.5 |
| UniVRD []​​ | ​​[ICCV2023] | CLIP ViT-B | - | - | - | - | - | - | - | 9.6 | 12.1 |
| DRM []​​ | ​​[CVPR2024] | ResNeXt101-FPN | - | - | - | - | 34.0 | 38.9 | - | 9.0 | 11.2 |
| One-stage methods |  |  |  |  |  |  |  |  |  |  |  |
| SGTR []​​ | ​​[CVPR2022] | ResNet101 | 123^+ | - | 117.1 | - | 25.1 | 26.6 | - | 12.0 | 14.6 |
| ISG []​​ | ​​[NeurIPS2022] | ResNet101 | 52 | - | 93.5 | - | 29.5 | 32.1 | - | 7.4 | 8.4 |
| RelTR []​​ | ​​[TPAMI2023] | ResNet50 | 150 | 6.5 | 63.7 | 21.2 | 27.5 | 30.7 | 6.8 | 10.8 | 12.3 |
| DSGG []​​ | ​​[CVPR2024] | - | 60 | - | - | - | 32.9 | 38.5 | - | 13.0 | 17.3 |
| SpeaQ []​​ | ​​[CVPR2024] | ResNet101 | 52 | - | - | - | 32.9 | 36.0 | - | 11.8 | 14.1 |
| EGTR []​​ | ​​[CVPR2024] | ResNet50 | 275^+ | - | 42.5 | 23.5 | 30.2 | 34.3 | 5.5 | 7.9 | 10.1 |
| Ours |  |  |  |  |  |  |  |  |  |  |  |
| Hydra-SGG ​​ | ​​ | ResNet50 | 12 | 5.3 | 67.6 | 21.9 | 28.4 | 33.1 | 10.6 | 16.0 | 19.7 |

**Table 2: Evaluation on Open Images V6 [] test (§4.2). Epochs marked with ^+ include detector pre-training time on Open Images V6. Performance metrics include R@50 (recall at 50), wmAPrel (weighted mAP for relationships), wmAPphr (weighted mAP for phrases), and score${}_{\textit{wtd}}$ (weighted score).**
| Method | Backbone | # Epoch | # Param (M) | R@50 | wmAP${}_{\textit{rel}}$ | wmAP${}_{\textit{phr}}$ | score${}_{\textit{wtd}}$ |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Two-stage methods |  |  |  |  |  |  |  |  |
| Motifts []​​​​​ | ​​​​​​[CVPR2018] | ResNeXt101-FPN | - | 369.9 | 71.6 | 29.9 | 31.6 | 38.9 |
| BGNN []​​​​​ | ​​​​​​[CVPR2021] | ResNeXt101-FPN | - | 341.9 | 75.0 | 35.5 | 34.2 | 42.1 |
| PE-Net []​​​​​ | ​​​​​​[CVPR2023] | ResNeXt101-FPN | - | - | 76.5 | 35.4 | 34.9 | 44.9 |
| One-stage methods |  |  |  |  |  |  |  |  |
| SGTR []​​​​​ | ​​​​​​[CVPR2022] | ResNet101 | 123^+ | 117.1 | 59.9 | 37.0 | 38.7 | 42.3 |
| RelTR []​​​​​ | ​​​​​​[TPAMI2023] | ResNet50 | 150 | 63.7 | 71.7 | 34.2 | 37.5 | 43.0 |
| EGTR []​​​​​ | ​​​​​​[CVPR2024] | ResNet50 | 275^+ | 42.5 | 75.0 | 42.0 | 41.9 | 48.6 |
| Ours |  |  |  |  |  |  |  |  |
| Hydra-SGG ​​ | ​​ | ResNet50 | 7 | 67.6 | 76.1 | 42.8 | 44.3 | 50.1 |

Open Images V6 [] test. As shown in Table 2, Hydra-SGG achieves SOTA in only 7 epochs while SGTR [], RelTR [] and EGTR [] require 119, 150, and 275 epochs. Although Open Images V6 contains more than 120,000 images, its scenes are not as complex as those in VG150 []. Training Hydra-SGG for 7 epochs is sufficient to achieve good performance.

**Table 3: Evaluation on GQA [] test (§4.2).**
| Method | Backbone | R@50 | R@100 | mR@50 | mR@100 |  |
| --- | --- | --- | --- | --- | --- | --- |
| SHA []​ | ​[CVPR2022] | ResNeXt101-FPN | 25.5 | 29.1 | 6.6 | 7.8 |
| VETO []​ | ​[ICCV2023] | ResNeXt101-FPN | 26.1 | 29.0 | 7.0 | 8.1 |
| CFA []​ | ​[ICCV2023] | ResNeXt101-FPN | - | - | 10.8 | 12.6 |
| Ours |  |  |  |  |  |  |
| Hydra-SGG ​ | ​​ | ResNet50 | 22.8 | 26.5 | 12.7 | 15.9 |

GQA [] test. Our experimental results demonstrate that Hydra-SGG achieves SOTA mean Recall performance on GQA. As shown in Table 3, HydraSGG achieves 12.7 and 15.9 for mR@50 and mR@100 respectively, surpassing previous best results. Our model employs the relatively lightweight ResNet50 as its backbone, in contrast to the heavier ResNeXt101 used by other methods. Notably, CFA [] achieves good mR results using unbiasing techniques, but Hydra-SGG surpasses these without such methods. Our approach outperforms CFA by 1.9 and 3.3 in mR@50 and mR@100 respectively, demonstrating its effectiveness.

**Table 4: A set of ablative experiments about on VG150 [] test (§4.3). The adopted hyperparameters are marked in red.**
| Method | mR@20 | mR@50 | # Epoch |
| --- | --- | --- | --- |
| Baseline | 8.7 | 12.9 | 50 |
| Vanilla Hydra-SGG | 9.9 (+1.2) | 14.9 (+2.0) | 12 |
| Hydra-SGG | 10.6 (+1.9) | 16.0 (+3.1) | 12 |

### 4.3 Diagnostic Experiment

We will conduct ablation studies to address the following key questions: (1) How effective are the core components of Hydra-SGG? (2) How does the training efficiency of Hydra-SGG compare to existing methods? (3) What is the impact of threshold $T$ in One-to-Many Relation Assignment on model performance? (4) How do the number of training epochs influence model performance? (5) What is the effect of the number of relation queries on model performance? Through these experiments, we aim to comprehensively evaluate various aspects of Hydra-SGG.

Key Components.
We first investigate the effectiveness of our core Hybrid Relation Assignment (§3.2) and Hydra Branch (§3.3) in Table 4(a). The first row gives the score of our baseline model (§3.1). The second row corresponds to the result of Vanilla Hydra-SGG, which directly utilizes Hybrid Relation Assignment into RelDecoder. The third row lists the results of the full Hydra-SGG model. We can find that taking the proposed Hybrid Relation Assignment in the baseline model improves the mean recall and achieves 9.9/16.0 mR@20/mR@50. Furthermore, the integration of Hydra Branch with One-to-Many Relation Assignment yields a synergistic effect, boosting performance substantially. Specifically, Hydra Branch increases mR@20 from 9.9 to 10.6 and mR@50 from 14.9 to 16.0, highlighting the complementary nature of these two strategies.

Training Efficacy. In Table 4(b), we compare the training time cost on VG150 []. All models are trained on eight NVIDIA 4090 GPUs with a ResNet50 backbone. Our model achieves 16.0 mR@50 in 720 minutes, whereas RelTR takes 3,000 minutes to achieve 6.8 mR@50. This demonstrates the improved training efficacy of Hydra-SGG.

Threshold $T$.
We next study the influence of the threshold $T$ in One-to-Many Relation Assignment in Table 4(c). The threshold $T$ controls the quality and quantity of positive relation queries. A higher value of $T$ keeps only the high-quality positive relation queries but at the cost of reducing their number. Conversely, lowering $T$ yields more positive samples, but their quality may decrease. This trade-off between quality and quantity directly affects the final performance of the model. Experimental results show optimal performance at $T=0.4$, yielding mR@20 of 10.6 and mR@50 of 16.0. As we increase $T$ to 0.5 and 0.6, the performance gradually decreases. This suggests that while maintaining high-quality positive samples is important, having a sufficient number of them is also crucial for the model to learn effectively.

Training Epochs.
We further investigate the influence of training epochs on the performance. As presented in Table 4(d), Hydra-SGG achieves state-of-the-art mean Recalls in just 12 epochs, demonstrating its fast convergence. We observe further improvements when increasing the epochs to 21, *i.e*., 10.6 mR@20 and 16.0 mR@50 respectively. However, the performance decreases at epoch 24, with mR@20 and mR@50 dropping to 10.4 and 15.2, respectively. This reduction in performance can be attributed to overfitting.

Number of Relation Queries.
Lastly, we studied the effect of the number of relation queries on model performance, as shown in Table 4(e). The performance with 200 queries and 400 queries is inferior to that with 300 queries. The model achieved mR@20/50 of 9.9/15.3 with 200 queries, and 10.6/15.5 with 400 queries. In contrast, with 300 queries, the model reached its highest performance, with 10.6 mR@20 and 16.0 mR@50. We hypothesize that using 200 queries may be insufficient to capture the diversity of relationships within the data. On the other hand, using 400 queries could introduce excessive noise and false positives, thereby reducing the overall precision of the model.

Figure: Figure 5: Qualitative results §4.4. (a)-(d) compare Hydra-SGG and RelTR [] on a VG150 [] val image. We use the same color for each entity category, and the color of a predicate matches that of its subject. Differences are highlighted with red dashed rectangles . (e)-(g) show scene graphs generated by Hydra-SGG from images sourced from [Unsplash](https://unsplash.com), a platform for freely-usable images. These images are real-world, “in the wild” scenarios, demonstrating our model’s capability to handle diverse and unseen visual content.
Refer to caption: x7.png

### 4.4 Qualitative Comparison Result

In Fig.${}_{\!}$ 5a-d, we visualize the generated scene graph results on the image of VG150 [] val. Both Hydra-SGG and RelTR [] detect plausible relations, but these relations were not annotated, so these reasonable predictions become false negatives. Our Hydra-SGG detects more fine-grained relations such as rock-on-mountain and logo-on-shirt, while RelTR fails to detect such relations. In Fig.${}_{\!}$ 5e-g, we visualize generated scene graph results on [Unsplash](https://unsplash.com) images. Hydra-SGG successfully identifies a new species of bird that was not present in the training dataset in Fig.${}_{\!}$ 5e. In Fig.${}_{\!}$ 5f, the model recognizes a truck and a person standing on it against a starry sky background, even though only the black silhouettes of the person and truck are visible. In Fig.${}_{\!}$ 5g, the model successfully identifies trees on a distant mountain, as well as tree-behind-man. This demonstrates the generalization of our method to unseen web images.

## 5 Conclusion

This paper introduces Hydra-SGG, a one-stage DETR-based scene graph generation (SGG) model that addresses the slow convergence issue in existing DETR-based SGG models. The key contributions of our work are as follows: i) We propose a Hybrid Relation Assignment, which combines One-to-One and One-to-Many Relation Assignment strategies to increase relation supervision signals. ii) We introduce a Hydra Branch, an auxiliary decoder that encourages relation queries to predict duplicate relations, further enhancing the proposed One-to-Many Relation Assignment. These innovations work in synergy to significantly accelerate the learning process. Consequently, Hydra-SGG achieves state-of-the-art results on VG150, GQA, and Open Images V6 in just 12, 12, and 7 training epochs, demonstrating remarkable performance and efficiency. Despite these advancements, there are still opportunities for further improvement. Future work should explore integrating Large Language Models (LLMs) with Hydra-SGG to enable open vocabulary SGG. This combination could potentially allow the model to recognize and describe a much wider range of objects and relationships beyond predefined categories.

## Appendix A Appendix

For a better understanding of the main paper, we provide additional details in this supplementary material, which is organized as follows:

- •
§B details the implementation details.
- •
§C provides the pseudo code of Hydra-SGG.
- •
§D shows failure cases of Hydra-SGG in VG150 [].
- •
§E discusses our limitations, societal impact, and directions of future work.

## Appendix B Implementation

Inspired by RelTR [], we also set relation queries to be composed of subject and object queries. We adopt the same training techniques and attention mechanisms as previous works [; ; ] in Hydra-SGG. In particular, we use anchor boxes as embeddings to accelerate training and employ deformable attention [] respectively. We input noised G) box-label pairs to generate both entity and relation denoising queries. To prevent information leakage, we employ attention masks. Given the absence of an attention map in the deformable decoder, we simplify the model by omitting the convolutional mask head in RelTR []. In particular, we concatenate the output subject and object queries and input them into an MLP. This simplification not only reduces computational complexity but also maintains performance.

Both One-to-One and One-to-Many losses are composed of box regression loss, entity classification loss, and relation classification loss as previous works [; ; ; ; ]. Specifically, we use Focal loss [] for both relation and detection, as in previous works [; ; ]. In the post-processing stage, the predictions are first ranked by the relation probability. Then we use the relation index to find corresponding subject and object predictions to compose the prediction triplets. Finally, we follow the same process as RelTR [] that removes predictions where the subject and object are the same, as such data does not exist in VG150 [], but we do not use this process in Open Images V6 [].

For training, we adopt the same data augmentation techniques as RelTR [] but discard random cropping since some triplets could be incomplete. The default training epochs are 12 for VG150 [] and 7 for Open Images V6 []. For VG150, the learning rate is scaled by 0.1 at epoch 11, while for Open Images V6, it is scaled at epoch 6. Open Images V6 [] contains more than 120,000 training images, but most scenes in the dataset are simpler than those in VG150 [], therefore training for 7 epochs is enough to achieve state-of-the-art performance. Extended training on Open Images V6 may improve the performance, but considering the dataset size, the marginal benefits are limited.

Due to the inherent bias in SGG datasets, numerous unbiasing algorithms have been developed [; ; ; ; ]. While adopting these unbiasing techniques typically leads to significant performance improvements, we opt for a fair comparison by evaluating Hydra-SGG against methods that do not employ such techniques.

## Appendix C Pseudo Code

The pseudo-code of Hydra-SGG is given in Algorithm 1. Our code and pre-trained models will be made publicly available.

Figure: Algorithm 1 Hydra-SGG: PyTorch-like Pseudo-code

## Appendix D Failure Cases

In this section, we present failure cases of scene graphs generated by Hydra-SGG on VG150 [] val. In the first row (Fig.${}_{\!}$ 6a-c), Hydra-SGG successfully recognizes the airplane in the image, but the predicted label is ‘plane’. Although ‘plane’ is a plausible label, the ground truth label is ‘airplane’, which leads to all predicted relationships being incorrect since they don’t match the ground truth. However, from a semantic perspective, the model correctly identifies these relationships and even recognizes more fine-grained relationships that are not annotated in the ground truth. For instance, the ground truth only marks the right engine of the airplane, but the model correctly identifies both engines. In addition, the model correctly identifies the logo and windows on the airplane, which are reasonable and correct predictions but are considered incorrect because they are not annotated in the ground truth. In the second row (Fig.${}_{\!}$ 6d-f), the ground truth annotation uses a single box to label two women, which is an unreasonable annotation. The model correctly predicts two women and identifies that both women are wearing shirts and shorts, which are annotations absent in the ground truth but are semantically accurate.

Figure: Figure 6: Failure cases of Hydra-SGG on VG150 [] val.
Refer to caption: x10.png

## Appendix E Discussion

Limitation Analysis.
A significant limitation of the current Hydra-SGG is its inability to predict object and relation categories beyond a predefined closed set. The algorithm can only make predictions for object and relation classes that have been explicitly defined and included in the training dataset. This constraint means that the model lacks the capability to recognize or infer novel object types or relationship categories that were not present during the training phase. Such a limitation restricts the model’s applicability in real-world scenarios, where encountering previously unseen objects or relations is common.

Societal Impact.
Hydra-SGG has the potential to significantly enhance autonomous driving systems, thereby improving road safety and efficiency. For instance, when integrated into self-driving vehicles, Hydra-SGG can provide a deeper understanding of complex traffic scenarios. Beyond merely identifying vehicles, pedestrians, and road signs, it can comprehend the spatial relationships and potential interactions between these elements. This advanced scene understanding could enable autonomous vehicles to more accurately predict the behavior of other road users, leading to safer and more efficient navigation in diverse traffic conditions.

Future Work.
A promising direction for future research is to extend the current model towards open vocabulary SGG. This advancement would allow Hydra-SGG to recognize and predict objects and relationships beyond the predefined closed set of categories used in training.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: please refer to the weakness part.
soundness: 2
strengths: **1.Clear Explanation of Methodology:** The paper does an excellent job of explaining the methodology in a step-by-step fashion. The One-to-One Assignment, One-to-Many Assignment, and HydraBranch are each discussed with sufficient detail, making it easier for readers to follow the technical contributions. Furthermore, the inclusion of pseudocode and diagrams helps clarify how each component interacts within the framework.

**2.Comprehensive Experimental Validation:** The paper provides extensive experiments on two widely-used datasets, Visual Genome, OpenImage, GQA, and demonstrates that Hydra-SGG, consistently outperforms existing baselines. The authors also conduct detailed ablation studies, examining the impact of various components (Threshold T, Training Epoch, Number of Relation Queries). The results substantiate the claim that the framework is a substantial improvement over current model.
summary: The manuscript introduces Hydra-SGG, a novel one-stage Scene Graph Generation (SGG) method designed to address the challenges of sparse supervision and false negative samples inherent in DETR-based SGG models. The authors propose a Hybrid Relation Assignment strategy that combines One-to-One and IoU-based One-to-Many Relation Assignments to increase positive training samples and mitigate sparse supervision issues. Additionally, the paper introduces Hydra Branch, an auxiliary decoder without self-attention layers, to enhance the One-to-Many Relation Assignment by promoting duplicate relation predictions among different queries. The model achieves state-of-the-art performance on multiple datasets, including VG150, Open Images V6, and GQA, with a significant reduction in training epochs compared to previous methods.
weaknesses: **1.Lack of Novelty:** The motivation and methodology of this work closely resemble those presented in [3], raising questions about its originality and distinct contributions. In particular, [3] introduced the one-to-many relation query matching technique, known as Quality-Aware Multi-Assignment, which enhances training efficiency by allowing a single ground truth (GT) to correspond to multiple sufficiently close predictions or queries. While this work makes a slight modification by removing self-attention among relation queries, this adjustment alone does not constitute a significant advancement in one-stage SGG research. As a result, it is difficult to regard this work as a notably innovative contribution. Further discussion is warranted to clarify how this work differentiates itself from existing approaches.
**2.Perverse Experimental Results:** The rationale for assigning ground truth (GT) to multiple sub-optimal queries is based on label softening and knowledge distillation. However, applying this approach to scene graph datasets with long-tailed distributions (e.g., Visual Genome, OpenImage, PSG) introduces significant challenges. This method tends to overemphasize common relationships (e.g., on, of, has) in the annotations, which can lead to model overfitting on these frequent relationships. Consequently, this emphasis on common relationships undermines the model’s ability to accurately capture rare relationships (e.g., standing on, walking on, lying on), ultimately lowering average recall performance. Given these limitations, a decline in mRecall performance would be expected for such datasets. Surprisingly, however, the experimental results in Table 1 show the opposite. Since this study does not incorporate any specific solutions to address data imbalance, the observed improvement in mRecall is unexpected. This outcome appears to contradict the foundational assumptions of the proposed Hydra-SGG approach, indicating a need for further analysis.

**3.Inadequate Model Performance:** Despite showing a substantially lower R@100 score than the DSGG method [6], the Hydra-SGG model demonstrates a corresponding improvement in the mR@100 metric. Based on prior research [5], incorporating the F-Recall metric would provide a more comprehensive assessment of Hydra-SGG’s effectiveness relative to state-of-the-art approaches. Additionally, the paper lacks a thorough comparison with other relevant studies [2].

**Ref:**

[1] Pair then Relation: Pair-Net for Panoptic Scene Graph Generation. Arxiv 2023

[2] Structured Sparse R-CNN for Direct Scene Graph Generation. CVPR 2022

[3] Groupwise Query Specialization and Quality-Aware Multi-Assignment for Transformer-based Visual Relationship Detection. CVPR 2024

[4] Not All Relations are Equal:Mining Informative Labels for Scene Graph Generation. CVPR 2021

[5] Fine-Grained Scene Graph Generation with Data Transfer. ECCV 2022

[6] DSGG: Dense Relation Transformer for an End-to-end Scene Graph Generation. CVPR 2024

---

confidence: 2
contribution: 2
initial_rating: 6
presentation: 3
questions: Does faster convergence come from more diverse samples or more training data within an epoch, because the proposed method is likely to give 16 images, but will generate more relation training pairs for training?

It would be better to compare the methods with unbiased SGG methods or adopted unbiased strategies, considering the higher performance of mean Recall.
soundness: 3
strengths: (1) Innovative Method Design: The proposed Hybrid Relation Assignment effectively combines One-to-One and One-to-Many matching strategies. This design helps mitigate the sparse supervision issue in existing methods and improves model convergence speed and learning efficiency.
(2) Efficient Auxiliary Branch: The Hydra Branch supports One-to-Many assignment by promoting consistent relation predictions across queries, all without adding inference-time computational costs. 
(3) Good Experimental Results: The experimental results show that Hydra-SGG achieves state-of-the-art performance across multiple datasets (VG150, Open Images V6, and GQA), reaching these results in significantly fewer training epochs.
summary: This paper addresses key challenges in the field of one-stage Scene Graph Generation (SGG), particularly focusing on sparse supervision and false negatives samples.To tackle these challenges, the authors propose two main contributions:
(1) Hybrid Relation Assignment: This method combines One-to-One and One-to-Many Relation Assignment strategies, increasing the number of positive samples during training and thus enhancing supervision.
(2) Hydra Branch: An auxiliary decoder branch without self-attention layers, designed to further support the One-to-Many Relation Assignment by promoting consistent relation predictions across queries.
Above methods jointly improve the training efficacy and performance of DETR-based SGG models, leading to state-of-the-art results on multiple benchmarks with significantly fewer training epochs. Overall, this paper’s motivation is clear, and the proposed method iseffective.
weaknesses: (1) Lacking theory/analysis, technical solutions appear to be intuitive and empirical. Faster convergence may come from more diverse samples or more training data within an epoch, because the proposed method is likely to give 16 images, but will generate more relation training pairs for training.

(2) Limited Exploration. Why removing Self-Attention benefits the One-to-Many Relation Assignment. The paper introduces the Hydra Branch without self-attention to support the One-to-Many relation assignment. However, the explanation of why removing self-attention aids this assignment is somewhat surface-level, lacking an in-depth analysis of the interaction between self-attention and One-to-Many assignment.

---

confidence: 4
contribution: 4
initial_rating: 8
presentation: 3
questions: 1. While the One-to-Many alignment approach helps mitigate sparse supervision, there is a concern that it may introduce significant noise, potentially leading to an increase in false positives. What are some strategies to manage this noise effectively?
2. How would performances be impacted if the weights for One-to-One and One-to-Many alignment losses were changed? For example, I'm curious how performance would change if the weight of One-to-Many alignment loss were increased or decreased.
soundness: 4
strengths: 1. This paper pinpoints the critical problems in one-stage SGG, which are sparse supervision and false negatives. By addressing this problem, the proposed method is superior on efficiency and effectiveness.
2. The author conducts extensive experiments, including effectiveness on diverse datasets and ablation studies, thereby validating the superiority of the proposed method. Especially, it significantly reduces the training epoch compared to the baselines.
3. The proposed method is simple yet effective.
summary: This paper proposes a new method called Hydra-SGG for Scene Graph Generation (SGG), which addresses the challenges of sparse supervision and false negatives in one-stage SGG. To this end, it employs a one-to-many assignment strategy and a transformer decoder without self-attention called a hydra-branch. Through comprehensive experiments across various datasets and detailed ablation studies, the paper confirms the efficiency and effectiveness of this method.
weaknesses: The paper lacks discussion on its limitations and future works.

There are no critical points for rejection.

Meta-review: This paper introduces Hydra-SGG, a novel method for scene graph generation that addresses sparse supervision and false negatives by employing a hybrid relation assignment strategy and a Hydra branch decoder. These innovations contribute to improved training and competitive results across several datasets, achieved with relatively few training epochs.

The methodology is acknowledged for its clarity and detail. The effectiveness and efficiency of the proposed approach in tackling critical issues in one-stage scene graph generation, such as sparse supervision and false negatives, are also well-appreciated. The experimental results are robust. However, some concerns and questions were raised during the initial round of feedback, including queries about the originality of the approach compared to existing work, unexpected results in the mRecall metric, insufficient performance metrics, and a lack of thorough analysis and exploration.

The authors have provided detailed clarifications, analyses, and additional experimental results focusing on the F-Recall metric and comparisons with additional baselines. After careful review of the paper, its revisions, and the discussion, I believe the key concerns including model performance and unexpected performance explanation have been adequately addressed. Therefore, I recommend the acceptance of this paper.

Decision: Accept (Poster)