Bir Makine Öğrenimi Modeli Nasıl Dağıtılır?

Son yıllarda makine öğrenimi ve yapay zeka önemli ölçüde popülerlik kazanmıştır. Bu durum büyük olasılıkla doğal dil işleme ve tavsiye sistemlerindeki ilerlemelere bağlanabilir.

Bu makalede makine öğrenimi, uygulamaları, dağıtım seçenekleri tanıtılmakta ve basit bir makine öğrenimi modelinin Back4app Containers‘a nasıl dağıtılacağı gösterilmektedir.

Makine Öğrenimi Nedir?

Makine öğrenimi, yapay zekanın bir alt alanıdır. Özünde, verilerden öğrenmek ve yeni, görülmemiş veriler hakkında tahminlerde bulunmak için istatistiksel algoritmalardan yararlanır.

Başka bir deyişle, bilgisayarlara açıkça programlanmadan öğrenme yeteneği kazandırır.

Makine öğrenimi ve yapay zeka sıklıkla birbirinin yerine kullanılsa da aynı şey değildir.

Makine öğrenimi algoritmalar ve veri yapılarına odaklanırken, yapay zeka insan benzeri düşünebilen makineler yaratmaya yönelik genel bir girişimdir.

Tipik makine öğrenimi teknikleri regresyon (ev fiyatı gibi sürekli bir değeri tahmin etme) ve sınıflandırmadır (film türü gibi sonlu bir sınıf kümesinden bir sınıfı tahmin etme).

Genel olarak makine öğrenimini üç türe ayırabiliriz:

• Denetimli öğrenme — algoritmalar etiketlenmiş bir veri kümesi kullanarak öğrenir. Veri kümesindeki her örnek bir etiket (veya hedef değişken olarak adlandırılır) içerir. Algoritma bunları görünmeyen örneklerin etiketlerini tahmin etmek için kullanır. Denetimli öğrenme algoritmaları arasında kNN, decision trees vb. bulunur.

• Denetimsiz öğrenme — algoritmalar herhangi bir açık yönlendirme olmadan öğrenir. Verilerdeki örüntüleri bulmak ve bunlara dayalı tahminler yapmak algoritmaya bağlıdır. Örnek algoritma k-ortalamalar kümelemesidir.

• Takviyeli öğrenme — algoritmalar deneme yanılma yoluyla öğrenir. Genellikle ödül tabanlıdırlar ve algoritmanın amacı ödülü maksimize etmektir. Örnek: genetik algoritmalar.

Makalenin pratik bölümünde, tipik bir model oluşturma sürecinden geçeceğiz. Denetimli öğrenmeyi kullanarak bir sınıflandırma görevini çözeceğiz.

Makine Öğrenimi Uygulamaları

Gerçek dünyadaki bazı makine öğrenimi uygulamalarına göz atalım!

Öneri Sistemleri

Öneri sistemleri, bir kullanıcının hangi öğeleri (filmler, ürünler, vb.) tüketmesi gerektiğini önerir. Bu sistemler içerik tabanlı ya da işbirlikçi tabanlı olabilir.

Bugünlerde tavsiye sistemleri neredeyse her şirket tarafından kullanılıyor. Şirketlerin iş başarısını artırmasına, ek talep yaratmasına, kullanıcı katılımını artırmasına, müşteriler hakkında bilgi edinmesine ve daha pek çok şeye olanak tanıyor.

Örneğin Netflix film önermek için, Spotify şarkı önermek için ve YouTube ilgi alanlarınıza göre izlemeniz gereken videoları önermek için bunları kullanıyor.

Doğal Dil İşleme (NLP)

Doğal dil işleme (NLP) bilgisayarların insan dilini işlemesini ve anlamasını sağlar. Doğal dil üretimi (NLG) bilgisayarların insan dili üretmesini sağlar.

Bu teknoloji sohbet robotları, dil çeviri araçları, duygu analizi araçları ve daha fazlası tarafından kullanılmaktadır. ChatGPT, NLP ve NLG’den yararlanan en ünlü örneklerden biridir.

ChatGPT hakkında daha fazla bilgi edinmek ister misiniz? ChatGPT kullanarak bir uygulama nasıl oluşturulur adlı diğer makalemize göz atın.

Bilgisayarla Görme ve Görüntü Tanıma

Bilgisayar görüşü, bilgisayarlara görüntüleri ve videoları “görme” ve “anlama” yeteneği verir. (Gerçek zamanlı) segmentasyon yapmalarına, nesneleri, yüzleri ve hatta duyguları tanımalarına olanak tanır.

Bu, fotoğraf uygulamaları tarafından arkadaşlarınızı otomatik olarak etiketlemek için kullanılan teknolojidir. Ayrıca, gözetim sistemleri tarafından şüpheli davranışları tespit etmek için kullanılır.

Dolandırıcılık Tespiti

İşletmeler, işlemlerdeki veya kullanıcı davranışlarındaki şüpheli faaliyetleri tespit etmek için makine öğrenimini kullanır. Bu sistemler, eğilimleri ve anormallikleri inceleyerek potansiyel dolandırıcılık eylemlerini tespit edebilir, işletmeleri ve müşterileri dolandırıcılık ve siber suçlardan koruyabilir.

Sürücüsüz Araçlar

Otonom araç sürüşü, en karmaşık makine öğrenimi problemlerinden biridir. Bilgisayarla görme, anomali tespiti, davranış tahmini, yol planlama gibi çeşitli uygulamaları bir araya getirir.

Bu yazının yazıldığı sırada, tam otonom otomobillere henüz yaklaşmış değiliz. Mevcut “sürücüsüz” otomobiller yalnızca kısıtlı coğrafi alanlarda iyi çalışıyor.

Makine Öğrenimi Dağıtım Seçenekleri

Bir makine öğrenimi modelini dağıtmak için genellikle onu bir web uygulamasından sunarsınız. Bu nedenle, makine öğrenimi modeli dağıtım seçenekleri web uygulamalarını dağıtmakla hemen hemen aynıdır. Hadi onlara bakalım!

Şirket içi

Şirket içi dağıtım, sunucular ve depolama cihazları gibi BT ekipmanlarının bir şirketin gerçek tesislerinde barındırılmasını ve yönetilmesini gerektirir.

Bu geleneksel strateji, donanım ve yazılım için önemli bir ilk yatırım ve sürekli bakım ve destek gerektirmektedir.

Artıları arasında daha yüksek düzeyde kontrol ve güvenlik ve daha erişilebilir özelleştirme yer alır. Öte yandan, maliyet, ölçeklenebilirlik ve bakım dezavantajlarıdır.

Bulut

Buna karşılık bulut dağıtımı, altyapı ve uygulamaları internet üzerinden barındırmak için üçüncü taraf hizmetleri kullanır.

Bu model, kullanıcıların bulut hizmet sağlayıcılarının idare ettiği ölçeklenebilir kaynaklar ve hizmetler için kullandıkça ödeme yapmalarına olanak tanır.

Artıları arasında ölçeklenebilirlik, kullanım kolaylığı ve ön maliyet olmaması yer alır. Öte yandan, dezavantajları daha düşük bir kontrol seviyesi, daha az esneklik ve olası satıcı kilitlenmesidir.

Bulut tabanlı platformlara örnek olarak şunlar verilebilir:

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Microsoft Azure

Popüler Makine Öğrenimi Algoritmaları

Popüler makine öğrenimi algoritmaları şunlardır:

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

Pratik örnekte, k-En Yakın Komşuları kullanacağız.

Bir makine öğrenimi modeli nasıl dağıtılır?

Bu makale bölümünde, bir makine öğrenimi modeli oluşturacağız, FastAPI ile sunacağız, dockerize edeceğiz ve son olarak Back4app Containers‘a dağıtacağız.

Ön Koşullar

• Temel makine öğrenimi bilgisi
• Python ve FastAPI ile deneyim
• Docker ve konteynerizasyon teknolojisi hakkında temel bilgi
• Yerel makinenizde Git ve Docker Desktop yüklü

Projeye Genel Bakış

Bir makine öğrenimi modelinin nasıl dağıtılacağını göstermeden önce, bir tane oluşturacağız. Popüler Iris veri kümesini kullanarak basit bir kNN sınıflandırıcı oluşturacağız. Modelin amacı, farklı özelliklere dayanarak bir gözlemin “setosa”, “versicolour” veya “virginica” olup olmadığını tahmin etmek olacaktır.

Daha sonra modeli bir dosyaya kaydedeceğiz, FastAPI’ye yükleyeceğiz ve bir uç nokta aracılığıyla sunacağız. Bundan sonra, uygulamayı dockerize edeceğiz, GitHub’a göndereceğiz ve Back4app Containers’a dağıtacağız.

Model Oluştur

Modeli oluşturmak için Jupyter Notebooks kullanacağız. Jupyter ‘i yerel makinenize yükleyebilir ya da Google Colab ‘ı ücretsiz olarak kullanabilirsiniz.

Önce yeni bir Jupyter not defteri oluşturun.

Bu makale bölümündeki her kod bloğu bir Jupyter hücresini temsil eder. Bunları menüden veya “B” tuş bağını kullanarak (komut modundayken) oluşturabilirsiniz.

Ayrıca, bunları çalıştırmayı da unutmayın (menüden veya “ALT + ENTER” tuşlarını kullanarak).

İlk hücreye aşağıdaki içe aktarımları ekleyin:

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Veri Kümesi Yükle

Iris veri seti varsayılan olarak Scikit-learn’e dahil edilmiştir. Tek yapmanız gereken load_iris() fonksiyonunu çağırmak ve nesneyi bir kareye dönüştürmektir.

Yeni bir hücre oluşturun:

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Iris veri kümesini yüklediğinizde, hedef değişkene göre sıralanır. Bu iyi değildir çünkü makine öğrenimi modelimiz eğitim aşamasında yalnızca bazı örnek türlerini görebilir. Örneğin sadece “setosa” ve “versicolour”.

Bu sorunu önlemek için karıştırabiliriz:

df = df.sample(frac=1, random_state=42)

Random_state özniteliği tekrarlanabilirlik için kullanılır. İstediğiniz herhangi bir sayıyı kullanabilirsiniz.

Veri Setini Keşfedin

Bir model oluşturmadan önce, hangi verilerle uğraştığınızı keşfetmek iyi bir fikirdir. Bunu yapmak için head(), describe() gibi yerleşik Pandas işlevlerini kullanabilirsiniz.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

Bunun da ötesinde, hangi özelliklerin örnekleri en iyi şekilde ayırdığını ve hangi makine öğrenimi algoritmasının probleminiz için yararlı olabileceğini anlamak için veri kümesini görselleştirmelisiniz.

Yukarıdaki görsel Python ile Veri Görselleştirme Rehberi makalesinden alınmıştır. Veri görselleştirme hakkında daha fazla bilgi edinmek için mutlaka göz atın.

Görüntü, “kırmızı” noktaların diğer ikisinden doğrusal olarak ayrılabildiğini göstermektedir. Öte yandan “mavi” ve “yeşil” noktalar doğrusal olarak ayrılamaz.

Bölünmüş Veri Kümesi

Devam edelim, özellikleri (tahmin ediciler) ve hedef değişkeni tanımlayalım:

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

Ardından bunları X (özellik verileri) ve y (hedef değişken verileri) olarak ayıklayın ve test edin, eğitin:

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

Test_size=0.25 kullanıldığında, veri kümesinin %25’i test için kullanılırken %75’i eğitim için kullanılır.

Model Oluşturun

Ardından, önce verileri ölçeklendiren ve ardından kNN sınıflandırıcıyı kullanan bir işlem hattı oluşturun:

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

Ölçeklendirmenin neden gerekli olduğunu öğrenmek için bu makaleye göz atın.

Ardından 10 kat çapraz doğrulama kullanın ve doğrulama hatasını kontrol edin:

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Modeli test seti üzerinde değerlendirin:

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

Doğrulama ve test doğruluğu hemen hemen eşittir. Bu, modelimizin yetersiz veya aşırı uyum sağlamadığını gösterir.

Modeli Kaydet

Son olarak, tüm verileri kullanarak modeli yeniden eğitin ve model.pkl dosyasına kaydedin:

knn.fit(X, y)
dump(knn, "model.pkl")

Google Colab kullanıyorsanız, model.pk dosyasını indirin çünkü bir sonraki adımda buna ihtiyacımız olacak.

Hizmet Modeli

Daha önce de belirtildiği gibi, modeli sunmak için FastAPI kullanacağız.

Devam edin ve yeni bir FastAPI projesi oluşturun ve main.py dosyasını aşağıdaki gibi değiştirin:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Geliştirme sunucusunu başlatın:

$ uvicorn app.main:app --reload

http://localhost:8000/ adresine gidin ve aşağıdaki yanıtı almalısınız:

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Yük Modeli

Ardından, modeli yükleyelim ve model_classes‘ı tanımlayalım.

Önce bir önceki adımdaki model.pkl dosyasını projenizin kök dizinine kopyalayın. Ardından modeli yükleyin ve FastAPI uygulamasını başlatmanın hemen altında sınıfları aşağıdaki gibi tanımlayın:

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Hedef değişkeni sayısaldan metne çevirmek için model_classes kullanacağız.

Yük Modeli

Ardından, özellikleri alan ve bir tahmin yapmak için yüklenen modeli kullanan /predict uç noktasını oluşturun:

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

Uç nokta, sayısal tahminin yanı sıra kullanıcı dostu test tahminini de döndürür.

Dosyanın üst kısmındaki içe aktarmaları unutmayın:

from joblib import load
from pydantic import BaseModel

Son main.py dosyanız şu şekilde görünmelidir.

Geliştirme sunucusunu yeniden başlatın ve favori web tarayıcınızda http://localhost:8000/docs adresine gidin. FastAPI, tüm uç noktalarınız için otomatik olarak etkileşimli belgeler oluşturur.

Bunun gibi bir talep göndererek modeli test edin:

Harika, web uygulamamız artık tamamen çalışıyor!

Dockerize Uygulaması

Bu makale bölümünde, web uygulamasını dockerize edeceğiz. Bir Dockerfile oluşturacağız ve .dockerignore dosyasını yapılandıracağız.

Dockerfile

Dockerfile, Docker Engine’in görüntüyü oluşturmak için izleyeceği talimatları içeren bir dosyadır.

Bunlar genellikle dosya aktarımı, temel görüntünün tanımlanması, çalışma dizininin yapılandırılması, özel komutların çalıştırılması ve daha fazlasını içerir.

Dockerfile komutları genellikle büyük harflerle yazılır ve doğrudan ilgili argümanlar tarafından takip edilir.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Tüm talimatlar hakkında daha fazla bilgi edinmek için Dockerfile referansını ziyaret edin.

Proje kök dizininde bir Docker dosyası oluşturun:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

Docker ile çalışırken mümkün olduğunca küçük imajlar oluşturmak isteyeceksiniz.

Görüntü boyutunu küçültmenin bir yolu da .dockerignore dosyası kullanmaktır. Bu dosya .gitignore dosyasına benzer şekilde çalışır. İmaja dahil edilmesi gerekmeyen dosyaları çıkarmanıza olanak tanır.

Proje kök dizininde bir .dockerignore oluşturun:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

.dockerignore dosyasını projenizin gereksinimlerine göre uyarladığınızdan emin olun (örneğin, farklı bir IDE kullanıyorsanız).

Oluşturun, çalıştırın, test edin

Görüntüyü buluta göndermeden önce yerel olarak test etmek iyi bir fikirdir.

Takip etmek için makinenizde Docker Desktop kurulu olmalıdır.

Terminali açın ve şu anda yüklü olan görüntüleri kontrol edin:

$ docker images

Ardından, Docker dosyasını kullanarak görüntüyü oluşturun:

$ docker build -t iris-webapp:1.0 .

Docker’ın görüntüyü oluşturması biraz zaman alacaktır. Bunun temel nedeni Scikit-learn’in Docker konteynerleri için optimize edilmemiş olmasıdır. Hızlı bir kahve molası vermekten çekinmeyin.

Komut bittikten sonra görüntüleri tekrar kontrol edin. Yeni oluşturulan görüntü orada olmalıdır.

Son olarak, yeni bir konteyner oluşturmak için görüntüyü kullanın:

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

Bu kadar!

Web uygulamanız artık konteynerleştirilmiştir. http://localhost:8000/ adresinden erişilebilir olmalı ve daha önce olduğu gibi aynı şekilde çalışmalıdır.

GitHub’a itin

İlk olarak GitHub’a gidin ve yeni bir depo oluşturun. Daha sonraki bir adımda ihtiyacımız olacağı için uzak URL’yi not alın.

Ardından, proje kök dizininize dönün.

Kaynak kodunu buluta göndermeden önce bir .gitignore dosyası oluşturun. Bir .gitignore dosyası, hangi dosya ve dizinlerin sürüm kontrolünden çıkarılması gerektiğini belirtmenizi sağlar.

Bu dosya türü .dockerignore dosyaları ile aynı şekilde çalışır.

Proje kök dizininde bir .gitignore dosyası oluşturun:

#.dockerignore

.idea/
__pycache__/
venv/

Terminali açın ve Git’i başlatmak için aşağıdaki komutu çalıştırın:

$ git init

Tüm dosyaları VCS’ye ekleyin ve işleyin:

$ git add .
$ git commit -m "first commit"

Son olarak, daha önceki URL’yi kullanarak uzak GitHub kaynağını ekleyin ve kaynak kodunu gönderin:

$ git remote add origin <remote_url>
$ git push origin master

yerine önceki adımdaki uzak URL’nin kullanıldığından emin olun. .

İşte bu kadar. Şimdi GitHub depo sayfasını ziyaret ederseniz, tüm dosyaların eklendiğini göreceksiniz.

Uygulama Dağıtma

Back4app Containers’a bir uygulama dağıtmak için önce kayıt olmanız veya giriş yapmanız gerekir (zaten bir hesabınız varsa).

Back4app hesabınızla kimlik doğrulaması yaptığınızda, uygulama kontrol panelinize yönlendirileceksiniz. Yeni bir uygulama oluşturmak için “Yeni uygulama oluştur” seçeneğine tıklayın.

Back4app, Backend as a Service ve Containers as a Service dağıtımına izin verir. Konteynerli bir uygulama dağıttığımız için ikinci seçeneği tercih edeceğiz.

Ardından, GitHub hesabınızı Back4app’e bağlamanız gerekecek. Bu, Back4app’in depolarınızdan kaynak kodu çekmesine izin verecektir. Tüm depolara erişim izni verebilir ya da belirli depoları seçebilirsiniz.

Depolar içe aktarıldıktan sonra “Seç “e tıklayın.

Ortamın yapılandırılması, açıklayıcı bir uygulama adı sağlamak dışında gereksizdir.

Ardından “Oluştur “a tıklayın.

Back4app’in imajı oluşturması, konteyner kayıt defterine göndermesi ve bir konteyner oluşturması için birkaç dakikaya ihtiyacı olacaktır. Dağıtım tamamlandığında, uygulamanızın durumu “Hazır” olarak değişmelidir.

Uygulamanızı ziyaret etmek için aşağıdaki resimde gösterilen URL’ye tıklayın.

Harika, Back4app Containers’a bir makine öğrenimi modelini başarıyla dağıttınız. Web uygulaması yerel olarak olduğu gibi aynı şekilde çalışmalıdır. Uygulamayı bir kez daha test ettiğinizden emin olun.

Özet

Bu makalede, makine öğreniminin temellerini, uygulamalarını ve bir makine öğrenimi modelinin nasıl dağıtılacağını öğrendiniz.

Artık kendi basit modellerinizi oluşturabilmeli, bunları FastAPI ile sunabilmeli ve Back4app Konteynerlerine dağıtabilmelisiniz.

Son kaynak kodunu back4app-deploy-ml-model GitHub reposundan alın.