.. _sec_integral_calculus:

Tümlev (Integral) Kalkülüsü
===========================


Türev alma, geleneksel bir matematik eğitiminin içeriğinin yalnızca
yarısını oluşturur. Diğer yapıtaşı, integral alma, oldukça ayrık bir
soru gibi görünerek başlar, "Bu eğrinin altındaki alan nedir?" Görünüşte
alakasız olsa da, integral alma, *kalkülüsün temel teoremi* olarak
bilinen ilişki aracılığıyla türev alma ile sıkı bir şekilde iç içe
geçmiştir.

Bu kitapta tartıştığımız makine öğrenmesi düzeyinde, derin bir türev
alma anlayışına ihtiyacımız olmayacak. Gene de, daha sonra
karşılaşacağımız diğer uygulamalara zemin hazırlamak için kısa bir giriş
sağlayacağız.

Geometrik Yorum
---------------

Bir :math:`f(x)` fonksiyonumuz olduğunu varsayalım. Basit olması için,
:math:`f(x)`'nin negatif olmadığını varsayalım (asla sıfırdan küçük bir
değer almıyor). Denemek ve anlamak istediğimiz şudur: :math:`f(x)` ile
:math:`x` ekseni arasındaki alan nedir?



.. raw:: html

     <div class="mdl-tabs mdl-js-tabs mdl-js-ripple-effect"><div class="mdl-tabs__tab-bar code"><a href="#mxnet-1-0" onclick="tagClick('mxnet'); return false;" class="mdl-tabs__tab is-active">mxnet</a><a href="#pytorch-1-1" onclick="tagClick('pytorch'); return false;" class="mdl-tabs__tab ">pytorch</a><a href="#tensorflow-1-2" onclick="tagClick('tensorflow'); return false;" class="mdl-tabs__tab ">tensorflow</a></div>



.. raw:: html

     <div class="mdl-tabs__panel is-active" id="mxnet-1-0">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    %matplotlib inline
    from IPython import display
    from mpl_toolkits import mplot3d
    from d2l import mxnet as d2l
    from mxnet import np, npx
    
    npx.set_np()
    
    x = np.arange(-2, 2, 0.01)
    f = np.exp(-x**2)
    
    d2l.set_figsize()
    d2l.plt.plot(x, f, color='black')
    d2l.plt.fill_between(x.tolist(), f.tolist())
    d2l.plt.show()



.. figure:: output_integral-calculus_06e2a4_3_0.svg




.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="pytorch-1-1">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    %matplotlib inline
    import torch
    from IPython import display
    from mpl_toolkits import mplot3d
    from d2l import torch as d2l
    
    x = torch.arange(-2, 2, 0.01)
    f = torch.exp(-x**2)
    
    d2l.set_figsize()
    d2l.plt.plot(x, f, color='black')
    d2l.plt.fill_between(x.tolist(), f.tolist())
    d2l.plt.show()



.. figure:: output_integral-calculus_06e2a4_6_0.svg




.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="tensorflow-1-2">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    %matplotlib inline
    from IPython import display
    from mpl_toolkits import mplot3d
    import tensorflow as tf
    from d2l import tensorflow as d2l
    
    x = tf.range(-2, 2, 0.01)
    f = tf.exp(-x**2)
    
    d2l.set_figsize()
    d2l.plt.plot(x, f, color='black')
    d2l.plt.fill_between(x.numpy(), f.numpy())
    d2l.plt.show()



.. figure:: output_integral-calculus_06e2a4_9_0.svg




.. raw:: html

     </div>



.. raw:: html

     </div>

Çoğu durumda, bu alan sonsuz veya tanımsız olacaktır
(:math:`f(x) = x^{2}` altındaki alanı düşünün), bu nedenle insanlar
genellikle bir çift uç arasındaki alan hakkında konuşacaklardır, örneğin
:math:`a` ve :math:`b`.



.. raw:: html

     <div class="mdl-tabs mdl-js-tabs mdl-js-ripple-effect"><div class="mdl-tabs__tab-bar code"><a href="#mxnet-3-0" onclick="tagClick('mxnet'); return false;" class="mdl-tabs__tab is-active">mxnet</a><a href="#pytorch-3-1" onclick="tagClick('pytorch'); return false;" class="mdl-tabs__tab ">pytorch</a><a href="#tensorflow-3-2" onclick="tagClick('tensorflow'); return false;" class="mdl-tabs__tab ">tensorflow</a></div>



.. raw:: html

     <div class="mdl-tabs__panel is-active" id="mxnet-3-0">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    x = np.arange(-2, 2, 0.01)
    f = np.exp(-x**2)
    
    d2l.set_figsize()
    d2l.plt.plot(x, f, color='black')
    d2l.plt.fill_between(x.tolist()[50:250], f.tolist()[50:250])
    d2l.plt.show()



.. figure:: output_integral-calculus_06e2a4_15_0.svg




.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="pytorch-3-1">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    x = torch.arange(-2, 2, 0.01)
    f = torch.exp(-x**2)
    
    d2l.set_figsize()
    d2l.plt.plot(x, f, color='black')
    d2l.plt.fill_between(x.tolist()[50:250], f.tolist()[50:250])
    d2l.plt.show()



.. figure:: output_integral-calculus_06e2a4_18_0.svg




.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="tensorflow-3-2">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    x = tf.range(-2, 2, 0.01)
    f = tf.exp(-x**2)
    
    d2l.set_figsize()
    d2l.plt.plot(x, f, color='black')
    d2l.plt.fill_between(x.numpy()[50:250], f.numpy()[50:250])
    d2l.plt.show()



.. figure:: output_integral-calculus_06e2a4_21_0.svg




.. raw:: html

     </div>



.. raw:: html

     </div>

Bu alanı aşağıdaki integral (tümlev) sembolü ile göstereceğiz:

.. math::


   \mathrm{Alan}(\mathcal{A}) = \int_a^b f(x) \;dx.

İç değişken, bir :math:`\sum` içindeki bir toplamın indisine çok
benzeyen bir yapay değişkendir ve bu nedenle bu, istediğimiz herhangi
bir iç değerle eşdeğer olarak yazılabilir:

.. math::


   \int_a^b f(x) \;dx = \int_a^b f(z) \;dz.

Bu tür integralleri nasıl yaklaşık olarak tahmin etmeye
çalışabileceğimizin ve anlayabileceğimizin geleneksel bir yolu var:
:math:`a` ile :math:`b` arasındaki bölgeyi alıp onu :math:`N` dikey
dilimlere böldüğümüzü hayal edebiliriz. :math:`N` büyükse, her dilimin
alanını bir dikdörtgenle tahmin edebilir ve ardından eğrinin altındaki
toplam alanı elde etmek için alanları toplayabiliriz. Bunu kodla yapan
bir örneğe bakalım. Gerçek değeri nasıl elde edeceğimizi daha sonraki
bir bölümde göreceğiz.



.. raw:: html

     <div class="mdl-tabs mdl-js-tabs mdl-js-ripple-effect"><div class="mdl-tabs__tab-bar code"><a href="#mxnet-5-0" onclick="tagClick('mxnet'); return false;" class="mdl-tabs__tab is-active">mxnet</a><a href="#pytorch-5-1" onclick="tagClick('pytorch'); return false;" class="mdl-tabs__tab ">pytorch</a><a href="#tensorflow-5-2" onclick="tagClick('tensorflow'); return false;" class="mdl-tabs__tab ">tensorflow</a></div>



.. raw:: html

     <div class="mdl-tabs__panel is-active" id="mxnet-5-0">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    epsilon = 0.05
    a = 0
    b = 2
    
    x = np.arange(a, b, epsilon)
    f = x / (1 + x**2)
    
    approx = np.sum(epsilon*f)
    true = np.log(2) / 2
    
    d2l.set_figsize()
    d2l.plt.bar(x.asnumpy(), f.asnumpy(), width=epsilon, align='edge')
    d2l.plt.plot(x, f, color='black')
    d2l.plt.ylim([0, 1])
    d2l.plt.show()
    
    f'approximation: {approx}, truth: {true}'



.. figure:: output_integral-calculus_06e2a4_27_0.svg




.. raw:: latex

   \diilbookstyleoutputcell

.. parsed-literal::
    :class: output

    'approximation: 0.7944855690002441, truth: 0.34657359027997264'





.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="pytorch-5-1">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    epsilon = 0.05
    a = 0
    b = 2
    
    x = torch.arange(a, b, epsilon)
    f = x / (1 + x**2)
    
    approx = torch.sum(epsilon*f)
    true = torch.log(torch.tensor([5.])) / 2
    
    d2l.set_figsize()
    d2l.plt.bar(x, f, width=epsilon, align='edge')
    d2l.plt.plot(x, f, color='black')
    d2l.plt.ylim([0, 1])
    d2l.plt.show()
    
    f'approximation: {approx}, truth: {true}'



.. figure:: output_integral-calculus_06e2a4_30_0.svg




.. raw:: latex

   \diilbookstyleoutputcell

.. parsed-literal::
    :class: output

    'approximation: 0.7944855690002441, truth: tensor([0.8047])'





.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="tensorflow-5-2">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    epsilon = 0.05
    a = 0
    b = 2
    
    x = tf.range(a, b, epsilon)
    f = x / (1 + x**2)
    
    approx = tf.reduce_sum(epsilon*f)
    true = tf.math.log(tf.constant([5.])) / 2
    
    d2l.set_figsize()
    d2l.plt.bar(x, f, width=epsilon, align='edge')
    d2l.plt.plot(x, f, color='black')
    d2l.plt.ylim([0, 1])
    d2l.plt.show()
    
    f'approximation: {approx}, truth: {true}'



.. figure:: output_integral-calculus_06e2a4_33_0.svg




.. raw:: latex

   \diilbookstyleoutputcell

.. parsed-literal::
    :class: output

    'approximation: 0.7944856286048889, truth: [0.804719]'





.. raw:: html

     </div>



.. raw:: html

     </div>

Sorun şu ki, sayısal (numerik) olarak yapılabilse de, bu yaklaşımı
analitik olarak sadece aşağıdaki gibi en basit işlevler için
yapabiliriz.

.. math::


   \int_a^b x \;dx.

Yukarıdaki koddaki örneğimizden biraz daha karmaşık bir şey, mesela:

.. math::


   \int_a^b \frac{x}{1+x^{2}} \;dx.

böyle doğrudan bir yöntemle çözebileceğimizin ötesinde bir örnektir.

Bunun yerine farklı bir yaklaşım benimseyeceğiz. Alan kavramıyla
sezgisel olarak çalışacağız ve integralleri bulmak için kullanılan ana
hesaplama aracını öğreneceğiz: *Kalkülüsün temel teoremi*. Bu, integral
alma (tümleme) çalışmamızın temeli olacaktır.

Kalkülüsün Temel Teoremi
------------------------

Integral alma teorisinin derinliklerine inmek için bir fonksiyon
tanıtalım:

.. math::


   F(x) = \int_0^x f(y) dy.

Bu işlev, :math:`x`'i nasıl değiştirdiğimize bağlı olarak :math:`0` ile
:math:`x` arasındaki alanı ölçer. İhtiyacımız olan her şeyin burada
olduğuna dikkat edin:

.. math::


   \int_a^b f(x) \;dx = F(b) - F(a).

Bu, :numref:`fig_area-subtract` içindeki gibi alanı en uzak uç noktaya
kadar ölçebildiğimiz ve ardından yakın uç noktaya kadarki alanı
çıkarabileceğimiz gerçeğinin matematiksel bir kodlamasıdır.

.. _fig_area-subtract:

.. figure:: ../img/sub-area.svg

   İki nokta arasındaki bir eğrinin altındaki alanı hesaplama sorununu
   bir noktanın solundaki alanı hesaplamaya neden indirgeyeceğimizi
   görselleştirelim.


Dolayısıyla, herhangi bir aralıktaki integralin ne olduğunu
:math:`F(x)`'in ne olduğunu bularak bulabiliriz.

Bunun için bir deney yapalım. Kalkülüste sık sık yaptığımız gibi, değeri
çok az değiştirdiğimizde ne olduğunu görelim. Yukarıdaki yorumdan
biliyoruz ki

.. math::


   F(x+\epsilon) - F(x) = \int_x^{x+\epsilon} f(y) \; dy.

Bu bize, fonksiyonun küçük bir fonksiyon şeridinin altındaki alana göre
değiştiğini söyler.

Bu, bir yaklaşıklama yaptığımız noktadır. Bunun gibi küçük bir alana
bakarsak, bu alan, yüksekliği :math:`f(x)` ve taban genişliği
:math:`\epsilon` olan dikdörtgenin alanına yakın görünüyor. Aslında,
:math:`\epsilon \rightarrow 0` olunca bu yaklaşıklamanın gittikçe daha
iyi hale geldiği gösterilebilir. Böylece şu sonuca varabiliriz:

.. math::


   F(x+\epsilon) - F(x) \approx \epsilon f(x).

Bununla birlikte, şimdi fark edebiliriz ki :math:`F`'nin türevini
hesaplıyor olsaydık, tam olarak beklediğimiz kalıp bu olurdu! Böylece şu
oldukça şaşırtıcı gerçeği görüyoruz:

.. math::


   \frac{dF}{dx}(x) = f(x).

Bu, *kalkülüsün temel teoremidir*. Bunu genişletilmiş biçimde şöyle
yazabiliriz:

.. math:: \frac{d}{dx}\int_{-\infty}^x f(y) \; dy = f(x).
   :label: eq_ftc

Alan bulma kavramını alır (ki muhtemelen oldukça zordur) ve onu bir
ifade türevine (çok daha anlaşılmış bir şey) indirger. Yapmamız gereken
son bir yorum, bunun bize :math:`F(x)`'nin tam olarak ne olduğunu
söylemediğidir. Aslında, herhangi bir :math:`C` için :math:`F(x) + C`
aynı türeve sahiptir. Bu, integral alma teorisinde hayatın gerçeğidir.
Belirli integrallerle çalışırken sabitlerin düştüğüne ve dolayısıyla
sonuçla ilgisiz olduklarına dikkat edin.

.. math::


   \int_a^b f(x) \; dx = (F(b) + C) - (F(a) + C) = F(b) - F(a).

Bu soyut olarak bir anlam ifade etmiyor gibi görünebilir, ancak bunun
bizde integral hesaplamaya yepyeni bir bakış açısı kazandırdığını
anlamak için biraz zaman ayıralım. Amacımız artık bir çeşit parçala ve
topla işlemi yapmak ve alanı geri kurtarmayı denemek değil; bunun yerine
sadece türevi sahip olduğumuz fonksiyon olan başka bir fonksiyon
bulmamız gerekiyor! Bu inanılmaz bir olay çünkü artık pek çok zorlu
integrali sadece :numref:`sec_derivative_table` içindeki tabloyu ters
çevirerek listeleyebiliriz. Örneğin, :math:`x^{n}`'nin türevinin
:math:`nx^{n-1}` olduğunu biliyoruz. Böylece, temel teoremi,
:eq:`eq_ftc`, kullanarak şunu söyleyebiliriz:

.. math::


   \int_0^{x} ny^{n-1} \; dy = x^n - 0^n = x^n.

Benzer şekilde, :math:`e^{x}`'nin türevinin kendisi olduğunu biliyoruz,
yani

.. math::


   \int_0^{x} e^{x} \; dx = e^{x} - e^{0} = e^x - 1.

Bu şekilde, türevsel hesaptan gelen fikirlerden özgürce yararlanarak
bütün integral alma teorisini geliştirebiliriz. Her integral kuralı bu
olgudan türetilir.

.. _integral_example:

Değişkenlerin Değişimi
----------------------


Aynen türev almada olduğu gibi, integrallerin hesaplanmasını daha
izlenebilir kılan bir dizi kural vardır. Aslında, türevsel hesabın her
kuralı (çarpım kuralı, toplam kuralı ve zincir kuralı gibi), integral
hesaplamada karşılık gelen bir kurala sahiptir (formül sırasıyla,
parçalayarak integral alma, integralin doğrusallığı ve değişkenler
değişimi). Bu bölümde, listeden tartışmasız en önemli olanı
inceleyeceğiz: değişkenlerin değişimi formülü.

İlk olarak, kendisi bir integral olan bir fonksiyonumuz olduğunu
varsayalım:

.. math::


   F(x) = \int_0^x f(y) \; dy.

Diyelim ki, :math:`F(u(x))`'i elde etmek için onu başka bir fonksiyonla
oluşturduğumuzda bu fonksiyonun nasıl göründüğünü bilmek istediğimizi
varsayalım. Zincir kuralı ile biliyoruz ki:

.. math::


   \frac{d}{dx}F(u(x)) = \frac{dF}{du}(u(x))\cdot \frac{du}{dx}.

Yukarıdaki gibi, temel teoremi, :eq:`eq_ftc`, kullanarak bunu
integral alma ilgili bir ifadeye dönüştürebiliriz. Böylece:

.. math::


   F(u(x)) - F(u(0)) = \int_0^x \frac{dF}{du}(u(y))\cdot \frac{du}{dy} \;dy.

:math:`F`'nin kendisinin bir integral olduğunu hatırlamak, sol tarafın
yeniden yazılabilmesine olanak verir.

.. math::


   \int_{u(0)}^{u(x)} f(y) \; dy = \int_0^x \frac{dF}{du}(u(y))\cdot \frac{du}{dy} \;dy.

Benzer şekilde, :math:`F`'nin bir integral olduğunu hatırlamak, temel
teoremi, :eq:`eq_ftc`, kullanarak :math:`\frac{dF}{dx} = f`'i
tanımamıza izin verir ve böylece şu sonuca varabiliriz:

.. math:: \int_{u(0)}^{u(x)} f(y) \; dy = \int_0^x f(u(y))\cdot \frac{du}{dy} \;dy.
   :label: eq_change_var

Bu, *değişkenlerin değişimi* formülüdür.

Daha sezgisel bir türetme için, :math:`x` ile :math:`x+\epsilon`
arasında bir :math:`f(u(x))` integralini aldığımızda ne olacağını
düşünün. Küçük bir :math:`\epsilon` için, bu integral, yaklaşık olarak
:math:`\epsilon f(u(x))`, yani ilişkili dikdörtgenin alanıdır. Şimdi
bunu :math:`u(x)` ile :math:`u(x+\epsilon)` arasındaki :math:`f(y)`
integraliyle karşılaştıralım.
:math:`u(x+\epsilon) \approx u(x) + \epsilon \frac{du}{dx}(x)` olduğunu
biliyoruz, bu nedenle bu dikdörtgenin alanı yaklaşık
:math:`\epsilon \frac{du}{dx}(x)f(u(x))`'dir. Bu nedenle, bu iki
dikdörtgenin alanını uyuşacak hale getirmek için
:numref:`fig_rect-transform` içinde gösterildiği gibi ilkini
:math:`\frac{du}{dx}(x)` ile çarpmamız gerekiyor.

.. _fig_rect-transform:

.. figure:: ../img/rect-trans.svg

   Değişkenlerin değişimi altında tek bir ince dikdörtgenin dönüşümünü
   görselleştirelim.


Bu bize şunu söyler:

.. math::


   \int_x^{x+\epsilon} f(u(y))\frac{du}{dy}(y)\;dy = \int_{u(x)}^{u(x+\epsilon)} f(y) \; dy.

Bu, tek bir küçük dikdörtgen için ifade edilen değişken değişimi
formülüdür.

:math:`u(x)` ve :math:`f(x)` doğru seçilirse, bu inanılmaz derecede
karmaşık integrallerin hesaplanmasına izin verebilir. Örneğin,
:math:`f(y) = 1` ve :math:`u(x) = e^{-x^{2}}` seçersek (bu
:math:`\frac{du}{dx}(x) = -2xe^{-x^{2}}` anlamına gelir), bu örnek şunu
gösterebilir:

.. math::


   e^{-1} - 1 = \int_{e^{-0}}^{e^{-1}} 1 \; dy = -2\int_0^{1} ye^{-y^2}\;dy,

Tekrar düzenlersek:

.. math::


   \int_0^{1} ye^{-y^2}\; dy = \frac{1-e^{-1}}{2}.

İşaret Gösterimlerine Bir Yorum
-------------------------------

Keskin gözlü okuyucular yukarıdaki hesaplamalarla ilgili tuhaf bir şey
gözlemleyecekler. Yani, aşağıdaki gibi hesaplamalar

.. math::


   \int_{e^{-0}}^{e^{-1}} 1 \; dy = e^{-1} -1 < 0,

negatif sayılar üretebilirler. Alanlar hakkında düşünürken, negatif bir
değer görmek garip olabilir ve bu nedenle bu gösterimin ne olduğunu
araştırmaya değer.

Matematikçiler işaretli alanlar kavramını benimser. Bu kendini iki
şekilde gösterir. İlk olarak, bazen sıfırdan küçük olan :math:`f(x)`
fonksiyonunu düşünürsek, alan da negatif olacaktır. Yani örneğin

.. math::


   \int_0^{1} (-1)\;dx = -1.

Benzer şekilde, soldan sağa değil sağdan sola ilerleyen integraller de
negatif alan olarak tanımlanır.

.. math::


   \int_0^{-1} 1\; dx = -1.

Standart alan (pozitif bir fonksiyonda soldan sağa) her zaman
pozitiftir. Ters çevirerek elde edilen herhangi bir şey (örneğin,
negatif bir sayının integralini elde etmek için :math:`x` eksenini ters
çevirmek veya bir integrali yanlış sırada elde etmek için :math:`y`
eksenini ters çevirmek gibi) negatif bir alan üretecektir. Aslında, iki
kez ters yüz etme, pozitif alana sahip olmak için birbirini götüren bir
çift negatif işaret verecektir.

.. math::


   \int_0^{-1} (-1)\;dx =  1.

Bu tartışma size tanıdık geliyorsa, normaldir!
:numref:`sec_geometry-linear-algebraic-ops` içinde determinantın
işaretli alanı nasıl aynı şekilde temsil ettiğini tartıştık.

Çoklu İntegraller
-----------------

Bazı durumlarda daha yüksek boyutlarda çalışmamız gerekecektir. Örneğin,
:math:`f(x, y)` gibi iki değişkenli bir fonksiyonumuz olduğunu ve
:math:`x`'nin :math:`[a, b]` ve :math:`y`'nin ise :math:`[c, d]`
arasında değiştiğinde :math:`f` altındaki hacim nedir bilmek
istediğimizi varsayalım.



.. raw:: html

     <div class="mdl-tabs mdl-js-tabs mdl-js-ripple-effect"><div class="mdl-tabs__tab-bar code"><a href="#mxnet-7-0" onclick="tagClick('mxnet'); return false;" class="mdl-tabs__tab is-active">mxnet</a><a href="#pytorch-7-1" onclick="tagClick('pytorch'); return false;" class="mdl-tabs__tab ">pytorch</a><a href="#tensorflow-7-2" onclick="tagClick('tensorflow'); return false;" class="mdl-tabs__tab ">tensorflow</a></div>



.. raw:: html

     <div class="mdl-tabs__panel is-active" id="mxnet-7-0">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    # Izgara oluştur ve işlevi hesapla
    x, y = np.meshgrid(np.linspace(-2, 2, 101), np.linspace(-2, 2, 101),
                       indexing='ij')
    z = np.exp(- x**2 - y**2)
    
    # İşlevi çiz
    ax = d2l.plt.figure().add_subplot(111, projection='3d')
    ax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy())
    d2l.plt.xlabel('x')
    d2l.plt.ylabel('y')
    d2l.plt.xticks([-2, -1, 0, 1, 2])
    d2l.plt.yticks([-2, -1, 0, 1, 2])
    d2l.set_figsize()
    ax.set_xlim(-2, 2)
    ax.set_ylim(-2, 2)
    ax.set_zlim(0, 1)
    ax.dist = 12



.. figure:: output_integral-calculus_06e2a4_39_0.svg




.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="pytorch-7-1">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    # Izgara oluştur ve işlevi hesapla
    x, y = torch.meshgrid(torch.linspace(-2, 2, 101), torch.linspace(-2, 2, 101))
    z = torch.exp(- x**2 - y**2)
    
    # İşlevi çiz
    ax = d2l.plt.figure().add_subplot(111, projection='3d')
    ax.plot_wireframe(x, y, z)
    d2l.plt.xlabel('x')
    d2l.plt.ylabel('y')
    d2l.plt.xticks([-2, -1, 0, 1, 2])
    d2l.plt.yticks([-2, -1, 0, 1, 2])
    d2l.set_figsize()
    ax.set_xlim(-2, 2)
    ax.set_ylim(-2, 2)
    ax.set_zlim(0, 1)
    ax.dist = 12


.. 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_integral-calculus_06e2a4_42_1.svg




.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="tensorflow-7-2">

.. raw:: latex

   \diilbookstyleinputcell

.. code:: python

    # Izgara oluştur ve işlevi hesapla
    x, y = tf.meshgrid(tf.linspace(-2., 2., 101), tf.linspace(-2., 2., 101))
    z = tf.exp(- x**2 - y**2)
    
    # İşlevi çiz
    ax = d2l.plt.figure().add_subplot(111, projection='3d')
    ax.plot_wireframe(x, y, z)
    d2l.plt.xlabel('x')
    d2l.plt.ylabel('y')
    d2l.plt.xticks([-2, -1, 0, 1, 2])
    d2l.plt.yticks([-2, -1, 0, 1, 2])
    d2l.set_figsize()
    ax.set_xlim(-2, 2)
    ax.set_ylim(-2, 2)
    ax.set_zlim(0, 1)
    ax.dist = 12



.. figure:: output_integral-calculus_06e2a4_45_0.svg




.. raw:: html

     </div>



.. raw:: html

     </div>

Şöyle yazabiliriz:

.. math::


   \int_{[a, b]\times[c, d]} f(x, y)\;dx\;dy.

Bu integrali hesaplamak istediğimizi varsayalım. Bizim iddiamız, bunu
önce :math:`x`'deki integrali yinelemeli olarak hesaplayarak ve sonra da
:math:`y`'deki integrale kayarak yapabileceğimizdir, yani

.. math::


   \int_{[a, b]\times[c, d]} f(x, y)\;dx\;dy = \int_c^{d} \left(\int_a^{b} f(x, y) \;dx\right) \; dy.

Bunun neden olduğunu görelim.

Fonksiyonu :math:`\epsilon \times \epsilon` karelere böldüğümüzü ve
:math:`i, j` tamsayı koordinatlarıyla indekslediğimizi düşünün. Bu
durumda integralimiz yaklaşık olarak şöyledir:

.. math::


   \sum_{i, j} \epsilon^{2} f(\epsilon i, \epsilon j).

Problemi ayrıklaştırdığımızda, bu karelerdeki değerleri istediğimiz
sırayla toplayabiliriz ve değerleri değiştirme konusunda endişelenmeyiz.
Bu, :numref:`fig_sum-order` şeklinde gösterilmektedir. Özellikle şunu
söyleyebiliriz:

.. math::


    \sum _ {j} \epsilon \left(\sum_{i} \epsilon f(\epsilon i, \epsilon j)\right).

.. _fig_sum-order:

.. figure:: ../img/sum-order.svg

   İlk önce sütunlar üzerinden bir toplam olarak birçok karede bir
   toplamın nasıl ayrıştırılacağını (1), ardından sütun toplamlarının
   nasıl toplanacağını (2) gösterelim.


İç kısımdaki toplam, tam olarak integralin ayrıklaştırılmasıdır.

.. math::


   G(\epsilon j) = \int _a^{b} f(x, \epsilon j) \; dx.

Son olarak, bu iki ifadeyi birleştirirsek şunu elde ettiğimize dikkat
edin:

.. math::


   \sum _ {j} \epsilon G(\epsilon j) \approx \int _ {c}^{d} G(y) \; dy = \int _ {[a, b]\times[c, d]} f(x, y)\;dx\;dy.

Böylece hepsini bir araya getirirsek, buna sahip oluruz:

.. math::


   \int _ {[a, b]\times[c, d]} f(x, y)\;dx\;dy = \int _ c^{d} \left(\int _ a^{b} f(x, y) \;dx\right) \; dy.

Dikkat edin, bir kez ayrıklaştırıldı mı, yaptığımız tek şey, bir sayı
listesi eklediğimiz sırayı yeniden düzenlemek oldu. Bu, burada hiçbir
zorluk yokmuş gibi görünmesine neden olabilir, ancak bu sonuç (*Fubini
Teoremi* olarak adlandırılır) her zaman doğru değildir! Makine öğrenmesi
(sürekli fonksiyonlar) yapılırken karşılaşılan matematik türü için
herhangi bir endişe yoktur, ancak başarısız olduğu durumlardan örnekler
oluşturmak mümkündür (örneğin :math:`f(x, y) = xy(x^2-y^2)/(x^2+y^2)^3`
fonksiyonunu :math:`[0,2]\times[0,1]` dikdörtgenin üzerinde deneyin).

İntegrali önce :math:`x` cinsinden ve ardından :math:`y` cinsinden yapma
seçeneğinin keyfi olduğuna dikkat edin. Önce :math:`y` için, sonra da
:math:`x` için yapmayı eşit derecede seçebilirdik:

.. math::


   \int _ {[a, b]\times[c, d]} f(x, y)\;dx\;dy = \int _ a^{b} \left(\int _ c^{d} f(x, y) \;dy\right) \; dx.

Çoğu zaman, vektör gösterimine yoğunlaşacağız ve
:math:`U = [a, b]\times [c, d]` için bunun şöyle olduğunu söyleyeceğiz:

.. math::


   \int _ U f(\mathbf{x})\;d\mathbf{x}.

Çoklu İntegrallerde Değişkenlerin Değiştirilmesi
------------------------------------------------

Tek değişkenlerdeki gibi :eq:`eq_change_var`, daha yüksek boyutlu
bir integral içindeki değişkenleri değiştirme yeteneği önemli bir
araçtır. Sonucu türetme yapmadan özetleyelim.

Integral alma alanımızı yeniden parametrelendiren bir işleve ihtiyacımız
var. Bunu :math:`\phi : \mathbb{R}^n \rightarrow \mathbb{R}^n` olarak
alabiliriz, bu :math:`n` tane gerçel değişkeni alıp başka bir :math:`n`
gerçele döndüren herhangi bir işlevdir. İfadeleri temiz tutmak için,
:math:`\phi`'nin *bire-bir* olduğunu varsayacağız, bu da onun hiçbir
zaman kendi üzerine katlanmadığını söylemektir
(:math:`\phi(\mathbf{x}) = \phi(\mathbf{y}) \implies \mathbf{x} = \mathbf{y}`).

Bu durumda şunu söyleyebiliriz:

.. math::


   \int _ {\phi(U)} f(\mathbf{x})\;d\mathbf{x} = \int _ {U} f(\phi(\mathbf{x})) \left|\det(D\phi(\mathbf{x}))\right|\;d\mathbf{x}.

:math:`D\phi`, :math:`\phi`'nin *Jacobi matrisi*\ dir, yani
:math:`\boldsymbol{\phi} = (\phi_1(x_1, \ldots, x_n), \ldots, \phi_n(x_1, \ldots, x_n))`'nin
kısmi türevlerinin matrisidir.

.. math::


   D\boldsymbol{\phi} = \begin{bmatrix}
   \frac{\partial \phi _ 1}{\partial x _ 1} & \cdots & \frac{\partial \phi _ 1}{\partial x _ n} \\
   \vdots & \ddots & \vdots \\
   \frac{\partial \phi _ n}{\partial x _ 1} & \cdots & \frac{\partial \phi _ n}{\partial x _ n}
   \end{bmatrix}.

Yakından baktığımızda, bunun tek değişkenli zincir kuralına,
:eq:`eq_change_var`, benzer olduğunu görüyoruz, ancak
:math:`\frac{du}{dx}(x)` terimini
:math:`\left|\det(D\phi(\mathbf{x}))\right|` ile değiştirdik. Bu terimi
nasıl yorumlayabileceğimize bir bakalım. :math:`\frac{du}{dx}(x)`
teriminin :math:`x` eksenimizi :math:`u`'yu uygulayarak ne kadar
uzattığımızı söylemek için var olduğunu hatırlayın. Daha yüksek
boyutlarda aynı işlem, :math:`\boldsymbol{\phi}` uygulayarak küçük bir
karenin (veya küçük *hiper küpün*) alanını (veya hacmini veya hiper
hacmini) ne kadar uzatacağımızı belirlemektir. Eğer
:math:`\boldsymbol{\phi}` bir matrisle çarpımsa, determinantın zaten
cevabı nasıl verdiğini biliyoruz.

Biraz çalışmayla, *Jacobi matrisi*\ nin çok değişkenli bir fonksiyona,
yani :math:`\boldsymbol{\phi}`'ye, bir noktada matrisin türevleri ve
gradyanları olan doğrular veya düzlemlerle yaklaşık olarak tahmin
edebileceğimiz gibi en iyi yaklaşıklamayı sağladığı gösterilebilir.
Böylece, Jacobi matrisinin determinantı, bir boyutta tanımladığımız
ölçeklendirme çarpanını tam olarak kopyalar.

Bunun ayrıntılarını doldurmak biraz çalışma gerektirir, bu yüzden şimdi
net değilse endişelenmeyin. Daha sonra kullanacağımız bir örnek görelim.
Bu integrali düşünün:

.. math::


   \int _ {-\infty}^{\infty} \int _ {-\infty}^{\infty} e^{-x^{2}-y^{2}} \;dx\;dy.

Bu integral ile doğrudan oynamak bizi hiçbir yere götürmez, ancak
değişkenleri değiştirirsek, önemli ilerleme kaydedebiliriz.
:math:`\boldsymbol{\phi}(r, \theta) = (r \cos(\theta), r\sin(\theta))`
olmasına izin verirsek (bu :math:`x = r \cos(\theta)`,
:math:`y = r \sin(\theta)` demektir), sonra bunun aynı şey olduğunu
görmek için değişken değişimi formülünü uygulayabiliriz:

.. math::


   \int _ 0^\infty \int_0 ^ {2\pi} e^{-r^{2}} \left|\det(D\mathbf{\phi}(\mathbf{x}))\right|\;d\theta\;dr,

ve

.. math::


   \left|\det(D\mathbf{\phi}(\mathbf{x}))\right| = \left|\det\begin{bmatrix}
   \cos(\theta) & -r\sin(\theta) \\
   \sin(\theta) & r\cos(\theta)
   \end{bmatrix}\right| = r(\cos^{2}(\theta) + \sin^{2}(\theta)) = r.

Böylece integral:

.. math::


   \int _ 0^\infty \int _ 0 ^ {2\pi} re^{-r^{2}} \;d\theta\;dr = 2\pi\int _ 0^\infty re^{-r^{2}} \;dr = \pi,

Burada son eşitlik, bölüm :numref:`integral_example` içinde
kullandığımız hesaplamanın aynısını izler.

Sürekli rastgele değişkenleri incelediğimizde,
:numref:`sec_random_variables`, bu integral ile tekrar karşılaşacağız.

Özet
----

-  Integral alma teorisi, alanlar veya hacimler hakkındaki soruları
   yanıtlamamıza izin verir.
-  Kalkülüsün temel teoremi, alanın türevinin bir noktaya kadar
   integrali alınan fonksiyonun değeri tarafından verildiği gözlemi
   sayesinde alanları hesaplamak için türevler hakkındaki bilgiden
   yararlanmamızı sağlar.
-  Daha yüksek boyutlardaki integraller, tek değişkenli integralleri
   sırasıyla izleyerek hesaplanabilir.

Alıştırmalar
------------

1. :math:`\int_1^2 \frac{1}{x} \;dx` nedir?
2. :math:`\int_0^{\sqrt{\pi}}x\sin(x^2)\;dx` ifadesini hesaplamak için
   değişken değişimi formülünü kullanınız.
3. :math:`\int_{[0,1]^2} xy \;dx\;dy` nedir?
4. :math:`\int_0^2\int_0^1xy(x^2-y^2)/(x^2+y^2)^3\;dy\;dx` ve
   :math:`\int_0^1\int_0^2f(x, y) = xy(x^2-y^2)/(x^2+y^2)^3\;dx\;dy`
   hesaplamak için değişken değişimi formülünü kullanınız ve farkı
   görünüz.



.. raw:: html

     <div class="mdl-tabs mdl-js-tabs mdl-js-ripple-effect"><div class="mdl-tabs__tab-bar text"><a href="#mxnet-9-0" onclick="tagClick('mxnet'); return false;" class="mdl-tabs__tab is-active">mxnet</a><a href="#pytorch-9-1" onclick="tagClick('pytorch'); return false;" class="mdl-tabs__tab ">pytorch</a><a href="#tensorflow-9-2" onclick="tagClick('tensorflow'); return false;" class="mdl-tabs__tab ">tensorflow</a></div>



.. raw:: html

     <div class="mdl-tabs__panel is-active" id="mxnet-9-0">

`Tartışmalar <https://discuss.d2l.ai/t/414>`__



.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="pytorch-9-1">

`Tartışmalar <https://discuss.d2l.ai/t/1092>`__



.. raw:: html

     </div>



.. raw:: html

     <div class="mdl-tabs__panel " id="tensorflow-9-2">

`Tartışmalar <https://discuss.d2l.ai/t/1093>`__



.. raw:: html

     </div>



.. raw:: html

     </div>