1. Genel Bakış
Bu laboratuvarda, özel bir container'da kod kullanarak TensorFlow modeli eğitmek ve sunmak için Vertex AI'ı kullanacaksınız.
Burada model kodu için TensorFlow kullanıyor olsak da bunu başka bir çerçeveyle kolayca değiştirebilirsiniz.
Öğrenecekleriniz
Öğrenecekleriniz:
- Vertex Workbench'te model eğitim kodu derleme ve container mimarisine alma
- Vertex AI'a özel model eğitim işi gönderme
- Eğitilen modelinizi bir uç noktaya dağıtıp bu uç noktayı kullanarak tahmin alma
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 1 ABD doları'dır.
2. Vertex AI'a giriş
Bu laboratuvarda, Google Cloud'da sunulan en yeni yapay zeka ürünü kullanılır. Vertex AI, Google Cloud'daki makine öğrenimi tekliflerini sorunsuz bir geliştirme deneyimiyle entegre eder. Önceden, AutoML ve özel modellerle eğitilen modellere ayrı hizmetler üzerinden erişilebiliyordu. Yeni teklif, diğer yeni ürünlerle birlikte her ikisini de tek bir API'de birleştirir. Dilerseniz mevcut projeleri Vertex AI'a taşıyabilirsiniz. Geri bildiriminiz varsa lütfen destek sayfasını inceleyin.
Vertex AI, uçtan uca makine öğrenimi iş akışlarını destekleyen birçok farklı ürün içerir. Bu laboratuvarda, aşağıda vurgulanan ürünlere odaklanılmaktadır: Eğitim, Tahmin ve Çalışma Alanı.
3. Ortamınızı ayarlama
Bu kod laboratuvarını çalıştırmak için faturalandırmanın etkin olduğu bir Google Cloud Platform projeniz olmalıdır. Proje oluşturmak için buradaki talimatları uygulayın.
1. Adım: Compute Engine API'yi etkinleştirin
Compute Engine'e gidin ve zaten etkinleştirilmemişse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için buna ihtiyacınız olacaktır.
2. Adım: Vertex AI API'yi etkinleştirin
Cloud Console'unuzun Vertex AI bölümüne gidin ve Vertex AI API'yi etkinleştir'i tıklayın.
3. Adım: Container Registry API'yi etkinleştirin
Container Registry'ye gidin ve halihazırda değilse Etkinleştir'i seçin. Özel eğitim işiniz için bir container oluşturmak üzere bunu kullanacaksınız.
4. Adım: Vertex AI Workbench örneği oluşturun
Cloud Console'un Vertex AI bölümünde Workbench'i tıklayın:
İlgili sayfada, Kullanıcı tarafından yönetilen Not defterleri'nde Yeni Not Defteri'ni tıklayın:
Ardından GPU'suz TensorFlow Enterprise (LTS özellikli) örnek türünün en son sürümünü seçin:
Varsayılan seçenekleri kullanın ve ardından Oluştur'u tıklayın.
Bu laboratuvarda eğitip sunacağımız model, TensorFlow belgelerindeki bu eğitim temel alınarak oluşturulmuştur. Eğitimde, bir aracın yakıt verimliliğini tahmin etmek için Kaggle'daki Auto MPG veri kümesi kullanılır.
4. Eğitim kodunu kapsayıcıya alma
Eğitim kodumuzu bir Docker container'ına yerleştirip bu container'ı Google Container Registry'ye göndererek bu eğitim işini Vertex'e göndereceğiz. Bu yaklaşımı kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebiliriz.
Başlatıcı menüsünden başlamak için not defteri örneğinizde bir Terminal penceresi açın:
mpg adında yeni bir dizin oluşturun ve cd'ye ekleyin:
mkdir mpg
cd mpg
1. Adım: Dockerfile oluşturun
Kodumuzu container mimarisine almanın ilk adımı bir Dockerfile oluşturmaktır. Dockerfile'imize, görüntümüzü çalıştırmak için gereken tüm komutları ekleriz. Kullandığımız tüm kitaplıkları yükler ve eğitim kodumuzun giriş noktasını ayarlar. Terminal'inizden boş bir Dockerfile oluşturun:
touch Dockerfile
Dockerfile'ı açın ve aşağıdakini bu dosyaya kopyalayın:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Bu Dockerfile, Deep Learning Container TensorFlow Enterprise 2.3 Docker görüntüsünü kullanır. Google Cloud'daki Deep Learning Containers, yaygın olarak kullanılan birçok makine öğrenimi ve veri bilimi çerçevesi önceden yüklenmiş olarak sunulur. Bizim kullanıyoruz. TF Enterprise 2.3, Pandas, Scikit-learn ve diğerleri. Bu görüntü indirildikten sonra bu Dockerfile, eğitim kodumuzun giriş noktasını oluşturur. Bu dosyaları henüz oluşturmadık. Bir sonraki adımda, modelimizi eğitmek ve dışa aktarmak için kodu ekleyeceğiz.
2. Adım: Cloud Storage paketi oluşturun
Eğitim işimizde, eğitilen TensorFlow modelimizi bir Cloud Storage paketine aktaracağız. Vertex, dışa aktarılan model öğelerimizi okumak ve modeli dağıtmak için bunu kullanır. Terminalinizde projeniz için bir env değişkeni tanımlamak üzere aşağıdaki komutu çalıştırın. your-cloud-project kısmına projenizin kimliğini girdiğinizden emin olun:
PROJECT_ID='your-cloud-project'
Ardından projenizde yeni bir paket oluşturmak için aşağıdaki komutu Terminal'de çalıştırın. -l (konum) işaretinin, eğiticinin ilerleyen bölümlerinde bir model uç noktası dağıttığınız bölgede olması gerektiğinden önemlidir:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
3. Adım: Model eğitim kodunu ekleyin
Terminalinizde, eğitim kodumuz için bir dizin ve kodu ekleyeceğimiz bir Python dosyası oluşturmak üzere aşağıdakileri çalıştırın:
mkdir trainer
touch trainer/train.py
Artık mpg/ dizininizde aşağıdakilerin olması gerekir:
+ Dockerfile
+ trainer/
+ train.py
Daha sonra, yeni oluşturduğunuz train.py dosyasını açın ve aşağıdaki kodu kopyalayın (bu kod, TensorFlow dokümanlarındaki eğitimden uyarlanmıştır).
Dosyanın başındaki BUCKET değişkenini, önceki adımda oluşturduğunuz depolama alanı paketinin adıyla güncelleyin:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
4. Adım: Container'ı yerel olarak derleyip test edin
Terminalinizden Google Container Registry'deki container görüntünüzün URI'siyle bir değişken tanımlayın:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Ardından, mpg dizininizin kök dizininden aşağıdaki komutu çalıştırarak container'ı oluşturun:
docker build ./ -t $IMAGE_URI
Doğru çalıştığından emin olmak için kapsayıcıyı not defteri örneğinizde çalıştırın:
docker run $IMAGE_URI
Modelin, %72 civarında doğrulama doğruluğuyla eğitimi 1-2 dakika içinde tamamlaması gerekir (tam doğruluk değişkenlik gösterebilir). Container'ı yerel olarak çalıştırmayı tamamladığınızda Google Container Registry'ye aktarın:
docker push $IMAGE_URI
Container'ımızı Container Registry'ye aktardığımıza göre artık özel model eğitim işine başlamaya hazırız.
5. Vertex AI'da eğitim işi çalıştırma
Vertex AI, eğitim modelleri için size iki seçenek sunar:
- AutoML: Yüksek kaliteli modelleri minimum düzeyde çaba ve makine öğrenimi uzmanlığı ile eğitin.
- Özel eğitim: Google Cloud'un önceden oluşturulmuş container'larından birini kullanarak özel eğitim uygulamalarınızı bulutta çalıştırın veya kendi container'larınızı kullanın.
Bu laboratuvarda, Google Container Registry'deki kendi özel container'ımız aracılığıyla özel eğitim kullanacağız. Başlamak için Cloud konsolunuzun Vertex bölümündeki Modeller bölümüne gidin:
1. Adım: Eğitim işini başlatın
Eğitim işiniz ve dağıtılan modelinizin parametrelerini girmek için Oluştur'u tıklayın:
- Veri Kümesi bölümünde, Yönetilen veri kümesi yok'u seçin.
- Ardından eğitim yönteminiz olarak Özel eğitim (gelişmiş) seçeneğini belirleyin ve Devam'ı tıklayın.
- Devam et'i tıklayın.
Sonraki adımda Model adı için mpg (veya modelinizi adlandırmak istediğiniz adı) girin. Ardından Özel kapsayıcı'yı seçin:
Kapsayıcı görüntüsü metin kutusunda Gözat'ı tıklayın ve Container Registry'ye yüklediğiniz Docker görüntüsünü bulun. Diğer alanları boş bırakıp Devam'ı tıklayın.
Bu eğitimde hiperparametre ayarını kullanmayacağız. Bu nedenle, Hiperparametre ayarını etkinleştir kutusunu işaretlenmemiş olarak bırakın ve Devam'ı tıklayın.
İşlem ve fiyatlandırma bölümünde, seçilen bölgeyi olduğu gibi bırakın ve makine türü olarak n1-standard-4'ü seçin:
Hızlandırıcı alanlarını boş bırakıp Devam'ı seçin. Bu demodaki model hızlı eğitildiği için daha küçük bir makine türü kullanıyoruz.
Tahmin container'ı adımı altında Önceden oluşturulmuş container'ı, ardından TensorFlow 2.6'yı seçin.
Önceden oluşturulmuş kapsayıcı için varsayılan ayarları olduğu gibi bırakın. Model dizini bölümünde, mpg alt diziniyle GCS paketinizi girin. Bu, model eğitimi komut dosyanızda eğitilen modelinizi dışa aktardığınız yoldur:
Vertex, modelinizi dağıtırken bu konuma bakar. Artık eğitim için hazırsınız! Eğitim işini başlatmak için Eğitimi başlat'ı tıklayın. Konsolunuzun Eğitim bölümünde aşağıdakine benzer bir şey görürsünüz:
6. Model uç noktası dağıtma
Eğitim işimizi oluştururken Vertex AI'ın dışa aktarılan model öğelerini nerede araması gerektiğini belirttik. Eğitim ardışık düzenimizin bir parçası olarak Vertex, bu öğe yoluna dayalı bir model kaynağı oluşturacaktır. Model kaynağı, dağıtılan bir model değildir. Ancak modeliniz olduğunda, bu modeli uç noktaya dağıtmaya hazırsınız demektir. Vertex AI'daki modeller ve uç noktalar hakkında daha fazla bilgi edinmek için belgeleri inceleyin.
Bu adımda, eğitilen modelimiz için bir uç nokta oluşturacağız. Bunu kullanarak Vertex AI API üzerinden modelimizle ilgili tahminler alabiliriz.
1. Adım: Uç noktayı dağıtın
Eğitim işiniz tamamlandığında, konsolunuzun Modeller bölümünde mpg (veya adlandırdığınız başka bir ad) adlı bir model görürsünüz:
Eğitim işiniz çalıştığında Vertex, sizin için bir model kaynağı oluşturdu. Bu modeli kullanmak için bir uç nokta dağıtmanız gerekir. Model başına çok sayıda uç noktanız olabilir. Modeli ve ardından Uç noktaya dağıt'ı tıklayın.
Yeni uç nokta oluştur'u seçin ve v1 gibi bir ad verin. Erişim için Standart'ı seçili bırakın ve Devam'ı tıklayın.
Trafik bölme'yi 100 olarak bırakın ve Minimum işlem düğümü sayısı için 1 girin. Makine türü bölümünde n1-standard-2'yi (veya istediğiniz herhangi bir makine türünü) seçin. Diğer varsayılan değerleri seçili bırakın ve Devam'ı tıklayın. Bu model için izleme etkinleştirilmeyecek. Bu nedenle, uç nokta dağıtımını başlatmak için bir sonraki Dağıt'ı tıklayın.
Uç noktanın dağıtılması 10-15 dakika sürer ve dağıtım tamamlandığında bir e-posta alırsınız. Uç nokta dağıtımı tamamlandığında Model kaynağınız altında dağıtılan bir uç noktanın gösterildiği aşağıdaki ekranı görürsünüz:
2. adım: Dağıtılan model üzerinde tahmin alın
Vertex Python API'yi kullanarak bir Python not defterinden eğitilmiş modelimiz hakkında tahminler alırız. Not defteri örneğinize geri dönün ve Başlatıcı'dan bir Python 3 not defteri oluşturun:
Not defterinizdeki bir hücrede aşağıdaki komutu çalıştırarak Vertex AI SDK'yı yükleyin:
!pip3 install google-cloud-aiplatform --upgrade --user
Ardından, SDK'yı içe aktarmak ve az önce dağıttığınız uç noktaya bir referans oluşturmak için not defterinize bir hücre ekleyin:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Yukarıdaki endpoint_name dizesinde bulunan iki değeri proje numaranız ve uç noktanızla değiştirmeniz gerekir. Proje numaranızı proje kontrol panelinize gidip Proje Numarası değerini alarak bulabilirsiniz.
Uç nokta kimliğinizi, konsolun uç noktalar bölümünde bulabilirsiniz:
Son olarak, aşağıdaki kodu kopyalayıp yeni bir hücreye çalıştırarak uç noktanız için bir tahminde bulunun:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Bu örnekte, modelimizin beklediği biçim olan normalleştirilmiş değerler zaten mevcuttur.
Bu hücreyi çalıştırdığınızda, yaklaşık 16 mil/galon değerinde bir tahmin çıktısı görürsünüz.
🎉 Tebrikler. 🎉
Vertex AI'ı kullanarak şunları öğrendiniz:
- Eğitim kodunu özel bir container'da sağlayarak bir modeli eğitin. Bu örnekte bir TensorFlow modeli kullanmıştınız ancak özel container'lar kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilirsiniz.
- Eğitim için kullandığınız iş akışının parçası olarak, önceden oluşturulmuş bir container kullanarak bir TensorFlow modeli dağıtın.
- Bir model uç noktası ve tahmin oluşturun.
Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için dokümanlara göz atın.
7. Temizleme
Bu laboratuvarda oluşturduğunuz not defterini kullanmaya devam etmek istiyorsanız, kullanmadığınız not defterini kapatmanız önerilir. Cloud Console'unuzdaki Workbench kullanıcı arayüzünde not defterini, ardından Durdur'u seçin.
Not defterini tamamen silmek isterseniz sağ üstteki Sil düğmesini tıklayın.
Dağıttığınız uç noktayı silmek için Vertex AI konsolunuzun Uç Noktalar bölümüne gidin, oluşturduğunuz uç noktayı tıklayın ve Modeli uç noktadan dağıtmayı kaldır'ı seçin:
Storage Paketini silmek için Cloud Console'unuzdaki gezinme menüsünü kullanarak Storage'a gidin, paketinizi seçin ve Sil'i tıklayın:
