Gap Preserving Distillation by Building Bidirectional Mappings with A Dynamic Teacher

## Abstract

Abstract Knowledge distillation aims to transfer knowledge from a large teacher model to a compact student counterpart, often coming with a significant performance gap between them. We find that a too-large performance gap can hamper the training process, which is also verified in recent studies.
To address this, we propose a Gap Preserving Distillation (GPD) method that trains an additional dynamic teacher model from scratch along with training the student to bridge this gap. In this way, it becomes possible to maintain a reasonable performance gap between teacher and student during the whole distillation process. To further strengthen distillation from the dynamic teacher to the student, we develop a hard strategy by enforcing them to share parameters and encouraging parameter inheritance. Besides hard strategy, we also build the soft bidirectional mappings between them which are built on an Inverse Reparameterization (IR) method and a Channel-Branch Reparameterization (CBR) strategy. We highlight that our IR is able to initialize a larger dynamic teacher with an arbitrary expansion ratio, while preserving exactly the same accuracy as the given student model. In this way, it guarantees that the dynamic teacher and student start from the same point and avoid a too large gap in early stage of training. As for our CBR, with parameter-sharing, it directly extracts an effective student model from the well-learned dynamic teacher without any post-training, making our method highly flexible for model deployment.
In the experiments, GPD significantly outperforms existing distillation methods on top of both CNNs and transformers architectures, achieving up to 1.58% accuracy improvement.
Interestingly, GPD also generalizes well to the scenarios without a pre-trained teacher, including training from scratch and fine-tuning, yielding a large improvement of 1.80% and 0.89% on ResNet18, respectively.

## 1 Introduction

Deep neural networks have achieved remarkable success across various domains (Gu & Dao, ; Liu et al., ; Touvron et al., ; Wang et al., ; Zhang et al., ). However, the high accuracy of these models often comes at the cost of large model sizes.
Recent studies have begun to explore methods to reduce model complexity.
In parallel to model compression techniques (Liu et al., ; Wei et al., ; Hu et al., ; Xiao et al., ), knowledge distillation (KD) (Hinton et al., ) offers a solution by transferring knowledge from complex, high-capacity models to simpler, more lightweight models, thereby achieving effective model compression.

The standard practice of KD is to train a smaller student model to mimic the behavior or predictions of a teacher model (Sun et al., ; Jin et al., ; Zhao et al., ; Li et al., ; Zhao et al., ; Passalis et al., ; Tian et al., ; Zagoruyko & Komodakis, ; Heo et al., ; Chen et al., ; Yang et al., ; Peng et al., ).
However, existing methods often exploit a fixed pre-trained teacher model but it does not always guide the training of student in the most effective way.
To be specific, it has been shown that it is often non-trivial for the student to obtain promising knowledge/improvements from the teacher when there is a very large gap between the teacher and student models, especially in the early training stage. In contrast, a weaker teacher, together with a smaller performance gap from the student, has been shown to be a better choice (Son et al., ; Yang et al., ; Mirzadeh et al., ; Gao et al., ; Wang et al., ). In fact, it can be theoretically proved by (Wang et al., ) that weak models “have higher mutual information regarding the input” compared to stronger teacher models, which can enhance knowledge distillation.
Interestingly, this phenomenon can be intuitively understood, just like it is hard for a child to learn advanced mathematics directly from a senior professor. Instead, it would be better to teach him/her to count or learn elementary mathematics first. In other words, for distillation, a student model should learn from a teacher that has an appropriate knowledge/performance gap over it.
Nevertheless, even with a relatively weak teacher that has a small performance gap, a fixed model that is commonly used would eventually become useless since the student will gradually improve and surpass the teacher at some time. Thus, how to adaptively control the performance gap within a reasonable range throughout the whole distillation process is a critical problem.

To address this, we seek to explicitly control the performance gap to boost knowledge transfer. However, it is non-trivial to determine what performance gap should be regarded as “too-large”. Although the gap can be measured by some criteria, *e.g.*, accuracy for classification, the threshold to distinguish a too-large gap is still ambiguous. To solve this, we cast the problem of determining a threshold into measuring the gap in terms of model size between student and teacher.
We propose to introduce a learnable dynamic teacher (DT) model besides the pre-trained static teacher model, training it from scratch together with the student. Since DT is a larger model and often converges faster than the student, we are able to keep a promising performance gap between DT and student during training.
In addition, we hope to build a stronger connection between DT and student to transfer knowledge in a more explicit way, in order to further enhance the performance. To achieve this, we develop a hard strategy for distillation that enforces DT and the student to share their parameters and encourage parameter inheritance. In addition to hard strategy, we also build a soft bidirectional mapping between them via a novel reparameterization method.

In this paper, we make the following key contributions:
1) We propose a Gap Preserving Distillation (GPD) method that enhances distillation performance by introducing an additional dynamic teacher (DT). We simultaneously train DT and the student to maintain a reasonable accuracy gap between them during the whole training process. In this way, it becomes possible to build a dynamic performance gap *at every iteration* between the student and teacher, which is essentially different from existing work.
2) We develop a hard strategy for distillation where the student and the teacher share the same set of parameters. The key idea is that, since the teacher is often easier to obtain high accuracy, it may also be easier for the student to get promising improvement if it directly inherits well-learned parameters from the teacher, as empirically shown in Table 5.
3) We explicitly enhance knowledge transfer by building *bidirectional mappings* between DT and the student via Inverse Reparameterization (IR) and Channel-Branch Reparameterization (CBR).
IR constructs the dynamic teacher model by expanding the student model with an arbitrary expansion ratio along both the channel and branch dimensions, while preserving the same accuracy as the student model. This guarantees that both DT and the student can start from the same initial point and thus avoid a too-large performance gap in early training stage. Interestingly, IR is not designed just for distillation, but a general initialization method for building any-size pre-trained models, yielding additional contributions to the community beyond distillation.
On the other hand, our CBR seeks to extract an effective student model from the shared parameters with DT without any post-training. Unlike existing reparameterization approaches, CBR does not equivalently transform a model into a more compact one,
but extracts an effective student out of DT.
4)
In experiments,
GPD consistently outperforms existing distillation methods on top of both CNN and transformer architectures. We emphasize
that GPD is very flexible in that it also generalizes well to other training settings, including both training from scratch and fine-tuning, which is rarely reported by other methods.

## 2 Related Work

Knowledge distillation.
Knowledge distillation (KD) (Hinton et al., ) transfers knowledge from a teacher to a smaller student model. Methods improve this by focusing on logits or intermediate features (Sun et al., ; Jin et al., ; Zhao et al., ; Li et al., ; Passalis et al., ; Tian et al., ; Zagoruyko & Komodakis, ; Heo et al., ; Chen et al., ; Heo et al., ; Kim et al., ).
Standard methods prioritize fully converged teachers with high performance, yet the performance gap can hinder knowledge transfer (Wang et al., ; Gao et al., ; Cho & Hariharan, ; Yuan et al., ).
Strategies to address this include using intermediate-stage teachers (Cho & Hariharan, ; Zhao et al., ), pre-training student-friendly teacher model (Yang et al., ; Park et al., ; Dong et al., ), introducing intermediate-sized assistant teachers (Mirzadeh et al., ; Son et al., )
or introducing auxiliary networks (Gao et al., ). These methods often rely on specially designed and pre-trained intermediate models.
Feature-based methods like DTSKD (Li et al., ) and DiffKD (Huang et al., ) focus on bridging semantic gaps or denoising features. SCKD (Zhu & Wang, ) optimizes transfer using gradient similarity. Recent works refine soft labels (Yuan et al., ; Rao et al., ) or student’s output entropy (Zhu et al., ) to enhance knowledge transfer.
In contrast, our GPD constructs a trainable dynamic teacher based on the student model, maintaining an appropriate accuracy gap throughout distillation for effective knowledge transfer.
Reparameterization.
Structural reparameterization (Ding et al., ; ) has gained attention in tasks such as compact model design (Dosovitskiy et al., ), architecture search (Chen et al., ; Zhang et al., ), and pruning (Ding et al., ). RepVGG (Ding et al., ) transforms training-time structures into equivalent, simpler inference structures. Other methods like DiracNet (Zagoruyko & Komodakis, ), ACB(Ding et al., ), DO-Conv(Cao et al., ), and ExpandNet (Guo et al., ) also achieve structural reparameterization. OREPA (Hu et al., ) reduces training costs by online reparameterization.
In contrast, our CBR enables the extraction of an effective student model from the dynamic teacher, enhancing knowledge transfer to the compact student model.
Model expansion.
Net2Net (Chen et al., ) pioneered functional-preserving model expansion. bert2BERT (Chen et al., ) applied this to Transformers, with other works focusing on depth growth (Dong et al., ; Chang et al., ; Yang et al., ; Gong et al., ).
Staged Training (Shen et al., ) and LEMON (Wang et al., ) further expanded both width and depth. ControlNet (Zhang et al., ) duplicates the model and adds zero convolution layers to maintain equivalence, freezing the original parameters for fine-tuning. ControlNet (Zhang et al., ) duplicates the model, adds zero convolution layers, and freezes original parameters for fine-tuning. In contrast, our GPD expands the model and enables adaptive switching between compact and expanded models during training, maintaining an appropriate performance gap.

Figure: Figure 1: Overview of the proposed Gap Preserving Distillation (GPD) method. Besides the static teacher, we introduce an additional dynamic teacher and train it from scratch along with the student. The student model shares parameters with the dynamic teacher via *Inverse Reparameterization (IR)* and *Channel-Branch Reparameterization (CBR)*. (a) The dynamic teacher is constructed through IR (top right) from the student model. For any layer, we replicate the weights along the channel dimension to build a wider layer while introducing additional branches to construct a multi-branch architecture. In order to maintain the same accuracy as the student, we only activate the first branch that contains the original student weights and zero out all the other extra branches, *i.e.*, one-scaling and zero-scaling. (b) We extract a promising student from the dynamic teacher via CBR. The expanded multi-branch architecture can be merged into the student’s single-branch architecture using a similar way proposed by OREPA (Hu et al., ). After that, given an expansion ratio $r$, we directly extract the first $1/r$ parameters multiplied by a scaling factor (see details in Section 3.3.1).
Refer to caption: x1.png

## 3 Gap Preserving Distillation

In this work, we develop a Gap Preserving Distillation (GPD) method that enhances knowledge distillation by preserving an appropriate performance gap between the teacher and student throughout the whole distillation process.
Instead of directly defining how large the gap should be, we propose to learn an additional dynamic teacher (DT) model as a proxy to maintain this gap, which is more flexible and controllable.
Unlike existing methods, we build bidirectional mappings between DT and student to strengthen their connections. These two mappings can be achieved by the Inverse Reparameterization (IR) method and the Channel-Branch Reparameterization (CRB) method, respectively.
The overview of our method is shown in Figure 1 and Algorithm 1.

### 3.1 Distillation with Dynamic Teacher

Popular KD methods often exploit a static teacher $T_{s}$ to guide the training of the student $S$ (Sun et al., ; Jin et al., ; Zhao et al., ; Li et al., ; Zhao et al., ; Furlanello et al., ; Zhao et al., ; Romero et al., ; Passalis et al., ; Tian et al., ; Zagoruyko & Komodakis, ; Heo et al., ; Chen et al., ; Heo et al., ; Kim et al., ). Unlike them, our Gap Preserving Distillation (GPD) introduces a learnable dynamic teacher (DT) model $T_{d}$, as shown in Figure 1. Moreover, we seek to boost knowledge transfer via not only optimizing the distillation objectives, but also inheriting parameters from a better teacher model. To achieve this, we exploit parameter-sharing techniques (Zhao et al., ; Xie et al., ; Zhang et al., ; Ma et al., ; Zhou et al., ) and enforce $T_{d}$ and $S$ to share the same set of parameters, which turns out to be particularly effective (see effectiveness in Section 5).

As for training, besides the standard objective of KD methods, we introduce an additional loss related to DT $\mathcal{L}_{\text{GPD}}$.
Let $\mathcal{L}_{\text{CE}}$ be the cross-entropy loss, and $S(x)$ denotes the student model’s prediction based on input $x$. We use $\psi(\cdot)$ to represent a function that extracts desired knowledge from models, which could be either logits or features. $\mathcal{L}_{\text{KD}}$ measures the discrepancy between the knowledge of two models, with $\lambda$ controlling the distillation loss’s importance.
Given an image-label pair ${(x,y)}$, the objective function of GPD with a dynamic teacher is formulated as follows:

$$ $\begin{split}\mathcal{L}_{\text{total}}=\underbrace{\mathcal{L}_{\text{CE}}(S( x),y)+\lambda\mathcal{L}_{\text{KD}}(\psi(S(x)),\psi(T_{s}(x)))}_{\text{ standard objective of KD methods}}+\mathcal{L}_{\text{GPD}}.\end{split}$ (1) $$

Where we simply set $\lambda=1$ in all experiments thus no additional hyperparameters are introduced.
As for $\mathcal{L}_{\text{GPD}}$, in Figure 1, we seek to use $T_{d}$ to guide the training of $S$ and thus introduce a KD loss $\mathcal{L}_{\text{KD}}(\psi(S(x)),\psi(T_{d}(x)))$. Regarding the training of $T_{d}$, we minimize both the cross-entropy loss $\mathcal{L}_{\text{CE}}$ and a KD loss between $T_{d}$ and $T_{s}$ via $\mathcal{L}_{\text{KD}}(\psi(T_{d}(x)),\psi(T_{s}(x)))$. Thus, $\mathcal{L}_{\text{GPD}}$ becomes

$$ $\begin{split}\mathcal{L}_{\text{GPD}}=\mathcal{L}_{\text{CE}}({T_{d}}(x),y)+ \mathcal{L}_{\text{KD}}(\psi(S(x)),\psi(T_{d}(x)))+\mathcal{L}_{\text{KD}}( \psi(T_{d}(x)),\psi(T_{s}(x))).\end{split}$ (2) $$

To avoid learning knowledge from a weaker model, we consider single-way knowledge transfer and apply stop-gradient on all the KD losses.

Figure: Algorithm 1 Training process of Gap Preserving Distillation (GPD).

Figure: Figure 2: Illustration of channel-level inverse reparameterization with an expansion ratio of 2. (a) For the first layer, weights are scaled by 2 and replicated along the output channel dimension, expanding from $C_{1}\times C_{0}$ to $2C_{1}\times C_{0}$. For intermediate layers, weights are scaled by 2, then replicated along both input and output dimensions, expanding from $C_{l}\times C_{l-1}$ to $2C_{l}\times 2C_{l-1}$. For the last layer, weights are replicated along the input dimension, expanding from $C_{L}\times C_{L-1}$ to $C_{L}\times 2C_{L-1}$. (b) Inverse re-parameterizing the student model (left) to construct the dynamic teacher model (right) by expanding channels from 2 to 4 following the procedures exemplified in (a), while preserving the initial input-output mapping.
Refer to caption: x2.png

### 3.2 Build Dynamic Teacher via Inverse Reparameterization

In order to build a suitable dynamic teacher, we develop an Inverse Reparameterization (IR) method to build a larger model from the student with any expansion ratio $r$, see Figure 1 (top right). To achieve this, we expand the model along both the channel and branch dimensions. One key characteristic is that the expanded dynamic teacher shares exactly the same accuracy as the student.
Notably, IR can serve as a general initialization method for building any-size pre-trained models, yielding additional contributions to the community beyond distillation.

#### 3.2.1 Channel-Level Inverse Reparameterization

In the channel level, we seek to expand the number of channels in each layer by an expansion ratio $r$ without sacrificing accuracy. To this end, we propose a channel-level inverse reparameterization strategy, as shown in Figure 2. The key idea is to replicate the weights of the student and introduce a scale factor to compensate for the increased number of channels.

Considering a student model with $L$ convolutional layers, let $\mathbf{W}^{l}\in\mathbb{R}^{C_{l}\times C_{l-1}\times K\times K}$ be the weight of the $l$-th layer. Here, $C_{l}$ and $C_{l-1}$ represent the number of output and input channels, and $K\times K$ denotes the kernel size.
Let $\mathbf{\widehat{W}}^{l}\in\mathbb{R}^{rC_{l}\times rC_{l-1}\times K\times K}$ be the expanded weight matrix for layer $l$ of the dynamic teacher, given the expansion ratio $r$.
To better illustrate our method, we divide all layers into three groups, including the first layer, intermediate layers, and the last layer.
In Figure 2, we take the expansion ratio $r=2$ for example to illustrate our method.
For the first layer ($l=1$),
we replicate $\mathbf{W}^{1}$ by $r$ times and scale them by $1/r$. In this way, given the same input $x$, the output would be $1/r$ of the original one. Nevertheless, since the number of output channels has been extended from $C_{1}$ to $rC_{1}$, summing up all the channels would obtain the same value as the original output. For convenience, we use $\mathbf{\widehat{W}}^{1}\in\mathbb{R}^{rC_{1}\times C_{0}\times K\times K}$ to denote the weight scaled by $1/r$. For the last layer ($l=L$), the original $\mathbf{W}^{L}$ is replicated $r$ times along the input dimension, giving $\mathbf{\widehat{W}}^{L}\in\mathbb{R}^{C_{L}\times rC_{L-1}\times K\times K}$.
As for the intermediate layers,
we scale $\mathbf{W}^{l}$ by $1/r$ and replicate the scaled weights $r$ times along both output and input channel dimensions, yielding $rC_{l}$ output channels and $rC_{l-1}$ input channels. To avoid the trivial solution caused by symmetrical/identical replications during training, we introduce a small noise $\epsilon$ into each replication.
The theoretical proof of the equivalence of channel-level inverse reparameterization is provided in Appendix B.

#### 3.2.2 Branch-Level Inverse Reparameterization

Besides channel-level expansion, we also seek to expand the student model along the branch dimension.
The branch-level inverse reparameterization aims to expand a single convolutional layer into a multi-branch structure with increased capacity, while preserving the identical input-output mapping. The key idea is to introduce additional branches with extra convolutions but zero-out them to keep the output of multi-branch architecture the same as the single-branch counterpart.

Specifically, considering a convolutional layer represented by the kernel $\mathbf{W}\in\mathbb{R}^{C_{l}\times C_{l-1}\times K\times K}$, where $\mathbf{X}\in\mathbb{R}^{C_{l-1}\times H\times W}$ and $\mathbf{Y}\in\mathbb{R}^{C_{l}\times H^{\prime}\times W^{\prime}}$ are the input and output tensors, respectively. Thus, the convolution operation can be represented by $\mathbf{Y}=\mathbf{W}\mathbf{X}$. As shown in Figure 1 (top right), we expand this single convolution into a multi-branch topology with $M$ branches.
The first branch consists of a single convolutional layer, whose weights are initialized with the original convolution weights $\mathbf{W}$, followed by a learnable linear scaling layer $\mathbf{S}_{1}\in\mathbb{R}^{C_{l}}$ initialized as a vector of ones.
For the remaining $M-1$ branches, each branch $m$ comprises a stack of convolutional layers, with their weights randomly initialized. All these branches are also followed by a learnable linear scaling layer $\mathbf{S}_{m}\in\mathbb{R}^{C_{l}}$, initialized with a vector of zeros.
In this way, the output of the multi-branch block is equivalent to the original single-branch convolution.
Let $f_{m}(\mathbf{X})$ denote the computation of the $m$-th branch. The expanded model along the branch dimension can be formulated by

$$ $\mathbf{Y}=\sum_{m=1}^{M}\mathbf{S}_{m}f_{m}(\mathbf{X})=\mathbf{S}_{1}f_{1}( \mathbf{X})=\mathbf{WX}.$ (3) $$

### 3.3 Parameter Sharing with Channel-Branch Reparameterization

To further enhance knowledge transfer between the student $S$ and the dynamic teacher $T_{d}$, we propose a hard strategy for distillation that forces them to share parameters. In this way, the student is able to directly inherit well-trained parameters from a larger model, *i.e.*, dynamic teacher $T_{d}$. Based on the shared parameters, $S(x)$ and $T_{d}(x)$ have different predictions due to different forward propagation methods, as shown in Figure 3. Specifically, $T_{d}$ directly performs the forward pass, while the student $S$ conducts online reparameterization in both channel-level and branch-level.

Figure: Figure 3: Illustration of the forward process for the student and dynamic teacher models. The dynamic teacher performs a direct forward pass, utilizing its increased capacity. The student model shares all parameters from the dynamic teacher and undergoes a two-step reparameterization process. First, channel-level reparameterization adjusts the expanded channels to match the original channel dimensions of the student model. Second, branch-level reparameterization merges the expanded multi-branch units into a single branch structure, thereby restoring the original topology of the student model while inheriting knowledge from the dynamic teacher.
Refer to caption: x3.png

#### 3.3.1 Channel-Level Reparameterization

As for channel-level reparameterization, given an expansion ratio $r$, we directly take the first $1/r$ kernels and scale them by $r$. Interestingly, this mapping is exactly the inverse transformation of how to conduct channel-level inverse parameterization (previously discussed in Section 3.2.1). Formally,
let $\mathbf{W}^{l}_{m}\in\mathbb{R}^{rC^{l}_{m}\times rC^{l-1}_{m}\times K\times K}$ denote the weight of the $l$-th convolutional layer in the $m$-th branch of an expanded layer, and $rC^{l}_{m}$ and $rC^{l-1}_{m}$ are the numbers of output and input channels, respectively.
During training, our channel-level reparameterization strategy explicitly extracts a subset of the dynamic teacher’s expanded parameters to construct the student model’s weights, enabling us to obtain a promising student model after training. Specifically, we extract a channel-wise slice from $\mathbf{W}^{l}_{m}$ and apply a scaling operation:

$$ $\mathbf{\bar{W}}^{l}_{m}=r\mathbf{W}^{l}_{m}[:C^{l}_{m},:C^{l-1}_{m},:,:],$ (4) $$

where $\mathbf{\bar{W}}^{l}_{m}\in\mathbb{R}^{C^{l}_{m}\times C^{l-1}_{m}\times K
\times K}$ denotes the reparameterized weight for the corresponding layer in the student model. The slicing operation $[:C^{l}_{m},:C^{l-1}_{m},:,:]$ extracts the first $C^{l}_{m}$ output channels and $C^{l-1}_{m}$ input channels from $\mathbf{W}^{l}_{m}$. The scaling ratio $r$ ensures the extracted parameters are appropriately scaled, aligning with the IR process applied during the construction of the dynamic teacher.
For the first and last layers, the channel extraction is performed only over the output or input channel dimensions, respectively. Specifically, for the first layer, $\bar{\mathbf{W}}^{1}_{m}=r\mathbf{W}^{1}_{m}[:C^{1}_{m},:,:,:]$, while for the last layer, $\bar{\mathbf{W}}^{L}_{m}=\mathbf{W}^{L}_{m}[:,:C^{L-1}_{m},:,:]$, as the last layer’s weights are not scaled during IR process.
Moreover, we found that parameter sharing with Batch Normalization (Ioffe & Szegedy, ) layers requires special treatment, as detailed in Appendix C.

#### 3.3.2 Branch-Level Reparameterization

After channel-level reparameterization, we merge the expanded multi-branch units of the dynamic teacher model into the student’s single-branch structure via branch-level reparameterization. Following Hu et al. (), for the $m$-th branch that contains $L_{m}$ convolutional layers ${\mathbf{W}^{1}_{m},\mathbf{W}^{2}_{m},...,\mathbf{W}^{L_{m}}_{m}}$, we first obtain ${\mathbf{\bar{W}}^{1}_{m},\mathbf{\bar{W}}^{2}_{m},...,\mathbf{\bar{W}}^{L_{m}
}_{m}}$ through channel-level reparameterization.
These are then merged into a single weight $\mathbf{\overline{W}}_{m}$ via the standard reparameterization, which is mathematically equivalent, as proven in (Ding et al., ), by conducting sequential convolution operations: $\mathbf{\overline{W}}_{m}=\mathbf{\bar{W}}^{1}_{m}\mathbf{\bar{W}}^{2}_{m}...
\mathbf{\bar{W}}^{L_{m}}_{m}$.
Performing this for all $M$ branches yields ${\mathbf{\overline{W}}_{1},\mathbf{\overline{W}}_{2},...,\mathbf{\overline{W}}
_{M}}$. After that, we sum up all of them to get the final new weight $\mathbf{\overline{W}}=\sum_{m=1}^{M}\mathbf{\overline{W}}_{m}$ for this layer in the student model.
Through the branch reparameterization strategy, the student model effectively inherits well-trained parameters from the dynamic teacher model.

**Table 1: Comparison of the performance of various distillation methods across different architectures. “-” denotes the result that is not reported. A $\rightarrow$ B indicates a teacher model A distilling knowledge to a student model B. GPD consistently enhances the performance of standard distillation methods across diverse architectures.**
| Model | Teacher $\rightarrow$ Student |  |  |
| --- | --- | --- | --- |
| ResNet34 $\rightarrow$ ResNet18 | ResNet50 $\rightarrow$ MobileNet | RVT-S $\rightarrow$ RVT-Ti |  |
| Teacher | 73.31 | 76.16 | 81.69 |
| Student | 69.75 | 68.87 | 78.45 |
| KD (Hinton et al., ) | 70.66 | 68.58 | - |
| AT (Zagoruyko & Komodakis, ) | 70.69 | 69.56 | - |
| OFD (Heo et al., ) | 70.81 | 71.25 | - |
| CRD (Tian et al., ) | 71.17 | 71.37 | - |
| RKD (Park et al., ) | 70.40 | 68.5 | - |
| WSLD (Zhou et al., ) | 72.04 | 71.52 | - |
| SRRL (Yang et al., ) | 71.73 | 72.49 | - |
| SimKD (Chen et al., ) | 71.59 | 72.25 | - |
| DIST (Huang et al., ) | 72.07 | 73.24 | - |
| NKD (Yang et al., ) | 71.96 | 72.58 | - |
| CAT-KD (Guo et al., ) | 71.26 | 72.24 | - |
| KD+CTKD (Li et al., ) | 71.38 | 71.16 | - |
| MLKD (Jin et al., ) | 71.90 | 73.01 | - |
| KD+CTKD+LS (Sun et al., ) | 71.81 | 72.92 | - |
| DKD+LSKD (Sun et al., ) | 71.88 | 72.85 | - |
| MLKD+LSKD (Sun et al., ) | 72.08 | 73.22 | - |
| CKD (Zhu et al., ) | 72.24 | 72.97 | - |
| ReviewKD (Chen et al., ) | 71.61 | 72.56 | 78.92 |
| ReviewKD + GPD | 72.50 (+0.89) | 73.21 (+0.65) | 80.01 (+1.09) |
| DKD (Zhao et al., ) | 71.70 | 72.05 | 79.12 |
| DKD + GPD | 72.71 (+1.01) | 73.63 (+1.58) | 80.14 (+1.02) |

### 3.4 Advantages over existing methods

Our GPD has specific advantages and is essentially different from existing distillation methods (Wang et al., ; Mirzadeh et al., ; Cho & Hariharan, ; Yang et al., ; Son et al., ; Zhao et al., ) in several aspects. First, they maintain different performance gaps. Existing methods (Dong et al., ; Mirzadeh et al., ; Son et al., ) utilize fixed-accuracy pre-trained teachers assistant models, which may hinder knowledge transfer as the gap still be too large, particularly in early training stages when student accuracy is low. GPD initializes the dynamic teacher with the same accuracy as the student and trains both simultaneously, maintaining a small, dynamic gap throughout the process.
Second, they construct the teacher assistants in different ways. Unlike methods (Mirzadeh et al., ; Son et al., ) that construct and train multiple intermediate-size teacher assistants separately, which can be computationally expensive, GPD builds a single dynamic teacher. We propose a novel IR technique for model expansion that maintains the same initial accuracy as the student. This approach is both computationally efficient and ensures a controlled start point for the distillation process.
Third, they transfer knowledge in different ways. Existing methods (Mirzadeh et al., ; Son et al., ) follow the standard distillation paradigm by incorporating a KD loss for transferring knowledge. Besides this, our GPD enforces parameter sharing between the student and dynamic teacher, allowing direct inheritance of parameters. This process is facilitated by our CBR, enabling a more direct and effective knowledge transfer.

## 4 Experiments

We evaluate GPD on ImageNet (Deng et al., ) using popular classification models. We first compare GPD with state-of-the-art KD methods across CNNs and transformers in Sec. 4.1.
We then explore two scenarios without a static teacher, including training models from scratch (Sec. 4.2) and fine-tuning (Sec. 4.3).
For clarity, we use GPD* to denote our models in the settings without a pre-trained static teacher. Detailed experimental settings are in Appendix D.

### 4.1 Distillation with A Static Teacher

We closely follow the settings of Zhao et al. (), Chen et al. () and put details in Appendix.
Table 1 shows the consistent superiority of our GPD across diverse architecture when training from scratch with a static teacher.
Notably, GPD not only yields substantial accuracy improvements when combined with existing KD methods like ReviewKD and DKD, but also outperforms the latest state-of-the-art KD approaches.
Specifically, in the ResNet34 $\rightarrow$ ResNet18 setting, GPD boosts ReviewKD from 71.61% to 72.50%, and improves DKD by 1.01%, reaching 72.71%. These results outperform the most recent methods.
In ResNet50 $\rightarrow$ MobileNet, GPD enhances ReviewKD by 0.65% and DKD by 1.58%. Similar gains are also observed in the transformer-based setting RVT-S $\rightarrow$ RVT-Ti.
These significant accuracy improvements across diverse architectures highlight the effectiveness of our proposed method. By introducing a dynamic teacher model to mitigate the substantial gap between the student and a powerful static teacher, our GPD enables the student to more effectively absorb knowledge from the teacher.
This leads to substantial performance improvements when combined with existing KD methods, surpassing even the most recent distillation techniques.

### 4.2 Train from Scratch

In this experiment, we train ResNet18 and MobileNet for 100 epochs, and RVT-Ti for 300 epochs. Table 2 illustrates the effectiveness of our GPD* method, which utilizes only the dynamic teacher for distillation, without a static teacher. Across various backbone architectures, GPD* consistently improves upon baseline models trained without knowledge distillation. For example, the ResNet-18 model achieves a significant accuracy boost from 70.07% to 71.87% with GPD*, indicating a notable 1.80% improvement. Similarly, with GPD*, the MobileNet achieves a noteworthy improvement from 71.68% to 73.07%.
These results highlight the versatility and effectiveness of our proposed method,
which not only enhances the performance of existing KD methods when a strong static teacher is available but also serves as an effective stand-alone training strategy in scenarios where pre-trained teacher models are unavailable.

**Table 2: Performance comparison of training from scratch without a static teacher model. GPD* denotes our method using only the dynamic teacher for distillation. As a standalone method, our GPD* consistently improves student model performance across diverse architectures.**
| Model | ResNet18 | MobileNet | RVT-Ti |
| --- | --- | --- | --- |
| Baseline | 70.07 | 71.68 | 78.45 |
| GPD* | 71.87 (+1.80) | 73.07 (+1.39) | 79.85 (+1.40) |

### 4.3 Model Fine-Tuning

In this experiment, we fine-tune the pre-trained models for 50 epochs and set the initial learning rate to 0.1$\times$ w.r.t. its base/standard value.
As for our GPD*, the dynamic teacher is constructed via Inverse Reparameterization based on the student model itself. This process ensures that the dynamic teacher initially exhibits the same accuracy as the student.
In Table 3,
compared to the accuracy of pre-trained model, GPD* consistently achieves performance improvements across different architectures. Moreover, GPD* outperforms the longer training approach by up to 0.89% for ResNet18, and similar performance gains are observed for MobileNet and RVT-Ti models as well.

**Table 3: Performance comparison of fine-tuning. GPD* denotes distillation using only the dynamic teacher model without the static teacher. Our method consistently outperforms the fine-tuning baseline with longer training across various architectures.**
| Model | ResNet18 | MobileNet | RVT-Ti |
| --- | --- | --- | --- |
| Pretrained Model | 69.75 | 68.87 | 78.45 |
| Fine-Tuning with Longer Training | 70.23 | 69.01 | 78.61 |
| GPD* | 71.12 (+0.89) | 69.47 (+0.46) | 78.84 (+0.23) |

## 5 Further Discussions

In this section, we present further ablation experiments to analyze the contributions of various components to performance gain. We also validate that too-large teacher models can hinder distillation. For a discussion on the computational cost of our GPD, please refer to Appendix E.

Gap preserving and parameter sharing.
We investigate the contribution of the proposed accuracy gap preserving mechanism and the parameter sharing strategy in this part.
The ablation study in Table 5 validates the critical role of these components in boosting performance. Individually, the gap preservation mechanism yields a 0.66% accuracy gain, demonstrating its effectiveness in guiding the student model’s learning trajectory. When combined with parameter sharing, the synergistic effect leads to a substantial 1.01% improvement over the baseline, underscoring the significance of these key innovations in facilitating knowledge transfer within the GPD framework.

Channel-branch reparameterization.
Table 5 provides insights into the impact of different inverse reparameterization strategies on the performance of our GPD. Both channel-level and branch-level reparameterization techniques individually contribute to performance improvements over the baseline DKD method, achieving accuracy gains of 0.86% and 0.61%, respectively. However, their combined application yields the highest performance boost, with a remarkable 1.01% accuracy gain.
Utilizing both techniques enables the dynamic teacher to effectively guide the student model, maximizing knowledge transfer within the GPD.

**Table 4: Ablation studies on preserving the accuracy gap and parameter sharing. We take DKD as the baseline method to distill knowledge from ResNet34 to ResNet18. Preserving the accuracy gap alone improves performance over the baseline, and combining it with parameter sharing yields further gains.**
| Preserve Gap | Share Param | Acc. (%) |
| --- | --- | --- |
| Baseline | 71.70 |  |
| ✓ |  | 72.36 (+0.66) |
| ✓ | ✓ | 72.71 (+1.01) |

Branch and channel expansion ratio.
Figure 4 (left) shows that increasing the number of branches from 1 to 6 gradually improves accuracy, peaking at $M=6$. However, further increasing to 12 branches leads to reduced performance gains, indicating that too many branches may be hard to train and do not necessarily improve performance.
Figure 4 (right) illustrates the impact of the channel expansion ratio $r$. Both $r=2$ and $r=3$ significantly outperform the DKD baseline, but improvement dramatically drops at $r=4$. The main reason is that the performance gap would be very large again when we consider a large dynamic teacher.
In practice, we recommend using $M=6$ and $r=2$ for a good balance between performance and efficiency.

Figure: Figure 4: Impact of branch expansion number and channel expansion ratio on model accuracy. Performance gains are shown above the baseline (DKD). Left: Increasing $M$ to 6 yields significant improvements, with diminishing returns beyond that. Right: Channel expansion ratios of 2 and 3 show substantial gains, while a ratio of 4 leads to degradation.
Refer to caption: x4.png

Teacher model size.
We highlight that a larger/better teacher model does not necessarily improve the distillation performance, which is a common observation and has been theoretically proved (Wang et al., ). To verify this, we distill ResNet18 from two large teacher models, including ResNet101 and ViT-L (Dosovitskiy et al., ). From Table 6, ResNet101 outperforms ResNet34 by 4.06% in accuracy but obtains similar distillation results based on DKD (71.70 vs. 71.74). As for a larger teacher ViT-L, it outperforms ResNet34 by 11.84% but yields even worse results. More critically, no matter what kinds of teachers are used, GPD consistently improves the distillation performance by at least 1.01%.

**Table 6: Comparison of distillation performance for ResNet18 with teacher models of varying sizes. Notably, larger teacher models, such as ViT-L, can hinder distillation performance, as observed with DKD. In contrast, our GPD consistently enhances results across all settings.**
| Method | ResNet34 $\rightarrow$ ResNet18 | ResNet101 $\rightarrow$ ResNet18 | ViT-L $\rightarrow$ ResNet18 |
| --- | --- | --- | --- |
| Teacher | 73.31 | 77.37 | 85.15 |
| Student | 69.75 | 69.75 | 69.75 |
| DKD | 71.70 | 71.74 | 71.43 |
| DKD + GPD | 72.71 (+1.01) | 72.90 (+1.16) | 72.71 (+1.28) |

## 6 Conclusion

In this paper, we propose Gap Preserving Distillation (GPD), a novel approach to bridging the accuracy gap between teacher and student models for more effective knowledge transfer. Our key contribution is the introduction of a dynamic teacher model that preserves an appropriate accuracy lead over the student during training. We propose Inverse Reparameterization to losslessly expand the student model along the channel and branch dimensions, constructing the dynamic teacher with increased capacity. Furthermore, we devise a parameter sharing strategy based on Channel-Branch Reparameterization, enabling the student to inherit parameters from the expanded dynamic teacher. This reduces computational costs while allowing the student to benefit from the teacher’s enriched knowledge representations.
The improved efficiency and performance of compact models facilitated by our approach could enable the deployment of deep learning solutions in resource-constrained environments, thereby promoting wider accessibility to AI technologies.
Comprehensive experiments on the ImageNet dataset validate the effectiveness of GPD in boosting the performance of standard knowledge distillation methods across various backbone architectures.

## Appendix

## Appendix A Overview and Outline

In this paper, we propose Gap Preserving Distillation (GPD) to bridge the performance gap between large teacher and compact student models. GPD trains a dynamic teacher alongside the student, maintaining a reasonable gap throughout. We utilize parameter sharing and establish mappings via *Inverse Reparameterization (IR)* and *Channel-Branch Reparameterization (CBR)*. The supplementary material provides detailed theoretical analyses and additional experimental information to support the main paper, organized as follows:

- •
In Section B, we provide a mathematical proof of channel-level inverse reparameterization, demonstrating the equivalence between the expanded model and the original model through detailed derivations.
- •
In Section C, we discuss our strategy for parameter sharing in batch normalization, illustrating the importance of maintaining independent running statistics for student and dynamic teacher models to ensure stable training.
- •
In Section D, we detail our experimental settings, covering various training scenarios including distillation with static teachers, training from scratch and fine-tuning.
- •
In Section E, we evaluate the computational overhead introduced by our proposed methods, providing comparative analyses that highlight the efficiency of our approach.

## Appendix B Proof of Channel-Level Inverse Reparameterization

To mathematically prove the equivalence of channel-level inverse reparameterization, consider a model with three convolutions (see Figure 2(b)), where the parameters are denoted as $W^{1}$, $W^{2}$, and $W^{3}$. Using $\otimes$ to represent the convolutional operation, the computation of this model becomes

$$ $Y=W^{3}\otimes W^{2}\otimes W^{1}\otimes X.$ (5) $$

Following the expansion rules in Figure 2(a), when performing channel-level expansion with a ratio of 2, we expand the number of output channels in the first two convolutions $W^{1}$ and $W^{2}$, scaling them by 1/2. For the Last convolution $W^{3}$, we expand the number of input channels without any scaling. For simplicity, we omit the introduced noise $\epsilon$ introduced to the expanded weights. Since the output channel of the first two convolutions is expanded, we use $\{A,B\}$ to denote the concatenation of expanded channel features. Thus, the output of these three convolutions becomes can then be derived as follows:

$$ $\displaystyle\ Y_{1}=\{W^{1}/2\otimes X,W^{1}/2\otimes X\}$ (6) $$

$$ $\displaystyle Y_{2}$ $\displaystyle=\{W^{2}/2\otimes Y_{1},W^{2}/2\otimes Y_{1}\}$ $\displaystyle=\{W^{2}/2\otimes\{W^{1}/2\otimes X,W^{1}/2\otimes X\},W^{2}/2 \otimes\{W^{1}/2\otimes X,W^{1}/2\otimes X\}\}$ (7) $\displaystyle=\{W^{2}/2\otimes W^{1}/2\otimes X+W^{2}/2\otimes W^{1}/2\otimes X ,W^{2}/2\otimes W^{1}/2\otimes X+W^{2}/2\otimes W^{1}/2\otimes X\}$ $\displaystyle=\{W^{2}\otimes W^{1}/2\otimes X,W^{2}\otimes W^{1}/2\otimes X\}$ $$

$$ $\displaystyle Y_{3}$ $\displaystyle=W^{3}\otimes Y_{2}$ $\displaystyle=W^{3}\otimes\{W^{2}\otimes W^{1}/2\otimes X,W^{2}\otimes W^{1}/2 \otimes X\}$ $\displaystyle=W^{3}\otimes W^{2}\otimes W^{1}/2\otimes X+W^{3}\otimes W^{2} \otimes W^{1}/2\otimes X\}$ (8) $\displaystyle=W_{3}\otimes W_{2}\otimes W_{1}\otimes X$ $\displaystyle=Y$ $$

Clearly, given the same input $X$, the expanded model has exactly the same output as that of the original model, *i.e.*, $Y_{3}=Y$.

## Appendix C Parameter Sharing for Batch Normalization

Batch normalization plays a crucial role in alleviating the vanishing gradient problem during the training of deep neural networks, ensuring stable convergence. However, since the student and dynamic teacher models may exhibit different data distributions during the training process, directly sharing the running statistics (*i.e.*, running mean and running variance) of the batch normalization layers would lead to mutual interference between the two models, potentially causing training instability. To avoid this issue, we propose maintaining independent running means and variances ($\bm{\tilde{\mu}}_{s}$, $\bm{\tilde{\sigma}}^{2}_{s}$) and ($\bm{\tilde{\mu}}_{t}$, $\bm{\tilde{\sigma}}^{2}_{t}$) for the student and dynamic teacher models, rather than sharing the statistics.

Figure: Figure 5: Illustration of parameter sharing for batch normalization in the student and dynamic teacher models. We main a separate set of running statistics for each model due to the distribution difference.
Refer to caption: x5.png

As illustrated in Figure  5, each model independently calculates its batch mean and batch variance from the input data, denoted as ($\bm{\mu}_{s}$, $\bm{\sigma}^{2}_{s}$) for the student model and ($\bm{\mu}_{t}$, $\bm{\sigma}^{2}_{t}$) for the dynamic teacher model. Subsequently, normalization is performed using these statistics, and the respective running statistics ($\bm{\tilde{\mu}}_{s}$, $\bm{\tilde{\sigma}}^{2}_{s}$) and ($\bm{\tilde{\mu}}_{t}$, $\bm{\tilde{\sigma}}^{2}_{t}$) are updated accordingly. The normalized outputs are then scaled and shifted using the learnable parameters $\bm{\gamma}$ and $\bm{\beta}$, which are shared across the two models through the channel ensemble strategy. This design effectively eliminates potential instabilities arising from sharing statistics, thereby guaranteeing the robustness of the entire training process.

## Appendix D Experimental Settings

### D.1 Distillation with A Static Teacher

In this experiment, we adopt the standard data pre-processing pipeline, including random cropping, resizing to 224x224, random horizontal flipping, and normalization. By default, we employ the SGD optimizer with an initial learning rate of 0.1 and a momentum of 0.9. For convolutional neural networks, the batch size is set to 256 on 4 Nvidia Tesla V100 GPUs, while for vision transformers (ViTs), the batch size is set to 256 on 8 Nvidia Tesla V100 GPUs. The models are trained for 100 epochs with a learning rate decay factor of 0.1 applied every 30 epochs. The weight decay is set to 1e-4, and the weights for cross-entropy loss and KD loss are both set to 1.0.
For convolutional neural networks, we strictly follow the settings from Zhao et al. (); Chen et al. (). For the same architecture family, the teacher model is ResNet-34, and the student model is ResNet-18. For different architecture families, the teacher model is ResNet-50, and the student model is MobileNet-V1. Additionally, we explore the vision transformer architecture RVT  Mao et al. (), employing RVT-S as the teacher model and RVT-Ti as the student model.

### D.2 Train from Scratch

To further evaluate the efficacy of our approach, we conducted experiments without the reliance on a pre-trained static teacher model. Instead, we construct the dynamic teacher model via Inverse Reparameterization of the student model, as described in Sec. 3.2. Both the dynamic teacher and the student model are trained simultaneously from random initialization. During training, we leverage the additional loss terms introduced by our GPD, given by Eq. 2, to facilitate knowledge transfer from the dynamic teacher to the student model. We adopt the same data preprocessing and optimization strategies as described in Sec. 4.1.

### D.3 Model Fine-Tuning

In this part, we begin with pre-trained student models and aim to further improve their performance through our proposed approach. The pre-trained models are fine-tuned for 50 epochs, with the initial learning rate set to 0.1x the initial learning rate used during the pretraining stage.
For the standard fine-tuning baseline, we fine-tuning the pre-trained models with cross entorpy loss.
Regarding our proposed GPD* method, we leverage the dynamic teacher model for distillation-based fine-tuning. Benefiting from Inverse Reparameterization, the dynamic teacher model initially exhibits the same accuracy as the student model. During the fine-tuning process, the dynamic teacher maintains a slightly higher accuracy than the student due to its increased capacity. We used the same loss function as in the experiment of training from scratch.

## Appendix E Analysis of Computational Overhead in GPD

We analysis the computational overhead introduced by GPD. From Table 7, training a small student model (*e.g.*, MobileNet) is not very efficient since it tends to come with a very low GPU utilization. Thanks to the high parallelism of GPU for large models (*i.e.*, our expanded dynamic teacher), GPD only introduces 33% extra overhead while yielding a performance improvement of 1.58%. Furthermore, as shown in Table 1, our improvement is significantly larger than recent methods, achieving a good trade-off between performance and training cost. Moreover, since the static teacher used for distillation is often very large with high computational cost, the most important goal of distillation should be improving the performance by sacrificing the training efficiency. From this point of view, our GPD could be a very strong baseline for distillation.

**Table 7: Comparison of computation cost on the experiment of ResNet50 → MobileNet distillation. We measure the training time on 4 A100 GPUs with a batch size of 512 on ImageNet.**
| Method | Acc. (%) | Training Time per Epoch (min) |
| --- | --- | --- |
| DKD | 72.05 | 12 |
| DKD + GPD | 73.63 (+1.58) | 16 (+33%) |

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: 1. How can we better understand and measure the impact of the performance gap on knowledge transfer? The paper mentions that keeping a reasonable performance gap between teacher and student models helps with effective knowledge transfer. However, it doesn’t fully explain why a larger gap might hurt the process. How exactly does the size of this gap affect the student model’s final performance? As mentioned in the weaknesses section, adding some theory or controlled experiments here could help clarify this point and give a clearer idea of the best range for this gap.

2. As mentioned in the weaknesses, is the complex design of the dynamic teacher model really necessary? To tackle the performance gap, the paper introduces a dynamic teacher model with intricate structures like Inverse Parameterization (IR) and parameter sharing. But has the author considered more straightforward options to close the gap? If this complex setup is essential, could they explain more about how it directly addresses the problem?
soundness: 3
strengths: 1. This paper identifies the performance gap between teacher and student models as a key challenge in knowledge distillation. By introducing a dynamic adjustment mechanism, the method effectively narrows this gap, facilitating more efficient knowledge transfer.

2. The proposed GPD demonstrates adaptability across various training settings, with significant improvements across multiple models and datasets. Extensive ablation studies further validate the method’s effectiveness.
summary: This paper introduces Gap Preserving Distillation (GPD) to address the challenge where large performance gaps between teacher and student models hinder effective knowledge transfer. GPD introduces a dynamic teacher model that trains alongside the student, maintaining an optimal performance gap to improve transfer efficiency. The performance gains from GPD are primarily due to its use of Inverse Reparameterization (IR) and Channel-Branch Reparameterization (CBR), which create flexible connections that enable parameter sharing between the dynamic teacher and student. Experimental results show that models trained with GPD outperform those using traditional fixed teacher models and perform robustly even in scenarios without a pre-trained teacher, such as training from scratch and fine-tuning.
weaknesses: 1. Needs More Theoretical Explanation
This paper could benefit from a deeper explanation of why a large performance gap between the teacher and student models makes knowledge transfer less effective. Right now, the idea that a big gap harms learning is mentioned, but it would be stronger if some theoretical reasoning or tests showed how this happens. Adding experiments that test different gap sizes could also help show how different levels of teacher-student gaps impact the student model’s final performance.

2. Overengineering in the Dynamic Teacher Model 
The necessity of the complex structure designed in this paper, including Inverse Reparameterization (IR) and parameter sharing, appears somewhat disconnected from the core problem. If the primary goal is to reduce the performance gap, it remains unclear whether the proposed architecture (specifically the IR and shared parameters) is required to achieve this. Making the connection between these design choices and the main goal a bit clearer could help the paper feel more cohesive.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. The paper claims that the dynamic teacher shares exactly the same accuracy as the student with the reparameterization techniques. However, Figure 1 shows that the weights of the dynamic teacher are modified with added noise, which seems to contradict this claim.
2. The claim in lines 68-69, “Since DT is a larger model and often converges faster than the student,” appears counterintuitive. Is there any evidence to support this?
3. The network pairs in Table 6 do not convincingly demonstrate the effect of the teacher-student capacity gap. For instance, Table 6 shows that ViT-L performs worse than ResNet101 when distilling to a ResNet18. This may be due not to the larger capacity gap between ViT-L and ResNet18, but rather to differences in architecture. It would be more consistent to use CNN or ViT architectures for both teacher and student.
soundness: 3
strengths: 1. The problem is well-motivated, particularly in lines 54-61, highlighting the importance of adaptively managing the performance gap.
2. The proposed approach is novel. It co-trains a dynamic teacher to alleviate the teacher-student capacity gap and applies inverse reparameterization and channel-branch reparameterization for efficient parameter sharing.
3. The paper is well-organized and easy to follow, with clear descriptions, intuitive figures, and rigorously detailed algorithms.
summary: The paper proposes Gap Preserving Distillation (GPD), a framework designed to address the capacity gap between teacher and student networks. GPD achieves this by training an additional dynamic teacher alongside the student. To further improve performance and efficiency, GPD enforces parameter sharing between the dynamic teacher and the student using Inverse Reparameterization and Channel-Branch Reparameterization techniques. Experiments on ImageNet-1K classification primarily compare GPD with baselines using static teachers, showing preliminary effectiveness.
weaknesses: 1. **Lack of comparisons with Knowledge Distillation (KD) methods using teacher assistants**. These methods are closely related to the proposed GPD. Without these comparisons, the effectiveness of GPD is unclear or less convincing. Suggested comparisons include, but are not limited to:
   - Mirzadeh, Seyed Iman, et al. "Improved knowledge distillation via teacher assistant." *AAAI 2020*
   - Son, Wonchul, et al. "Densely guided knowledge distillation using multiple teacher assistants." *CVPR 2021*
   - Ganta, Durga Prasad, Himel Das Gupta, and Victor S. Sheng. "Knowledge distillation via weighted ensemble of teaching assistants." *ICBK 2021*
   - Zhou, Yuhang, and Wei Ai. "Teaching-Assistant-in-the-Loop: Improving Knowledge Distillation from Imperfect Teacher Models in Low-Budget Scenarios." *arXiv:2406.05322* (2024)

2. **Inappropriate and unfair baselines in Section 4.2**. The paper compares GPD without a static teacher against networks trained without any KD techniques. Since GPD involves an additional dynamic teacher, it would be more appropriate to compare it with self-distillation methods.

3. **Practicality and efficiency concerns**. The size of the additional dynamic teacher must still be tuned by adjusting the branch and channel expansion ratios, making GPD less practical and efficient.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Please refer to the weaknesses.
soundness: 3
strengths: - The problem of effectively performing KD with an extremely large teacher model is important and well-motivated.
- The paper is well-organized and easy to follow.
summary: This paper aims to improve the effectiveness of knowledge distillation (KD) when using a teacher model with a large performance gap relative to the student model. The authors propose a method called Gap Preserving Distillation (GPD). By adopting a dynamic teacher model created through a re-parameterization operation on the student model as a proxy teacher, the performance gap is narrowed. Experimental results demonstrate the effectiveness of this approach.
weaknesses: 1. The abstract is too lengthy, as it seems to emphasize every aspect in detail. I suggest revising the abstract to improve clarity and conciseness.

2. The KD process involves training a dynamic teacher model alongside the student, which requires frequent re-parameterization. I am curious about the training cost compared to baseline methods.

3. In Table 6, it appears that the larger ViT-L teacher model leads to worse student performance than the smaller ResNet-101 teacher model (as with DKD). This suggests that the proposed method may still struggle with extremely large teacher models, despite it aims to overcome this issue.

4. The method's description primarily focuses on convolutional models. Although experimental results are provided for transformer models, it would be helpful to explain how re-parameterization is achieved for these models.

Meta-review: After discussion, the major concerns about novelty, contribution and experiments of the proposed approach were mostly solved. The main contribution lies in a dynamic teacher approach to alleviate the teacher-student capacity gap and applies inverse re-parameterization and channel-branch re-parameterization for efficient parameter sharing. The paper defines an improved teacher-assistant method for the important self-distillation problem. 

As pointed out by the reviewer, there remains a large performance gap between the teacher and student models after applying the proposed distillation approach, which is not fully explained and not well solved after rebuttal. As shown in Table 10 in the revised paper, the performance improvement upon the ImageNet benchmark over a 2022-year baseline is marginal (72.71 vs. 72.60).

Decision: Accept (Poster)