16 KiB

Raw Permalink Blame History Unescape Escape

Bir ML Modelini Kullanmak için Web Uygulaması Oluşturun

Bu derste, son yüzyıldaki UFO gözlemleri gibi dünyadışı bir veri seti üzerinde bir ML modeli eğiteceksiniz. Bu veriler NUFORC'un veritabanından alınmıştır.

Öğreneceğiniz konular:

Eğitilmiş bir modeli nasıl 'pickle' yapacağınız
Bu modeli bir Flask uygulamasında nasıl kullanacağınız

Verileri temizlemek ve modelimizi eğitmek için defterleri kullanmaya devam edeceğiz, ancak süreci bir adım öteye taşıyarak, modelinizi bir web uygulamasında kullanmayı keşfedebilirsiniz.

Bunu yapmak için Flask kullanarak bir web uygulaması oluşturmanız gerekecek.

Ders Öncesi Testi

Bir Uygulama Oluşturmak

Makine öğrenimi modellerini tüketen web uygulamaları oluşturmanın birkaç yolu vardır. Web mimariniz, modelinizin nasıl eğitildiğini etkileyebilir. Bir işletmede çalıştığınızı ve veri bilimi grubunun bir model eğittiğini ve bu modeli bir uygulamada kullanmanızı istediğini hayal edin.

Dikkat Edilmesi Gerekenler

Sormanız gereken birçok soru var:

Bu bir web uygulaması mı yoksa mobil uygulama mı? Bir mobil uygulama oluşturuyorsanız veya modeli bir IoT bağlamında kullanmanız gerekiyorsa, TensorFlow Lite kullanarak modeli bir Android veya iOS uygulamasında kullanabilirsiniz.
Model nerede bulunacak? Bulutta mı yoksa yerel olarak mı?
Çevrimdışı destek. Uygulamanın çevrimdışı çalışması gerekiyor mu?
Modeli eğitmek için hangi teknoloji kullanıldı? Seçilen teknoloji, kullanmanız gereken araçları etkileyebilir.
- TensorFlow Kullanmak. Örneğin, TensorFlow kullanarak bir model eğitiyorsanız, bu ekosistem, TensorFlow.js kullanarak bir web uygulamasında kullanmak üzere bir TensorFlow modelini dönüştürme yeteneği sağlar.
- PyTorch Kullanmak. PyTorch gibi bir kütüphane kullanarak bir model oluşturuyorsanız, modeli JavaScript web uygulamalarında kullanmak üzere Onnx Runtime kullanarak ONNX (Open Neural Network Exchange) formatında dışa aktarma seçeneğiniz vardır. Bu seçenek, gelecekteki bir derste Scikit-learn ile eğitilmiş bir model için incelenecektir.
- Lobe.ai veya Azure Custom Vision Kullanmak. Lobe.ai veya Azure Custom Vision gibi bir ML SaaS (Hizmet Olarak Yazılım) sistemi kullanarak bir model eğitiyorsanız, bu tür yazılımlar, modeli birçok platform için dışa aktarma yolları sağlar, bu da çevrimiçi uygulamanız tarafından bulutta sorgulanacak özel bir API oluşturmayı içerir.

Ayrıca, modelin kendisini bir web tarayıcısında eğitebilecek bir Flask web uygulaması oluşturma fırsatınız da var. Bu, bir JavaScript bağlamında TensorFlow.js kullanılarak da yapılabilir.

Bizim amacımız için, Python tabanlı defterlerle çalıştığımızdan, eğitilmiş bir modeli bu tür bir defterden Python ile oluşturulmuş bir web uygulaması tarafından okunabilir bir formata nasıl dışa aktaracağınızı inceleyelim.

Araç

Bu görev için iki araca ihtiyacınız var: Flask ve Pickle, her ikisi de Python üzerinde çalışır.

✅ Flask nedir? Yaratıcıları tarafından bir 'mikro-çerçeve' olarak tanımlanan Flask, Python kullanarak web çerçevelerinin temel özelliklerini ve web sayfaları oluşturmak için bir şablon motoru sağlar. Flask ile inşa etmeyi pratik yapmak için bu Öğrenme modülüne göz atın.

✅ Pickle nedir? Pickle 🥒, bir Python nesne yapısını serileştiren ve serileştiren bir Python modülüdür. Bir modeli 'pickle' yaptığınızda, yapısını webde kullanmak üzere serileştirir veya düzleştirirsiniz. Dikkatli olun: pickle doğası gereği güvenli değildir, bu yüzden bir dosyayı 'un-pickle' yapmanız istendiğinde dikkatli olun. Bir pickled dosyası .pkl uzantısına sahiptir.

Alıştırma - verilerinizi temizleyin

Bu derste, NUFORC (Ulusal UFO Raporlama Merkezi) tarafından toplanan 80.000 UFO gözleminden veri kullanacaksınız. Bu veriler, UFO gözlemlerine dair ilginç açıklamalar içerir, örneğin:

Uzun örnek açıklama. "Bir adam geceleyin çimenli bir alana parlayan bir ışık huzmesinden çıkar ve Texas Instruments otoparkına doğru koşar".
Kısa örnek açıklama. "ışıklar bizi kovaladı".

ufos.csv elektronik tablosu, gözlemin city, state ve country nerede gerçekleştiği, nesnenin shape ve latitude ve longitude ile ilgili sütunları içerir.

Bu derste yer alan boş notebook dosyasında:

Önceki derslerde yaptığınız gibi pandas, matplotlib ve numpy içe aktarın ve ufos elektronik tablosunu içe aktarın. Örnek bir veri setine göz atabilirsiniz:
```
import pandas as pd
import numpy as np

ufos = pd.read_csv('./data/ufos.csv')
ufos.head()
```

Ufolar verilerini yeni başlıklarla küçük bir dataframe'e dönüştürün. Country alanındaki benzersiz değerleri kontrol edin.

ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})

ufos.Country.unique()

Şimdi, ele almamız gereken veri miktarını azaltmak için herhangi bir boş değeri atabilir ve sadece 1-60 saniye arasındaki gözlemleri içe aktarabilirsiniz:
```
ufos.dropna(inplace=True)

ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]

ufos.info()
```

Metin değerlerini ülkelere dönüştürmek için Scikit-learn'ün LabelEncoder kütüphanesini içe aktarın:

✅ LabelEncoder verileri alfabetik olarak kodlar

from sklearn.preprocessing import LabelEncoder

ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])

ufos.head()

Verileriniz şu şekilde görünmelidir:

	Seconds	Country	Latitude	Longitude
2	20.0	3		53.200000	-2.916667
3	20.0	4		28.978333	-96.645833
14	30.0	4		35.823889	-80.253611
23	60.0	4		45.582778	-122.352222
24	3.0		3		51.783333	-0.783333

Alıştırma - modelinizi oluşturun

Şimdi verileri eğitim ve test gruplarına ayırarak bir model eğitmeye hazır olabilirsiniz.

Eğitmek istediğiniz üç özelliği X vektörü olarak seçin ve y vektörü Country. You want to be able to input Seconds, Latitude and Longitude olacak ve bir ülke kimliği döndürecek.

from sklearn.model_selection import train_test_split

Selected_features = ['Seconds','Latitude','Longitude']

X = ufos[Selected_features]
y = ufos['Country']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Modelinizi lojistik regresyon kullanarak eğitin:

from sklearn.metrics import accuracy_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('Accuracy: ', accuracy_score(y_test, predictions))

Doğruluk fena değil (yaklaşık %95), şaşırtıcı değil, çünkü Country and Latitude/Longitude correlate.

The model you created isn't very revolutionary as you should be able to infer a Country from its Latitude and Longitude, ancak ham verilerden temizlediğiniz, dışa aktardığınız ve ardından bu modeli bir web uygulamasında kullandığınız bir modeli eğitmeye çalışmak iyi bir egzersizdir.

Alıştırma - modelinizi 'pickle' yapın

Şimdi, modelinizi pickle yapma zamanı! Bunu birkaç satır kodla yapabilirsiniz. Bir kez pickled olduktan sonra, pickled modelinizi yükleyin ve saniye, enlem ve boylam değerlerini içeren bir örnek veri dizisine karşı test edin,

import pickle
model_filename = 'ufo-model.pkl'
pickle.dump(model, open(model_filename,'wb'))

model = pickle.load(open('ufo-model.pkl','rb'))
print(model.predict([[50,44,-12]]))

Model '3' değerini döndürüyor, bu da Birleşik Krallık için ülke kodu. Harika! 👽

Alıştırma - bir Flask uygulaması oluşturun

Şimdi modelinizi çağıracak ve benzer sonuçlar döndürecek, ancak daha görsel olarak hoş bir şekilde, bir Flask uygulaması oluşturabilirsiniz.

notebook.ipynb dosyasının yanında web-app adlı bir klasör oluşturun ve ufo-model.pkl dosyanızın bulunduğu yer.
Bu klasörde üç klasör daha oluşturun: static, içinde bir css klasörü bulunan ve templates. Şimdi aşağıdaki dosya ve dizinlere sahip olmalısınız:
```
web-app/
  static/
    css/
  templates/
notebook.ipynb
ufo-model.pkl
```
✅ Bitmiş uygulamanın bir görünümünü görmek için çözüm klasörüne başvurun
web-app klasöründe oluşturulacak ilk dosya requirements.txt dosyasıdır. Bir JavaScript uygulamasındaki package.json gibi, bu dosya uygulama tarafından gerekli bağımlılıkları listeler. requirements.txt dosyasına şu satırları ekleyin:
```
scikit-learn
pandas
numpy
flask
```
Şimdi, web-app klasörüne giderek bu dosyayı çalıştırın:
```
cd web-app
```
Terminalinizde pip install yazarak requirements.txt dosyasında listelenen kütüphaneleri yükleyin:
```
pip install -r requirements.txt
```
Şimdi, uygulamayı bitirmek için üç dosya daha oluşturmaya hazırsınız:
1. Kök dizinde app.py oluşturun.
2. templates dizininde index.html oluşturun.
3. static/css dizininde styles.css oluşturun.

styles.css dosyasını birkaç stil ile oluşturun:

body {
	width: 100%;
	height: 100%;
	font-family: 'Helvetica';
	background: black;
	color: #fff;
	text-align: center;
	letter-spacing: 1.4px;
	font-size: 30px;
}

input {
	min-width: 150px;
}

.grid {
	width: 300px;
	border: 1px solid #2d2d2d;
	display: grid;
	justify-content: center;
	margin: 20px auto;
}

.box {
	color: #fff;
	background: #2d2d2d;
	padding: 12px;
	display: inline-block;
}

Ardından, index.html dosyasını oluşturun:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>🛸 UFO Appearance Prediction! 👽</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
  </head>

  <body>
    <div class="grid">

      <div class="box">

        <p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>

        <form action="{{ url_for('predict')}}" method="post">
          <input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
          <input type="text" name="latitude" placeholder="Latitude" required="required" />
          <input type="text" name="longitude" placeholder="Longitude" required="required" />
          <button type="submit" class="btn">Predict country where the UFO is seen</button>
        </form>

        <p>{{ prediction_text }}</p>

      </div>

    </div>

  </body>
</html>

Bu dosyadaki şablonlamaya bir göz atın. Uygulama tarafından sağlanacak değişkenler etrafındaki 'bıyık' sözdizimine dikkat edin, örneğin tahmin metni: {{}}. There's also a form that posts a prediction to the /predict route.

Finally, you're ready to build the python file that drives the consumption of the model and the display of predictions:

In app.py ekleyin:

import numpy as np
from flask import Flask, request, render_template
import pickle

app = Flask(__name__)

model = pickle.load(open("./ufo-model.pkl", "rb"))


@app.route("/")
def home():
    return render_template("index.html")


@app.route("/predict", methods=["POST"])
def predict():

    int_features = [int(x) for x in request.form.values()]
    final_features = [np.array(int_features)]
    prediction = model.predict(final_features)

    output = prediction[0]

    countries = ["Australia", "Canada", "Germany", "UK", "US"]

    return render_template(
        "index.html", prediction_text="Likely country: {}".format(countries[output])
    )


if __name__ == "__main__":
    app.run(debug=True)

💡 İpucu: debug=True while running the web app using Flask, any changes you make to your application will be reflected immediately without the need to restart the server. Beware! Don't enable this mode in a production app.

If you run python app.py or python3 app.py - your web server starts up, locally, and you can fill out a short form to get an answer to your burning question about where UFOs have been sighted!

Before doing that, take a look at the parts of app.py:

First, dependencies are loaded and the app starts.
Then, the model is imported.
Then, index.html is rendered on the home route.

On the /predict route, several things happen when the form is posted:

The form variables are gathered and converted to a numpy array. They are then sent to the model and a prediction is returned.
The Countries that we want displayed are re-rendered as readable text from their predicted country code, and that value is sent back to index.html to be rendered in the template.

Using a model this way, with Flask and a pickled model, is relatively straightforward. The hardest thing is to understand what shape the data is that must be sent to the model to get a prediction. That all depends on how the model was trained. This one has three data points to be input in order to get a prediction.

In a professional setting, you can see how good communication is necessary between the folks who train the model and those who consume it in a web or mobile app. In our case, it's only one person, you!

🚀 Challenge

Instead of working in a notebook and importing the model to the Flask app, you could train the model right within the Flask app! Try converting your Python code in the notebook, perhaps after your data is cleaned, to train the model from within the app on a route called train. Bu yöntemi takip etmenin artıları ve eksileri nelerdir?

Ders Sonrası Testi

Gözden Geçirme ve Kendi Kendine Çalışma

ML modellerini tüketen bir web uygulaması oluşturmanın birçok yolu vardır. Makine öğrenimini kullanmak için JavaScript veya Python kullanarak bir web uygulaması oluşturmanın yollarını listeleyin. Mimariyi göz önünde bulundurun: model uygulamada mı kalmalı yoksa bulutta mı yaşamalı? Eğer ikinci seçenekse, ona nasıl erişirsiniz? Uygulamalı bir ML web çözümü için bir mimari model çizin.

Ödev

Farklı bir model deneyin

Feragatname: Bu belge, makine tabanlı AI çeviri hizmetleri kullanılarak çevrilmiştir. Doğruluğu sağlamak için çaba göstersek de, otomatik çevirilerin hata veya yanlışlıklar içerebileceğini lütfen unutmayın. Orijinal belgenin kendi dilindeki hali yetkili kaynak olarak kabul edilmelidir. Kritik bilgiler için profesyonel insan çevirisi tavsiye edilir. Bu çevirinin kullanımından kaynaklanan herhangi bir yanlış anlama veya yanlış yorumlamadan sorumlu değiliz.

16 KiB Raw Permalink Blame History Unescape Escape