Машинное обучение от локального к производственному (Вершинный ИИ)

Перейти от локального тестирования машинного обучения к рабочей среде очень просто! Это пошаговое руководство проведет вас через процесс создания машинного обучения с нуля и передачи его в облако.

Если вы похожи на меня и ненавидите читать, чтобы делать простые вещи, просто перейдите к «коду»!

О данных:

1. Данные «Автомобильные мили на галлон» были взяты из библиотеки StatLib, которая поддерживается в Университете Карнеги-Меллона.
2. Этикетка (что вы предсказываете): MPG (миль на галлон)
3. Характеристики (что вы используете для прогнозирования): цилиндры, рабочий объем, мощность, вес, ускорение, год выпуска, происхождение.

Фреймворки:

1. Панды
2. Тензорный поток [керас]
3. Докер
4. фастапи https://fastapi.tiangolo.com/

5. gcloud SDK + Вертекс

Сначала мы будем использовать Google Cloud (почему бы и нет?).

Примечания:

1. Приготовьтесь!, Мы будем использовать bash / ваш Mac, терминал Linux и т. д., потому что я ленивый.
2. Все инкапсулируем контейнерами, потому что они портативные!

Безопасность превыше всего:

Установите google cloud sdk в своем терминале и аутентифицируйтесь, используя учетные данные приложения по умолчанию.

Если вы хотите узнать больше о безопасности за контейнерами, мне понравилась эта история.

Вот так (выполните эти шаги в своем терминале):

gcloud auth login
gcloud auth application-default login
gcloud auth configure-docker us-central1-docker.pkg.dev

Обе команды запускают поток аутентификации OAuth2, синхронный или асинхронный, и локально сохраняют токен обновления. Спасибо guillaume blaquiere

Локальная топология

Установите свои переменные, друг!

Проверьте свои переменные (это может помочь), нам нужен идентификатор проекта Google Cloud, хранилище (корзина) и имя пользователя.

REGION=something  # [us-central1]                                                            
PROJECT_ID=something                                                          
BUCKET=something  # Name of the bucket @string                                                          
BUCKET_FOLDER_ARTIFACTS=$BUCKET/something                                     
USERNAME=something                                                            
IMAGE_URI=$REGION-docker.pkg.dev/$PROJECT_ID/repo-models/something                
ADC=/home/$USERNAME/.config/gcloud/application_default_credentials.json

Первое: создайте обучающий код, заверните его в контейнер и сохраните модель в облачном хранилище Google.

Создайте свой сегмент

Что такое, черт возьми, сегмент? Сегменты — это основные контейнеры для хранения ваших данных.

gsutil mb -l $REGION $BUCKET

Создайте структуру папок:

if [ ! -d train ]; then
   mkdir train;
fi
cd train

Создайте DockerFile:

да? Dockerfile – это декларативный документ/файл для создания контейнера Docker.

cat << EOF > Dockerfile
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"]
EOF

Создайте код для обучения машинному обучению (train.py):

Я знаю, это некрасиво, но вот шаги.

1. Чтение данных о милях на галлон.
2. Очистите и нормализуйте его.
3. Создайте нейронную сеть.
4. Обучите модель и сохраните ее.

cat << EOF > trainer/train.py
import warnings
import pandas as pd
import tensorflow as tf
warnings.filterwarnings('ignore')
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
BUCKET = '$BUCKET_FOLDER_ARTIFACTS'
# Extraction process
dataset = pd.read_csv('https://storage.googleapis.com/jchavezar-public-datasets/auto-mpg.csv')
dataset.tail()
dataset.isna().sum()
dataset = dataset.dropna()
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
train_dataset = dataset.sample(frac=0.8, random_state=0)
test_dataset = dataset.drop(train_dataset.index)
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
def norm(x):
    return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
def build_model():
    model_ai = 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_ai.compile(loss='mse',
                     optimizer=optimizer,
                     metrics=['mae', 'mse'])
    return model_ai
model = build_model()
model.summary()
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
print(BUCKET)
model.save(BUCKET)
EOF

Создайте модель и запустите ее локально:

docker build -t train .
docker run -ti --name train -e GOOGLE_APPLICATION_CREDENTIALS=/tmp/temp.json -v ${ADC}:/tmp/temp.json train

Отлично, вы обучили свою первую модель машинного обучения и сохранили ее в Google Cloud Storage.

Второе: создайте веб-сервер, который обрабатывает предсказания, оберните его и протестируйте локально.

Подготовительный этап (создание своих папок):

cd ..
if [ ! -d prediction ]; then
   mkdir prediction;
fi
cd prediction
if [ ! -d app ]; then
   mkdir app;
fi

Создать DockerFile

cat << EOF > Dockerfile
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7

COPY app /app
WORKDIR /app
RUN pip install sklearn joblib pandas tensorflow
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

EXPOSE 8080
EOF

Создать логику позади веб-сервера

cat << EOF > app/main.py
from fastapi import Request, FastAPI
from tensorflow import keras
import json
import os
app = FastAPI()
if os.environ.get('AIP_STORAGE_URI') is not None:
    BUCKET = os.environ['AIP_STORAGE_URI']
else:
    BUCKET = '$BUCKET_FOLDER_ARTIFACTS'
print(BUCKET)
model = keras.models.load_model(BUCKET)
@app.get('/')
def get_root():
    return {'message': 'Welcome mpg API: miles per gallon prediction'}
@app.get('/health_check')
def health():
    return 200
if os.environ.get('AIP_PREDICT_ROUTE') is not None:
    method = os.environ['AIP_PREDICT_ROUTE']
else:
    method = '/predict'
print(method)
@app.post(method)
async def predict(request: Request):
    print("----------------- PREDICTING -----------------")
    body = await request.json()
    instances = body["instances"]
    outputs = model.predict(instances)
    response = outputs.tolist()
    print("----------------- OUTPUTS -----------------")
    return {"predictions": response}
EOF

Создать репозиторий контейнеров

Вы уже должны пройти аутентификацию с помощью GCP, поэтому давайте воспользуемся SDK:

gcloud artifacts repositories create repo-models --repository-format=docker \
--location=$REGION --description="Models repository"

Создать/пометить контейнер

docker build -t $IMAGE_URI .

Запускать контейнер локально

docker run --name predict \
  -e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json \
  -v ${ADC}:/tmp/keys/FILE_NAME.json \
  -p 732:8080 $IMAGE_URI

Вы можете разбить его, нажав Ctrl+C.

Для прогнозов откройте новый терминал и сделайте http-запрос с данными в формате json:

curl -X POST -H "Content-Type: application/json" http://localhost:732/predict -d '{
 "instances": [[1.4838871833555929,
 1.8659883497083019,
 2.234620276849616,
 1.0187816540094903,
 -2.530890710602246,
 -1.6046416850441676,
 -0.4651483719733302,
 -0.4952254087173721,
 0.7746763768735953]]
}'

ГОТОВО

Вы обучили, развернули и протестировали свой первый механизм прогнозирования.

Подождите, это все? Нет…

Если вы хотите вывести свою модель на новый уровень (производство), выполните следующие шаги.

Третье: загрузка и развертывание на конечных точках вершин.

И снова ПЕРЕМЕННЫЕ:

ENDPOINT_NAME=something               # Endpoint's name
MODEL_NAME=something                  # Model's name
DEPLOYED_MODEL_NAME=something         # Deployed model's name
MACHINE_TYPE=n1-standard-2            # Machine type (more types)

Нажмите проверенное локальное изображение

docker push $IMAGE_URI

Загрузите свою модель

gcloud ai models upload \
  --region=$REGION \
  --display-name=$MODEL_NAME \
  --container-image-uri=$IMAGE_URI \
  --container-ports=8080 \
  --container-health-route=/health_check \
  --artifact-uri=$BUCKET_FOLDER_ARTIFACTS

Создайте конечную точку

Подождите, зачем?, потому что с конечными точками вы можете развернуть несколько версий модели без потери URL-адреса. (умный)

gcloud ai endpoints create \
  --display-name=$ENDPOINT_NAME \
  --region=$REGION

Список модели и конечной точки (опять же я ленив).

MODEL_ID=$(gcloud ai models list \
  --region=$REGION \
  --filter=displayName:$MODEL_NAME \
  --format='value(name)')
ENDPOINT_ID=$(gcloud ai endpoints list \
  --region=$REGION \
  --filter=displayName:$ENDPOINT_NAME \
  --format='value(name)')

Развернуть конечную точку

gcloud ai endpoints deploy-model $ENDPOINT_ID\
  --region=$REGION \
  --model=$MODEL_ID \
  --display-name=$DEPLOYED_MODEL_NAME \
  --machine-type=$MACHINE_TYPE \
  --min-replica-count=1 \
  --max-replica-count=1 \
  --traffic-split=0=100

Проверьте, проверьте:

Вам надоел интерфейс командной строки?

Проверьте это, это графический способ.