UMAP'ı Anlamak: Boyut Azaltmaya Kapsamlı Bir Rehber

Makine öğrenmesi problemlerinde sık sık yüzlerce hatta binlerce özelliğe sahip veri kümeleriyle karşılaşırız ve bu ölçek, anlamlı görselleştirme ve analiz açısından zorluklar doğurur. Geleneksel çizim yöntemleri aynı anda yalnızca iki veya üç boyutu gösterebilir; bu da yüksek boyutlu verinin yapısını anlamayı neredeyse imkânsız kılar. İşte bu noktada UMAP (Uniform Manifold Approximation and Projection) gibi boyut azaltma teknikleri imdadımıza yetişir.

Zamanla, UMAP çeşitli alanlarda karmaşık veri kümelerini görselleştirmek için başvurulan bir yöntem hâline gelmiştir. Bu eğitim, temellerinden uygulamalı kullanıma ve yaygın zorluklara kadar UMAP hakkında bilmeniz gereken her şeyi adım adım anlatacak; böylece bu tekniği projelerinizde hemen kullanmaya başlayabileceksiniz.

UMAP nedir?

UMAP, yüksek boyutlu veriyi daha düşük boyutlu bir uzaya (genellikle 2B veya 3B) yansıtırken verinin öz yapısını koruyan doğrusal olmayan bir boyut azaltma algoritmasıdır. UMAP, Uniform Manifold Approximation and Projection ifadesinin kısaltmasıdır ve manifold öğrenmesi ile topolojik veri analizine dayanır.

t-SNE gibi diğer boyut azaltma yöntemleri yerel komşulukları iyi korurken, küresel ilişkileri bozma eğilimindedir. UMAP’ın temel faydası, hem yerel komşuluklar hem de küresel ilişkiler arasında denge kurmasıdır. Veri noktalarının bir Riemann manifoldunda yattığını ve bu manifoldun yerel olarak bulanık bir topolojik yapıyla modellenebileceğini varsayar. Bu matematiksel temel, UMAP’ın benzer veri noktalarının kümelendiği, veri setinin genel topolojisini de koruyan daha anlamlı görselleştirmeler üretmesine olanak tanır.

Algoritma, önce verinin yüksek boyutlu bir grafik gösterimini kurar, ardından yapısal olarak mümkün olduğunca benzer olacak şekilde düşük boyutlu bir grafiği optimize eder. Görselleştirmenin yanı sıra UMAP, kümeleme algoritmaları için bir ön işleme adımı olarak ya da makine öğrenmesi boru hatlarında genel bir doğrusal olmayan boyut azaltma tekniği olarak da kullanışlıdır.

UMAP Nasıl Çalışır

UMAP’ın nasıl çalıştığını anlamak için süreci birkaç temel adıma böleceğiz. Tam matematiksel teori topoloji ve topolojik veri analizinden ileri kavramlar içerir; bu nedenle bu eğitimde çekirdek algoritmaya sezgisel bir yaklaşımla bakacağız.

Adım 1: Yüksek boyutlu grafiğin kurulması

UMAP, yüksek boyutlu uzaydaki ilişkileri temsil eden ağırlıklı bir grafik inşa ederek başlar. Her bir veri noktası için en yakın k komşuyu belirler (k ayarlanabilir bir parametredir). Ancak basit k-NN grafiklerinden farklı olarak UMAP olasılıksal bir yaklaşım kullanır. İki noktanın bağlantılı olma olasılığını, her noktanın çevresindeki yerel yoğunluğa bağlı pürüzsüz bir yaklaşımı kullanarak mesafelerine göre hesaplar.

Buradaki kilit içgörü, UMAP’ın verimizin yerel yapısına uyum sağlamasıdır. Yoğun bölgelerde noktaların komşu sayılması için çok yakın olması gerekirken, seyrek bölgelerde algoritma arama yarıçapını genişletir. 

Bu uyarlanabilir davranış şu formülle kontrol edilir:

p(i,j) = exp(-(d(xi, xj) - ρi) / σi)Altyapı:

Burada d(xi, xj) noktalar arasındaki mesafedir, ρi en yakın komşuya olan mesafedir ve σi her nokta için hesaplanan bir ölçekleme katsayısıdır.

Adım 2: Bulanık topolojik bir gösterim oluşturma

UMAP daha sonra bu yerel olasılık dağılımlarını topolojik veri analizinden gelen bulanık bir topolojik yapıya dönüştürür. Olasılıkları iki yönü birleştirerek simetrikleştirir:

p(i,j) = p(i|j) + p(j|i) - p(i|j) * p(j|i)Altyapı:

Bu, yüksek boyutlu verinin manifold yapısını yakalayan, bulanık bir simpleks kümesi oluşturur.

Adım 3: Düşük boyutlu gösterimin optimize edilmesi

Son adım, bulanık topolojik yapıyı koruyan düşük boyutlu bir gösterim bulmayı içerir. UMAP, düşük boyutlu uzaydaki noktaları (spektral gömme kullanarak) başlatır ve ardından yüksek ve düşük boyutlu bulanık topolojik gösterimler arasındaki çapraz entropiyi en aza indirmek için gradyan inişi uygular.

Optimizasyon, yakın olması gereken noktaları (yüksek boyutlu yapıya göre) birbirine çeken çekici kuvvetleri ve uzak olması gereken noktaları iten itici kuvvetleri kullanır. Bu itme-çekme dinamiği, kümelerin kendi iç yapısını korurken birbirinden iyi ayrıldığı karakteristik görselleştirmeleri üretir.

UMAP’ın Pratik Kullanım Alanları

UMAP, yüksek boyutlu veriyi anlamanın faydalı olduğu pek çok alanda kullanılmaktadır. 

Gerçek dünyadan bazı kullanım örnekleri şunlardır:

• Tek hücreli genomik ve biyoinformatik: Genomik araştırmalarda UMAP, tek hücre RNA dizileme verilerini görselleştirmede standart hâline gelmiştir. Araştırmacılar bunu hücre tiplerini belirlemek, gelişimsel süreçleri izlemek ve hastalık ilerlemesini anlamak için kullanır. Binlerce gen ifade ölçümünü 2B bir grafiğe indirerek UMAP, ham veride görülmesi imkânsız olan farklı hücre popülasyonlarını ve ilişkilerini ortaya çıkarır.
• Doğal dil işleme: Metin verileri yüksek boyutlu gömmelere dönüştürüldüğünde, anlamsal ilişkileri anlamak için UMAP ile görselleştirilebilir. Sıklıkla kelime gömmelerini, belge kümelerini görselleştirmek ve farklı kavramların gömme uzayında birbirleriyle nasıl ilişkilendiğini göstermek suretiyle dil modellerini hata ayıklamak için kullanılır.
• Bilgisayarla görü ve görüntü analizi: UMAP, sinir ağlarının öğrendiği özellik gösterimlerini görselleştirmeye yardımcı olur; böylece modelin hangi örüntüleri öğrendiğini anlamayı kolaylaştırır. Yüz tanıma sistemlerinde yüzlerin özelliklerine göre nasıl kümelendiğini görselleştirmede ve tıpta benzer vakaları veya anomalileri belirlemede de kullanılır.
• Veri keşfi ve aykırı değer tespiti: UMAP, karmaşık veri kümelerini yorumlanabilir bir görsel uzaya yansıtarak gizli örüntüleri ortaya çıkarmaya ve aykırı değerleri tespit etmeye yardımcı olur. Bu görsel yaklaşım, geleneksel istatistiksel yöntemlerin yüksek boyutlu etkileşimlerle zorlandığı durumlarda özellikle değerlidir.
• Müşteri segmentasyonu ve pazar analizi: Pazarlama ekipleri, satın alma geçmişi, demografi ve etkileşim metrikleri gibi çoklu özelliklere dayalı müşteri davranış örüntülerini görselleştirmek için UMAP kullanır. Bu, farklı müşteri segmentlerini belirlemeye ve gruplar arasındaki ilişkileri anlamaya yardımcı olur.
• İlaç keşfi: İlaç araştırmacıları, kimyasal bileşik uzaylarını görselleştirmek için UMAP kullanır; böylece bilinen etkili ilaçlara yakın kümelenen, toksik bileşiklerden uzak olan umut vadeden adayları belirlemeye yardımcı olur.

Artık UMAP’ın kavramını, matematiksel temellerini ve pratik uygulamalarını anladığımıza göre uygulamaya geçelim.

Python ile UMAP Uygulaması

UMAP’ı pratikte nasıl çalıştığını görmek için gerçek bir veri kümesi üzerinde uygulayalım. 40 farklı kişiye ait gri tonlamalı yüz görüntüleri içeren Olivetti Faces veri setini kullanacağız. Olivetti veri seti Kaggle üzerinden veya scikit-learn Python kütüphanesi aracılığıyla indirilebilir.

Olivetti Faces veri seti şunları içerir:

• 400 gri tonlamalı görüntü (64x64 piksel = 4096 boyut)
• 40 farklı kişi
• Kişi başına 10 görüntü (farklı ifadeler, ışık koşulları)

Bu, UMAP için idealdir; çünkü aynı kişiye ait görüntülerin, ifade ve aydınlatma farklılıklarına rağmen birlikte kümelenmesini bekleriz.

Adım 1: Kütüphaneleri içe aktarın ve veriyi yükleyin

Önce gerekli kütüphaneleri içe aktaralım ve veri setimizi yükleyelim:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from sklearn.datasets import fetch_olivetti_faces
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import umap
import warnings
warnings.filterwarnings('ignore')

# Load the Olivetti faces dataset
faces = fetch_olivetti_faces(shuffle=True, random_state=42)
X = faces.data
y = faces.target

print(f"Dataset shape: {X.shape}")
print(f"Number of individuals: {len(np.unique(y))}")
print(f"Number of images per individual: {X.shape[0] // len(np.unique(y))}")

# Display sample faces
fig, axes = plt.subplots(2, 5, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
   ax.imshow(X[i].reshape(64, 64), cmap='gray')
   ax.set_title(f'Person {y[i]}')
   ax.axis('off')
plt.suptitle('Sample Faces from the Dataset')
plt.tight_layout()
plt.show()Altyapı:

Yukarıdaki koddan, veri setini aşağıdaki gibi görselleştirebiliriz:

Adım 2: Varsayılan parametrelerle UMAP uygulayın

Olivetti yüz veri seti piksel değerleri 0 ile 1 arasında olacak şekilde önceden normalize edilmiştir, bu nedenle UMAP’ı doğrudan uygulayabiliriz:

# Create UMAP instance with default parameters
reducer = umap.UMAP(random_state=42)

# Fit and transform the data
embedding = reducer.fit_transform(X)

# Create a custom colormap for 40 distinct classes
colors = cm.get_cmap('hsv', 40)  

# Create visualization
plt.figure(figsize=(12, 10))
scatter = plt.scatter(embedding[:, 0], embedding[:, 1], c=y,
                    cmap=colors, s=50, alpha=0.8, edgecolors='black', linewidth=0.5)
plt.colorbar(scatter, label='Person ID', ticks=np.arange(0, 40, 5))
plt.title('UMAP Projection of Olivetti Faces (Default Parameters)')
plt.xlabel('UMAP 1')
plt.ylabel('UMAP 2')
plt.grid(True, alpha=0.3)
plt.show()Altyapı:

UMAP görselleştirmesi olarak renkli bir dağılım grafiği ile karşılaşırız:

Diyagramı daha iyi anlamak için dikkat edilmesi gereken bazı noktalar:

• Her nokta bir yüz görüntüsünü temsil eder
• Renkler farklı kişileri temsil eder (Kişi ID 0–39)
• Yakınlık benzerlik demektir: Birbirine yakın noktalar, UMAP’ın 4096 boyutlu uzayda benzer gördüğü yüzlerdir

Gerçek dünyada her zaman böyle olmasa da, ideal olarak aynı kişiye ait tüm 10 görüntünün (aynı renk) birlikte kümelenmesini bekleriz. Görüntüde, varsayılan parametrelerle UMAP oluşturduğumuzda benzer renklerin yer yer kümelendiğini görüyoruz.

Adım 3: Temel UMAP parametrelerini keşfedin

UMAP’ın davranışını kontrol eden birkaç önemli parametre vardır. Bunların sonuçları nasıl etkilediğini inceleyelim:

# Create subplots for different parameter settings
fig, axes = plt.subplots(2, 3, figsize=(18, 12))
axes = axes.ravel()

# Different parameter configurations
param_configs = [
   {'n_neighbors': 5, 'min_dist': 0.1},
   {'n_neighbors': 15, 'min_dist': 0.1},
   {'n_neighbors': 50, 'min_dist': 0.1},
   {'n_neighbors': 15, 'min_dist': 0.0},
   {'n_neighbors': 15, 'min_dist': 0.5},
   {'n_neighbors': 15, 'min_dist': 0.99}
]

# Apply UMAP with different parameters
for idx, params in enumerate(param_configs):
   reducer = umap.UMAP(random_state=42, **params)
   embedding = reducer.fit_transform(X_scaled)
  
   ax = axes[idx]
   scatter = ax.scatter(embedding[:, 0], embedding[:, 1], c=y,
                       cmap='tab20', s=30, alpha=0.8)
   ax.set_title(f"n_neighbors={params['n_neighbors']}, "
                f"min_dist={params['min_dist']}")
   ax.set_xlabel('UMAP 1')
   ax.set_ylabel('UMAP 2')
   ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()Altyapı:

Çıktı görselleştirmesi aşağıdaki gibidir:

Yukarıdaki ızgara, parametrelerin görselleştirmeyi nasıl etkilediğini gösterir. Üst sırada n_neighbors etkisini düşünürsek:

• n_neighbors=5: Çok yerel bir görünüm, birçok küçük ve sıkı küme oluşturur.
• n_neighbors=15: Dengeli bir görünüm, yerel ve küresel yapının iyi bir karışımını sunar.
• n_neighbors=50: Küresel bir görünüm; genel yapıya odaklanır ve benzer bireyleri birleştirebilir.

Alt sırada min_dist etkisini düşünürsek:

• min_dist=0.0: Noktalar aşırı yakın; bu da çok sıkı, yoğun kümeler oluşturur.
• min_dist=0.5: Orta düzeyde aralıklı; kümeler daha fazla yayılır.
• min_dist=0.99: Maksimum aralık; noktalar eşit dağılır ancak küme yapısı kaybolur.

Eldeki problem için en iyi kümelemeyi elde etmek adına bu parametrelerle denemeler yapmak her zaman önerilir.

Boyut Azaltmada UMAP’a Alternatifler

Farklarını anlamak için UMAP’ı PCA ve t-SNE ile karşılaştırmak üzere Olivetti veri seti örneğimize devam edelim:

from sklearn.decomposition import PCA
from sklearn.manifold import TSNE

# Create figure with subplots
fig, axes = plt.subplots(1, 3, figsize=(18, 6))

colors = cm.get_cmap('hsv', 40)

# PCA
pca = PCA(n_components=2, random_state=42)
pca_result = pca.fit_transform(X)
axes[0].scatter(pca_result[:, 0], pca_result[:, 1], c=y,
               cmap=colors, s=50, alpha=0.8)
axes[0].set_title('PCA Projection')
axes[0].set_xlabel('PC 1')
axes[0].set_ylabel('PC 2')
axes[0].grid(True, alpha=0.3)

# t-SNE
tsne = TSNE(n_components=2, random_state=42, perplexity=30)
tsne_result = tsne.fit_transform(X)
axes[1].scatter(tsne_result[:, 0], tsne_result[:, 1], c=y,
               cmap=colors, s=50, alpha=0.8)
axes[1].set_title('t-SNE Projection')
axes[1].set_xlabel('t-SNE 1')
axes[1].set_ylabel('t-SNE 2')
axes[1].grid(True, alpha=0.3)

# UMAP
umap_reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, random_state=42)
umap_result = umap_reducer.fit_transform(X)
scatter = axes[2].scatter(umap_result[:, 0], umap_result[:, 1], c=y,
                        cmap=colors, s=50, alpha=0.8)
axes[2].set_title('UMAP Projection')
axes[2].set_xlabel('UMAP 1')
axes[2].set_ylabel('UMAP 2')
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()Altyapı:

Karşılaştırma grafiğini aşağıdaki gibi göreceğiz:

PCA projeksiyonu (solda), köken etrafında yoğun bir nokta bulutu gösterir ve farklı renkli noktalar arasında yoğun örtüşme vardır. Bu, PCA’dan tam olarak beklediğimiz şeydir — verideki maksimum varyans yönlerini yakalar; ancak farklı kişileri etkin biçimde ayıramaz. Farklı bireylere ait yüzlerin (farklı renkler) tamamen birbirine karıştığını görürüz; bu da belirgin grupları tanımlamayı neredeyse imkânsız kılar.

t-SNE projeksiyonu (ortada), iyi ayrılmış kümelerle bir iyileşme gösterir. Her renk (farklı bir kişiyi temsil eder) belirgin, kompakt bir grup oluşturur ve gruplar arasında net sınırlar vardır. t-SNE’nin, aynı kişiye ait yüzleri birbirine çok yaklaştırırken diğer gruplardan uzaklaştıran neredeyse kusursuz yerel gruplamalar oluşturduğuna dikkat edin. Bu, t-SNE’nin güçlü yanıdır: yerel komşulukları korumada ve görsel olarak belirgin kümeler yaratmada ustadır. 

UMAP projeksiyonu (sağda) farklı bir yaklaşım sergiler. Kümeler t-SNE’ye kıyasla daha yaygın olsa da bu, UMAP’ın hem yerel hem de küresel yapıyı koruma çabasını yansıtır. Her kişinin yine tanınabilir gruplar oluşturduğunu ancak daha fazla iç varyasyon bulunduğunu görebiliriz. Bazı kümeler hafif örtüşmeler gösterir veya birbirine daha yakın konumlanır; bu da bu bireyler arasında gerçek benzerlikler olduğuna işaret edebilir.

Bu karşılaştırma önemli bir noktayı ortaya koyar: “daha iyi”, amacımıza bağlıdır. Sunum veya ilk keşif için olabildiğince net görsel ayrım gerekiyorsa, bu veri seti için t-SNE’nin sıkı kümeleri mükemmeldir. Ancak verinin genel yapısını ve farklı grupların birbirleriyle nasıl ilişkili olduğunu anlamak istiyorsak, küresel ilişkileri korumadaki başarısı nedeniyle UMAP bu veri seti için daha uygun olabilir.

UMAP ile Yaygın Zorluklar ve Çözüm Yolları

Her algoritma ve teknikte olduğu gibi, UMAP’ı gerçek dünya verilerine uygularken çeşitli zorluklarla karşılaşırız. 

Bu konuda kapsamlı çalışmış biri olarak, sıkça tekrar eden bazı zorluklar şunlardır:

1. Doğru parametreleri seçmek

En yaygın zorluk, n_neighbors ve min_dist için uygun değerleri belirlemektir. Bu parametreler görselleştirmeyi önemli ölçüde etkiler ve herkese uyan tek bir çözüm yoktur. 

n_neighbors parametresi, yerel ve küresel yapı koruması arasındaki dengeyi belirler. Küçük değerler (5-15) çok yerel komşulukları korumaya odaklanır; ince ayrıntıları yakalarken daha büyük örüntüleri parçalayabilir. Büyük değerler (30-100) daha geniş bağlantısallık örüntülerini vurgular; küresel yapıyı ortaya koyarken yerel ayrıntıları gölgeleyebilir. 

min_dist parametresi, noktaların düşük boyutlu yerleşimde ne kadar sıkı paketlendiğini kontrol eder; ancak yüksek boyutlu grafik inşasını etkilemez. 0’a yakın değerler noktaların sıkı biçimde paketlenmesine izin verir ve görsel olarak sıkı kümeler oluşturur; 1’e yaklaşan değerler ise noktaları projeksiyon uzayı boyunca daha eşit dağıtır.

En iyi yaklaşım, varsayılan değerlerle (n_neighbors=15, min_dist=0.1) başlamak ve veri özelliklerine göre ayarlama yapmaktır:

• Açıkça ayrılmış kümelere sahip veri setleri için yerel yapıyı korumak adına daha küçük n_neighbors (5-15) kullanabiliriz
• Daha sürekli veya hiyerarşik yapıda veri setleri için küresel ilişkileri yakalamak adına daha büyük n_neighbors (30-100) kullanabiliriz
• Projeksiyonda daha sıkı görsel kümeler için min_dist değerini (0’a doğru) düşürmek
• Görsel olarak daha kolay ayırt edilebilir eşit dağılımlar için min_dist değerini (0.5-1.0’a doğru) artırmak

2. Büyük veri setlerinde hesaplama performansı

UMAP, çok büyük veri setlerinde (milyonlarca nokta) yavaş olabilir ve etkileşimli keşfi zorlaştırabilir. Performansı artırmak için aşağıdaki teknikleri deneyebiliriz:

• Daha hızlı yakınsama için epoch sayısını azaltmak: umap.UMAP(n_epochs=200) (varsayılan None’dır; veri seti boyutuna göre otomatik seçer)
• Çok büyük veri setlerinde spektral yerine rastgele başlatma kullanmak: umap.UMAP(init='random')
• İlk keşif için veriyi alt örneklemek, ardından tamamına uygulamak
• Paralel işlem için n_jobs parametresini kullanmak: umap.UMAP(n_jobs=-1)
• Yeterli RAM varsa, bellek pahasına daha hızlı hesaplama için low_memory=False ayarlamak
• Uygun donanımda GPU hızlandırması için RAPIDS cuML kullanmak.
• Büyük veri setleri için densmap=False (varsayılan) kullanmak; çünkü DensMAP korunumu ek hesaplama yükü getirir

3. UMAP projeksiyonlarında mesafeleri yorumlamak

PCA’dan farklı olarak, UMAP projeksiyonlarındaki mesafelerin doğrudan bir yorumu yoktur. Yakın görünen noktalar, özgün uzayda benzer olmak zorunda değildir. Bu sınırlamayı gidermek için şunlar önemlidir:

• UMAP’ta bulunan kümeleri özgün özelliklerle doğrulamak
• UMAP’ı öncelikle görselleştirme ve hipotez üretimi için kullanmak
• UMAP’ı silhouette skorları gibi diğer doğrulama teknikleriyle birleştirmek
• Analiz görevleri için daha fazla boyutu (3B veya 4B) korumak

4. Yeniden üretilebilirlik sorunları

UMAP, rastgele başlatma kullanır ve bu da çalıştırmalar arasında farklı sonuçlara yol açabilir; bu da tam olarak aynı görselleştirmeleri yeniden üretmeyi zorlaştırır. Yeniden üretilebilirliği sağlamak için şu uygulamaları izleyebiliriz:

• Her zaman random_state parametresini ayarlamak: umap.UMAP(random_state=42)
• Kritik analizlerde UMAP’ı birden fazla kez çalıştırmak ve tutarlı örüntüler aramak
• init parametresini kullanarak tam yeniden üretilebilirlik gerektiğinde başlangıç konumlarını belirtmek

5. Karışık veri türleriyle başa çıkmak

UMAP’ın varsayılan uzaklık metriği sürekli sayısal veriyi varsayar; bu da kategorik veya karışık özelliklere sahip veri setleri için sorun yaratabilir. Karışık veri türleriyle çalışırken şu yaklaşımlar değerlendirilebilir:

• Kategorik değişkenleri uygun şekilde ön işlemek (one-hot kodlama veya gömme)
• Karışık veri türlerini işleyebilen özel uzaklık metrikleri kullanmak
• metric parametresini ikili veriler için 'hamming' gibi seçeneklerle kullanmak
• UMAP’ı farklı özellik türlerine ayrı ayrı uygulamak ve içgörüleri birleştirmek

6. Aykırı değerlerin görselleştirmeyi bozması

Aşırı aykırı değerler ana veri dağılımını sıkıştırabilir ve çoğunluğu oluşturan noktaların yapısını görmeyi zorlaştırabilir. Bunu aşmak için şu teknikleri kullanabiliriz:

• UMAP’ı uygulamadan önce aşırı aykırı değerleri belirleyip kaldırmak
• Standart ölçekleme yerine dayanıklı ölçekleme kullanmak
• local_connectivity parametresini aykırı değerlere karşı daha dayanıklı olacak şekilde ayarlamak
• Temiz veriye fit ettikten sonra aykırı değerleri yansıtmak için UMAP’ın transform yöntemini kullanmak

Bu liste kapsamlı olmasa da UMAP ile çalışırken karşılaşılan en yaygın sorunları kapsar. Bu sorunları ve çözümlerini anlamak, UMAP’tan en iyi şekilde yararlanmamıza yardımcı olacaktır.

Sonuç

Bu eğitimde, UMAP’ın kavramsal ve pratik düzeyde nasıl çalıştığını inceledik; gerçek veriler üzerinde uyguladık, alternatif yöntemlerle karşılaştırdık ve yaygın zorlukları ele aldık. En önemli çıkarım, UMAP’ın yerel ve küresel yapı korunumu arasında denge kurma yeteneğinin, karmaşık ve yüksek boyutlu veri kümeleriyle çalışırken keşif amaçlı veri analizi için onu faydalı kılmasıdır.

Boyut azaltma tekniklerindeki uzmanlığınızı derinleştirmek için Python ile Boyut Azaltma kursumuzu inceleyebilirsiniz; burada UMAP’ın yanı sıra PCA ve t-SNE gibi tekniklerle uygulamalı deneyim kazanacaksınız. Boyut azaltmanın makine öğrenmesi iş akışlarına nasıl oturduğuna dair daha geniş bir bakış için, Python ile Makine Öğrenmesi Bilimcisi öğrenim yolumuz, gözetimli ve gözetimsiz öğrenme tekniklerini öğreterek gerçek dünya veri zorlukları için uçtan uca çözümler geliştirmenize yardımcı olur.