Eniyileme ve Derin Öğrenme
==========================
Bu bölümde, eniyileme ve derin öğrenme arasındaki ilişkiyi ve derin
öğrenmede optimizasyonu kullanmanın zorluklarını tartışacağız. Derin
öğrenme problemi için, genellikle önce *kayıp fonksiyonu* tanımlarız.
Kayıp işlevini aldığımızda kayıpları en aza indirmek için bir
optimizasyon algoritması kullanabiliriz. Optimizasyonda, bir kayıp
fonksiyonu genellikle optimizasyon sorununun *amaç fonksiyonu* olarak
adlandırılır. Geleneksel ve alışılmış olarak çoğu optimizasyon
algoritması, *minimizasyon (en aza indirme)* ile ilgilidir. Eğer bir
hedefi en üst düzeye çıkarmamız (maksimize etmemiz) gerekirse basit bir
çözüm vardır: Sadece amaç işlevindeki işareti tersine çevirin.
Eniyilemenin Hedefi
-------------------
Optimizasyon derin öğrenme için kayıp işlevini en aza indirmenin bir
yolunu sağlasa da, özünde optimizasyonun ve derin öğrenmenin amaçları
temelde farklıdır. Birincisi öncelikle bir amaç işlevini en aza
indirmekle ilgiliyken, ikincisi, sınırlı miktarda veri verildiğinde
uygun bir model bulmakla ilgilidir. :numref:`sec_model_selection`
içinde, bu iki hedef arasındaki farkı ayrıntılı olarak tartıştık.
Örneğin, eğitim hatası ve genelleme hatası genellikle farklılık
gösterir: Optimizasyon algoritmasının amaç işlevi genellikle eğitim veri
kümesine dayalı bir kayıp fonksiyonu olduğundan, optimizasyonun amacı
eğitim hatasını azaltmaktır. Bununla birlikte, derin öğrenmenin amacı
(veya daha geniş bir şekilde istatistiksel çıkarımın) genelleme hatasını
azaltmaktır. İkincisini başarmak için, eğitim hatasını azaltmada
optimizasyon algoritmasını kullanmanın yanı sıra aşırı öğrenme işlemine
de dikkat etmeliyiz.
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
%matplotlib inline
from mpl_toolkits import mplot3d
from d2l import mxnet as d2l
from mxnet import np, npx
npx.set_np()
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
%matplotlib inline
import numpy as np
import torch
from mpl_toolkits import mplot3d
from d2l import torch as d2l
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
%matplotlib inline
import numpy as np
from mpl_toolkits import mplot3d
import tensorflow as tf
from d2l import tensorflow as d2l
.. raw:: html
.. raw:: html
Yukarıda belirtilen farklı hedefleri göstermek için, riski ve deneysel
riski ele alalım. :numref:`subsec_empirical-risk-and-risk` içinde
açıklandığı gibi, deneysel risk, eğitim veri kümesinde ortalama bir
kayıptır ve risk veri nüfusunun tamamında beklenen kayıptır. Aşağıda iki
fonksiyon tanımlıyoruz: Risk fonksiyonu ``f`` ve deneysel risk
fonksiyonu ``g``. Sadece sınırlı miktarda eğitim verisi olduğunu
varsayalım. Sonuç olarak, burada ``g`` ``f``'den daha az pürüzsüzdür.
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def f(x):
return x * np.cos(np.pi * x)
def g(x):
return f(x) + 0.2 * np.cos(5 * np.pi * x)
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def f(x):
return x * torch.cos(np.pi * x)
def g(x):
return f(x) + 0.2 * torch.cos(5 * np.pi * x)
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def f(x):
return x * tf.cos(np.pi * x)
def g(x):
return f(x) + 0.2 * tf.cos(5 * np.pi * x)
.. raw:: html
.. raw:: html
Aşağıdaki grafik, bir eğitim veri kümesinde deneysel riskin minimumunun,
minimum riskten farklı bir konumda olabileceğini göstermektedir
(genelleme hatası).
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def annotate(text, xy, xytext): #@save
d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,
arrowprops=dict(arrowstyle='->'))
x = np.arange(0.5, 1.5, 0.01)
d2l.set_figsize((4.5, 2.5))
d2l.plot(x, [f(x), g(x)], 'x', 'risk')
annotate('min \ndeneysel risk', (1.0, -1.2), (0.5, -1.1))
annotate('min risk', (1.1, -1.05), (0.95, -0.5))
.. figure:: output_optimization-intro_70d214_27_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def annotate(text, xy, xytext): #@save
d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,
arrowprops=dict(arrowstyle='->'))
x = torch.arange(0.5, 1.5, 0.01)
d2l.set_figsize((4.5, 2.5))
d2l.plot(x, [f(x), g(x)], 'x', 'risk')
annotate('min \ndeneysel risk', (1.0, -1.2), (0.5, -1.1))
annotate('min risk', (1.1, -1.05), (0.95, -0.5))
.. figure:: output_optimization-intro_70d214_30_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def annotate(text, xy, xytext): #@save
d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,
arrowprops=dict(arrowstyle='->'))
x = tf.range(0.5, 1.5, 0.01)
d2l.set_figsize((4.5, 2.5))
d2l.plot(x, [f(x), g(x)], 'x', 'risk')
annotate('min \ndeneysel risk', (1.0, -1.2), (0.5, -1.1))
annotate('min risk', (1.1, -1.05), (0.95, -0.5))
.. figure:: output_optimization-intro_70d214_33_0.svg
.. raw:: html
.. raw:: html
Derin Öğrenmede Eniyileme Zorlukları
------------------------------------
Bu bölümde, özellikle bir modelin genelleme hatası yerine amaç işlevini
en aza indirmede optimizasyon algoritmalarının başarımına odaklanacağız.
:numref:`sec_linear_regression` içinde optimizasyon problemlerinde
analitik çözümler ve sayısal çözümler arasında ayrım yaptık. Derin
öğrenmede, çoğu amaç fonksiyonu karmaşıktır ve analitik çözümleri
yoktur. Bunun yerine, sayısal optimizasyon algoritmaları kullanmalıyız.
Bu bölümdeki optimizasyon algoritmalarının tümü bu kategoriye girer.
Derin öğrenme optimizasyonunda birçok zorluk vardır. En eziyetli
olanlardan bazıları yerel minimum, eyer noktaları ve kaybolan
gradyanlardır. Onlara bir göz atalım.
Yerel En Düşüklükler
~~~~~~~~~~~~~~~~~~~~
Herhangi bir :math:`f(x)` amaç işlevi için :math:`f(x)` değerinin
:math:`x`'teki değeri :math:`x` civarındaki diğer noktalardaki
:math:`f(x)` değerlerinden daha küçükse, :math:`f(x)` yerel minimum
olabilir. :math:`x` değerindeki :math:`f(x)` değeri, tüm etki alanı
üzerinde amaç işlevin minimum değeriyse, :math:`f(x)` genel minimum
değerdir.
Örneğin, aşağıdaki fonksiyon göz önüne alındığında
.. math:: f(x) = x \cdot \text{cos}(\pi x) \text{ for } -1.0 \leq x \leq 2.0,
bu fonksiyonun yerel minimum ve küresel minimum değerlerini yaklaşık
olarak değerlendirebiliriz.
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = np.arange(-1.0, 2.0, 0.01)
d2l.plot(x, [f(x), ], 'x', 'f(x)')
annotate('yerel minimum', (-0.3, -0.25), (-0.77, -1.0))
annotate('kuresel minimum', (1.1, -0.95), (0.6, 0.8))
.. figure:: output_optimization-intro_70d214_39_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = torch.arange(-1.0, 2.0, 0.01)
d2l.plot(x, [f(x), ], 'x', 'f(x)')
annotate('yerel minimum', (-0.3, -0.25), (-0.77, -1.0))
annotate('kuresel minimum', (1.1, -0.95), (0.6, 0.8))
.. figure:: output_optimization-intro_70d214_42_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = tf.range(-1.0, 2.0, 0.01)
d2l.plot(x, [f(x), ], 'x', 'f(x)')
annotate('yerel minimum', (-0.3, -0.25), (-0.77, -1.0))
annotate('kuresel minimum', (1.1, -0.95), (0.6, 0.8))
.. figure:: output_optimization-intro_70d214_45_0.svg
.. raw:: html
.. raw:: html
Derin öğrenme modellerinin amaç işlevi genellikle birçok yerel eniyi
değere sahiptir. Bir optimizasyon probleminin sayısal çözümü yerel eniyi
seviyesine yakın olduğunda, nihai yineleme ile elde edilen sayısal
çözüm, amaç fonksiyonun çözümlerinin gradyanının sıfıra yaklaştığı veya
olduğu için, objektif işlevi *küresel* yerine yalnızca *yerel* en aza
indirebilir. Parametreyi yalnızca bir dereceye kadar gürültü yerel
minimum seviyeden çıkarabilir. Aslında bu, minigrup üzerindeki
gradyanların doğal çeşitliliğin parametreleri yerel en düşük yerinden
çıkarabildiği minigrup rasgele gradyan inişinin yararlı özelliklerinden
biridir.
Eyer Noktaları
~~~~~~~~~~~~~~
Yerel minimumun yanı sıra eyer noktaları gradyanların kaybolmasının bir
başka nedenidir. *Eyer noktası*, bir işlevin tüm gradyanların kaybolduğu
ancak ne küresel ne de yerel minimum olmayan herhangi bir konumdur.
:math:`f(x) = x^3` işlevini düşünün. Onun birinci ve ikinci türevi
:math:`x=0` için kaybolur. Eniyileme minimum olmasa bile, bu noktada
durabilir.
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = np.arange(-2.0, 2.0, 0.01)
d2l.plot(x, [x**3], 'x', 'f(x)')
annotate('eyer noktasi', (0, -0.2), (-0.52, -5.0))
.. figure:: output_optimization-intro_70d214_51_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = torch.arange(-2.0, 2.0, 0.01)
d2l.plot(x, [x**3], 'x', 'f(x)')
annotate('eyer noktasi', (0, -0.2), (-0.52, -5.0))
.. figure:: output_optimization-intro_70d214_54_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = tf.range(-2.0, 2.0, 0.01)
d2l.plot(x, [x**3], 'x', 'f(x)')
annotate('eyer noktasi', (0, -0.2), (-0.52, -5.0))
.. figure:: output_optimization-intro_70d214_57_0.svg
.. raw:: html
.. raw:: html
Aşağıdaki örnekte gösterildiği gibi, daha yüksek boyutlardaki eyer
noktaları daha da gizli tehlikedir. :math:`f(x, y) = x^2 - y^2` işlevini
düşünün. :math:`(0, 0)` onun eyer noktası vardır. Bu, :math:`y`'ye göre
maksimum ve :math:`x`'e göre minimum değerdir. Dahası, bu, matematiksel
özelliğin adını aldığı bir eyer gibi *görünür*.
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x, y = np.meshgrid(
np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))
z = x**2 - y**2
ax = d2l.plt.figure().add_subplot(111, projection='3d')
ax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(),
**{'rstride': 10, 'cstride': 10})
ax.plot([0], [0], [0], 'rx')
ticks = [-1, 0, 1]
d2l.plt.xticks(ticks)
d2l.plt.yticks(ticks)
ax.set_zticks(ticks)
d2l.plt.xlabel('x')
d2l.plt.ylabel('y');
.. figure:: output_optimization-intro_70d214_63_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x, y = torch.meshgrid(
torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))
z = x**2 - y**2
ax = d2l.plt.figure().add_subplot(111, projection='3d')
ax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})
ax.plot([0], [0], [0], 'rx')
ticks = [-1, 0, 1]
d2l.plt.xticks(ticks)
d2l.plt.yticks(ticks)
ax.set_zticks(ticks)
d2l.plt.xlabel('x')
d2l.plt.ylabel('y');
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
/home/d2l-worker/miniconda3/envs/d2l-tr-release-0/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2895.)
return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]
.. figure:: output_optimization-intro_70d214_66_1.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x, y = tf.meshgrid(
tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))
z = x**2 - y**2
ax = d2l.plt.figure().add_subplot(111, projection='3d')
ax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})
ax.plot([0], [0], [0], 'rx')
ticks = [-1, 0, 1]
d2l.plt.xticks(ticks)
d2l.plt.yticks(ticks)
ax.set_zticks(ticks)
d2l.plt.xlabel('x')
d2l.plt.ylabel('y');
.. figure:: output_optimization-intro_70d214_69_0.svg
.. raw:: html
.. raw:: html
Bir fonksiyonun girdisinin :math:`k` boyutlu bir vektör olduğunu ve
çıktısının bir skaler olduğunu varsayıyoruz, bu nedenle Hessian
matrisinin :math:`k` tane özdeğere sahip olacağını varsayıyoruz
(`özayrışımlar üzerine çevrimiçi
ek `__'e
bakın). Fonksiyonun çözümü yerel minimum, yerel maksimum veya işlev
gradyanının sıfır olduğu bir konumda eyer noktası olabilir:
- Sıfır-gradyan konumundaki fonksiyonun Hessian matrisinin özdeğerleri
pozitif olduğunda, işlev için yerel minimum değerlere sahibiz.
- Sıfır-gradyan konumundaki fonksiyonun Hessian matrisinin özdeğerleri
negatif olduğunda, işlev için yerel maksimum değerlere sahibiz.
- Sıfır-gradyan konumundaki fonksiyonun Hessian matrisinin özdeğerleri
negatif ve pozitif olduğunda, fonksiyon için bir eyer noktamız
vardır.
Yüksek boyutlu problemler için özdeğerlerin en azından *bazılarının*
negatif olma olasılığı oldukça yüksektir. Bu eyer noktalarını yerel
minimumlardan daha olasıdır yapar. Dışbükeyliği tanıtırken bir sonraki
bölümde bu durumun bazı istisnalarını tartışacağız. Kısacası, dışbükey
fonksiyonlar Hessian'ın özdeğerlerinin asla negatif olmadığı yerlerdir.
Ne yazık ki, yine de, çoğu derin öğrenme problemi bu kategoriye
girmiyor. Yine de optimizasyon algoritmaları incelemek için harika bir
araçtır.
Kaybolan Gradyanlar
~~~~~~~~~~~~~~~~~~~
Muhtemelen aşılması gereken en sinsi sorun kaybolan gradyanlardır.
:numref:`subsec_activation-functions` içinde yaygın olarak kullanılan
etkinleştirme fonksiyonlarımızı ve türevlerini hatırlayın. Örneğin,
:math:`f(x) = \tanh(x)` işlevini en aza indirmek istediğimizi ve
:math:`x = 4`'te başladığımızı varsayalım. Gördüğümüz gibi,
:math:`f`'nin gradyanı sıfıra yakındır. Daha özel durum olarak,
:math:`f'(x) = 1 - \tanh^2(x)`'dir ve o yüzden
:math:`f'(4) = 0.0013`'tür. Sonuç olarak, ilerleme kaydetmeden önce
optimizasyon uzun süre takılıp kalacak. Bunun, derin öğrenme
modellerinin, ReLU etkinleştirme işlevinin tanıtılmasından önce oldukça
zor olmasının nedenlerinden biri olduğu ortaya çıkıyor.
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = np.arange(-2.0, 5.0, 0.01)
d2l.plot(x, [np.tanh(x)], 'x', 'f(x)')
annotate('kaybolan gradyan', (4, 1), (2, 0.0))
.. figure:: output_optimization-intro_70d214_75_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = torch.arange(-2.0, 5.0, 0.01)
d2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')
annotate('kaybolan gradyan', (4, 1), (2, 0.0))
.. figure:: output_optimization-intro_70d214_78_0.svg
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
x = tf.range(-2.0, 5.0, 0.01)
d2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')
annotate('kaybolan gradyan', (4, 1), (2, 0.0))
.. figure:: output_optimization-intro_70d214_81_0.svg
.. raw:: html
.. raw:: html
Gördüğümüz gibi, derin öğrenme için optimizasyon zorluklarla doludur.
Neyse ki iyi performans ve yeni başlayanlar için bile kullanımı kolay
bir dizi gürbüz algoritma var. Ayrıca, en iyi çözümü bulmak gerçekten
gerekli değildir. Yerel en iyi veya hatta yaklaşık çözümler hala çok
faydalıdır.
Özet
----
- Eğitim hatasının en aza indirilmesi, genelleme hatasını en aza
indirmek için en iyi parametre kümesini bulduğumuzu garanti etmez.
- Optimizasyon sorunlarının birçok yerel minimumu olabilir.
- Problemlerin daha fazla eyer noktası olabilir, genellikle problemler
dışbükey değildir.
- Kaybolan gradyanlar eniyilemenin durmasına neden olabilir. Genellikle
sorunun yeniden parametrelendirilmesi yardımcı olur. Parametrelerin
iyi ilklenmesi de faydalı olabilir.
Alıştırmalar
------------
1. Gizli katmanında :math:`d` boyutlu tek bir gizli katmanına ve tek bir
çıktıya sahip basit bir MLP düşünün. Herhangi bir yerel minimum için
en az :math:`d!` tane aynı davranan eşdeğer çözüm olduğunu gösterin.
2. Simetrik bir rastgele :math:`\mathbf{M}` matrisimiz olduğunu
varsayalım, burada :math:`M_{ij} = M_{ji}` girdilerinin her biri
:math:`p_{ij}` olasılık dağılımından çekilir. Ayrıca,
:math:`p_{ij}(x) = p_{ij}(-x)`'nin, yani dağılımın simetrik olduğunu
varsayalım (ayrıntılar için bkz. :cite:`Wigner.1958`).
1. Özdeğerler üzerindeki dağılımın da simetrik olduğunu kanıtlayın.
Yani, herhangi bir özvektör :math:`\mathbf{v}` için, ilişkili
özdeğer :math:`\lambda`'nin
:math:`P(\lambda > 0) = P(\lambda < 0)`'i karşılama olasılığı.
2. Yukarıdaki ifade neden :math:`P(\lambda > 0) = 0.5` anlamına
*gelmez*?
3. Derin öğrenme optimizasyonunda yer alan hangi diğer zorlukları
düşünebilirsiniz?
4. (Gerçek) bir topu (gerçek) bir eyer üzerinde dengelemek istediğinizi
varsayalım.
1. Neden bu kadar zordur?
2. Optimizasyon algoritmaları için de bu etkiyi kullanabilir misiniz?
.. raw:: html
.. raw:: html
`Tartışmalar `__
.. raw:: html
.. raw:: html
`Tartışmalar `__
.. raw:: html
.. raw:: html
`Tartışmalar `__
.. raw:: html
.. raw:: html