Fungsi kehilangan ialah algoritma yang mengukur sejauh mana model sesuai dengan data. Fungsi kerugian ialah satu cara untuk mengukur perbezaan antara ukuran sebenar dan nilai ramalan. Semakin tinggi nilai fungsi kerugian, semakin tidak tepat ramalannya, dan semakin rendah nilai fungsi kerugian, semakin dekat ramalan dengan nilai sebenar. Fungsi kehilangan dikira untuk setiap pemerhatian individu (titik data). Fungsi yang meratakan nilai semua fungsi kerugian dipanggil fungsi kos Pemahaman yang lebih mudah ialah fungsi kehilangan adalah untuk satu sampel, manakala fungsi kos adalah untuk semua sampel.
Sesetengah fungsi kehilangan juga boleh digunakan sebagai metrik penilaian. Tetapi fungsi dan metrik kerugian mempunyai tujuan yang berbeza. Walaupun metrik digunakan untuk menilai model akhir dan membandingkan prestasi model yang berbeza, fungsi kehilangan digunakan semasa fasa pembinaan model sebagai pengoptimum untuk model yang dibuat. Fungsi kehilangan membimbing model tentang cara meminimumkan ralat.
Maksudnya, fungsi kehilangan mengetahui cara model dilatih, dan indeks pengukuran menerangkan prestasi model.
Memandangkan fungsi kehilangan mengukur perbezaan antara nilai ramalan dan nilai sebenar, ia boleh digunakan untuk membimbing penambahbaikan model semasa melatih model ( biasanya kaedah penurunan kecerunan). Dalam proses membina model, jika berat ciri berubah dan mendapat ramalan yang lebih baik atau lebih teruk, anda perlu menggunakan fungsi kehilangan untuk menilai sama ada berat ciri dalam model perlu diubah, dan arah perubahan .
Kami boleh menggunakan pelbagai fungsi kehilangan dalam pembelajaran mesin, bergantung pada jenis masalah yang kami cuba selesaikan, kualiti data dan pengedaran, dan algoritma yang kami gunakan. Rajah berikut menunjukkan 10 yang kami ada disusun fungsi kehilangan biasa:
Ralat kuasa dua min merujuk kepada semua nilai yang diramalkan. dan nilai sebenar, dan purata mereka. Selalunya digunakan dalam masalah regresi.
def MSE (y, y_predicted):sq_error = (y_predicted - y) ** 2sum_sq_error = np.sum(sq_error)mse = sum_sq_error/y.sizereturn mse
dikira sebagai purata perbezaan mutlak antara nilai ramalan dan nilai sebenar. Ini adalah ukuran yang lebih baik daripada ralat kuasa dua min apabila data mempunyai outlier.
def MAE (y, y_predicted):error = y_predicted - yabsolute_error = np.absolute(error)total_absolute_error = np.sum(absolute_error)mae = total_absolute_error/y.sizereturn mae
Fungsi kehilangan ini ialah punca kuasa dua ralat min kuasa dua. Ini adalah pendekatan yang ideal jika kita tidak mahu menghukum kesilapan yang lebih besar.
def RMSE (y, y_predicted):sq_error = (y_predicted - y) ** 2total_sq_error = np.sum(sq_error)mse = total_sq_error/y.sizermse = math.sqrt(mse)return rmse
adalah serupa dengan min ralat mutlak tetapi tidak mengira nilai mutlak. Kelemahan fungsi kehilangan ini ialah ralat negatif dan positif boleh membatalkan satu sama lain, jadi adalah lebih baik untuk mengaplikasikannya apabila pengkaji tahu bahawa ralat hanya pergi ke satu arah.
def MBE (y, y_predicted):error = y_predicted - ytotal_error = np.sum(error)mbe = total_error/y.sizereturn mbe
Fungsi kerugian Huber menggabungkan kelebihan ralat mutlak min (MAE) dan ralat kuasa dua min (MSE). Ini kerana Hubber loss adalah fungsi dengan dua cawangan. Satu cabang digunakan pada MAE yang sepadan dengan nilai yang dijangkakan, dan cabang lain digunakan pada outlier. Fungsi umum Hubber Loss ialah:
Di sini
def hubber_loss (y, y_predicted, delta)delta = 1.35 * MAEy_size = y.sizetotal_error = 0for i in range (y_size):erro = np.absolute(y_predicted[i] - y[i])if error < delta:hubber_error = (error * error) / 2else:hubber_error = (delta * error) / (0.5 * (delta * delta))total_error += hubber_errortotal_hubber_error = total_error/y.sizereturn total_hubber_error
Fungsi kehilangan ini digunakan terutamanya untuk masalah klasifikasi binari. Kebarangkalian setiap nilai yang diramalkan didarabkan untuk mendapatkan nilai kerugian, dan fungsi kos yang berkaitan ialah purata semua nilai yang diperhatikan. Mari kita ambil contoh klasifikasi binari berikut di mana kelasnya ialah [0] atau [1]. Jika kebarangkalian keluaran adalah sama dengan atau lebih besar daripada 0.5, kelas yang diramalkan ialah [1], sebaliknya ia adalah [0]. Contoh kebarangkalian keluaran adalah seperti berikut:
[0.3, 0.7, 0.8, 0.5, 0.6, 0.4]
Kelas ramalan yang sepadan ialah:
[0, 1, 1, 1 , 1 , 0]
manakala kelas sebenar ialah:
[0 , 1 , 1 , 0 , 1 , 0]
Sekarang yang sebenar kelas dan Output kebarangkalian untuk mengira kerugian. Jika kelas sebenar ialah [1], kami menggunakan kebarangkalian keluaran, jika kelas sebenar ialah [0], kami menggunakan kebarangkalian 1:
((1–0.3)+0.7+0.8+(1 –0.5)+ 0.6+(1–0.4)) / 6 = 0.65
Kod Python adalah seperti berikut:
def LHL (y, y_predicted):likelihood_loss = (y * y_predicted) + ((1-y) * (y_predicted))total_likelihood_loss = np.sum(likelihood_loss)lhl = - total_likelihood_loss / y.sizereturn lhl
— (y . log (p) + (1 — y) . log (1 — p))
Mari teruskan menggunakan Nilai di atas sebagai contoh:
Kebarangkalian output = [0.3, 0.7, 0.8, 0.5, 0.6, 0.4]
Kelas sebenar = [0, 1, 1, 0, 1, 0]
— (0 . log (0.3) + (1–0) . log (1–0.3)) = 0.155
— (1 . log(0.7) + (1–1) . log (0.3)) = 0.155
— (1 . log(0.8) + (1–1) . log (0.2)) = 0.097
— (0 . log (0.5) + (1–0) . log (1–0.5)) = 0.301
— (1 . log(0.6) + (1–1) . log (0.4)) = 0.222
— (0 . log (0.4) + (1–0) . log (1–0.4)) = 0.222
那么代价函数的结果为：
(0.155 + 0.155 + 0.097 + 0.301 + 0.222 + 0.222) / 6 = 0.192
Python的代码如下：
def BCE (y, y_predicted):ce_loss = y*(np.log(y_predicted))+(1-y)*(np.log(1-y_predicted))total_ce = np.sum(ce_loss)bce = - total_ce/y.sizereturn bce
Hinge Loss被翻译成铰链损失或者合页损失，这里还是以英文为准。
Hinge Loss主要用于支持向量机模型的评估。错误的预测和不太自信的正确预测都会受到惩罚。 所以一般损失函数是：
l(y) = max (0 , 1 — t . y)
这里的t是真实结果用[1]或[-1]表示。
使用Hinge Loss的类应该是[1]或[-1](不是[0])。为了在Hinge loss函数中不被惩罚，一个观测不仅需要正确分类而且到超平面的距离应该大于margin(一个自信的正确预测)。如果我们想进一步惩罚更高的误差，我们可以用与MSE类似的方法平方Hinge损失,也就是Squared Hinge Loss。
如果你对SVM比较熟悉，应该还记得在SVM中，超平面的边缘（margin）越高，则某一预测就越有信心。如果这块不熟悉，则看看这个可视化的例子:
如果一个预测的结果是1.5，并且真正的类是[1]，损失将是0(零)，因为模型是高度自信的。
loss= Max (0,1 - 1* 1.5) = Max (0， -0.5) = 0
如果一个观测结果为0(0)，则表示该观测处于边界(超平面)，真实的类为[-1]。损失为1，模型既不正确也不错误，可信度很低。
loss = max (0 , 1–(-1) * 0) = max (0 , 1) = 1
如果一次观测结果为2，但分类错误(乘以[-1])，则距离为-2。损失是3(非常高)，因为我们的模型对错误的决策非常有信心（这个是绝不能容忍的）。
loss = max (0 , 1 — (-1) . 2) = max (0 , 1+2) = max (0 , 3) = 3
python代码如下：
#Hinge Lossdef Hinge (y, y_predicted):hinge_loss = np.sum(max(0 , 1 - (y_predicted * y)))return hinge_loss#Squared Hinge Lossdef SqHinge (y, y_predicted):sq_hinge_loss = max (0 , 1 - (y_predicted * y)) ** 2total_sq_hinge_loss = np.sum(sq_hinge_loss)return total_sq_hinge_loss
在多分类中，我们使用与二元交叉熵类似的公式，但有一个额外的步骤。首先需要计算每一对[y, y_predicted]的损失，一般公式为：
如果我们有三个类，其中单个[y, y_predicted]对的输出是：
这里实际的类3（也就是值=1的部分），我们的模型对真正的类是3的信任度是0.7。计算这损失如下：
Loss = 0 . log (0.1) + 0 . log (0.2) + 1 . log (0.7) = -0.155
为了得到代价函数的值，我们需要计算所有单个配对的损失，然后将它们相加最后乘以[-1/样本数量]。代价函数由下式给出：
使用上面的例子，如果我们的第二对：
Loss = 0 . log (0.4) + 1. log (0.4) + 0. log (0.2) = -0.40
那么成本函数计算如下：
使用Python的代码示例可以更容易理解：
def CCE (y, y_predicted):cce_class = y * (np.log(y_predicted))sum_totalpair_cce = np.sum(cce_class)cce = - sum_totalpair_cce / y.sizereturn cce
又被简化称为KL散度，它类似于分类交叉熵，但考虑了观测值发生的概率。 如果我们的类不平衡，它特别有用。
def KL (y, y_predicted):kl = y * (np.log(y / y_predicted))total_kl = np.sum(kl)return total_kl
以上就是常见的10个损失函数，希望对你有所帮助。
Atas ialah kandungan terperinci Sepuluh penjelasan fungsi kehilangan yang biasa digunakan dan pelaksanaan kod Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
