1. Genel Bakış
Bu laboratuvarda, Google Cloud'un kısa süre önce duyurulan yönetilen makine öğrenimi platformu Vertex AI'ı kullanarak uçtan uca makine öğrenimi iş akışları oluşturma hakkında bilgi edineceksiniz. Ham verilerden dağıtılan modele nasıl geçeceğinizi öğrenecek ve bu atölyede, Vertex AI ile kendi makine öğrenimi projelerinizi geliştirip üretim sürecine hazır hale geleceksiniz. Bu laboratuvarda, Vertex AI ile eğitime yönelik özel container'ları göstermek amacıyla özel bir Docker görüntüsü oluşturmak için Cloud Shell'i kullanacağız.
Burada model kodu için TensorFlow kullanıyor olsak da bunu başka bir çerçeveyle kolayca değiştirebilirsiniz.
Öğrenecekleriniz
Öğrenecekleriniz:
- Cloud Shell'i kullanarak model eğitim kodunu 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 2 ABD dolarıdır.
2. Vertex AI'a giriş
Bu laboratuvarda, Google Cloud'daki en yeni AI ürün teklifi kullanılmaktadı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, her ikisi de tek bir API'de ve diğer yeni ürünlerle birleştirilir. Dilerseniz mevcut projeleri Vertex AI'a taşıyabilirsiniz. Geri bildiriminiz varsa lütfen destek sayfasını inceleyin.
Aşağıdaki şemadan görebileceğiniz gibi Vertex, makine öğrenimi iş akışının her aşamasında size yardımcı olacak birçok farklı araç içerir. Aşağıda vurgulanan Vertex Eğitimi ve Tahmin özelliklerini kullanmaya odaklanacağız.
3. Ortamınızı ayarlama
Kendi hızınızda ortam kurulumu
Cloud Console'da oturum açıp yeni bir proje oluşturun veya mevcut bir projeyi yeniden kullanın. (Gmail veya Google Workspace hesabınız yoksa hesap oluşturmanız gerekir.)
Tüm Google Cloud projelerinde benzersiz bir ad olan proje kimliğini unutmayın (yukarıdaki ad zaten alınmış ve size uygun olmayacaktır!).
Sonraki adımda, Google Cloud kaynaklarını kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir.
Bu codelab'i çalıştırmanın maliyeti, yüksek değildir. "Temizleme" bölümündeki talimatları izlediğinizden emin olun. bölümünde, bu eğiticinin dışında faturalandırmayla karşılaşmamanız için kaynakları nasıl kapatacağınız konusunda tavsiyelerde bulunuyoruz. Yeni Google Cloud kullanıcıları, 300 ABD doları değerindeki ücretsiz denemeden yararlanabilir.
1. adım: Cloud Shell'i başlatın
Bu laboratuvarda, Google'ın bulutunda çalışan bir sanal makine tarafından barındırılan bir komut çevirmeni olan Cloud Shell oturumunda çalışacaksınız. Bu bölümü yerel olarak kendi bilgisayarınızda da yerel olarak çalıştırabilirsiniz. Ancak Cloud Shell kullanarak herkes tutarlı bir ortamda tekrarlanabilir bir deneyime erişebilir. Laboratuvardan sonra bu bölümü bilgisayarınızda yeniden deneyebilirsiniz.
Cloud Shell'i etkinleştirme
Cloud Console'un sağ üst köşesinden aşağıdaki düğmeyi tıklayarak Cloud Shell'i etkinleştirin:
Cloud Shell'i daha önce hiç başlatmadıysanız ne olduğunu açıklayan bir ara ekran (ekranın alt kısmında) gösterilir. Bu durumda Devam'ı tıklayın (bunu bir daha görmezsiniz). Tek seferlik ekran şöyle görünür:
Temel hazırlık ve Cloud Shell'e bağlanmak yalnızca birkaç dakika sürer.
İhtiyaç duyduğunuz tüm geliştirme araçları bu sanal makinede yüklüdür. 5 GB boyutunda kalıcı bir ana dizin sunar ve Google Cloud'da çalışarak ağ performansını ve kimlik doğrulamasını büyük ölçüde iyileştirir. Bu codelab'deki çalışmalarınızın tamamı olmasa bile büyük bir kısmı yalnızca bir tarayıcı veya Chromebook'unuzla yapılabilir.
Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin proje kimliğinize ayarlandığını görürsünüz.
Kimlik doğrulamanızın tamamlandığını onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud auth list
Komut çıkışı
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
gcloud komutunun projenizi bildiğini onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud config list project
Komut çıkışı
[core] project = <PROJECT_ID>
Doğru değilse aşağıdaki komutla ayarlayabilirsiniz:
gcloud config set project <PROJECT_ID>
Komut çıkışı
Updated property [core/project].
Cloud Shell'de birkaç ortam değişkeni bulunur. Bunların arasında mevcut Cloud projemizin adını içeren GOOGLE_CLOUD_PROJECT yer alır. Bu adı, bu laboratuvar boyunca çeşitli yerlerde kullanacağız. Bu klasörü şu komutu çalıştırarak görebilirsiniz:
echo $GOOGLE_CLOUD_PROJECT
2. Adım: API'leri etkinleştirme
Sonraki adımlarda bu hizmetlerin nerede, neden gerekli olduğunu göreceksiniz. Şimdilik projenizin Compute Engine, Container Registry ve Vertex AI hizmetlerine erişmesine izin vermek için şimdilik şu komutu çalıştırın:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Bu işlem, aşağıdakine benzer başarılı bir mesaj üretir:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3. Adım: Cloud Storage Paketi oluşturun
Vertex AI'da eğitim işi çalıştırmak için kayıtlı model öğelerimizi depolayacak bir depolama paketine ihtiyacımız vardır. Paket oluşturmak için Cloud Shell terminalinizde aşağıdaki komutları çalıştırın:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
4. Adım: Takma Ad Python 3
Bu laboratuvardaki kod Python 3 kullanır. Bu laboratuvarda oluşturacağınız komut dosyalarını çalıştırırken Python 3 kullandığınızdan emin olmak için Cloud Shell'de aşağıdaki komutu çalıştırarak bir takma ad oluşturun:
alias python=python3
Bu laboratuvarda eğitip sunacağımız model, TensorFlow belgelerindeki bu eğitim temel alınarak oluşturulmuştur. Eğitim, bir aracın yakıt verimliliğini tahmin etmek için Kaggle'ın Auto MPG veri kümesini kullanır.
4. Eğitim kodunu container mimarisine alın
Eğitim kodumuzu bir Docker kapsayıcısına yerleştirip bu container'ı Google Container Registry'ye aktararak bu eğitim işini Vertex'e göndereceğiz. Bu yaklaşımı kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebiliriz.
1. Adım: Dosyaları oluşturun
Öncelikle Cloud Shell'deki terminalde, Docker container'ımız için gereken dosyaları oluşturmak üzere aşağıdaki komutları çalıştırın:
mkdir mpg
cd mpg
touch Dockerfile
mkdir trainer
touch trainer/train.py
Artık aşağıdakine benzer bir mpg/ dizininizin olması gerekir:
+ Dockerfile
+ trainer/
+ train.py
Bu dosyaları görüntülemek ve düzenlemek için Cloud Shell'in yerleşik kod düzenleyicisini kullanacağız. Cloud Shell'de sağ üstteki menü çubuğunda yer alan düğmeyi tıklayarak düzenleyici ile terminal arasında geçiş yapabilirsiniz:
2. Adım: Dockerfile oluşturun
Kodumuzu container mimarisine almak için önce bir Dockerfile oluşturacağız. Dockerfile'ımıza 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.
Cloud Shell dosya düzenleyicisinde mpg/ dizininizi açın, ardından çift tıklayarak Dockerfile'ı açın:
Ardından, aşağıdakini bu dosyaya kopyalayın:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-3
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. Görüntüyü indirdikten sonra bu Dockerfile, eğitim kodumuzun giriş noktasını oluşturur. Bu kodu bir sonraki adımda ekleyeceğiz.
3. Adım: Model eğitim kodunu ekleyin
Ardından, Cloud Shell düzenleyicisinden train.py dosyasını açın ve aşağıdaki kodu kopyalayın (bu kod, TensorFlow belgelerindeki eğitimden uyarlanmıştır).
# This will be replaced with your bucket name after running the `sed` command in the tutorial
BUCKET = "BUCKET_NAME"
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.
"""
"""Import it using pandas"""
dataset_path = "https://storage.googleapis.com/io-vertex-codelab/auto-mpg.csv"
dataset = pd.read_csv(dataset_path, na_values = "?")
dataset.tail()
"""### 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')
Yukarıdaki kodu mpg/trainer/train.py dosyasına kopyaladıktan sonra Cloud Shell'inizde Terminal'e dönün ve aşağıdaki komutu çalıştırarak dosyaya kendi paketinizin adını ekleyin:
sed -i "s|BUCKET_NAME|$BUCKET_NAME|g" trainer/train.py
4. Adım: Container'ı yerel olarak derleyip test edin
Google Container Registry'deki container görüntünüzün URI'si ile bir değişken tanımlamak için Terminal'inizden aşağıdaki komutu çalıştırın:
IMAGE_URI="gcr.io/$GOOGLE_CLOUD_PROJECT/mpg:v1"
Ardından, mpg dizininizin kök dizininden aşağıdaki komutu çalıştırarak container'ı oluşturun:
docker build ./ -t $IMAGE_URI
Container'ı oluşturduğunuzda Google Container Registry'ye aktarın:
docker push $IMAGE_URI
Görüntünüzün Container Registry'ye aktarıldığını doğrulamak için konsolunuzun Container Registry bölümüne gittiğinizde aşağıdakine benzer bir durumla karşılaşırsınız:
Container'ımız Container Registry'ye aktarıldığında artık özel bir model eğitimi işi başlatmaya hazırız.
5. Vertex AI'da eğitim işi çalıştırma
Vertex, 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 Eğitim 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.
- Model adı için
mpgdeğerini (veya modelinizi adlandırmak istediğiniz adı) girin - Devam et'i tıklayın.
Kapsayıcı ayarları adımında Özel kapsayıcı'yı seçin:
İlk kutuda (Kapsayıcı görüntüsü) Göz at'ı tıklayın ve az önce Container Registry'ye aktardığınız kapsayıcıyı bulun. Şuna benzer bir görünümde olacaktır:
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ünüz olarak n1-standard-4'ü 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 Tahmin kapsayıcısı yok'u seçin:
6. Model uç noktası dağıtma
Bu adımda, eğitilen modelimiz için bir uç nokta oluşturacağız. Bunu kullanarak Vertex AI API üzerinden modelimizle ilgili tahminler alabiliriz. Bunu yapmak için dışa aktarılan eğitilmiş model öğelerinin bir sürümünü, herkese açık bir GCS paketinde kullanıma sunduk.
Bir kurumda genellikle modelin geliştirilmesinden bir ekip ya da bireyin ve modeli dağıtmaktan sorumlu farklı bir ekip bulunur. Buradaki adımlarda, önceden eğitilmiş bir modeli nasıl alıp tahmin için dağıtacağınız gösterilir.
Bu makalede, Vertex AI SDK'yı kullanarak model oluşturacağız, modeli bir uç noktaya dağıtacağız ve tahminde bulunacağız.
1. Adım: Vertex SDK'yı yükleyin
Vertex AI SDK'yı yüklemek için Cloud Shell terminalinizden aşağıdaki komutu çalıştırın:
pip3 install google-cloud-aiplatform --upgrade --user
Bu SDK'yı, Vertex'in birçok farklı bölümüyle etkileşime geçmek için kullanabiliriz.
2. Adım: Model oluşturma ve uç nokta dağıtma
Şimdi bir Python dosyası oluşturacağız ve SDK'yı kullanarak bir model kaynağı oluşturacağız ve bunu bir uç noktaya dağıtacağız. Cloud Shell'deki Dosya düzenleyicide Dosya'yı ve ardından Yeni Dosya'yı seçin:
Dosyayı deploy.py olarak adlandırın. Bu dosyayı düzenleyicinizde açın ve aşağıdaki kodu kopyalayın:
from google.cloud import aiplatform
# Create a model resource from public model assets
model = aiplatform.Model.upload(
display_name="mpg-imported",
artifact_uri="gs://io-vertex-codelab/mpg-model/",
serving_container_image_uri="gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-3:latest"
)
# Deploy the above model to an endpoint
endpoint = model.deploy(
machine_type="n1-standard-4"
)
Ardından, Cloud Shell'deki Terminal'e geri dönün, cd işlemini kök dizinde yapın ve yeni oluşturduğunuz bu Python komut dosyasını çalıştırın:
cd ..
python3 deploy.py | tee deploy-output.txt
Kaynaklar oluşturulurken terminalinize güncellemeler kaydedildiğini görürsünüz. Bunun çalışması 10-15 dakika sürer. Düzgün çalıştığından emin olmak için Vertex AI'da konsolunuzun Modeller bölümüne gidin:
mgp-imported'ı tıklayın. Bu modele ait uç noktanızın oluşturulduğunu görürsünüz:
Uç nokta dağıtımınız tamamlandığında Cloud Shell Terminal'inizde aşağıdakine benzer bir günlük görürsünüz:
Endpoint model deployed. Resource name: projects/your-project-id/locations/us-central1/endpoints/your-endpoint-id
Dağıtılan endop'unuz hakkında bir tahmin almak için bir sonraki adımda bunu kullanacaksınız.
3. adım: Dağıtılan uç nokta hakkında tahminler alın
Cloud Shell düzenleyicinizde predict.py adlı yeni bir dosya oluşturun:
predict.py dosyasını açın ve aşağıdaki kodu koda yapıştırın:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="ENDPOINT_STRING"
)
# A test example we'll send to our model for prediction
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])
Sonra terminalinize geri dönün ve tahmin dosyasındaki ENDPOINT_STRING değerini kendi uç noktanızla değiştirmek için aşağıdakini girin:
ENDPOINT=$(cat deploy-output.txt | sed -nre 's:.*Resource name\: (.*):\1:p' | tail -1)
sed -i "s|ENDPOINT_STRING|$ENDPOINT|g" predict.py
Şimdi, dağıtılan model uç noktamızdan bir tahmin almak için predict.py dosyasını çalıştırma zamanı:
python3 predict.py
Test tahminimiz için tahmini yakıt verimliliğiyle birlikte API'nin yanıtının kaydedildiğini 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 AI'ın farklı bölümleri hakkında daha fazla bilgi edinmek için belgeleri inceleyin. 5. adımda başlattığınız eğitim işinin sonuçlarını görmek için Vertex konsolunuzun eğitim bölümüne gidin.
7. Temizleme
Dağıttığınız uç noktayı silmek için Vertex konsolunuzun Uç Noktalar bölümüne gidin ve sil simgesini tıklayın:
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:
