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ıyoruz ancak bunu kolayca başka bir çerçeveyle değiştirebilirsiniz.
Öğrenecekleriniz
Öğrenecekleriniz:
- Vertex Workbench'te model eğitim kodu oluşturma ve kapsayıcıya yerleştirme
- Vertex AI'a özel model eğitimi işi gönderme
- Eğitilen modelinizi bir uç noktaya dağıtın ve tahmin almak için bu uç noktasını kullanın
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. Daha önce, AutoML ile eğitilen modellere ve özel modellere ayrı hizmetler üzerinden erişilebiliyordu. Yeni teklif, diğer yeni ürünlerle birlikte her ikisini de tek bir API'de birleştirir. Mevcut projeleri Vertex AI'a da 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 (Eğitim, Tahmin ve Workbench) odaklanacağız.
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'a gidin ve etkin değilse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için bu anahtara ihtiyacınız vardı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
Kapsayıcı Kaydı'na gidin ve henüz etkinleştirilmediyse Etkinleştir'i seçin. Özel eğitim işiniz için bir kapsayıcı oluşturmak üzere bu dosyayı kullanırsınız.
4. Adım: Vertex AI Workbench örneği oluşturun
Cloud Console'unuzun Vertex AI bölümünden Workbench'i tıklayın:
Buradan Kullanıcı tarafından yönetilen not defterleri bölümünde Yeni Not Defteri'ni tıklayın:
Ardından, TensorFlow Enterprise (LTS özellikli) örnek türünün GPU'suz en son sürümünü seçin:
Varsayılan seçenekleri kullanın ve Oluştur'u tıklayın.
Bu laboratuvarda eğiteceğimiz ve sunacağımız model, TensorFlow dokümanlarındaki 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şlamak için Başlatıcı menüsünden 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 kapsayıcıya dönüştürmedeki ilk adımımız bir Dockerfile oluşturmaktır. Dockerfile'ımızda görüntümüzü çalıştırmak için gereken tüm komutları ekleyeceğiz. Kullandığımız tüm kitaplıkları yükler ve eğitim kodumuzun giriş noktasını ayarlar. Terminalinizde boş bir Dockerfile oluşturun:
touch Dockerfile
Dockerfile dosyasını açın ve aşağıdakileri 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. Kullandığımız sürümde TF Enterprise 2.3, Pandas, Scikit-learn ve diğerleri yer alıyor. Bu Dockerfile, görüntüyü indirdikten sonra eğitim kodumuz için giriş noktasını ayarlar. Bu dosyaları henüz oluşturmadık. Bir sonraki adımda, modelimizi eğitme ve dışa aktarma kodunu 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. Projeniz için bir env değişkeni tanımlamak üzere Terminal'inizde aşağıdaki komutu çalıştırın. your-cloud-project yerine projenizin kimliğini yazın:
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şareti, eğitimde daha sonra 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
mpg/ dizininizde şu dosyalar bulunmalıdır:
+ 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
Terminalinizde, Google Container Registry'deki container görüntünüzün URI'sini içeren 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
Model, eğitimi yaklaşık %72 doğrulukla 1-2 dakikada tamamlar (tam doğruluk değişebilir). 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şi başlatmaya hazırız.
5. Vertex AI'da eğitim işi çalıştırma
Vertex AI, model eğitimi için size iki seçenek sunar:
- AutoML: Minimum düzeyde çaba ve makine öğrenimi uzmanlığıyla yüksek kaliteli modeller 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 Console'unuzun Vertex bölümündeki Modeller bölümüne gidin:
1. Adım: Eğitim işini başlatın
Eğitim işinizin 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ş)'i seçin ve Devam'ı tıklayın.
- Devam et'i tıklayın.
Sonraki adımda, Model adı için mpg (veya modelinize vermek 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ıp 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ın ve Devam'ı seçin. Bu demodaki model hızlı bir şekilde eğitildiğinden daha küçük bir makine türü kullanıyoruz.
Tahmin kapsayıcısı adımında Önceden oluşturulmuş kapsayıcı'yı ve 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ğitim komut dosyanızda eğitilen modelinizi dışa aktardığınız yoldur:
Vertex, modelinizi dağıtırken bu konuma bakar. Artık eğitime 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 mesaj 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. Vertex, eğitim ardışık düzenimizin bir parçası olarak bu öğe yoluna dayalı bir model kaynağı oluşturur. Model kaynağı dağıtılmış bir model değildir ancak bir modeliniz olduğunda bunu bir uç noktaya dağıtmaya hazırsınız demektir. Vertex AI'daki modeller ve uç noktalar hakkında daha fazla bilgi edinmek için belgelere göz atın.
Bu adımda, eğitilmiş modelimiz için bir uç nokta oluşturacağız. Bu modeli, Vertex AI API aracılığıyla modelimizle ilgili tahminler almak için kullanabiliriz.
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ırıldığı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 birçok 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 olarak bırakın ve Devam'ı tıklayın.
Trafik yükü'nü 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. Varsayılan ayarların geri kalanını seçili bırakın ve Devam'ı tıklayın. Bu model için izlemeyi etkinleştirmeyeceğiz. Ardından, uç nokta dağıtımını başlatmak için Dağıt'ı tıklayın.
Bitiş noktasının dağıtılması 10-15 dakika sürer. 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 modelde tahminler alın
Vertex Python API'yi kullanarak bir Python not defterinden eğitilmiş modelimiz hakkında tahminler alırız. Not defteri örneğinize dönün ve Başlatıcı'dan bir Python 3 not defteri oluşturun:
Vertex AI SDK'sını yüklemek için not defterinizde bir hücrede aşağıdakileri çalıştırın:
!pip3 install google-cloud-aiplatform --upgrade --user
Ardından, SDK'yı içe aktarmak ve yeni dağıttığınız uç noktaya 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 dizesindeki 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 yeni bir hücreye kopyalayıp çalıştırarak uç noktanız için 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. 🎉
Aşağıdakiler için Vertex AI'ı nasıl kullanacağınızı öğrendiniz:
- Eğitim kodunu özel bir container'da sağlayarak bir modeli eğitin. Bu örnekte bir TensorFlow modeli kullandık ancak özel kapsayıcılar kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilirsiniz.
- Eğitim için kullandığınız iş akışının bir parçası olarak önceden oluşturulmuş bir kapsayıcı kullanarak TensorFlow modeli dağıtın.
- Model uç noktası oluşturun ve tahmin oluşturun.
Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için belgelere göz atın.
7. Temizleme
Bu laboratuvarda oluşturduğunuz not defterini kullanmaya devam etmek istiyorsanız kullanmadığınızda kapatmanız önerilir. Cloud Console'unuzdaki Workbench kullanıcı arayüzünde not defterini, ardından Durdur'u seçin.
Not defterini tamamen silmek istiyorsanız 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 ardından Modeli uç noktadan kaldır'ı seçin:
Depolama paketini silmek için Cloud Console'daki Gezinme menüsünü kullanarak Depolama'ya gidin, paketinizi seçin ve Sil'i tıklayın:
