Deep transfer learning with conditional adversarial net
作者：禅与计算机程序设计艺术
1.简介
深度迁移学习（deep transfer learning）使模型能够从源域（source domain）中获得知识，并将其应用至目标域（target domain）上，是一种机器学习方法。该方法基于源域数据以及现有的预训练模型参数等信息，在目标域直接实施学习过程，并实现了模型在零样本情况下的迁移能力。选择合适的领域自适应表示（domain-adaptive representation）是该方法的核心所在，从而充分挖掘了源域与目标域间的差异性。
在对比现有迁移学习方法（包括特征拼接、特征提取及深层网络结构迁移）以及生成式迁移技术（如VAE-GAN）的基础上，深度迁移学习展现出显著的优势与可靠性。本研究系统性探讨了一种创新性的深度迁移学习架构——条件对抗网络（Conditional Adversarial Networks, CANs）。该架构作为一种无监督特征学习模型，在不依赖标注数据的前提下，能够揭示各类别间的相互作用关系。具体而言，在于通过设计有效的判别器区分源域与目标域样本间的差异，并在此基础上实现对源-目标域差异的精准建模。此外，该架构还具备独特的类内注意力机制功能，在特定类别范围内集中关注样本特征而不受其他类别干扰；同时能够有效捕捉样本间的全局信息特征，在提升分类性能的同时显著降低对噪声数据的敏感度。最后研究表明，在保持对抗训练优势的同时，该架构能够实现多任务共 trained框架下的共享知识表示；其独特的全局信息捕捉能力使得在小样本条件下依然能获得令人满意的分类性能表现。基于以上理论分析与实验验证结果表明：条件对抗网络在深度迁移学习领域展现出广阔的应用前景
2.基本概念术语说明
2.1 无监督学习
无监督学习(unsupervised learning)是指通过分析数据集中输入数据的内在规律或模式来识别出隐藏在其中的数据结构。它通常采用聚类分析、降维技术和关联规则挖掘等方法对原始数据进行预处理，并在此基础上建立基于这些发现的数据模型。随后利用识别出的模式对样本进行分类标注，并将这些标注后的样本作为后续任务的数据输入来源。
2.2 源域目标域
原始数据所处的领域即为源域（source domain），而目标领域的知识（target domain knowledge）旨在应用于特定应用场景。在迁移学习中，默认情况下以源区域的数据（source domain data）作为训练集，默认的目标区域测试集则用于评估模型性能（performance）。基于此，在迁移学习中通常会采用策略性地从源区域获取知识的方法（method），以确保该方法能在不同场景下有效推广至其他相关领域。
2.3 领域自适应表示(Domain Adaptation Representation)
领域自适应表示是一种能够融合两个不同领域数据特征的方法，在深度迁移学习过程中，则是通过先从源域中提取特征再结合目标域中的信息来进行优化调整的策略实现知识迁移的。研究发现无论是源域还是目标域都不可避免地会面临样本分布上的差异但二者间通常具有较强的关联性因此开发一种能够融合多领域信息的技术框架显得尤为重要
2.4 对抗网络
对抗式网络属于深度神经网络的一种特定结构形式。其核心组成部分包括两个关键模块：生成模型G和鉴别模型D。其中生成模型G的任务是根据给定输入数据产生新的数据样本；鉴别模型D则旨在识别并区分真实数据与生成的数据。在接收输入数据后，在线学习环境中系统会动态地执行以下功能：首先由鉴别模型D输出待分类样例的概率值；接着基于该概率值由生成模型G按照一定规则自动生成新的样例数据集。双方的目标相互对立：一方面希望实现对对方任务的成功干扰；另一方面则致力于提高自身任务的成功率，在此过程中不断调整两方的参数设置，在对抗训练的过程中逐步提升整体系统的性能水平
2.5 判别器
判别器（Discriminator）是一种二分类网络模型。该判别器接收一组包含两个相同来源的数据输入：一个为源域样本数据实例（即来自源域的实例），另一个为目标域样本数据实例（即来自目标Domain的实例）。其主要功能在于评估这两个输入数据是否属于同一类别：一个是来自源Domain的数据实例,另一个则是来自Target Domain的数据实例.此外,该判别器采用了一种基于差异度的最大化方法来优化其损失函数,从而实现对不同来源数据区别的能力。
2.6 生成器
作为另一个类型的生成模型，在GAN框架中
2.7 类内注意力机制
类内注意力机制(intra-class attention mechanism)是基于强化学习的方法，在此基础上结合了判别器提供的判别结果, 从而促进生成器输出包含有价值信息的内容. 在使用判据评估每个样本的基础上, 生成器会根据其反馈聚焦于更多具有负面特征的实例或对其同类对象施加更高关注度. 这类机制能够明显提升所生成样本的质量.
2.8 协同训练策略
协同训练策略是一种专为多标签分类问题设计的训练方法。在多标签分类任务中进行建模时，默认假设模型能够同时处理多个相关的标记信息。通常情况下，在多标签分类任务中使用交叉熵损失函数作为基本损失函数，并将不同类别的标记特征映射到同一个潜在的空间中进行学习。然而这种基于单一假设的设计可能会影响模型对复杂数据的学习能力。为此研究者们提出了一个新的协同训练框架该框架旨在促进不同类别标记之间的相互学习和促进共同优化具体而言在每一个优化步骤中算法会同时优化所有目标类别对应的损失函数而不是仅关注单个目标类别所对应的损失函数
2.9 共同底层表示
公共基础特征（common low-level features）是指源域和目标域中的样本可以作为这些基础特征的应用。作者的观点是：如果一个样本在另一个领域中表现良好，则会提升整体模型的能力。因此，作者提出了一种能够有效提取这些基础特征的方法——统一通用视觉编码器（a unified generic visual encoder）。这样做的优点在于能够使模型更加灵活地适应不同领域的需求，并提高其泛化能力。
3. 核心算法原理和具体操作步骤以及数学公式讲解
3.1 数据准备阶段
首先，我们需要收集源域的训练数据、测试数据以及目标域的数据。这些标注好的数据通常已标好，并建议优先使用开源数据集。针对训练样本数量不足的问题，在源域样本上实施增强处理以提升模型性能。需要注意的是，在测试阶段由于缺乏标注信息无法直接评估模型效果，因此建议采用划分好的验证集作为评估依据。
3.2 模型选择阶段
目前阶段,我们应挑选一个优质的技术方案来构建迁移学习架构。通常情况下,推荐采用以下几种经典的深度学习架构:AlexNet,VGG-16,ResNet-50等。此外,在神经网络领域中出现了一些创新性的解决方案:Cycle GAN,StarGAN等。具体而言,在不同应用场景下需要选用不同的基础架构以达到最佳效果。例如,在图像分类问题中常用以下几种方案:基于CNN的经典架构如AlexNet,VGG-16等;针对文本匹配问题,则适合采用基于RNN的结构:包括LSTM,双层LSTM和GRU等多种类型;最后,在多标签分类问题中,则可运用以下几种方法:支持向量机(SVM)、线性逻辑回归以及带有Softmax激活函数的全连接层等多种算法。
3.3 特征提取阶段
针对源域数据集而言，在提取特征方面可采用预训练模型。在此研究中，则采用AlexNet这一现成的预训练模型进行操作。针对目标域数据集而言，在直接应用现有预训练模型方面存在显著差异。为此提出了一种共性低级特征学习机制——即在两个领域间探索一致性的低级特性关系，并基于所获得的一致性低级特征信息进行下一步的学习与优化过程
3.4 特征融合阶段
在特征融合过程中（或：在该过程的主要负责方面），研究人员主要承担着对不同领域间特征进行整合的任务（或：研究者着重致力于实现不同领域间特征的有效整合）。现有的主流特征融合方法大致可分为直接拼接、基础融合以及加权融合等方式（或：现有的主流特征 fusion 方法主要包括直接拼接、基础级联以及加权级联等多种类型）。其中较为简单的直接拼接方式操作简便且易于实现（但其计算效率较低），而加权级联方式则能够在一定程度上兼顾各子领域间的特性差异（但其计算复杂度相对较高）。针对这一现有技术瓶颈问题，在本文中我们提出了一种新型的特征 fusion 模块（或：一种创新性的特征 fusion 结构），该模块能够充分考虑各子领域间的独特属性差异。具体而言，在该模块中首先通过深度学习机制提取各子领域的独特表征（即：通过深度学习模型获取各个子领域的独立性表征），随后基于两两子域间的相似度评估和距离度量构建相应的关联关系矩阵（即：根据各对子领域的相似性和距离信息构建关联权重矩阵），最终将两个子领域的原始表征空间通过预设权重矩阵进行线性变换处理以获得最终联合表征空间
3.5 可见软标签阶段
为了实现类内注意力机制这一目标，作者提出了一种称为可见软标签的概念。对于一个样本而言，在这种情况下模型无法得知该样本的真实标签。然而，在类内注意力机制的作用下，通过分析判别器输出的结果来模拟出真实标签的形式，并最终生成了具有可见性的软标签。这种可见性设计有助于帮助模型更好地捕捉样本的局部特征信息并提升性能水平。具体而言，在这一过程中作者设计了一个名为注意力池化模块（attention pooling module）的核心组件。该模块的主要功能是接收可观察到的软标签信号并完成相应的处理步骤：首先计算样本在不同关注点上的权重值；接着根据这些权重值将原始特征与其对应的位置进行加权相乘操作；最后将经过加权处理后的特征向量进行汇总形成最终输出结果并将其传递给分类器进行识别判断任务的具体执行。
3.6 目标域微调阶段
在目标域微调阶段致力于样本分组研究中
3.7 Loss function
CANs引入了一个具有创新性的Loss function并命名为"交叉熵加惩罚项"（cross-entropy plus regularization term）。其中包含两个部分：一个是用于Discriminator（判别器）训练的交叉熵损失部分；另一个是用于Generator（生成器）训练的标准loss函数部分。Generator的目标是阻止Discriminator能够有效地区分真实数据与Generator所生成的数据；而Discriminator的目标则是要求能够有效地将真实数据与其自身产生的虚假数据区分开来。这样一来，在优化过程中两个网络会协同学习出最佳的数据分布模式。此外作者还提出了"类别内部注意力机制"（category internal attention mechanism），旨在促进Generator能够更好地生成具有相似特性的数据
3.8 Optimizer
作者采用了Adam优化器，并设置了初始学习率为0.001；其学习率衰减机制基于step decay策略。此外，在判别器与生成器之间引入了损失平衡机制以实现两者的均衡发展。
4. 具体代码实例和解释说明
4.1 安装包
首先，安装pytorch和torchvision包，使用conda安装：
conda install pytorch torchvision -c pytorch
代码解读其次，下载源代码，使用git克隆项目：
git clone https://github.com/jindongwang/transferlearning.git
cd transferlearning
代码解读4.2 数据准备
在这个例子中，我们将使用CIFAR-10数据集。具体步骤如下：
- 导入相关的包：
import torch
import numpy as np
from sklearn.model_selection import train_test_split
from torchvision import datasets
import torchvision.transforms as transforms
代码解读- 配置数据预处理：
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
代码解读trainset: datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
testset: datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
classes: ('plane','car',...,'truck')
num_classes: len(classes)
X: np.concatenate([trainset.data,testset.data])
y: np.concatenate([trainset.targets,testset.targets])
x_train,x_val,y_train,y_val: train_test_split(X,y,test_size=0.1,random_state=42)
设置批量大小为32，并生成训练数据加载器。
训练数据加载器被生成为一个批量大小为32且打乱顺序的数据加载器。
测试数据加载器被生成为一个批量大小为32且不打乱顺序的数据加载器。
验证数据加载器被生成为一个批量大小为32且不打乱顺序的数据加载器。
数据可视化：
```python
import matplotlib.pyplot as plt
%matplotlib inline
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
images, labels = next(iter(trainloader))
imshow(torchvision.utils.make_grid(images))
print(' '.join('%5s' % classes[labels[j]] for j in range(batch_size)))
代码解读4.3 模型定义
在此例中采用CAN模型。该模型由生成器网络与鉴别器网络构成。
4.3.1 Generator Network
生成器网络（Generator Network）是一种生成式模型，能够将输入噪声向量映射到目标图像空间。该网络由一个全连接层、带有 ReLU 激活的全连接层、一个上采样层（带双 ReLU 激活）、三个连续的全连接层以及 tanh 激活函数构成。该网络输出的数值限定在区间[-1, 1]之间。
import torch.nn as nn
class Generator(nn.Module):
def __init__(self, input_dim=100, output_channels=3, ngf=64):
super().__init__()
self.input_dim = input_dim
self.output_channels = output_channels
self.ngf = ngf
self.fc1 = nn.Linear(self.input_dim, self.ngf*4*4)
self.bn1 = nn.BatchNorm2d(self.ngf * 4)
self.relu1 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.convTranspose2d1 = nn.ConvTranspose2d(in_channels=self.ngf * 4, out_channels=self.ngf * 2, kernel_size=4, stride=2, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(self.ngf * 2)
self.relu2 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.convTranspose2d2 = nn.ConvTranspose2d(in_channels=self.ngf * 2, out_channels=self.ngf, kernel_size=4, stride=2, padding=1, bias=False)
self.bn3 = nn.BatchNorm2d(self.ngf)
self.relu3 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.convTranspose2d3 = nn.ConvTranspose2d(in_channels=self.ngf, out_channels=self.output_channels, kernel_size=4, stride=2, padding=1, bias=False)
def forward(self, z):
fc1 = self.fc1(z).view(-1, self.ngf * 4, 4, 4) # batch_size x ngf*4 x 4 x 4
bn1 = self.bn1(fc1) # batch_size x ngf*4 x 4 x 4
relu1 = self.relu1(bn1) # batch_size x ngf*4 x 4 x 4
convTranspose2d1 = self.convTranspose2d1(relu1) # batch_size x ngf*2 x 8 x 8
bn2 = self.bn2(convTranspose2d1) # batch_size x ngf*2 x 8 x 8
relu2 = self.relu2(bn2) # batch_size x ngf*2 x 8 x 8
convTranspose2d2 = self.convTranspose2d2(relu2) # batch_size x ngf x 16 x 16
bn3 = self.bn3(convTranspose2d2) # batch_size x ngf x 16 x 16
relu3 = self.relu3(bn3) # batch_size x ngf x 16 x 16
convTranspose2d3 = self.convTranspose2d3(relu3) # batch_size x output_channels x 32 x 32
return convTranspose2d3 # batch_size x output_channels x 32 x 32
代码解读4.3.2 Discriminator Network
判别网络(Discriminator Network)是一种分类器网络，在图像处理中可实现分类功能。该网络由四个卷积层、一个ReLU激活单元、三个全连接层以及一个sigmoid型激活函数构成。其输出值限定在区间[0,1]之间。
class Discriminator(nn.Module):
def __init__(self, input_channels=3, ndf=64):
super().__init__()
self.input_channels = input_channels
self.ndf = ndf
self.conv2d1 = nn.Conv2d(in_channels=self.input_channels, out_channels=self.ndf, kernel_size=4, stride=2, padding=1, bias=False)
self.leakyRelu1 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.conv2d2 = nn.Conv2d(in_channels=self.ndf, out_channels=self.ndf * 2, kernel_size=4, stride=2, padding=1, bias=False)
self.batchNorm2d1 = nn.BatchNorm2d(self.ndf * 2)
self.leakyRelu2 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.conv2d3 = nn.Conv2d(in_channels=self.ndf * 2, out_channels=self.ndf * 4, kernel_size=4, stride=2, padding=1, bias=False)
self.batchNorm2d2 = nn.BatchNorm2d(self.ndf * 4)
self.leakyRelu3 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.fc1 = nn.Linear(self.ndf * 4 * 4 * 4, 1)
self.sigmod = nn.Sigmoid()
def forward(self, X):
conv2d1 = self.conv2d1(X) # batch_size x ndf x 16 x 16
leakyRelu1 = self.leakyRelu1(conv2d1) # batch_size x ndf x 16 x 16
conv2d2 = self.conv2d2(leakyRelu1) # batch_size x ndf*2 x 8 x 8
batchNorm2d1 = self.batchNorm2d1(conv2d2) # batch_size x ndf*2 x 8 x 8
leakyRelu2 = self.leakyRelu2(batchNorm2d1) # batch_size x ndf*2 x 8 x 8
conv2d3 = self.conv2d3(leakyRelu2) # batch_size x ndf*4 x 4 x 4
batchNorm2d2 = self.batchNorm2d2(conv2d3) # batch_size x ndf*4 x 4 x 4
leakyRelu3 = self.leakyRelu3(batchNorm2d2) # batch_size x ndf*4 x 4 x 4
flat = leakyRelu3.view(-1, self.ndf * 4 * 4 * 4) # batch_size x ndf*4*4*4
fc1 = self.fc1(flat) # batch_size x 1
sigmoid = self.sigmod(fc1) # batch_size x 1
return sigmoid # batch_size x 1
代码解读4.3.3 CAN Model
CAN model is composed of two subnetworks, one being a generative network and the other a discriminative network. The generative network is capable of producing outputs that meet the requirements of the discriminative network. The discriminative network is designed to identify discrepancies between source and target domains.
class CANModel():
def __init__(self, num_classes, feature_extractor, discriminator, generator):
self.num_classes = num_classes
self.feature_extractor = feature_extractor
self.discriminator = discriminator
self.generator = generator
self.discriminator_optimizer = torch.optim.Adam(self.discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))
self.generator_optimizer = torch.optim.Adam(self.generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
self.classification_loss = nn.CrossEntropyLoss()
self.entropy_loss = nn.BCEWithLogitsLoss()
self.mse_loss = nn.MSELoss()
def train(self, source_dataloader, target_dataloader, epochs):
for epoch in range(epochs):
running_loss = {}
### Training on Source Domain ###
self.feature_extractor.eval()
self.generator.train()
self.discriminator.train()
pbar = tqdm(enumerate(source_dataloader), total=len(source_dataloader))
for i, data in pbar:
images, labels = data
real_features = self.feature_extractor(images.cuda())
noise = torch.randn(images.shape[0], 100).cuda()
fake_images = self.generator(noise)
fake_features = self.feature_extractor(fake_images)
dis_real = self.discriminator(real_features.detach()).squeeze()
dis_fake = self.discriminator(fake_features.detach().clone().requires_grad_(True)).squeeze()
classification_loss = self.classification_loss(dis_fake, labels.to("cuda").long())
entropy_loss = self.entropy_loss(dis_real, dis_fake)
d_loss = (-1)*classification_loss+entropy_loss
self.discriminator_optimizer.zero_grad()
d_loss.backward()
self.discriminator_optimizer.step()
pbar.set_description('[Epoch %d/%d] [Batch %d/%d] D Loss: %.4f'
%(epoch+1, epochs, i+1, len(source_dataloader), d_loss.item()))
### Training on Target Domain ###
self.feature_extractor.train()
self.generator.train()
self.discriminator.eval()
pbar = tqdm(enumerate(target_dataloader), total=len(target_dataloader))
for i, data in pbar:
images, _ = data
real_features = self.feature_extractor(images.cuda())
noise = torch.randn(images.shape[0], 100).cuda()
fake_images = self.generator(noise)
fake_features = self.feature_extractor(fake_images)
if not hasattr(self, "generated_labels"):
generated_labels = torch.LongTensor(np.random.randint(0, self.num_classes, size=fake_features.shape[0])).to("cuda")
classification_loss = self.classification_loss(fake_features, generated_labels)
g_loss = 0.1*classification_loss
self.generator_optimizer.zero_grad()
g_loss.backward()
self.generator_optimizer.step()
pbar.set_description('[Epoch %d/%d] [Batch %d/%d] G Loss: %.4f'
%(epoch+1, epochs, i+1, len(target_dataloader), g_loss.item()))
print("Epoch:", epoch, "Done!")
def generate(self, num_samples):
self.generator.eval()
samples = []
with torch.no_grad():
for i in range(num_samples//batch_size):
noise = torch.randn(batch_size, 100).cuda()
sample = self.generator(noise)
samples.append(sample)
samples = torch.cat(samples, dim=0)[:num_samples].cpu()
return samples
代码解读4.4 运行示例
在这个例子中，我们将使用CIFAR-10数据集和VGG-16作为特征提取器。
vgg16 = models.vgg16(pretrained=True).features
for param in vgg16.parameters():
param.requires_grad_(False)
new_classifier = nn.Sequential(
nn.Linear(in_features=4096, out_features=1024),
nn.ReLU(),
nn.Dropout(p=0.5),
nn.Linear(in_features=1024, out_features=10)
)
vgg16.classifier[6] = new_classifier
can_model = CANModel(num_classes=num_classes,
feature_extractor=vgg16,
discriminator=Discriminator(),
generator=Generator())
if __name__ == '__main__':
can_model.train(source_dataloader=trainloader, target_dataloader=valloader, epochs=20)
generated_imgs = can_model.generate(num_samples=64)
fig = plt.figure(figsize=(8, 8))
plt.axis("off")
plt.title("Generated Images")
plt.imshow(np.transpose(vutils.make_grid(generated_imgs.unsqueeze(1), normalize=True).cpu(), (1, 2, 0)))
plt.show()
代码解读5. 未来发展趋势与挑战
在迁移学习的热潮中不断升温的同时,近年来深度迁移学习的发展势头十分强劲。过去几年中,随着研究者们的不断探索与创新,模型类型日益多样化,其性能持续提升。然而,尽管CAN模型已在多个领域取得了一定成效,但目前仍面临诸多亟待解决的问题,例如:
- 大规模迁移学习面临的挑战较高。目前，在实际应用中仍存在诸多困难，在现有技术下尚无法有效支持规模较大的跨域数据集。
- 内存消耗较高是当前系统面临的一个关键问题，在分布式环境下进行训练时会面临较高的内存消耗问题。
- 运算效率较低导致整体性能不足，在迁移学习的实际应用中仍需探索更高效率的解决方案。
6. 附录常见问题与解答
深度迁移学习（Deep Transfer Learning）是一种让模型通过源域学习获得知识并将其应用于目标域的方法。这种技术的核心理念在于利用源域数据以及预训练模型参数等信息，在目标域上直接进行学习以实现模型的零样本迁移能力。这种方法的关键在于找到一种适合任务的领域自适应表示形式，在此形式下可充分挖掘源域与目标域之间的差异性。
-
**How to define Conditional Adversarial Networks (CANs) ? They are defined as a type of unsupervised feature learning method built upon the foundation of adversarial networks, designed to uncover the interdependencies between different classes. By introducing a discriminator (discriminator), this method distinguishes between samples of source and target domains, thereby learning the discrepancies between these two domains. Furthermore, CANs can implement class-specific attention mechanisms that focus solely on certain categories within the sample set, effectively mitigating the impact of label noise on classification performance. Lastly, they are capable of capturing global correlations among samples, which helps enhance the generalization capability of the model.
-
什么是类内注意力机制？ 类内注意力机制（Intra-class attention mechanism）是一种基于强化学习的方法，在分析判别器对各样本分类结果的基础上帮助生成器优化输出质量。通过深入研究判别器对各个具体样本的表现情况，该方法能够引导生成模型更加关注具有代表性的正类样例或减少负类干扰的影响。在这一过程中，算法会动态调整各类样例之间的权重分配策略，在训练过程中逐步提升模型的整体性能表现。
-
CANs 的训练流程包含以下几个主要环节：首先是对数据进行预处理以确保质量；接着通过深度学习模型自动识别关键特征；随后将不同模态的数据特征进行有机整合；在此基础上建立基于真实场景的可见性标记体系；最后通过精细调节使模型能够在目标领域表现更加突出或适应新的应用场景。
数据准备阶段：主要涉及对数据进行整理与划分工作。经过划分后得到三个子集：训练集、验证集和测试集。其中训练集与验证集主要用于指导模型的学习过程，在此过程中通过优化算法逐步提升模型性能；而测试集则被用来评估所建立的模型是否能够有效识别新的未知样本，并为后续应用提供依据。
在特徵提取階段中，在此階段利用訓練好的模型（例如VGG或AlexNet） Extracting高层特徵。這些 Extracted高层特徵將會被進一步處理後作為 CANs 的特徵提取網路的輸入
在该阶段中，在特征融合阶段中，在这一阶段中，在这一阶段里，
CANs 模型训练了一个用于整合多模态数据的模块，
这个模块能够识别各个领域中的关键特征，
并基于两个领域的相似度和距离信息，
计算出各领域间的权重关系，
随后，在这一过程中，
通过将两个领域的特征矩阵与各自的权重矩阵相乘，
从而生成最终的融合特征矩阵。
在可见软标签阶段中：CANs 掌握了一种新的生成标签的方法，这种方法能够基于判别器得出的结果来生成与可见软标签相匹配的结果
在目标域微调阶段中，在这一阶段中,CANs构建了一个用于对目标域数据样本进行分类的深度学习模型。首先,CANs会从头开始训练一个基于普通CNN的分类模型。然后,通过使用目标领域特化的训练数据对上述模型进行精细微调。最后,评估系统会对收集的目标领域测试数据进行处理,将融合优化后的模型应用于预测任务中。
采用交叉熵加惩罚项作为Loss function的原因是什么？该系统采用了创新性的Loss function被称为'Cross-Entropy with Penalty Term'。它包含了两个部分：一是判别器所对应的Cross-Entropy loss用于衡量真实与假数据之间的差异；二是生成器所对应的另一个损失用于引导其输出更符合数据分布。具体而言，在这一框架下：一是为了使判别器无法有效区分来自真实数据集与由模型产生的虚假样本；二是为了引导模型在识别来自真实数据集与虚假数据方面的性能上达到平衡。此外，在这一过程中还引入了'类内注意力机制'的概念