Response to Comment by Reviewer 4MBF
We thank the reviewer's detailed comment. It seems that there are still some misunderstandings. Please allow us to explain them again. The responses are listed below and free feel to deeply discuss.
**Q: "For Q2"**
A: As we have clarified in the rebuttal, we DO NOT use any label (i.e. ReID loss is NOT used) in this experiment. The improvement should come from denoising loss. Based on the observation, we "suppose that in the inference stage, the features obtained by backbone extraction are noisy".
**Q: "For Q4"**
A: As far as I know, "unifying feature extraction and feature denoising" is pioneeringly proposed in this manuscript. Thus, we can't provide previous works to prove "why denoising loss and task losses can be used together". However, we show the fake code of our proposed method, hoping this can solve your misunderstanding. Please pay attention to the line "denoised_feats = feats - self.denoise_layer(x)", which we think may cause your misunderstanding.
```
// Fake Code of the Proposed Algorithm
// Plz note that, this code targets understanding "why reid_loss and denosing_loss can be used together". Thus, we only show some critical logic and details may be missed and inaccurate.
class DenoiseLinear:
def __init__(self):
self.linear = nn.Linear()
self.denoise_layer = nn.Linear()
set_require_grad_false(self.linear)
def forward_train(self, x):
// basic branch
feats = self.linear(x)
// denoising branch, this process is the same with DDPM
gt_noise = sample_from_gaussian()
pred_noise = self.denoise_layer(x + gt_noise)
denoise_loss = l1_or_l2_loss(gt_noise, pred_noise)
// tip to optimzie denoise layer with reid_loss is returning denoised_feats NOT feats
denoised_feats = feats - self.denoise_layer(x)
return denoised_feats, denoise_loss
def forward_test(self, x);
w, b = fuse_weight(self.linear, self.denoise_layer) // compute offline
denosied_feats = w * x + b
return denosied_feats
// A Toy ReID Model with 2 linear layers
class ReIDModel:
def __init__(self):
self.linear1 = DenoiseLinear()
self.linear2 = DenoiseLienar()
// unsupervised manner
def train_without_reid_loss(self, x):
feat1, denoise_loss1 = self.linear1.forward_train(x)
feat2, denoise_loss2 = self.lienar2.forward_train(x)
return feat2, denoise_loss1 + denoise_loss2
// supervised manner
def train_with_reid_loss(self, x, y):
feat1, denoise_loss1 = self.linear1.forward_train(x)
feat2, denoise_loss2 = self.lienar2.forward_train(x)
reid_loss = compute_reid_loss(feat2, y)
return feat2, denoise_loss1 + denoise_loss2 + reid_loss
def forward_test(self, x):
feat1 = self.linear1.forward_test(x)
feat2 = self.linear2.forward_test(feat1)
return feat2
```
**Q: "For Q1"**
A: Our proposed method is very different from the related work [1-3]. We summarize them in the table below:
| | Usage | Scalibity | Improvement and Latency |
| :-----------------: | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| Ours | Improve existing vision models, which could be from many vision tasks. | [better] ONE method for MANY vision taks without customizing implementation and hyper-parameters. | [better] Given a model of specific vision task (e.g. CLIP-REID), achieve STABLE improvement with NO extra latency compared to the given model. |
| Related Works [1-3] | Customize a model for a specific vision task based on a well-trained strong diffusion model. | ONE method for ONE vision task. Need customize Implementation and hyper-parameters for specific tasks. | Given a diffusion model (e.g. StableDiffusionXL), improvement and latency depend on how strong the diffusion model is and the details of the customized implementation for specific tasks. |