Makine Öğrenmesi Yöntemleri. Bu yazıda sizlere ML hakkında izlediğim… | by Hasan Gunduz | Jul, 2024

Bu yazıda sizlere ML hakkında izlediğim eğitim ile beraber araştırdıklarım doğrultusunda bilgiler vermeye çalışacağım.

Makine öğrenmesi (ML), bilgisayarların veri kullanarak belirli görevleri otomatik olarak öğrenmesini ve geliştirmesini sağlayan bir yapay zeka (AI) dalıdır. Makine öğrenmesi, farklı algoritmalar ve yaklaşımlar kullanarak çeşitli problemlere çözümler sunar. İşte en yaygın makine öğrenmesi yöntemleri ve kısaca açıklamaları:

Denetimli öğrenmede, mannequin, etiketli eğitim verileri kullanılarak eğitilir. Her eğitim örneği, bir girdi (özellikler) ve bir çıktı (hedef) çiftinden oluşur. Mannequin, girdileri kullanarak çıktıları tahmin etmeyi öğrenir.

a. Regresyon (Regression)

Sürekli değişkenlerin tahmini için kullanılır. Etiketler kategoriktir.

Lineer regresyon, bağımsız değişkenler ile bağımlı değişken arasındaki doğrusal ilişkiyi modellemeyi amaçlar.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]])
y = np.array([1, 2, 3, 4, 5])
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = LinearRegression()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Hata metriği hesaplama
mse = mean_squared_error(y_test, y_pred)
print(f'Imply Squared Error: {mse}')

Lojistik regresyon, bir olayın olasılığını tahmin etmek için kullanılır ve çıktı, belirli bir sınıfa ait olma olasılığıdır.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]])
y = np.array([0, 0, 1, 1, 1])
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = LogisticRegression()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

b. Sınıflandırma (Classification)

Kategorik değişkenlerin tahmini için kullanılır. Etiketler Nümeriktir.

• Ok-En Yakın Komşu (Ok-Nearest Neighbors, KNN)

KNN, bir veri noktasını, komşuları arasında en yaygın sınıfın bir üyesi olarak sınıflandırır. KNN, özellikle küçük veri kümelerinde etkilidir.

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]])
y = np.array([0, 0, 1, 1, 1])
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = KNeighborsClassifier(n_neighbors=3)
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

• Destek Vektör Makineleri (Help Vector Machines, SVM)

SVM, veri noktalarını, sınıflar arasındaki en geniş marjini maksimize eden bir hiper düzlem ile ayırır.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# Veri setini yükleme
knowledge = pd.read_csv('knowledge.csv') # Verinizi buraya yükleyin
X = knowledge[['feature1', 'feature2']] # Özellikler
y = knowledge['target'] # Hedef değişken
# Eğitim ve check seti oluşturma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Mannequin oluşturma ve eğitme
mannequin = SVC(kernel='linear')
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Performans değerlendirme
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy:', accuracy)

• Karar Ağaçları (Resolution Timber)

Karar ağaçları, verileri özelliklerine göre bölerek sınıflandırma veya regresyon yapar. Her düğümde, veri seti, belirli bir özellik ve eşik değerine göre ikiye ayrılır.

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]])
y = np.array([0, 0, 1, 1, 1])
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = DecisionTreeClassifier()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

• Rastgele Ormanlar (Random Forests)

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Veri setini yükleme
knowledge = pd.read_csv('knowledge.csv') # Verinizi buraya yükleyin
X = knowledge[['feature1', 'feature2']] # Özellikler
y = knowledge['target'] # Hedef değişken
# Eğitim ve check seti oluşturma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Mannequin oluşturma ve eğitme
mannequin = RandomForestClassifier(n_estimators=100)
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Performans değerlendirme
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy:', accuracy)

Naive Bayes Sınıflandırıcı (Naive Bayes Classifier)

Naive Bayes sınıflandırıcılar, Bayes teoremine dayalı istatistiksel sınıflandırıcı modellerdir. Bu algoritma, her özelliğin sınıflandırmada bağımsız olarak katkıda bulunduğunu varsayar (bu yüzden “naive” olarak adlandırılır).

• Naive Bayes algoritmaları, özellikle metin sınıflandırma (spam filtreleme, belge sınıflandırma) gibi yüksek boyutlu veri setlerinde etkili olabilir.
• Üç yaygın Naive Bayes algoritması vardır: Gaussian Naive Bayes, Multinomial Naive Bayes ve Bernoulli Naive Bayes.

Gaussian Naive Bayes

Gaussian Naive Bayes, özellikle sürekli veri ile çalışır ve her sınıfın özelliklerinin regular dağılıma sahip olduğunu varsayar.

from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score
import numpy as np
# Örnek veri seti
X = np.array([[1.0, 2.1], [2.2, 3.4], [3.5, 5.0], [4.1, 6.8], [5.2, 8.0]])
y = np.array([0, 0, 1, 1, 1])
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = GaussianNB()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

Multinomial Naive Bayes

Multinomial Naive Bayes, özellikle metin sınıflandırmada kullanılır ve her sınıfın özelliklerinin Poisson dağılımına sahip olduğunu varsayar.

from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score
from sklearn.feature_extraction.textual content import CountVectorizer
# Örnek metin veri seti
X = ["free money", "win money now", "money back guarantee", "free trial", "best price", "limited offer"]
y = [1, 1, 1, 1, 0, 0]
# Metin verilerini sayısal verilere dönüştürme
vectorizer = CountVectorizer()
X_vectorized = vectorizer.fit_transform(X)
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X_vectorized, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = MultinomialNB()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

Bernoulli Naive Bayes

Bernoulli Naive Bayes, ikili özelliklere (0 veya 1) sahip veri setleriyle çalışır ve özellikle metin verilerinde kelimenin varlığı veya yokluğuna dayanır.

from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB
from sklearn.metrics import accuracy_score
from sklearn.feature_extraction.textual content import CountVectorizer
# Örnek metin veri seti
X = ["free money", "win money now", "money back guarantee", "free trial", "best price", "limited offer"]
y = [1, 1, 1, 1, 0, 0]
# Metin verilerini sayısal verilere dönüştürme
vectorizer = CountVectorizer(binary=True)
X_vectorized = vectorizer.fit_transform(X)
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X_vectorized, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = BernoulliNB()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

Denetimsiz öğrenmede, mannequin etiketli verilere ihtiyaç duymaz. Mannequin, verilerdeki gizli yapı ve kalıpları keşfetmeye çalışır.

a. Kümeleme (Clustering)

Veri noktalarını gruplara ayırma.

Ok-Means algoritması, veri noktalarını ok küme olacak şekilde ayırır ve her kümenin merkezini belirler.

from sklearn.cluster import KMeans
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]])
# Modeli oluşturma ve eğitme
kmeans = KMeans(n_clusters=2, random_state=42)
kmeans.match(X)
# Küme merkezlerini ve tahminleri yazdırma
print(f'Cluster Facilities: {kmeans.cluster_centers_}')
print(f'Predictions: {kmeans.predict(X)}')

• Hiyerarşik Kümeleme (Hierarchical Clustering)

Hiyerarşik kümeleme, veri noktalarını hiyerarşik bir yapıya göre kümeler. Kümeler, bir dendrogram aracılığıyla görselleştirilebilir.

from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]])
# Hiyerarşik kümeleme
linked = linkage(X, technique='ward')
# Dendrogram çizimi
plt.determine(figsize=(10, 7))
dendrogram(linked)
plt.present()

b. Boyut İndirgeme (Dimensionality Discount)

Veri setinin boyutunu azaltma.

• Temel Bileşen Analizi (Principal Element Evaluation, PCA)

PCA, verideki en büyük varyansı açıklayan bileşenleri bulmak için kullanılır. Bu bileşenler, orijinal değişkenlerin doğrusal kombinasyonlarıdır.

from sklearn.decomposition import PCA
import numpy as np
# Örnek veri seti
X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0], [2.3, 2.7]])
# PCA uygulama
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
print("Orijinal Veri:n", X)
print("PCA ile İndirgenmiş Veri:n", X_pca)

• t-Distributed Stochastic Neighbor Embedding (t-SNE)

t-SNE, özellikle yüksek boyutlu verilerin 2D veya 3D görselleştirilmesi için kullanılır. Verilerin benzerliklerini koruyarak düşük boyutlu bir temsili oluşturur.

from sklearn.manifold import TSNE
import numpy as np
# Örnek veri seti
X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0], [2.3, 2.7]])
# t-SNE uygulama
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X)
print("Orijinal Veri:n", X)
print("t-SNE ile İndirgenmiş Veri:n", X_tsne)

Pekiştirmeli öğrenmede, bir ajan bir ortamda etkileşimde bulunarak ödüller toplar ve en uygun stratejiyi öğrenir.

Pekiştirmeli öğrenme, bir yapay zeka (AI) modelinin, bir ortamla etkileşime geçerek belirli bir görevi gerçekleştirmeyi öğrenmesini sağlayan bir öğrenme türüdür.

Q-Öğrenme, bir ajan için optimum eylem-politikasını öğrenmek amacıyla kullanılan bir pekiştirmeli öğrenme algoritmasıdır.

import numpy as np
# Ortam parametreleri
states = vary(6)
actions = vary(2)
rewards = np.array([[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 1, 0]])
q_table = np.zeros((len(states), len(actions)))
# Q-Öğrenme parametreleri
alpha = 0.1
gamma = 0.6
epsilon = 0.1
# Eğitim döngüsü
for episode in vary(1000):
state = np.random.randint(0, len(states))
whereas state != 4:
if np.random.uniform(0, 1) < epsilon:
motion = np.random.randint(0, len(actions))
else:
motion = np.argmax(q_table[state])
next_state = state + motion - 1
if next_state >= len(states):
next_state = len(states) - 1
reward = rewards[action, next_state]
old_value = q_table[state, action]
next_max = np.max(q_table[next_state])
new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)
q_table[state, action] = new_value
state = next_state
print("Q-Tablosu:n", q_table)

• Derin Q-Ağları (Deep Q-Networks, DQN)

DQN, Q-öğrenmeyi derin sinir ağları ile birleştirerek, yüksek boyutlu durum uzaylarında etkili öğrenme sağlar.

import fitness center
import numpy as np
import tensorflow as tf
from tensorflow.keras import fashions, layers, optimizers
env = fitness center.make("CartPole-v1")
num_actions = env.action_space.n
num_states = env.observation_space.form[0]
# Mannequin tanımlama
mannequin = fashions.Sequential([
layers.Dense(24, activation="relu", input_shape=(num_states,)),
layers.Dense(24, activation="relu"),
layers.Dense(num_actions, activation="linear")
])
mannequin.compile(optimizer=optimizers.Adam(lr=0.001), loss="mse")
# Parametreler
gamma = 0.99
epsilon = 1.0
epsilon_min = 0.01
epsilon_decay = 0.995
batch_size = 64
reminiscence = []
# Eğitim döngüsü
for episode in vary(1000):
state = env.reset()
state = np.reshape(state, [1, num_states])
total_reward = 0
for time in vary(500):
if np.random.rand() <= epsilon:
motion = np.random.selection(num_actions)
else:
motion = np.argmax(mannequin.predict(state))
next_state, reward, accomplished, _ = env.step(motion)
next_state = np.reshape(next_state, [1, num_states])
reminiscence.append((state, motion, reward, next_state, accomplished))
if len(reminiscence) > batch_size:
minibatch = np.random.selection(reminiscence, batch_size)
for state_b, action_b, reward_b, next_state_b, done_b in minibatch:
goal = reward_b
if not done_b:
goal += gamma * np.max(mannequin.predict(next_state_b))
target_f = mannequin.predict(state_b)
target_f[0][action_b] = goal
mannequin.match(state_b, target_f, epochs=1, verbose=0)
state = next_state
total_reward += reward
if accomplished:
print(f"Episode: {episode}/{1000}, Reward: {total_reward}, Epsilon: {epsilon}")
break
if epsilon > epsilon_min:
epsilon *= epsilon_decay

Bu yöntem, hem etiketli hem de etiketlenmemiş verileri kullanarak öğrenir. Özellikle etiketli veri sayısının az olduğu durumlarda kullanışlıdır.

from sklearn.datasets import load_digits
from sklearn.semi_supervised import LabelSpreading
import numpy as np
# Veri seti yükleme
digits = load_digits()
X = digits.knowledge
y = digits.goal
# Etiketlerin %50'sini etiketlenmemiş yapma
rng = np.random.RandomState(42)
random_unlabeled_points = rng.rand(len(y)) < 0.5
y[random_unlabeled_points] = -1
# Modeli oluşturma ve eğitme
mannequin = LabelSpreading(kernel='knn', n_neighbors=7)
mannequin.match(X, y)
# Tahmin yapma
y_pred = mannequin.transduction_
print("Gerçek Etiketler:", digits.goal)
print("Tahmin Edilen Etiketler:", y_pred)

Switch öğrenme, önceden eğitilmiş bir modelin başka bir ilgili görev için uyarlanmasıdır. Özellikle derin öğrenmede yaygın olarak kullanılır.

import tensorflow as tf
from tensorflow.keras.functions import VGG16
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.fashions import Mannequin
# Önceden eğitilmiş VGG16 modeli
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
# Yeni katmanlar ekleme
x = base_model.output
x = Flatten()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)
# Yeni mannequin oluşturma
mannequin = Mannequin(inputs=base_model.enter, outputs=predictions)
# Önceden eğitilmiş katmanları dondurma
for layer in base_model.layers:
layer.trainable = False
# Modeli derleme
mannequin.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Modeli eğitme
# mannequin.match(train_data, train_labels, epochs=10, batch_size=32)

Derin öğrenme, çok katmanlı yapay sinir ağları kullanarak daha karmaşık ve büyük veri setlerini işleyen bir makine öğrenmesi dalıdır.

• Yapay Sinir Ağları (Synthetic Neural Networks, ANN)

import tensorflow as tf
from tensorflow.keras.fashions import Sequential
from tensorflow.keras.layers import Dense
# Modeli oluşturma
mannequin = Sequential([
Dense(64, activation='relu', input_shape=(784,)),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
# Modeli derleme
mannequin.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Modeli eğitme
# mannequin.match(train_images, train_labels, epochs=10, batch_size=32)

• Evrişimsel Sinir Ağları (Convolutional Neural Networks, CNN)

import tensorflow as tf
from tensorflow.keras.fashions import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
# Modeli oluşturma
mannequin = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D((2, 2)),
Flatten(),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
# Modeli derleme
mannequin.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Modeli eğitme
# mannequin.match(train_images, train_labels, epochs=10, batch_size=32)

• Tekrarlayan Sinir Ağları (Recurrent Neural Networks, RNN)

import tensorflow as tf
from tensorflow.keras.fashions import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense
# Modeli oluşturma
mannequin = Sequential([
SimpleRNN(128, input_shape=(100, 1)),
Dense(10, activation='softmax')
])
# Modeli derleme
mannequin.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Modeli eğitme
# mannequin.match(train_sequences, train_labels, epochs=10, batch_size=32)

• Generative Adversarial Networks (GANs)

import tensorflow as tf
from tensorflow.keras.fashions import Sequential, Mannequin
from tensorflow.keras.layers import Dense, Reshape, Flatten, LeakyReLU, BatchNormalization, Enter
import numpy as np
# Generator
generator = Sequential([
Dense(256, input_dim=100),
LeakyReLU(0.2),
BatchNormalization(momentum=0.8),
Dense(512),
LeakyReLU(0.2),
BatchNormalization(momentum=0.8),
Dense(1024),
LeakyReLU(0.2),
BatchNormalization(momentum=0.8),
Dense(28 * 28 * 1, activation='tanh'),
Reshape((28, 28, 1))
])
# Discriminator
discriminator = Sequential([
Flatten(input_shape=(28, 28, 1)),
Dense(512),
LeakyReLU(0.2),
Dense(256),
LeakyReLU(0.2),
Dense(1, activation='sigmoid')
])
# GAN modeli
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
discriminator.trainable = False
z = Enter(form=(100,))
img = generator(z)
legitimate = discriminator(img)
gan = Mannequin(z, legitimate)
gan.compile(optimizer='adam', loss='binary_crossentropy')
# training loop
# for epoch in vary(epochs):
#     # Eğitim kodu ekleyeceğim

Birden fazla modelin bir araya getirilerek daha güçlü ve kararlı bir mannequin oluşturulmasıdır. Topluluk yöntemleri, tek bir modelden daha iyi performans gösterebilir.

a. Bagging (Bootstrap Aggregating)

Veri setlerinden rastgele örnekler alınarak birden fazla mannequin eğitilir ve tahminlerin ortalaması alınır.

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Veri seti yükleme
iris = load_iris()
X, y = iris.knowledge, iris.goal
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# BaggingClassifier modeli
mannequin = BaggingClassifier(base_estimator=DecisionTreeClassifier(), n_estimators=10, random_state=42)
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

• Rassal Ormanlar (Random Forests)

b. Boosting

Zayıf modeller ardışık olarak eğitilir ve her mannequin, önceki modelin hatalarını düzeltmeye çalışır.

• AdaBoost
• Gradient Boosting
• XGBoost

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Veri seti yükleme
iris = load_iris()
X, y = iris.knowledge, iris.goal
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# AdaBoostClassifier modeli
mannequin = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(), n_estimators=50, random_state=42)
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

Veri setindeki olağandışı veya beklenmedik olayları tespit etmek için kullanılır. Bu yöntem, siber güvenlik, dolandırıcılık tespiti gibi alanlarda yaygın olarak kullanılır.

• One-Class SVM
• Isolation Forest

from sklearn.ensemble import IsolationForest
import numpy as np
# Örnek veri seti
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [10, 10]])
# IsolationForest modeli
mannequin = IsolationForest(contamination=0.2, random_state=42)
mannequin.match(X)
# Anomali tespiti
y_pred = mannequin.predict(X)
print("Anomali Tespiti Sonuçları:", y_pred)

Metin verisiyle çalışmak için kullanılan yöntemlerdir. Dilin anlaşılması ve işlenmesi üzerine yoğunlaşır.

• Duygu Analizi (Sentiment Evaluation)

from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.textual content import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score
# Örnek metin veri seti
X = ["I love this product", "This is the worst thing ever", "I am so happy", "I hate it"]
y = [1, 0, 1, 0]
# Metin verilerini sayısal verilere dönüştürme
vectorizer = CountVectorizer()
X_vectorized = vectorizer.fit_transform(X)
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X_vectorized, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = MultinomialNB()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

• Metin Sınıflandırma (Textual content Classification)

from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.textual content import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Örnek metin veri seti
X = ["I love this product", "This is the worst thing ever", "I am so happy", "I hate it"]
y = [1, 0, 1, 0]
# Metin verilerini sayısal verilere dönüştürme
vectorizer = TfidfVectorizer()
X_vectorized = vectorizer.fit_transform(X)
# Eğitim ve check veri setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X_vectorized, y, test_size=0.2, random_state=42)
# Modeli oluşturma ve eğitme
mannequin = LogisticRegression()
mannequin.match(X_train, y_train)
# Tahmin yapma
y_pred = mannequin.predict(X_test)
# Doğruluk metriği hesaplama
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

• Dil Modelleri (Language Fashions) (Örneğin, GPT-4)

from gensim.fashions import Word2Vec
# Örnek cümleler
sentences = [["I", "love", "machine", "learning"], ["Deep", "learning", "is", "fun"], ["NLP", "is", "interesting"]]
# Word2Vec modeli oluşturma ve eğitme
mannequin = Word2Vec(sentences, vector_size=100, window=5, min_count=1, staff=4)
# Kelime vektörlerini elde etme
word_vectors = mannequin.wv
print(word_vectors["learning"])

• Word2Vec, GloVe (Kelime Gömme Teknikleri)

Word2Vec

Word2Vec, kelimeleri vektörlere dönüştürmek için yaygın olarak kullanılan bir yöntemdir. Word2Vec modeli, kelimeleri bağlamlarıyla birlikte öğrenerek kelime vektörlerini oluşturur. İki ana algoritma kullanır: Skip-gram ve Steady Bag of Phrases (CBOW).

from gensim.fashions import Word2Vec
# Örnek cümleler
sentences = [["I", "love", "machine", "learning"], ["Deep", "learning", "is", "fun"], ["NLP", "is", "interesting"]]
# Word2Vec modeli oluşturma ve eğitme
mannequin = Word2Vec(sentences, vector_size=100, window=5, min_count=1, staff=4)
# Kelime vektörlerini elde etme
word_vectors = mannequin.wv
print(word_vectors["learning"])

GloVe

GloVe (World Vectors for Phrase Illustration), kelimeleri world bağlam istatistiklerini kullanarak vektörlere dönüştüren bir yöntemdir. Word2Vec’in aksine, GloVe algoritması, kelimelerin birlikte geçiş sıklıklarını analiz eder ve bu bilgiyi kullanarak kelime vektörlerini oluşturur.

import numpy as np
# Örnek kelime-ortak geçiş matrisi
cooccurrence_matrix = np.array([
[1, 2, 0],
[2, 1, 1],
[0, 1, 3]
])
# GloVe modelini eğitme
def train_glove(cooccurrence_matrix, vector_size=2, learning_rate=0.05, epochs=100):
vocab_size = cooccurrence_matrix.form[0]
word_vectors = np.random.rand(vocab_size, vector_size)
biases = np.random.rand(vocab_size)
for epoch in vary(epochs):
for i in vary(vocab_size):
for j in vary(vocab_size):
if cooccurrence_matrix[i, j] > 0:
x_ij = cooccurrence_matrix[i, j]
weight = (x_ij / np.max(cooccurrence_matrix)) ** 0.75
diff = np.dot(word_vectors[i], word_vectors[j]) + biases[i] + biases[j] - np.log(x_ij)
word_vectors[i] -= learning_rate * weight * diff * word_vectors[j]
word_vectors[j] -= learning_rate * weight * diff * word_vectors[i]
biases[i] -= learning_rate * weight * diff
biases[j] -= learning_rate * weight * diff
return word_vectors
word_vectors = train_glove(cooccurrence_matrix)
print(word_vectors)

Veri noktaları arasındaki ilişkileri grafikler aracılığıyla modelleme yöntemidir. Sosyal ağ analizi, kimyasal yapıların analizi gibi alanlarda kullanılır.

• Grafik Sinir Ağları (Graph Neural Networks, GNN)

Bu modeller, değişkenler arasındaki olasılıksal bağımlılıkları temsil eder.

• Gizli Markov Modelleri (Hidden Markov Fashions, HMM)
• Bayes Ağları (Bayesian Networks)

Doğal seleksiyon ve genetik mekanizmalardan esinlenen optimizasyon teknikleridir.

• Genetik Algoritmalar (Genetic Algorithms)
• Evrim Stratejileri (Evolution Methods)

Zaman serisi verileri üzerinde çalışmak için kullanılan yöntemlerdir. Finans, hava tahmini, envanter yönetimi gibi alanlarda yaygın olarak kullanılır.

• ARIMA (AutoRegressive Built-in Transferring Common)
• LSTM (Lengthy Quick-Time period Reminiscence)

Makine öğrenmesi modellerini insan bilgisi veya diğer bilgi kaynaklarıyla güçlendirmek için kullanılır.

• Aktif Öğrenme (Energetic Studying)
• İnsan ve Makine İşbirliği (Human-in-the-Loop Studying)

Modelin verilerden kendi kendine öğrenme görevleri oluşturması ve bu görevlerle öğrenmesi üzerine kurulu yöntemlerdir. Özellikle derin öğrenme modellerinde yaygın olarak kullanılır.

• BERT (Bidirectional Encoder Representations from Transformers)
• SimCLR (Easy Framework for Contrastive Studying of Visible Representations)

İstatistiksel teknikleri ve olasılık teorisini kullanan yöntemlerdir. Bu yöntemler, genellikle parametrik veya parametrik olmayan modellere dayanır.

• Genelleştirilmiş Doğrusal Modeller (Generalized Linear Fashions, GLM)
• Gizli Dirichlet Ayrımı (Latent Dirichlet Allocation, LDA): Metin madenciliği ve konu modelleme için kullanılır.
• Çok Değişkenli İstatistiksel Analiz (Multivariate Statistical Evaluation)

Metin verilerinden bilgi çıkarma teknikleridir. Bu, doğal dil işleme (NLP) yöntemlerini de kapsar.

• Frekans Tabanlı Yaklaşımlar (Time period Frequency-Inverse Doc Frequency, TF-IDF)
• Adlandırılmış Varlık Tanıma (Named Entity Recognition, NER)
• Metin Özetleme (Textual content Summarization)

Mannequin temelli öğrenme, veri kümesindeki ilişkileri ve yapılarını öğrenmek için belirli mannequin yapılarını kullanırken, mannequin temasız öğrenme belirli bir mannequin yapısına dayanmadan öğrenir.

a. Mannequin Temelli (Mannequin-Based mostly)

• Gaussian Combination Fashions (GMM)
• Hidden Markov Fashions (HMM)

b. Mannequin Temasız (Mannequin-Free)

• Kernel Density Estimation (KDE)

Veriler zaman içinde geldikçe modeli sürekli olarak güncelleyebilen bir öğrenme yöntemidir. Dinamik ortamlar için kullanışlıdır.

• Stochastic Gradient Descent (SGD)
• On-line Boosting

Metin ve görüntü verilerini birleştiren yöntemlerdir. Örneğin, sosyal medya analizlerinde yaygın olarak kullanılır.

• Multimodal Studying
• Visible Query Answering (VQA)

Kendi kendine öğrenme, modelin veri setindeki yapı ve ilişkileri keşfetmek için kendi içindeki bilgileri kullanır.

• Autoencoders
• Self-Organizing Maps (SOM)

Özellikle pazarlama ve sosyal medya analizinde kullanılan yöntemlerdir.

• Duygu Analizi (Sentiment Evaluation)
• Kullanıcı Geri Bildirimi Analizi

Karar verme süreçlerini modellemek için oyun teorisi ve ekonomi prensiplerini kullanır.

• Nash Dengesi (Nash Equilibrium)
• Olasılıksal Mantık Modelleri (Probabilistic Logic Fashions)

Büyük veri tabanlarından bilgi bulma ve çıkarma teknikleridir.

• Arama Motoru Optimizasyonu (Search Engine Optimization, search engine optimisation)
• Belge Sıralama Algoritmaları (Doc Rating Algorithms)

Modellerin nasıl öğrenileceğini öğrenme sürecidir. Yeni görevler için öğrenme süresini kısaltmak için kullanılır.

• Few-Shot Studying
• Hyperparameter Optimization

Kuantum bilgi işlem prensiplerini makine öğrenmesi algoritmalarına uygulayan yöntemlerdir. Bu yöntemler henüz araştırma aşamasında olmasına rağmen, gelecekte büyük potansiyele sahiptir.

• Quantum Neural Networks (QNN)
• Quantum Help Vector Machines (QSVM)

Bayes teoremi üzerine kurulu yöntemlerdir. Veri ve mannequin parametreleri hakkında olasılıksal çıkarım yapılmasını sağlar.

• Baysyen Optimizasyon (Bayesian Optimization)
• Gaussian Processes (GP)
• Bayesian Neural Networks (BNN)

Mannequin seçimi, hiperparametre ayarlama ve mannequin eğitimi gibi süreçleri otomatikleştirir.

• AutoKeras
• Auto-sklearn
• TPOT (Tree-based Pipeline Optimization Software)

Verilerin merkezileştirilmesine gerek kalmadan, dağıtık veri kümeleri üzerinde makine öğrenmesi modelleri eğitilmesini sağlar.

Veri üzerinden doğrudan öğrenmeyi hedefleyen yöntemlerdir. Örneğin:

• Characteristic Studying (Özellik Öğrenme): Özelliklerin otomatik olarak çıkarılması.
• Illustration Studying (Temsil Öğrenme): Veriyi daha verimli ve anlamlı temsil edebilecek yapılar öğrenme.

Modelin en çok fayda sağlayacağı veri örneklerini seçerek eğitilmesi sürecidir.

• Question by Committee (Komite ile Sorgulama)
• Uncertainty Sampling (Belirsizlik Örneklemesi)

Veri setini çeşitli dönüşümlerle genişleterek modelin genel performansını artırmayı hedefler. Özellikle görüntü işleme alanında yaygındır.

• Random Cropping (Rastgele Kırpma)
• Horizontal Flipping (Yatay Çevirme)

Hem parametrik hem de parametrik olmayan bileşenler içeren modellerdir.

• Gaussian Processes with Parametric Imply Features
• Generalized Additive Fashions (GAMs)

Veri setindeki değişkenler arasındaki nedensel ilişkileri belirlemek için kullanılır.

• Instrumental Variables (IV)
• Causal Bayesian Networks

Zamanla değişen sistemlerin modellenmesi ve tahmini için kullanılır.

• State Area Fashions (Durum Uzay Modelleri)
• Kalman Filters (Kalman Filtreleri)

Kullanıcılara özel önerilerde bulunmak için kullanılır. Yaygın olarak e-ticaret, müzik ve video platformlarında kullanılır.

• Collaborative Filtering (Ortak Filtreleme)
• Content material-Based mostly Filtering (İçerik Tabanlı Filtreleme)

Veri gizliliğini ve güvenliğini sağlamak için kullanılan yöntemler.

• Differential Privateness (Diferansiyel Gizlilik)
• Homomorphic Encryption (Homomorfik Şifreleme)

Az sayıda örnekle (few-shot) veya hiç örnek olmadan (zero-shot) öğrenme yapabilen modellerdir.

• Prototypical Networks
• Siamese Networks

Graf yapılarını vektör uzayına gömme yöntemleri, sosyal ağlar ve biyolojik ağlar gibi alanlarda kullanılır.

• Node2Vec
• Graph Convolutional Networks (GCN)

Pekiştirmeli öğrenmede, ajanların davranış politikalarını doğrudan optimize eden yöntemlerdir.

• REINFORCE Algorithm
• Actor-Critic Strategies

Çoklu ajan ortamlarında karar verme süreçlerini modellemek için oyun teorisi yöntemlerini kullanır.

• Multi-Agent Reinforcement Studying (MARL)
• Nash-Q Studying

Kuantum hesaplama prensiplerinden ilham alan, ancak klasik bilgisayarlarda çalışan algoritmalar.

• Quantum Annealing
• Quantum-Impressed Optimization Algorithms

Derin öğrenme ve takviyeli öğrenmeyi birleştirerek karmaşık görevleri çözmek için kullanılır. Özellikle oyunlarda ve robotikte önemli başarılar elde etmiştir.

• Deep Q-Networks (DQN)
• Coverage Gradients
• Proximal Coverage Optimization (PPO)
• Belief Area Coverage Optimization (TRPO)

Algoritmaların yeni görevleri daha hızlı ve daha az veri ile öğrenmesini sağlar. “Öğrenmeyi öğrenme” olarak da bilinir.

• MAML (Mannequin-Agnostic Meta-Studying)
• Reptile
• Studying to Study

Yeni veriler üretebilen modellerdir. Özellikle yaratıcı uygulamalarda ve veri artırmada kullanılır.

• Generative Adversarial Networks (GANs)
• Variational Autoencoders (VAEs)
• Circulate-Based mostly Fashions

Bir modelin, başka bir görev veya veri seti üzerinde önceden eğitilmiş bilgiyi kullanarak öğrenmesini sağlar. Bu, özellikle derin öğrenme modellerinde yaygındır.

• Nice-Tuning (İnce Ayar)
• Characteristic Extraction (Özellik Çıkarımı)

Modellerin zaman içinde yeni bilgileri öğrenirken eski bilgileri unutmasını önlemeyi hedefler.

• Elastic Weight Consolidation (EWC)
• Progress & Compress

Modelin, büyük miktarda etiketlenmemiş veriyi kullanarak kendi kendine öğrenmesini sağlar. Özellikle dil modellerinde ve görüntü tanımada kullanılır.

• Contrastive Studying
• BERT (Bidirectional Encoder Representations from Transformers)
• SimCLR

Merkezi olmayan veri kaynakları üzerinde makine öğrenmesi modelleri eğitmek için kullanılır. Verilerin gizliliğini korur ve veri merkezileştirmesine ihtiyaç duymaz.

• Federated Averaging (FedAvg)
• Safe Aggregation

Modellerin kararlarını ve tahminlerini anlaşılabilir ve açıklanabilir hale getirmek için kullanılır. Şeffaflık ve güvenilirlik açısından önemlidir.

• LIME (Native Interpretable Mannequin-agnostic Explanations)
• SHAP (SHapley Additive exPlanations)
• Mannequin Agnostic Strategies

Aynı anda birden fazla görevi öğrenme ve bu görevlerin birbirlerinden faydalanmasını sağlama yöntemi.

• Shared Representations (Paylaşılan Temsiller)
• Cross-Sew Networks

Hiperparametre ayarlarını ve diğer optimizasyon problemlerini çözmek için kullanılır. Özellikle mannequin tuning’de yaygındır.

• Gaussian Processes (GP)
• Tree-structured Parzen Estimator (TPE)

Kuantum bilgi işlem tekniklerini makine öğrenmesi problemlerine uygulamayı hedefler. Henüz araştırma aşamasında olup, gelecekte büyük potansiyele sahiptir.

• Quantum Neural Networks (QNN)
• Quantum Help Vector Machines (QSVM)
• Quantum Annealing

Makine öğrenmesi algoritmalarının veri toplama noktalarında (örneğin, IoT cihazları, mobil cihazlar) çalıştırılması. Veri merkezlerine olan ihtiyacı azaltır ve gerçek zamanlı işlemeyi mümkün kılar.

Modellerin güvenliğini ve sağlamlığını artırmak için kullanılan yöntemlerdir. Modelleri kötü niyetli saldırılara karşı korumayı hedefler.

• Adversarial Coaching
• Sturdy Optimization

Geleneksel derin öğrenme modellerinin bazı eksikliklerini gidermeyi amaçlayan, nesnelerin özellikleri arasındaki ilişkilere odaklanan ağlardır.

• Dynamic Routing Between Capsules

Modellerin performansını artırmak için optimum hiperparametre setlerinin bulunmasını sağlar.

• Grid Search
• Random Search
• Bayesian Optimization

Veri ve modellerdeki gereksiz öğelerin azaltılmasını sağlar. Özellikle yüksek boyutlu verilerde kullanılır.

• Lasso Regression
• Sparse Coding

Veri gizliliğini koruyarak makine öğrenmesi modelleri eğitmek için kullanılan yöntemler.

• Differential Privateness
• Federated Studying
• Homomorphic Encryption

Bir modelin, yaşamı boyunca sürekli olarak yeni bilgiler öğrenmesi ve bu bilgileri mevcut bilgi tabanına entegre etmesi sürecidir.

Bu yöntemler, çeşitli veri türlerine ve problemlere uygulanabilir. Makine öğrenmesi alanında başarılı olabilmek için, bu yöntemleri ve algoritmaları iyi anlamak ve uygun veri ön işleme tekniklerini kullanmak önemlidir.Makine Öğrenmesi Terminolojisi