【教程】为NLP构建MLOps管道：机器翻译任务

机器学习操作通常被称为MLOps**，使我们能够创建一个端到端的机器学习管道，从设计实验、构建ML模型、训练和测试，到部署和监控，换句话说就是机器学习生命周期。这个领域的MLOps类似于DevOps，但专门为机器学习项目量身定做。

作为一个相对较新的领域，MLOps像机器学习一样获得了很大的吸引力，正因为如此，人工智能驱动的软件在所有行业都变得很普遍。我们必须为这样的过程配备专门的操作。MLOps使我们能够建立人工智能驱动的软件，它有两个主要组成部分：持续集成和持续部署。我们可以创建一个从开始到部署的无缝管道，并在移动中修改构建。

在这篇文章中，我们将详细讨论如何使用各种技术为机器翻译建立MLOps管道。我们将使用的一些关键技术是。

• TensorFlow。
• Neptune.ai,
• GitHub行动。
• Docker。
• Kubernetes。
• 和Google Cloud Build。

本教程旨在让你全面了解如何为自己的机器学习或数据科学项目逻辑地实现MLOps。

什么是MLOps管道？

MLOps可以被描述为机器学习或数据科学项目的一个生命周期。生命周期本身由三个主要部分组成。

• 1设计
• 2模型开发
• 3操作

通过结合这三个部分，我们可以建立一个集成系统，可以利用机器学习和软件应用的力量。这个管道可以自动完成数据收集、数据预处理、训练和测试、部署和监控等过程。除此之外，它还能够检测到构建中的任何新变化，并同时在全球范围内更新新变化。

了解更多

构建机器翻译的MLOps管道：从哪里开始？

为了打造一个时尚的MLOps生命周期管道，人们必须考虑以下步骤。

设计

设计基本上是一个了解业务问题的过程，通常涉及到目标受众。

设计一个实验还包括研究可用的资源，如知识收集、可使用的数据类型、合适的架构、财政资源、计算资源等等。

一般来说，在这个过程中，数据科学家和机器学习工程师试图寻找可用的解决方案，并根据要求修改它们，以节省时间。

从本质上讲，设计通过预设的解决方案来设定目标。

问题陈述

作为本文的一部分，让我们考虑，我们需要建立一个将葡萄牙语翻译成英语的应用程序。这个问题属于自然语言处理的范畴，更确切地说，是属于机器翻译的范畴。现在，作为一个数据科学家或ML工程师，你需要考虑以下问题。

• 1应该使用什么计算语言和相关库？
• 2我们可以从哪里获得数据？
• 3模型的核心架构必须是什么？
• 4训练目标和输出应该是什么，以及准确性和损失指标、优化技术等等。
• 5最后期限和预算是什么？

同时检查

研究

研究是我们探索每一个可能的解决方案来建立产品的部分。例如，当涉及到选择一种语言来构建一个深度学习模型时，python是一种方式。但如果你是一个iOS开发者，那么Swift是首选的语言，而像特斯拉这样的一些公司在考虑Python的同时也考虑C和C++。对于这篇文章，让我们坚持使用Python，因为它是构建深度学习和机器学习模型最广泛使用的语言。

现在，为了建立一个深度学习模型，可以使用两个python库中的一个。Tensorflow和Pytorch。两者都非常流行，用途广泛，并有大量的社区支持。在这个阶段，这一切都归结为偏好和一个比另一个的优势。在我们的案例中，我们将使用Tensorflow，因为它有一个结构非常好的API，即Keras，而且与Pytorch相比，实现它需要更少的代码行。

当语言和核心库确定后，我们就可以研究可用于实现机器翻译的架构了。目前我们知道，大多数SOTA语言模型大量使用变形金刚，因为它的自我关注机制。所以我们也会这么做。

说到数据，我们几乎可以从任何地方轻松下载语言翻译数据，但最好的做法是从Kaggle等合法资源中下载经过整理的数据。在我们的案例中，我们将使用TensorFlow-datasetAPI来下载数据。

现在让我们了解一下目录结构。

目录结构

在所有项目中，最关键的是目录结构。一个结构良好的项目有利于读者的跟踪和高效协作。就MLOps而言，它起着重要的作用，因为我们将使用不同的技术来访问端点，从构建到部署。

MLOps项目的一般结构看起来是这样的。

Machine-translation
├── kube
├── metadata
├── notebook
├── requirements.txt
├── README.md
└── source

这是主目录结构及其子目录、requirements.txt和README.md文件。随着我们将继续前进，我们将不断向目录中添加更多的文件。

机器翻译的MLOps管道：模型开发

在这篇文章中，我们将使用Tensorflow网站上提供的笔记本。该笔记本内容丰富，对如何编写和训练机器翻译模型给出了一个全面的概念。

我们将对该笔记本做一些修改，并整合Neptune客户端，以便在训练期间监控模型。现在让我们简单地探讨和修改一下这个笔记本。

设置

首先，我们必须安装三个库。Tensorflow-datasets用于下载数据，Tensorflow用于深度学习，Neptune-client用于监控和保存元数据。

!pip install tensorflow_datasets
!pip install -U 'tensorflow-text==2.8.*'

!pip install neptune-client

一旦这些库安装完毕，我们就可以将它们全部导入笔记本。

下载数据集

我们将使用的数据集，即把葡萄牙语翻译成英语，可以直接从TensorFlow-datasets库中下载。一旦下载了数据集，我们就可以把它分成训练和验证数据集。

examples, metadata = tfds.load('ted_hrlr_translate/pt_to_en', with_info=True,
                               as_supervised=True)
train_examples, val_examples = examples['train'], examples['validation']

创建requirements.txt

Requirements.txt是一个重要的文件，因为它包含了所有的库，作为一个捆绑文件。这使得新的贡献者可以在他们的工作环境中快速安装所有的库或依赖关系。

要创建requirements.txt文件，我们所要做的就是运行。

!pip freeze > requirements.txt 

这可以在我们安装并导入所有文件后立即进行，或者在你完成训练并对模型进行推理后进行。最好是采用后者的做法。

下面是requirements.txt文件应该是这样的。

matplotlib==3.2.2
neptune-client==0.16.1
numpy==1.21.6
tensorflow-datasets==4.0.1
tensorflow==2.8.0

保持对模型元数据的跟踪

登录到neptune.ai仪表盘 是非常简单的。首先，我们创建一个类来存储所有的超参数。这种方法在创建独立的python模块时真的很方便（我们后面会看到）。

class config():
 BUFFER_SIZE = 20000
 BATCH_SIZE = 64
 MAX_TOKENS = 128
 MAX_EPOCHS = 5
 TRAIN_LOSS = 'train_loss'
 TRAIN_ACCURACY = 'train_accuracy'
 OPTIMIZER = 'Adam'
 BETA_1 = 0.9
 BETA_2 = 0.98
 EPSILON = 1e-9
 NUM_LAYER = 4
 D_MODEL = 128
 DFF = 512
 NUM_HEAD = 8
 DROP_OUT = 0.1

然后我们可以创建一个存储所有超参数的字典。

params = {
   'BUFFER_SIZE': config.BUFFER_SIZE,
   'BATCH_SIZE' : config.BATCH_SIZE,
   "MAX_TOKENS" : config.MAX_TOKENS,
   "MAX_EPOCHS" : config.MAX_EPOCHS,
   "TRAIN_LOSS" : config.TRAIN_LOSS,
   "TRAIN_ACCURACY" : config.TRAIN_ACCURACY,
   "OPTIMIZER" : config.OPTIMIZER,
   "BETA_1" : config.BETA_1,
   "BETA_2" : config.BETA_2,
   "EPSILON" : config.EPSILON,
   "NUM_LAYER" : config.NUM_LAYER,
   "D_MODEL" : config.D_MODEL,
   "DFF" : config.DFF,
   "NUM_HEAD" : config.NUM_HEAD,
   "DROP_OUT" : config.DROP_OUT,
}
   

一旦创建了字典，我们就可以使用API令牌初始化Neptune客户端，并以字典的形式传递参数。

run = neptune.init(
   project="nielspace/machine-translation",
   api_token="eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiJkYjRhYzI0Ny0zZjBmLTQ3YjYtOTY0Yi05ZTQ4ODM3YzE0YWEifQ==",
) 

run["parameters"] = params

一旦执行，这就是它在neptune.ai仪表板上的样子。

Neptune.ai中记录的参数 |来源

如你所见，所有的超参数都被记录下来了。

模型训练

一旦模型的所有组件，如编码器、解码器、自我关注机制等准备就绪，就可以进行模型训练了。但是，我们必须再次确保在训练过程中整合Neptune-client来监控模型，看看它的表现如何。

要做到这一点，我们只需要定义准确度和损失函数，并将它们传入训练循环。

train_loss = tf.keras.metrics.Mean(name=config.TRAIN_LOSS)
train_accuracy = tf.keras.metrics.Mean(name=config.TRAIN_ACCURACY)

在训练循环中，我们将使用与之前相同的方法来记录精度和损失。

run['Training Accuracy'].log(train_accuracy.result())
run['Training Loss'].log(train_loss.result())

让我们在训练循环中整合它们。

for epoch in range(config.MAX_EPOCHS):
 start = time.time()

 train_loss.reset_states()
 train_accuracy.reset_states()

 # inp -> portuguese, tar -> english
 for (batch, (inp, tar)) in enumerate(train_batches):
   train_step(inp, tar)
   run['Training Accuracy'].log(train_accuracy.result())
   run['Training Loss'].log(train_loss.result())

   if batch % 50 == 0:
     print(f'Epoch {epoch + 1} Batch {batch} Loss {train_loss.result():.4f} Accuracy {train_accuracy.result():.4f}')

 if (epoch + 1) % 5 == 0:
   ckpt_save_path = ckpt_manager.save()
   print(f'Saving checkpoint for epoch {epoch+1} at {ckpt_save_path}')

 print(f'Epoch {epoch + 1} Loss {train_loss.result():.4f} Accuracy {train_accuracy.result():.4f}')

 print(f'Time taken for 1 epoch: {time.time() - start:.2f} secs\n')

run.stop()

这就是训练期间的仪表板的样子。

在Neptune.ai中记录的训练准确率和损失 |来源

需要记住的一个关键点是，在实验完成后或训练循环完全执行后停止运行。

Neptune-client API的一个好处是，你可以记录几乎任何东西。

验证和测试模型

一旦训练完成，我们就可以在创建应用程序之前对模型进行推理测试。在创建一个用于推理的类对象时，你必须记住，所有的预处理步骤都必须包括在内，因为这个相同的类将在app.py中用来创建端点。

下面是一个例子。

class Translator(tf.Module):
 def __init__(self, tokenizers, transformer):
   self.tokenizers = tokenizers
   self.transformer = transformer

 def __call__(self, sentence, max_length=config.MAX_TOKENS):
   # input sentence is portuguese, hence adding the start and end token
   assert isinstance(sentence, tf.Tensor)
   if len(sentence.shape) == 0:
     sentence = sentence[tf.newaxis]

   sentence = self.tokenizers.pt.tokenize(sentence).to_tensor()

   encoder_input = sentence

   # As the output language is english, initialize the output with the
   # english start token.
   start_end = self.tokenizers.en.tokenize([''])[0]
   start = start_end[0][tf.newaxis]
   end = start_end[1][tf.newaxis]

   # `tf.TensorArray` is required here (instead of a python list) so that the
   # dynamic-loop can be traced by `tf.function`.
   output_array = tf.TensorArray(dtype=tf.int64, size=0, dynamic_size=True)
   output_array = output_array.write(0, start)

   for i in tf.range(max_length):
     output = tf.transpose(output_array.stack())
     predictions, _ = self.transformer([encoder_input, output], training=False)

     # select the last token from the seq_len dimension
     predictions = predictions[:, -1:, :]  # (batch_size, 1, vocab_size)

     predicted_id = tf.argmax(predictions, axis=-1)

     # concatentate the predicted_id to the output which is given to the decoder
     # as its input.
     output_array = output_array.write(i+1, predicted_id[0])

     if predicted_id == end:
       break

   output = tf.transpose(output_array.stack())
   # output.shape (1, tokens)
   text = tokenizers.en.detokenize(output)[0]  # shape: ()

   tokens = tokenizers.en.lookup(output)[0]

   # `tf.function` prevents us from using the attention_weights that were
   # calculated on the last iteration of the loop. So recalculate them outside
   # the loop.
   _, attention_weights = self.transformer([encoder_input, output[:,:-1]], training=False)

   return text, tokens, attention_weights

正如你所看到的，预处理和预测所需的步骤都包含在同一个类对象中。现在我们测试一下我们的模型在未见过的数据上表现如何。

def print_translation(sentence, tokens, ground_truth):
 print(f'{"Input:":15s}: {sentence}')
 print(f'{"Prediction":15s}: {tokens.numpy().decode("utf-8")}')
 print(f'{"Ground truth":15s}: {ground_truth}')

sentence = 'este é um problema que temos que resolver.'
ground_truth = 'this is a problem we have to solve .'

translator = Translator(tokenizers, transformer)
translated_text, translated_tokens, attention_weights = translator(
   tf.constant(sentence))
print_translation(sentence, translated_text, ground_truth)

输出。

Input:         : este é um problema que temos que resolver.
Prediction     : this is a problem that we have to solve .
Ground truth   : this is a problem we have to solve .

下载元数据和笔记本

一旦训练和推理完成，我们就可以继续前进，将元数据和笔记本本身从Google Colab下载到我们的本地目录，然后为每个类对象创建单独的python模块。

例如，你可以看到，所有的目录已经完全被各自的文件和元数据填满。

machine-translation
├── metadata
│   ├── checkpoints
│   │   └── train
│   │       ├── checkpoint
│   │       ├── ckpt

在上面的例子中，源目录由python模块组成，其中包含了直接从笔记本中提取的函数和类对象。

app.py

下一步是创建一个app.py，它将利用flask的API来服务于模型。为了服务于模型，我们需要。

• 1导入预处理和转化器模块的所有函数。
• 2加载保存在翻译器目录中的权重。
• 3定义一个用于获取预测结果的端点。

import flask
from flask import Flask
import logging
import time
 
import numpy as np
import matplotlib.pyplot as plt
 
import tensorflow_datasets as tfds
import tensorflow as tf
import tensorflow_text
 
import source.config as config
from source.preprocessing import *
from source.transformer import *
 
app = Flask(__name__)
 
@app.route("/predict")
def predict():
   sentence = request.args.get("sentence")
   response = translator(sentence).numpy()
   return flask.jsonify(response)
 
if __name__ == "__main__":
   translator = tf.saved_model.load('../translator')
   app.run(host="0.0.0.0", port="9999")

机器翻译的MLOps管道：操作（CI/CD）

一旦代码库准备好了，我们就可以进入第三个也是最后一个阶段，即操作，这就是我们将实施持续部署和持续集成的地方。这就是事情变得有点棘手的地方。但不要担心，我已经把整个操作分为不同的部分，这样每一个模块都会很清楚，很容易遵循。这些是我们将遵循的步骤。

• 1创建一个Github repo。
• 2使用Docker文件创建一个镜像。
• 3将镜像推送到Google Cloud Build。
• 4部署。

创建GitHub repo

第一步是将所有代码从本地目录推送到GitHub账户。这将有助于我们将repo目录连接到谷歌云开发。从那里我们可以创建Kubernetes pods并在其中部署应用程序。

Dockerfile

Dockerfile使我们能够创建一个容器*，它是一种软件类型，包裹了一个应用程序，包括其库和依赖*。它还创建了一个静态环境，使应用程序可以在任何环境中运行。

另一方面，Docker是构建和管理容器的软件。而且，我们可以创建我们想要的许多容器。

为了给我们的app.py创建一个容器，我们需要创建一个Docker文件。这个文件即镜像必须存储所有需要遵循的指令来构建容器。一些一般的说明是。

• 1安装编程语言，在我们的例子中是python。
• 2创建环境。
• 3安装库和依赖项。
• 4复制模型、API和其他工具文件，以便正确执行。

在下面的例子中，你会看到我是如何组织Docker配置的。相当简单和简约。

FROM python:3.7-slim
RUN apt-get update

ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . ./

RUN ls -la $APP_HOME/

RUN pip install -r requirements.txt

CMD ["python3","app.py" ]

谷歌云开发

配置完Docker文件后，我们将使用谷歌云开发或GCD来自动化CI/CD管道。当然，你可以使用任何其他服务，如Azure、AWS等，但我发现GCD很简单，很容易使用。我将详细解释这部分内容，以便于你掌握完整的概念和理解这个过程。

第一步将是登录你的GCD账户，如果你是一个新用户，那么你将得到一个免费的300美元信用额度，你可以在90天内使用。

谷歌云开发。云外壳

一旦你登录到你的GCD，创建一个**新的项目。**之后，点击屏幕右上角的Cloud Shell图标，激活Cloud Shell。

需要注意的一点是，在大多数情况下，我们将使用内置的Cloud Shell来执行这些程序。其中第一个是克隆来自Github的版本库。你可以使用给定链接中的相同代码来进行操作。

谷歌云开发。云外壳｜来源。作者

一旦克隆了repo，cd进入它。

谷歌云开发。Kubernetes

现在我们将启用、设置并启动Kubernetes引擎。Kubernetes引擎将使我们能够管理我们的docker化应用程序。为了配置Kubernetes，我们需要遵循4个步骤。

• 1创建一个deployment.yaml文件。
• 2创建一个service.yaml文件。
• 3在GCD中启用Kubernetes引擎。
• 4通过Cloud Shell启动Kubernetes引擎。

创建部署.yaml

deployment.yaml的目的是为了配置部署设置。它由两部分组成。

• API版本和操作的种类

apiVersion: apps/v1
kind: Deployment

• 元数据

metadata:
 name: translation

spec:
 replicas: 2 #no of pods
 selector:
   matchLabels:
     app: translation-app #app name
 template:
   metadata: 
     labels:
       app: translation-app #app name
   spec:
     containers:
     - name: translation-app
       image: gcr.io/tensor-machine-translation/translation:v1
       ports:
       - containerPort: 9999

下面是我在元数据中指定的配置内容。

• 我将使用的副本或pod的数量，在这种情况下，它是2。
• 容器的位置。地点也可以分成四个步骤。
  • URL。"gcr.io"。这是容器的地址，是通用的。
  • 项目ID。"tensor-machine-translation"
  • 应用程序名称：translation。你可以给任何名字，但在所有配置文件中必须是相同的。
  • 版本：v1。这是一个标签。

创建一个service.yaml

service.yaml将整个应用程序暴露在网络中。它与deployment.yaml类似，但主要区别在于我们要实现的操作种类，它也由两部分组成。

• API版本和操作的种类

apiVersion: v1
kind: Service

• 元数据

metadata:
 name: machinetranslation
spec:
 type: LoadBalancer
 selector:
   app: machinetranslation
 ports:
 - port: 80
   targetPort: 9999

在配置完部署和服务文件后，让我们转到Kubernetes。

在GCD中启用Kubernetes引擎

一旦我们的配置文件准备好了，我们就可以继续启用Kubernetes API。它是一个开源系统，用于管理Docker化的应用程序。要启用Kubernetes，只需在GCD搜索栏中输入*"GKE* "。你将会被导航到Kubernetes引擎API页面，在那里点击**"启用**"即可。

用Kubernetes构建MLOPS管道|来源：中国新闻网。

启用API后，你需要创建Kubernetes集群。你可以通过两种方式来创建集群。

• 1直接点击屏幕上的 "创建 "按钮。
• 2使用Google-Cloud shell。

Kubernets集群|来源

在我们的例子中，我们将使用Google-Cloud shell，因为你可以更具体地说明你想要什么类型的集群。

启动Kubernetes引擎

为了启动Kubernetes引擎，在你的云端shell中写下以下代码。

!gcloud config set project tensor-machine-translation


!gcloud config set compute/zone us-central1


!gcloud container clusters create tensorflow-machine-translation --num-nodes=2

启动Kubernetes引擎。作者

完成后，你可以在仪表板上查看K8集群。

启动Kubernetes引擎|来源：作者

现在，我们的Kubernetes配置文件和引擎已经准备好了，我们就可以着手配置clouldbuild.yaml文件，然后启动整个应用。

谷歌云开发。云构建

cloudbuild.yaml文件将所有的进程同步到一起。它很简单易懂。该配置文件通常包含以下步骤。

• 1从Dockerfile中建立一个容器镜像。
• 2将容器镜像推送到谷歌云注册中心（GCR）。
• 3配置入口点。
• 4在Kubernetes引擎中部署整个应用程序。

steps:
- name: 'gcr.io/cloud-builders/docker'
 args: ['build', '-t', 'gcr.io/tensor-machine-translation/translation', '.']
 timeout: 180s
- name: 'gcr.io/cloud-builders/docker'
 args: ['push', 'gcr.io/tensor-machine-translation/translation']
- name: 'gcr.io/cloud-builders/gcloud'
 entrypoint: "bash"
 args:
 - "-c"
 - |
   echo "Docker Container Built"
   ls -la
   ls -al metadata/
- name: "gcr.io/cloud-builders/gke-deploy"
 args:
 - run
 - --filename=kube/
 - --location=us-west1-b
 - --cluster=tensor-machine-translation

配置完cloudbuild.yaml文件后，你可以回到Google-Cloud Shell并运行以下命令。

!gcloud builds submit --config cloudbuild.yaml

谷歌云开发。云构建|源。作者

一旦部署完毕，你将得到应用程序的链接。

GitHub行动

现在，我们已经完成了所有重要的过程，我们的应用程序已经启动并运行。但现在我们将看到如何使用Github Actions创建触发器，这将使我们能够在我们修改和推送Github repo中的代码时自动更新构建。让我们来看看我们如何做到这一点。

进入Github市场，搜索Google Cloud Build。

Github市场｜来源。作者

点击Google Cloud Build。

选择Google Cloud Build |来源。作者

单击 "设置计划"。

用Google Cloud Build设置一个计划 | 来源。作者

用Google Cloud Build设置一个计划 | 来源。作者

点击配置。

Google Cloud Build的配置 | 来源。作者

选择存储库。

选择 Google Cloud Build 仓库 | 来源。作者

选择项目，在我们的例子中，它是Tensor-machine-translation。

选择 "Tensor-machine-translation"|来源：作者。作者

点击创建一个触发器。

创建一个触发器 | 来源。作者

为触发器提供一个 "名字"，并保持所有设置不变。

命名触发器|来源：作者。作者

点击创建。

创建一个触发器作者

创建后，你会被引导到以下页面。

触发器在Google Cloud Build中的视图|来源：作者。作者

现在，有趣的部分是，每当你对Github repo做任何修改，Cloud Build都会自动检测到，并在部署的构建中进行修改。

生产中的监控模式

到目前为止，我们已经看到了如何建立一个自动MLOps管道，现在我们将探索最后一步，即如何监控部署在云上的应用程序。这个过程被称为云部署。GCD为我们提供了一个仪表盘，使我们能够从任何设备上监控应用程序：手机、平板电脑或电脑。

下面是iOS中给出的谷歌云控制台的图片。

谷歌云控制台|来源。作者

为了监控应用程序，你可以简单地在GCD搜索栏中输入监控，它就会把你导航到相应的页面。

谷歌云中的监控｜来源：作者。作者

你会看到有一堆选项可以选择。我建议你先选择一个概述，然后探索所有可能的选项。例如，如果你选择GKE，那么你会看到所有关于Kubernetes的信息。Pods、Nodes、Clusters等各自项目的信息。

谷歌云中的监控｜来源。作者

同样的，你也可以创建一个警报策略。还有很多其他的事情。

谷歌云中的监控｜来源：作者。作者

在监控阶段，你必须熟悉的一个重要概念是模型漂移。它发生在模型的预测能力随着时间的推移而退化的时候。

模型漂移可分为两种类型。

数据漂移

数据漂移一般是指生产数据与训练/测试数据的变化。它通常发生在训练和部署之间有时间差的时候。一个例子是任何时间序列数据，如COVID-19数据或股票市场数据。在这种情况下，可变性等因素可能每小时都会被引入，换句话说，数据会随着时间的推移不断演变。数据的这种演变会在生产阶段产生预测误差。

在我们的案例中，我们不必担心，因为语言数据在大部分时间内保持稳定，因此我们可以在更长的时间内使用同一个模型。

你可以在下面的博客中找到更多关于数据漂移检测的信息。为什么数据漂移检测很重要，以及如何通过5个简单的步骤将其自动化。

概念漂移

当预测变量随时间变化或换句话说，输出的统计属性随时间变化时，就会发生概念漂移。在概念漂移中，模型无法利用它在训练期间提取的模式。例如，让我们说，自从定义了垃圾邮件后，它已经随着时间的推移而演变。现在，该模型将发现很难利用它在3周前的训练中提取的模式来检测垃圾信息。为了解决这些问题，必须对模型参数进行调整。

如果公司的商业模式在改变，或者使用的数据集不能代表整个人口，就会发生概念漂移。

如何监控一个模型？

• 像顺序分析和时间分布方法可以帮助识别数据漂移。
• 另一方面，持续监测传入的数据并观察其统计特性可以帮助克服概念漂移。
• 除此之外，像ADWIN、卡方检验、直方图交集、科尔莫戈罗夫-斯米尔诺夫统计学等技术也会有所帮助。

如何克服模型漂移？

模型再训练是解决模型漂移的最好方法，包括数据漂移、概念漂移和模型退化问题。你可以参考这些策略进行再训练。

• 预定的再训练--定期进行：每周、每月，等等。
• 数据/事件驱动--每当有新数据可用时。
• 模型/指标驱动-- 每当准确性低于阈值时。

总结

在本教程中，我们探讨了如何使用各种技术来无缝部署机器翻译应用程序。这就是MLOps的力量。当然，你可以在app.py文件中添加很多东西，比如UI/UX，并完全创建一个全新的网页。

总结一下，我们看到了。

• 1如何设计一个实验？
• 2训练和测试模型。
• 3保存模型的权重和元数据。
• 4结构化目录。
• 5分离函数和创建python模块。
• 6创建一个Flask应用程序。
• 7停靠该应用程序。
• 8创建和配置谷歌Kubernetes引擎。
• 9在Google Kubernetes引擎中部署应用程序。
• 10最后，使用Github Actions自动完成整个过程。

如果你正在创建任何利用机器学习或深度学习算法的项目，那么你不应该停留在模型训练上，而是应该超越，并创建一个MLOps管道。我希望这个教程能帮助你了解如何在你自己的项目中实现MLOps。

请确保尝试一下，因为它是部署ML和DL应用程序的最佳方式。

代码

你可以在这里找到完整的资源库。另外，值得一提的是，机器翻译的Notebook取自官方网站。

参考文献

1. 注意的神经机器翻译
2. 机器学习操作
3. 如何用GitHub Actions构建MLOps管道[分步指南］
4. 使用GitHub Actions进行MLOps
5. 在谷歌Kubernetes引擎上部署机器学习管道
6. 为什么数据漂移检测很重要，如何用5个简单的步骤将其自动化？