今天介绍下损失函数，先介绍下我常用的方法SmoothedL1，它是一个平滑的L1 penalty函数,用于处理约束violation。
标准的L1 penalty函数定义为:
L
1
(
x
)
=
{
0
,
if
x
≤
0
x
,
if
x
>
0
L_1(x)=
其中
x
x
x表示约束violation。然而,这个函数在
x
=
0
x=0
x=0处不可导,会给基于梯度的优化算法带来数值问题。
为了解决这个问题,SmoothedL1使用了一个分段的、光滑的函数来近似L1 penalty。它的定义如下:
smoothedL1
(
x
,
μ
)
=
{
0
,
if
x
<
0
1
2
μ
x
2
,
if
0
≤
x
<
μ
x
−
1
2
μ
,
if
x
≥
μ
\text{smoothedL1}(x,\mu)=
其中
μ
>
0
\mu>0
μ>0是一个平滑参数。当
μ
→
0
\mu\to 0
μ→0时,smoothedL1趋近于标准的L1 penalty;当
μ
\mu
μ增大时,smoothedL1变得更加平滑。
在代码中,smoothedL1的实现如下:
static inline bool smoothedL1(const double &x,
const double &mu,
double &f,
double &df)
{
if (x < 0.0)
{
df = 0;
return false;
}
else if (x < mu)
{
f = x * x / (2.0 * mu);
df = x / mu;
return true;
}
else
{
f = x - 0.5 * mu;
df = 1.0;
return true;
}
}
这个函数接受约束violation x和平滑参数mu,返回penalty值f和梯度df。具体来说:
通过这种分段定义,smoothedL1实现了对L1 penalty的光滑近似。在 x = 0 x=0 x=0和 x = μ x=\mu x=μ处,虽然函数本身不可导,但左右导数存在且相等,因此不会引入数值问题。
在轨迹优化中,smoothedL1被用于计算速度约束、加速度约束等的violation对应的cost和梯度。通过将这些cost项添加到目标函数中,并将梯度信息反向传播,优化算法可以在最小化能量(minimum-energy)的同时,将轨迹逐步修正为满足约束的状态,最终得到一条动力学可行(dynamically feasible)的轨迹。这就是smoothedL1在这个问题中的作用和实现原理。
我可以给你一个通俗的例子来解释smoothedL1函数的用途。
假设你是一家披萨店的老板,你需要制定一个披萨配送的最优路线。你的目标是找到一条路线,使得配送时间尽可能短,但同时也要考虑到路上可能会遇到一些意外情况,如交通堵塞、红绿灯等。
在这个问题中,我们可以将配送时间看作是优化的目标函数。我们希望实际的配送时间与预期的配送时间尽可能接近。如果实际配送时间比预期时间长,就会有一个惩罚项。
现在,假设我们使用二次函数(即L2损失)来计算惩罚项。这意味着,如果实际配送时间比预期时间长2分钟,惩罚值为4;如果长5分钟,惩罚值为25。你可以看到,随着差异的增大,惩罚值会急剧增加。这在某些情况下可能不太合理,因为一些小的延迟是可以接受的,而大的延迟可能是由一些无法控制的因素引起的,如交通事故。
另一种选择是使用绝对值函数(即L1损失)。这意味着,无论实际配送时间比预期时间长2分钟还是5分钟,惩罚值都是一样的。这也有问题,因为它不能区分小的延迟和大的延迟。
smoothedL1函数提供了一个折衷的方案。它在小的延迟时表现得像二次函数,惩罚值随着差异的增大而平滑增加;在大的延迟时表现得像绝对值函数,惩罚值增加的速度变慢。这样,我们就可以在考虑小的延迟的同时,也对大的延迟更加宽容。
下面是一个简单的Python代码,展示了如何使用smoothedL1函数计算惩罚值:
def smoothedL1(x, mu):
if x < 0:
return 0
elif x > mu:
return x - 0.5 * mu
else:
return (mu - 0.5 * x) * (x / mu)**3
# 预期配送时间为10分钟
expected_time = 10
# 实际配送时间为12分钟
actual_time = 12
# 计算延迟
delay = actual_time - expected_time
# 设定平滑参数为5分钟
mu = 5
# 计算惩罚值
penalty = smoothedL1(delay, mu)
print(f"The penalty for a delay of {delay} minutes is {penalty}.")
如果实际配送时间比预期时间长2分钟,惩罚值为0.384;如果长5分钟,惩罚值为2.5。你可以看到,对于小的延迟,惩罚值较小;对于大的延迟,惩罚值增加的速度变慢。
当然,在实际的路线优化问题中,情况会更加复杂。这在许多优化问题中都非常有用。
除了smoothedL1损失函数,还有许多其他先进的损失函数在各个领域发挥着关键作用。下面我将介绍几个常用的损失函数及其应用。
交叉熵损失(Cross-Entropy Loss)
交叉熵损失函数常用于分类问题。它衡量了模型预测的概率分布与真实标签的差异。对于二分类问题,交叉熵损失函数定义为:
L
C
E
=
−
∑
i
=
1
N
y
i
log
(
p
i
)
+
(
1
−
y
i
)
log
(
1
−
p
i
)
L_{CE}=-\sum_{i=1}^N y_i\log(p_i)+(1-y_i)\log(1-p_i)
LCE=−i=1∑Nyilog(pi)+(1−yi)log(1−pi)
其中
y
i
y_i
yi是第
i
i
i个样本的真实标签(0或1),
p
i
p_i
pi是模型预测的概率。
交叉熵损失函数在图像分类、自然语言处理等领域得到广泛应用。它能够促使模型学习到正确的类别,同时抑制错误的类别。许多著名的神经网络,如AlexNet, VGG, ResNet等,都使用交叉熵损失函数进行训练。
对比损失(Contrastive Loss)
对比损失函数常用于学习嵌入空间(embedding space),使得相似的样本在嵌入空间中靠近,不相似的样本在嵌入空间中远离。它的定义如下:
L
c
o
n
t
r
a
s
t
=
∑
(
i
,
j
)
y
i
j
d
(
x
i
,
x
j
)
+
(
1
−
y
i
j
)
max
(
0
,
α
−
d
(
x
i
,
x
j
)
)
L_{contrast}=\sum_{(i,j)}y_{ij}d(x_i,x_j)+(1-y_{ij})\max(0,\alpha-d(x_i,x_j))
Lcontrast=(i,j)∑yijd(xi,xj)+(1−yij)max(0,α−d(xi,xj))
其中
y
i
j
y_{ij}
yij表示样本
i
i
i和
j
j
j是否相似(1表示相似,0表示不相似),
d
(
x
i
,
x
j
)
d(x_i,x_j)
d(xi,xj)是样本
i
i
i和
j
j
j在嵌入空间中的距离,
α
\alpha
α是一个margin参数。
对比损失函数在人脸识别、图像检索等领域发挥了重要作用。通过最小化对比损失,模型可以学习到一个鲁棒的嵌入空间,使得相似的样本(如同一个人的不同照片)聚集在一起,不相似的样本(如不同人的照片)分散开来。
焦点损失(Focal Loss)
焦点损失函数是一种用于处理类别不平衡问题的损失函数。在许多实际问题中,不同类别的样本数量差异很大。这会导致模型更加关注样本量大的类别,而忽视样本量小的类别。焦点损失函数通过引入一个调制因子来缓解这个问题:
L
f
o
c
a
l
=
−
∑
i
=
1
N
(
1
−
p
i
)
γ
log
(
p
i
)
L_{focal}=-\sum_{i=1}^N(1-p_i)^\gamma\log(p_i)
Lfocal=−i=1∑N(1−pi)γlog(pi)
其中
p
i
p_i
pi是模型预测的概率,
γ
\gamma
γ是一个超参数。当模型预测错误时,
p
i
p_i
pi较小,
(
1
−
p
i
)
γ
(1-p_i)^\gamma
(1−pi)γ较大,损失函数会给这些样本更大的权重。
焦点损失函数在目标检测领域取得了巨大成功。在著名的目标检测算法RetinaNet中,使用焦点损失函数替代交叉熵损失函数,大幅提高了对小目标的检测精度。
Wasserstein损失(Wasserstein Loss)
Wasserstein损失函数源于最优传输理论,它衡量了两个概率分布之间的距离。在生成对抗网络(GAN)中,Wasserstein损失函数被用于度量生成数据和真实数据的分布差异:
L
W
a
s
s
e
r
s
t
e
i
n
=
sup
∣
∣
f
∣
∣
L
≤
1
E
x
∼
P
r
[
f
(
x
)
]
−
E
x
∼
P
g
[
f
(
x
)
]
L_{Wasserstein}=\sup_{||f||_L\leq1}\mathbb{E}_{x\sim P_r}[f(x)]-\mathbb{E}_{x\sim P_g}[f(x)]
LWasserstein=∣∣f∣∣L≤1supEx∼Pr[f(x)]−Ex∼Pg[f(x)]
其中
P
r
P_r
Pr是真实数据的分布,
P
g
P_g
Pg是生成数据的分布,
f
f
f是一个Lipschitz连续函数。
相比于传统的GAN损失函数,Wasserstein损失函数提供了一个更加稳定的训练过程。它在图像生成、风格迁移等领域取得了令人印象深刻的成果。著名的WGAN和WGAN-GP都是基于Wasserstein损失函数构建的。
一个好的损失函数可以引导模型学习到正确的特征表示,加速训练过程,提高模型的泛化能力。
import torch
import torch.nn as nn
# 定义模型
class ImageClassifier(nn.Module):
def __init__(self):
super(ImageClassifier, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.fc1 = nn.Linear(64 * 6 * 6, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = nn.functional.relu(x)
x = self.conv2(x)
x = nn.functional.relu(x)
x = x.view(-1, 64 * 6 * 6)
x = self.fc1(x)
x = nn.functional.relu(x)
x = self.fc2(x)
return x
# 定义损失函数
criterion = nn.CrossEntropyLoss()
# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# 训练模型
for epoch in range(10):
for i, (images, labels) in enumerate(train_loader):
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
这个例子中定义了一个简单的卷积神经网络ImageClassifier,使用nn.CrossEntropyLoss()作为损失函数。在训练过程中,我们将图像输入模型,计算模型的预测结果和真实标签之间的交叉熵损失,然后使用优化器更新模型参数。交叉熵损失函数能够有效地指导模型学习,使其对不同类别的图像进行准确分类。
import tensorflow as tf
# 定义模型
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D((2, 2)),
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
tf.keras.layers.MaxPooling2D((2, 2)),
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(10)
])
# 定义损失函数
def contrastive_loss(y_true, y_pred):
margin = 1
square_pred = tf.math.square(y_pred)
margin_square = tf.math.square(tf.math.maximum(margin - y_pred, 0))
return tf.math.reduce_mean(
y_true * square_pred + (1 - y_true) * margin_square
)
# 编译模型
model.compile(optimizer='adam',
loss=contrastive_loss,
metrics=['accuracy'])
# 训练模型
model.fit(x_train, y_train, epochs=5)
在这个例子中定义了一个卷积神经网络作为人脸嵌入模型。我们自定义了一个contrastive_loss函数,它接收两个参数:真实标签y_true(1表示两张图片属于同一个人,0表示属于不同的人)和模型的预测值y_pred(表示两张图片在嵌入空间中的距离)。对比损失函数鼓励模型将同一个人的照片映射到相近的位置,将不同人的照片映射到相distant的位置。通过最小化对比损失,模型可以学习到一个判别性强的人脸嵌入空间,用于人脸识别和验证。
import torch
import torch.nn as nn
# 定义焦点损失函数
class FocalLoss(nn.Module):
def __init__(self, alpha=0.25, gamma=2):
super(FocalLoss, self).__init__()
self.alpha = alpha
self.gamma = gamma
def forward(self, pred, target):
ce_loss = nn.functional.cross_entropy(pred, target, reduction='none')
pt = torch.exp(-ce_loss)
focal_loss = self.alpha * (1 - pt) ** self.gamma * ce_loss
return torch.mean(focal_loss)
# 定义模型
model = nn.Sequential(
nn.Conv2d(3, 32, 3, padding=1),
nn.ReLU(),
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 2, 1)
)
# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# 训练模型
for epoch in range(10):
for i, (images, targets) in enumerate(train_loader):
preds = model(images)
loss = FocalLoss()(preds, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
在这个例子中,我们定义了一个FocalLoss类,它继承自nn.Module。在forward方法中,我们首先计算交叉熵损失,然后根据预测的准确性计算一个调制因子
(
1
−
p
t
)
γ
(1 - p_t)^\gamma
(1−pt)γ。这个调制因子可以减少easy example的损失贡献,同时增大hard example的损失贡献。最后将调制后的损失取平均作为最终的焦点损失。在训练过程中,使用焦点损失函数可以使模型更加关注那些难以分类的目标,提高检测精度。
import tensorflow as tf
# 定义生成器
generator = tf.keras.Sequential([
tf.keras.layers.Dense(7 * 7 * 256, input_shape=(100,)),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.LeakyReLU(),
tf.keras.layers.Reshape((7, 7, 256)),
tf.keras.layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.LeakyReLU(),
tf.keras.layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.LeakyReLU(),
tf.keras.layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', activation='tanh')
])
# 定义判别器
discriminator = tf.keras.Sequential([
tf.keras.layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=(28, 28, 1)),
tf.keras.layers.LeakyReLU(),
tf.keras.layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'),
tf.keras.layers.LeakyReLU(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(1)
])
# 定义Wasserstein损失函数
def wasserstein_loss(y_true, y_pred):
return tf.math.reduce_mean(y_true * y_pred)
# 编译模型
discriminator.compile(optimizer=tf.keras.optimizers.RMSprop(lr=0.00005),
loss=wasserstein_loss,
metrics=['accuracy'])
generator.compile(optimizer=tf.keras.optimizers.RMSprop(lr=0.00005),
loss=wasserstein_loss)
# 训练模型
for epoch in range(100):
for i in range(num_batches):
noise = tf.random.normal([batch_size, 100])
generated_images = generator(noise)
real_images = next(iter(train_dataset))[0]
x = tf.concat([real_images, generated_images], axis=0)
y_dis = tf.concat([tf.ones((batch_size, 1)), tf.ones((batch_size, 1)) * -1], axis=0)
discriminator.trainable = True
discriminator.train_on_batch(x, y_dis)
noise = tf.random.normal([batch_size, 100])
y_gen = tf.ones((batch_size, 1))
discriminator.trainable = False
generator.train_on_batch(noise, y_gen)
在这个例子中定义了一个生成器网络和一个判别器网络。生成器接收一个随机噪声作为输入,输出一张生成的图像。判别器接收一张图像作为输入,输出一个标量值,表示输入图像是真实的还是生成的。我们使用wasserstein_loss作为损失函数,它计算了判别器的预测值和真实标签的乘积的平均值。在训练过程中,我们交替训练判别器和生成器。对于判别器,我们希望它能够正确区分真实图像(标签为1)和生成图像(标签为-1)。对于生成器,我们希望它能够生成更加逼真的图像,使得判别器将其预测为真实图像(标签为1)。通过最小化Wasserstein损失,生成器可以学习到真实图像的分布,生成高质量的图像。
选择合适的损失函数可以帮助模型更好地学习到数据的内在模式,提高任务的性能。同时,损失函数的设计也需要考虑问题的特点和模型的结构,根据实际情况进行进一步的调整和优化。