Scipy Eğitimi: Vektörler ve Diziler (Lineer Cebir)

NumPy ndarray Nesnelerinin Temelleri

Yapısal olarak bir dizi, işaretçilerden ibarettir. Bir bellek adresi, bir veri türü, bir şekil ve adımların (strides) birleşimidir. Ham veri hakkında, bir öğenin nasıl bulunacağı ve yorumlanacağı hakkında bilgi içerir.

Bellek adresi ve adımlar, dizilerin daha alt düzey detaylarına indiğinizde önem kazanırken, veri türü ve şekil, yeni başlayanların mutlaka bilmesi ve anlaması gereken şeylerdir. Göz önünde bulundurmak isteyebileceğiniz iki başka öznitelik de diziniz hakkında daha fazla bilgi toplamanızı sağlayan data ve size’dır.

Aşağıdaki DataCamp Light parçasında ndarray özniteliklerinin kullanımını tazeleyin. myArray dizisi zaten yüklendi. IPython kabuğuna yazarak ve ENTER’a basarak inceleyebilirsiniz.

# Inspect the data of `myArray`
print(myArray.data)

# Inspect the data type of `myArray`
print(_________________)

# Inspect the shape of `myArray`
print(__________________)

# Inspect the size of `myArray`
print(__________________)

Yukarıdaki kod parçasında yer alan sonuçlarda myArray’in veri türünün int64 olduğunu göreceksiniz. Dizilerle yoğun çalışırken, astype() yöntemiyle dizilerinizi bir veri türünden diğerine dönüştürmenin yolları olduğunu kesinlikle hatırlarsınız.

Bununla birlikte, SciPy ve NumPy’yi birlikte kullanırken, özellikle karmaşık sayılarla çalışıyorsanız, aşağıdaki NumPy tür yönetimi işlevlerini de çok kullanışlı bulabilirsiniz:

# Return the real part of `myArray` elements
np.real(myArray)

# Return the imaginary part of `myArray` elements
np.imag(myArray)

# Return a real array if the complex parts are close to 0
np.real_if_close(myArray,tol=1000)

# Cast `myArray` to float
np.cast['f'](myArray)

Sonuçları görmek için print() çağrıları eklemeyi deneyin. Ardından karmaşık sayıların gerçek ve sanal kısımları olduğunu göreceksiniz. np.real() ve np.imag() işlevleri sırasıyla bu kısımları döndürmek üzere tasarlanmıştır.

Alternatif olarak, bir dizi nesnesini farklı bir veri türüne dökmek için yukarıdaki örnekte olduğu gibi np.cast da kullanabilirsiniz.

Yukarıdaki kod parçasında gerçekten zor görünen tek şey np.real_if_close() işlevidir. myArray gibi karmaşık bir girdi verdiğinizde, karmaşık kısımlar sıfıra yakınsa gerçek bir dizi elde edersiniz. Bu son kısım, “0’a yakınlık”, işlevine iletebileceğiniz tol argümanıyla kendiniz tarafından ayarlanabilir. Eşiikle oynayıp neler olduğunu görün!

Dizi (Array) Oluşturma

Artık dizinizi nasıl inceleyeceğinizi ve veri türünde nasıl ayarlamalar yapacağınızı gördünüz; fakat dizileri nasıl oluşturacağınızı açıkça görmediniz. Bunu yapmak için np.array() kullanabileceğinizi zaten biliyor olmalısınız; ancak bilmeniz gereken başka dizi oluşturma yordamları da var: np.eye() ve np.identity().

np.eye() işlevi, argüman olarak verdiğiniz pozitif tam sayıya eşit boyutlarda kare bir matris oluşturmanıza olanak tanır. Elemanlar genellikle sıfırlarla doldurulur, yalnızca matrisin köşegeni birlerle doldurulur. np.identity() işlevi de aynı şekilde çalışır ve birim (identity) bir dizi döndürür.

Ancak, unutmayın ki np.eye(), hangi köşegenin birlerle doldurulacağını belirtmek için belirtebileceğiniz ek bir k argümanı alabilir.

Lineer cebir için matrislerle çalışırken işinize kesinlikle yarayacak diğer dizi oluşturma işlevleri şunlardır:

• np.arange() işlevi, iki sayı arasında eşit aralıklı değerlere sahip bir dizi oluşturur. Elemanlar arasındaki aralığı belirtebilirsiniz,
• Aynısı np.linspace() için de geçerlidir; ancak bu işlevle dizinizde kaç eleman istediğinizi belirtirsiniz.
• Son olarak np.logspace(), yine eşit aralıklı değerlerden oluşan diziler oluşturur; fakat bu kez logaritmik ölçekte. Bu, aralığın artık logaritmik olduğu anlamına gelir: iki sayı, bu sayıların 10 tabanındaki logaritmaları arasında eşit aralıklıdır.

Bu işlevler, önce bu yazıda okuduğunuz ağ (mesh) ızgaralarını oluşturmak için kullanılabilecek ağ biçiminde diziler oluşturur.

Not: Aşağıdaki kod parçasında numpy zaten np olarak içe aktarılmıştır!

# Create a 2X2 identity matrix with `np.eye()`
__________________

# Create a 3X3 identity matrix with `np.identity()`
__________________

# Uniformly spaced values: spacing
_________(3, 7, 2)

# Uniformly spaced values: number of samples
___________(2, 3, 5)

# Uniformly spaced values: logarithmic spacing 
___________(2, 3, 4)

Artık hafızanızı tazelediniz ve dizilerinizin veri türlerini nasıl ele alacağınızı biliyorsunuz; şimdi indeksleme ve dilimleme konusunu da ele alma zamanı.

# Slice `myArray` at index 0 and 1
print(____________)

# Slice `my_2dArray` at row 0 and 1, column 1
print(________________)

# Slice `my_3dArray` at row 1
print(my_3dArray[1,...])

# Boolean indexing: only values < 2
print(myArray[____________])

# Fancy indexing
print(my_2dArray[[1, 0, 1, 0],[0, 1, 2, 0]])

# Create a dense meshgrid
np.mgrid[1:11:2, -12:-3:3]

# Create an open meshgrid
np.ogrid[1:11:2, -12:-3:3]

# Stack arrays vertically
np.r_[3,[0]*5,-1:1:10j]

# Stack arrays horizontally 
np.c_[array, my_2dArray]

# Initialize a 2D array 
my_2dArray = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Select values from `my_2dArray`
np.select([my_2dArray < 4],[my_2dArray * 2])

#Stack arrays horizontally (column-wise)
print(_________((np.eye(2), my_2dArray)))

# Stack arrays vertically (row-wise)
print(__________((myArray, my_2dArray)))

# Split the array horizontally at the 2nd index
print(___________(my_2dArray, 2))

# Split the array vertically at the 2nd index
print(____________(my_2dArray, 2))

#Permute `myArray` dimensions
print(np.transpose(myArray))

# Flatten `my_3dArray`
print(my_3dArray.flatten())

# Reshape but don't change the data
print(my_2dArray.reshape(4,2))

# Resize to (6,4)
print(np.resize(my_3dArray, (6,4)))

# Define a function `myfunc`
def myfunc(a,b):
  if a > b:
     return a - b
  else:
     return a + b
    
# Vectorize `myfunc`
vectorizedFunc = np.vectorize(myfunc) 

# Apply 
vectorizedFunc(myArray, 2)

SciPy Kurulumu

Elbette önce Python’un kurulu olduğundan emin olmanız gerekir. Bunu hâlâ yapmanız gerekiyorsa bu sayfaya gidin :) Windows üzerinde çalışıyorsanız, Python’u PATH ortam değişkenine eklediğinizden emin olun. Ek olarak, Python’un açık kaynak kütüphanelerini kullanabilmenizi sağlayacak bir paket yöneticisini, örneğin pip’i kurmayı unutmayın.

Python 3’ün güncel sürümlerinin pip ile geldiğini unutmayın; bu nedenle pip’iniz olup olmadığını iki kez kontrol edin; varsa, başka paketler kurmadan önce yükseltin:

 pip install pip --upgrade pip --versionAltyapı:

Ama sadece bir paket yöneticisi kurmak yeterli değil; Kütüphane için wheel dosyasını da indirmeniz gerekir: SciPy wheel’ınızı almak için buraya gidin. İndirdikten sonra, bilgisayarınızda indirme dizininde bir terminal açın ve kurulumu yapın. Ek olarak, kurulumun başarılı olup olmadığını kontrol edebilir ve çalıştırdığınız paket sürümünü doğrulayabilirsiniz:

# Install the wheel install "scipy‑0.18.1‑cp36‑cp36m‑win_amd64.whl"# Confirm successful installimport scipy# Check package versionscipy.__version__Altyapı:

Bu adımlardan sonra hazırsınız!

İpucu: paketi, Anaconda Python dağıtımını indirerek kurun. Başlamak için kolay bir yoldur; çünkü Anaconda yalnızca veri bilimi için en popüler 100 Python, R ve Scala paketini içermekle kalmaz, aynı zamanda Jupyter ve Spyder gibi çeşitli açık kaynak geliştirme ortamlarını da içerir. Jupyter Notebook ile çalışmaya başlamak isterseniz, şu Jupyter notebook eğitimine göz atın.

Henüz indirmediyseniz, almak için buraya gidin.

Vektörler ve Matrisler: Temeller

Artık çalışma alanınızı hazırladığınıza göre, Python’da lineer cebire nihayet başlayabilirsiniz. Özünde bu disiplin, vektör uzaylarının ve aralarındaki lineer dönüşümlerin incelenmesiyle ilgilenir. Bu lineer dönüşümler matrislerle ifade edilebilir; bu da hesaplamayı kolaylaştırır.

Unutmayın: Bir vektör uzayı, lineer cebirde temel bir kavramdır. Vektörlerden oluşan bir koleksiyona sahip olduğunuz ve iki vektörü topladığınızda veya ölçeklendirdiğinizde, ortaya çıkan vektörün uzayın dışına çıkmadığı bir uzaydır. Ayrıca vektörlerin, bir matrisin satırları (veya sütunları) olduğunu hatırlayın.

Peki bu Python’da nasıl çalışır?

np.array() işleviyle kolayca bir vektör oluşturabilirsiniz. Benzer şekilde, her bir bir veya iki boyutlu ndarray’e np.matrix() veya np.mat() komutlarıyla bir matris yapısı kazandırabilirsiniz.

Aşağıdaki kod parçasında deneyin:

# Create a vector
myVector = np.array([1,2,3,4])

# Create a matrix
myMatrix = np.matrix(np.random.random((5,5)))

Yani diziler ve matrisler biçimlendirme dışında aynı şey mi?

Tam olarak değil. Bazı farklılıklar var:

• Matris 2 boyutludur; diziler genellikle n boyutludur,
• Yukarıdaki işlevlerin de ima ettiği gibi, matris ndarray’in bir alt sınıfıdır,
• Hem dizilerin hem matrislerin .T()’si vardır; ancak yalnızca matrislerin .H() ve .I()’si bulunur,
• Matris çarpımı, eleman düzeyinde dizi çarpımından farklı çalışır ve
• Buna ek olarak ** işleminin matrisler ve diziler için sonuçları farklıdır

Matrislerle çalışırken, elemanlarının çoğu sıfır olan bazı matrislere rastlayabilirsiniz. Bu matrislere “seyrek matrisler” denir; çoğu elemanı sıfır olmayanlara ise “yoğun matrisler”.

Bu kendi başına önemsiz görünebilir; ancak SciPy ile lineer cebir çalışırken bazı şeyleri yapmak için kullanacağınız modüllerde fark yaratabilir. Daha somut olarak, yoğun matrisler için scipy.linalg kullanabilirsiniz; seyrek matrislerle çalışırken ise kendi scipy.sparse.linalg’ını da içeren scipy.sparse modülünü kontrol etmeyi düşünebilirsiniz.

Seyrek matrisler için onları oluşturmanın bir hayli seçeneği vardır. Aşağıdaki kod parçası bazılarını listeler:

# Create a 2X2 identity matrix
np.eye(3, k=1)        

# Create a 2x2 identity matrix
np.mat(np.identity(2))         

# Compressed Sparse Row matrix
sparse.csr_matrix(C)  

# Compressed Sparse Column matrix
sparse.csc_matrix(C)  

# Dictionary Of Keys matrix
sparse.dok_matrix(C)  

Ek olarak, seyrek matris oluşturmak için kullanabileceğiniz başka işlevler de vardır: bsr_matrix() ile Blok Seyrek Satır matrisleri, coo_matrix() ile Koordinat formatında seyrek matrisler, dia_matrix() ile Diyagonal depolama seyrek matrisleri ve lil_matrix() ile satır tabanlı bağlı liste seyrek matrisleri.

Gerçekten çok fazla seçenek var; peki kendi seyrek matrisinizi oluştururken hangisini seçmelisiniz?

O kadar da zor değil.

Özetle, önce nasıl başlatacağınıza bakmalısınız. Sonra, seyrek matrisinizle ne yapmak istediğinizi düşünün.

Daha somut olarak, hangi tür seyrek matrisi kullanacağınıza karar vermek için aşağıdaki kontrol listesinden geçebilirsiniz:

• Matrisi tek tek sayılarla doldurmayı planlıyorsanız, oluşturmak için coo_matrix() veya dok_matrix() seçin.
• Matrisi köşegen olarak bir diziyle başlatmak istiyorsanız, başlatma için dia_matrix() seçin.
• Dilim tabanlı matrisler için lil_matrix() kullanın.
• Matrisi daha küçük matris bloklarından oluşturuyorsanız, bsr_matrix() kullanmayı düşünün.
• Satır ve sütunlarınıza hızlı erişim istiyorsanız, matrislerinizi sırasıyla csr_matrix() ve csc_matrix() işlevlerini kullanarak dönüştürün. Bu son iki işlev, matrislerinizi başlatırken harika değildir; ancak çarparken hız farkını kesinlikle fark edeceksiniz.

Çok kolay!

# Addition of `vector1` and `vector2`
vector3 = vector1 + vector2

# Print `vector3`
print(_______)

# Subtraction of `vector2` and `vector1`
vector4 = ________ - vector1

# print `vector4`
print(vector4)

# Dot product of `vector1` and `vector2`
dotProduct = np.dot(vector1, vector2)

# Print `dotProduct`
print(dotProduct)

# Cross product of `vector1` and `vector2`
crossProduct = np.cross(________, vector2)

# Print `crossProduct`
print(____________)

# Vector dot product
vectorDotProduct = np.vdot(vector1, vector2)

# Inner product
innerProduct = np.inner(vector1, vector2)

# Outer product
outerProduct = np.outer(vector1, vector2)

# Tensor dot product
tensorDotProduct = np.tensordot(matrix1, matrix2)

# Kronecker product
kronProduct = np.kron(matrix1, matrix2)

linalg.funm(myMatrix, lambda x: x*x)

# Transposition
myMatrix._

# Conjugate transposition
myMatrix._

# Inverse
myMatrix._

# Array
myMatrix._

# Dense matrix solver
linalg.solve(A, b)

# Linear least-square solver
linalg.lstsq(F,E)

Özdeğerler ve Özvektörler

Ele alacağınız ilk konu özdeğerler ve özvektörlerdir.

Özdeğerler, bir matrisin özüne bakmanın yeni bir yoludur. Ancak daha fazla detaya inmeden önce, önce özvektörlerin ne olduğunu açıklayalım. Neredeyse tüm vektörler, bir matrisle çarpıldıklarında yön değiştirir. Ancak belirli istisnai, ortaya çıkan vektörler, çarpımın sonucu olan vektörlerle aynı yöndedir. Bunlar özvektörlerdir.

Başka bir deyişle, bir özvektörü bir matrisle çarpın; bu çarpımın sonucu, orijinal özvektörün \(\lambda\) (özdeğer) ile çarpımına eşittir: \[Ax = \lambda x. \]

Bu, özdeğerin size çok değerli bilgi verdiği anlamına gelir: bir özvektörün bir matrisle çarpıldığında gerilip gerilmediğini, küçülüp küçülmediğini, tersine dönüp dönmediğini veya değişmeden kalıp kalmadığını söyler.

# Solve eigenvalue problem
la, v = linalg.eig(myMatrix) 

# Unpack eigenvalues
l1, l2 = la

# First eigenvector
v[:,0]

# Second eigenvector
v[:,1]

# Or unpack eigenvalues with `eigvals()`
linalg.eigvals(myMatrix)

Kare matrisler için olağan veya genelleştirilmiş özdeğer problemlerini çözmek üzere SciPy’nin linalg modülünden eig() işlevini kullanırsınız.

eigvals() işlevinin, bir matrisin özdeğerlerini açmanın başka bir yolu olduğunu unutmayın.

Seyrek matrislerle çalışırken, özdeğerleri ve özvektörleri bulmak için doğru işlevleri sağlamak üzere scipy.sparse modülüne başvurabilirsiniz:

la, v = sparse.linalg.eigs(myMatrix,1)Altyapı:

Not: Yukarıdaki kod, alınacak özdeğer ve özvektör sayısını, yani 1’i belirtir.

Özdeğerler ve özvektörler, Boyut İndirgeme için Temel Bileşenler Analizi (PCA) ve yüz tanıma için EigenFaces gibi birçok görüntü işleme ve makine öğrenimi tekniğinde önemli kavramlardır.

Tekil Değer Ayrışımı (SVD)

Veri bilimi öğrenmek istiyorsanız sırada SVD’yi bilmeniz gerekiyor. Bir \(A\) matrisinin tekil değer ayrışımı, \(A\)’nın üç matrisin çarpımına ayrıştırılması ya da çarpanlara ayrılmasıdır: \(A = U * \Sigma * V^t\).

\(A\) matrisinin boyutunun \(M\) x \(N\) olduğunu biliyorsanız, bireysel matrislerin boyutları şu şekildedir:

• \(U\) matrisi \(M\) x \(M\) boyutundadır
• \(V\) matrisi \(N\) x \(N\) boyutundadır
• \(\Sigma\) matrisi \(M\) x \(N\) boyutundadır

\(*\), matrislerin çarpıldığını; \(V^t\) ifadesindeki \(^t\) ise matrisin devrik (transpoz) olduğunu, yani satır ve sütunların yer değiştirdiğini ifade eder.

Basitçe söylemek gerekirse, tekil değer ayrışımı bir matrisi daha basit ve anlamlı parçalara ayırmanın bir yolunu sunar. Bu parçalar, ilgilendiğimiz bazı verileri içerebilir.

# Singular Value Decomposition
U,s,Vh = linalg.svd(myMatrix) 

# Initialize `M` and `N`
M,N = myMatrix.shape

# Construct sigma matrix in SVD
Sig = linalg.diagsvd(s,M,N)

Not: Seyrek matrisler için ayrıştırmayı gerçekleştirmek üzere sparse.linalg.svds() işlevini kullanabilirsiniz.

Veri bilimine yeniyseniz, matris ayrıştırması size oldukça kapalı gelebilir: Bunu uygulayabileceğiniz kullanım alanlarını hemen göremeyebilirsiniz. Ancak SVD, veri sıkıştırma, gürültü azaltma ve veri analizi gibi birçok görevde kullanışlıdır. Aşağıda SVD’nin görselleri sıkıştırmak için nasıl kullanılabileceğini göreceksiniz:

# Import the necessary packagesimport numpy as npfrom scipy import linalgfrom skimage import dataimport matplotlib.pyplot as plt# Get an image from `skimage`img= data.camera()# Check number of singular valueslinalg.svdvals(img)# Singular Value DecompositionU, s, Vh = linalg.svd(img)# Use only 32 singular valuesA = np.dot(U[:,0:32],           np.dot(np.diag(s[0:32]), Vh[0:32,:]))fig = plt.figure(figsize=(8, 3))# Add a subplot to the figureax = fig.add_subplot(121)# Plot `img` on grayscaleax.imshow(img, cmap='gray')# Add a second subplot to the figureax2 = fig.add_subplot(122)# Plot `A` in the second subplotax2.imshow(A)# Add a titlefig.suptitle('Image Compression with SVD', fontsize=14, fontweight='bold')# Show the plotplt.show()Altyapı:

Bu da size aşağıdaki sonucu verecektir:

Ayrıca SVD’nin kullanıldığı şu örnekleri de göz önünde bulundurun:

• SVD, boyut indirgeme için kullanılan Temel Bileşenler Analizi (PCA) ile yakından bağlantılıdır: her ikisi de verinizin özellik uzayı eksenlerinin lineer birleşimlerinden oluşturulmuş bir dizi “yeni eksen” ile sonuçlanır. Bu “yeni eksenler”, verilerdeki varyansı, her yönün verideki varyansa katkısına göre ayrıştırır. PCA’nın veriler üzerinde nasıl çalıştığına dair somut bir örnek görmek için Scikit-Learn Eğitimimize gidin.
• Bir diğer bağlantı ise veri madenciliği ve doğal dil işleme (NLP) ile ilgilidir: Gizli Anlamsal Dizinleme (LSI). Bu, belge getirme ve kelime benzerliğinde kullanılan bir tekniktir. Gizli anlamsal dizinleme, belgeleri bu belgelerde bulunan farklı kelimelerden oluşan kavramlarla eşlemek için SVD’yi kullanır. Çeşitli kelimeler bir kavramda gruplanabilir. Burada da SVD, kelimeler ve belgeleri arasındaki gürültülü ilişkiyi azaltır ve orijinal verinin boyut sayısını düşürür.

Gördüğünüz gibi SVD, veri bilimi yolculuğunuzda mutlaka ele almanız gereken önemli bir kavramdır. Bu nedenle, bu eğitimin kapsadığından daha derine inmeyi düşünmelisiniz: örneğin bu matris ayrıştırması hakkında daha fazlasını okumak için bu sayfaya gidin.