Прогнозирование уровня текучести сотрудников с использованием ZenML и Streamlit

Улучшение прогнозирования текучести сотрудников с помощью ZenML и Streamlit

Введение

Работаете ли вы в качестве HR-специалиста? Столкнулись ли вы с трудностями в прогнозировании, будут ли сотрудники в вашей команде продолжать работать или они собираются покинуть организацию? Не волнуйтесь! Вам не нужно быть астрологом, чтобы предсказать это. С помощью силы науки о данных мы можем предсказать это точно. Давайте начнем наше замечательное путешествие по расчету текучести кадров с помощью простого, но мощного инструмента MLOps, называемого ZenML и streamlit. Поехали.

Цели обучения

В этой статье мы узнаем:

  • Что такое ZenML? Почему и как его использовать?
  • Почему использовать MLflow и как интегрировать его с ZenML?
  • Необходимость использования конвейера развертывания
  • Реализация проекта по оценке текучести кадров и делание прогнозов

Эта статья была опубликована в рамках Data Science Blogathon.

Реализация проекта

Постановка задачи: Предсказать, покинет ли сотрудник организацию или нет на основе нескольких факторов, таких как возраст, доход, производительность и т.д.

Решение: Построить модель логистической регрессии для предсказания показателя текучести кадров сотрудников

Набор данных: IBM HR Analytics Employee Attrition & Performance

[Источник]: https://www.kaggle.com/datasets/pavansubhasht/ibm-hr-analytics-attrition-dataset

Прежде чем рассмотреть реализацию нашего проекта, давайте сначала посмотрим, почему мы здесь используем ZenML.

Почему ZenML?

ZenML – простой и мощный инструмент оркестрации MLOps, используемый для создания ML-конвейеров, кэширования шагов конвейера и экономии вычислительных ресурсов. ZenML также предлагает интеграцию с несколькими инструментами машинного обучения, что делает его одним из лучших инструментов для создания ML-конвейеров. Мы можем отслеживать шаги наших моделей, метрики оценки, визуально видеть наши конвейеры на панелях инструментов и многое другое.

В этом проекте мы реализуем традиционный конвейер, использующий ZenML, и будем интегрировать mlflow с zenml для отслеживания экспериментов. Мы также реализуем конвейер непрерывного развертывания с использованием интеграции MLflow с ZenML, который производит предобработку и очистку данных, обучает модель и повторно развертывает модель, когда прогноз соответствует некоторым минимальным критериям оценки. С помощью этого конвейера мы можем убедиться, что если новая модель работает лучше, чем предыдущая модель, то сервер развертывания MLFlow будет обновлен новой моделью вместо старой.

Общие понятия в ZenML

  • Конвейеры: Последовательность шагов в нашем проекте.
  • Компоненты: Строительные блоки или конкретные функции в нашем конвейере MLOps.
  • Стеки: Сборники компонентов на локальной/облачной платформе.
  • Артефакты: Входные и выходные данные шага в нашем проекте, которые хранятся в хранилище артефактов.
  • Хранилище артефактов: Место хранения и отслеживания версий наших артефактов.
  • Материализаторы: Компоненты, которые определяют, как хранятся и извлекаются артефакты из хранилища артефактов.
  • Вкусы: Решения для конкретных инструментов и сценариев использования.
  • Сервер ZenML: Развертывание для удаленного запуска компонентов стека.

Предварительные требования и основные команды ZenML

  • Активация виртуальной среды:
#создание виртуальной средыpython3 -m venv venv#Активация виртуальной среды в папке проектасource venv/bin/activate
  • Команды ZenML:

Ниже приведены все основные команды ZenML со своими функциональностями:

#Установка ZenMLpip install zenml#Запуск сервера и панели управления ZenML в локальной средеpip install "zenml[server]"#Получение версии ZenMLzenml version#Инициализация нового репозиторияzenml init#Запуск панели управления ZenML в локальной средеzenml up#Проверка статуса ZenML Pipelineszenml show

Эти команды необходимо знать для работы с ZenML.

Интеграция MLflow с ZenML

Мы используем mlflow в качестве трекера экспериментов для отслеживания модели, артефактов и значений гиперпараметров. Здесь мы регистрируем компонент стека, трекер экспериментов и модельный развертыватель:

#Интеграция MLflow с ZenMLzenml integration install mlflow -y#Регистрация трекера экспериментовzenml experiment-tracker register mlflow_tracker_employee --flavor=mlflow#Регистрация модельного развертывателяzenml model-deployer register mlflow_employee --flavor=mlflow#Регистрация стеказenml stack register mlflow_stack_employee -a default -o default -d mlflow_employee -e mlflow_tracker_employee --set

Список стеков ZenML

Структура проекта

employee-attrition-prediction/          # Директория проекта├── data/                               │   └── HR-Employee-Attrition.csv       # Файл набора данных│├── pipelines/                          │   ├── deployment_pipeline.py          # Пайплайн развертывания│   ├── training_pipeline.py            # Пайплайн обучения│   └── utils.py                        │├── src/                                # Исходный код│   ├── data_cleaning.py                # Очистка и предобработка данных│   ├── evaluation.py                   # Оценка модели│   └── model_dev.py                    # Разработка модели│                 ├── steps/                              # Файлы кода для шагов ZenML│   ├── ingest_data.py                  # Загрузка данных│   ├── clean_data.py                   # Очистка и предобработка данных│   ├── model_train.py                  # Обучение модели    │   ├── evaluation.py                   # Оценка модели│   └── config.py                       │├── streamlit_app.py                    # Веб-приложение Streamlit│├── run_deployment.py                   # Код для запуска пайплайна развертывания и предсказаний├── run_pipeline.py                     # Код для запуска пайплайна обучения│├── requirements.txt                    # Список необходимых пакетов проекта├── README.md                           # Документация проекта└── .zen/                               # Директория ZenML (создается автоматически после инициализации ZenML)

Загрузка данных

Сначала мы загружаем данные из набора данных HR-Employee-Attrition-Rate из папки data.

import pandas as pdfrom zenml import stepclass IngestData:    def get_data(self) -> pd.DataFrame:        df = pd.read_csv("./data/HR-Employee-Attrition.csv")        return df@stepdef ingest_data() -> pd.DataFrame:    ingest_data = IngestData()    df = ingest_data.get_data()    return df    

@step это декоратор, используемый для того, чтобы функцию ingest_data() сделать шагом пайплайна.

Анализ исследовательских данных

#Понимание данныхdf.info()# Осмотр данныхdf.describe()# Проверка примера данныхdf.head()#Проверка наличия пустых значенийdf.isnull.sum()#Проверка процента людей, которые остались и ушли из компании:df['Attrition'].value_counts()df_left = df[df['Attrition'] == "Yes"]df_stayed = df[df['Attrition'] == "No"]left_percentage=df_left.shape[0]*100/df.shape[0]stayed_percentage=df_stayed.shape[0]*100/df.shape[0]print(f"Процент людей, покинувших компанию:{left_percentage}")print(f"Процент людей, остающихся в компании:{stayed_percentage}")#Анализ различий между характеристиками людей, оставшихся и покинувших компаниюdf_left.describe()df_stayed.describe()

Вывод

Наблюдения

  • Сотрудники, которые ушли с работы, проработали меньше лет в компании.
  • Сотрудники, которые покинули компанию, были моложе, чем сотрудники, которые остались.
  • У сотрудников, которые ушли, офис находится дальше от дома, чем у оставшихся.

Очистка и обработка данных

  • Очистка данных: Мы удалили ненужные столбцы в наборе данных, такие как: “EmployeeCount”, “EmployeeNumber”, “StandardHours”, затем мы изменили признаки, которые имеют только значения данных между Да (или) Нет, на двоичные 1 (или) 0.
  • One hot Encoding: Затем мы выполнили кодирование one-hot на категориальные столбцы, такие как ‘BusinessTravel’, ‘Department’, ‘EducationField’, ‘Gender’, ‘JobRole’, ‘MaritalStatus’.
import pandas as pdclass DataPreProcessStrategy(DataStrategy):    def __init__(self, encoder=None):        self.encoder = encoder    """Этот класс используется для предварительной обработки заданного набора данных"""    def handle_data(self, data: pd.DataFrame) -> pd.DataFrame:        try:            print("Названия столбцов перед предварительной обработкой:", data.columns)  # Добавьте эту строку            data = data.drop(["EmployeeCount", "EmployeeNumber", "StandardHours"], axis=1)            if 'Attrition' in data.columns:                print("Столбец Attrition найден в данных.")            else:                print("Столбец Attrition не найден в данных.")            data["Attrition"] = data["Attrition"].apply(lambda x: 1 if x == "Yes" else 0)            data["Over18"] = data["Over18"].apply(lambda x: 1 if x == "Yes" else 0)            data["OverTime"] = data["OverTime"].apply(lambda x: 1 if x == "Yes" else 0)            # Извлечение категориальных переменных            cat = data[['BusinessTravel', 'Department', 'EducationField', 'Gender', 'JobRole', 'MaritalStatus']]            # Выполнение кодирования one-hot на категориальных переменных            onehot = OneHotEncoder()            cat_encoded = onehot.fit_transform(cat).toarray()                                    # Преобразование cat_encoded в DataFrame            cat_df = pd.DataFrame(cat_encoded)            # Извлечение числовых переменных            numerical = data[['Age', 'Attrition', 'DailyRate', 'DistanceFromHome', 'Education', 'EnvironmentSatisfaction', 'HourlyRate', 'JobInvolvement', 'JobLevel', 'JobSatisfaction', 'MonthlyIncome', 'MonthlyRate', 'NumCompaniesWorked', 'Over18', 'OverTime', 'PercentSalaryHike', 'PerformanceRating', 'RelationshipSatisfaction', 'StockOptionLevel', 'TotalWorkingYears', 'TrainingTimesLastYear', 'WorkLifeBalance', 'YearsAtCompany', 'YearsInCurrentRole', 'YearsSinceLastPromotion', 'YearsWithCurrManager']]            # Конкатенация X_cat_df и X_numerical            data = pd.concat([cat_df, numerical], axis=1)            print("Названия столбцов после предварительной обработки:", data.columns)  # Добавьте эту строку            print("Предварительно обработанные данные:")            print(data.head())            return data        except Exception as e:            logging.error(f"Ошибка при предварительной обработке данных: {e}")            raise e            

Вывод

Данные выглядят так, после всех операций по очистке и обработке данных: Вы можете увидеть на изображении, что данные состоят только из числовых данных после завершения кодирования.

Разделение данных

Затем мы разделим тренировочные и тестовые наборы данных в соотношении 80:20.

from sklearn.model_selection import train_test_splitclass DataDivideStrategy(DataStrategy):    def handle_data(self, data: pd.DataFrame) -> Union[pd.DataFrame, pd.Series]:        try:            # Проверяем, присутствует ли 'Attrition' в данных            if 'Attrition' in data.columns:                X = data.drop(['Attrition'], axis=1)                Y = data['Attrition']                X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)                return X_train, X_test, Y_train, Y_test            else:                raise ValueError("Столбец 'Attrition' не найден в данных.")        except Exception as e:            logging.error(f"Ошибка при обработке данных: {str(e)}")            raise e            

Обучение модели

Поскольку это проблема классификации, мы используем здесь логистическую регрессию, также можно использовать случайный лес, градиентный бустинг и другие алгоритмы классификации.

from zenml import pipeline@training_pipelinedef training_pipeline(data_path: str):    df = ingest_data(data_path)    X_train, X_test, y_train, y_test = clean_and_split_data(df)    model = define_model()  # Определите вашу модель машинного обучения    trained_model = train_model(model, X_train, y_train)    evaluation_metrics = evaluate_model(trained_model, X_test, y_test)

Здесь используется декоратор @training_pipeline, чтобы определить функцию training_pipeline() в качестве конвейера в ZenML.

Оценка

Для проблем бинарной классификации мы используем метрики оценки, такие как: точность, полнота, F1-мера, ROC-AUC-кривая и т. д. Мы импортируем classification_report из библиотеки scikit-learn для расчета метрик оценки и предоставления отчета классификации. Код:

import loggingimport numpy as npfrom sklearn.metrics import classification_reportclass ClassificationReport:    @staticmethod    def calculate_scores(y_true: np.ndarray, y_pred: np.ndarray):        try:            logging.info("Расчет отчета классификации")            report = classification_report(y_true, y_pred, output_dict=True)            logging.info(f"Отчет классификации:\n{report}")            return report        except Exception as e:            logging.error(f"Ошибка при расчете отчета классификации: {e}")            raise e

Отчет классификации:

Чтобы увидеть панель мониторинга training_pipeline, нам нужно запустить run_pipelilne.py,

run_pipelilne.py,

from zenml import pipelinefrom pipelines.training_pipeline import train_pipelinefrom zenml.client import Clientimport pandas as pdif __name__ == "__main__":    uri = Client().active_stack.experiment_tracker.get_tracking_uri()    print(uri)    train_pipeline(data_path="./data/HR-Employee-Attrition.csv")

что вернет URL панели мониторинга, который выглядит так: “URL панели управления: http://127.0.0.1:8237/workspaces/default/pipelines/6e7941f4-cf74-4e30-b3e3-ff4428b823d2/runs/2274fc18-aba1-4536-aaee-9d2ed7d26323/dag“. Вы можете щелкнуть по этому URL и просмотреть ваш потрясающий конвейер обучения в панели мониторинга ZenML. Здесь изображение всего конвейера разбито на разные части, чтобы можно было видеть его более ясно и подробно.

В целом, так выглядит pipeline обучения на панели инструментов:

Деплой модели

Триггер деплоя

class DeploymentTriggerConfig(BaseParameters):    min_accuracy: float = 0.5

В этом классе `DeploymentTriggerConfig` мы устанавливаем параметр минимальной точности, который определяет, какой должна быть минимальная точность модели.

Настройка триггера деплоя

@step(enable_cache=False)def deployment_trigger(    accuracy: float,    config: DeploymentTriggerConfig,):    return accuracy > config.min_accuracy

Здесь, функция `deployment_trigger()` используется для деплоя модели только в случае, если точность превышает минимальную. В следующем разделе рассмотрим, почему здесь используется `caching`.

Pipeline для непрерывного деплоя

@pipeline(enable_cache=False, settings={"docker":docker_settings})def continuous_deployment_pipeline(   data_path: str,   #data_path="C:/Users/user/Desktop/machine learning/Project/zenml Pipeline/Customer_Satisfaction_project/data/olist_customers_dataset.csv",   min_accuracy:float=0.0,   workers: int=1,   timeout: int=DEFAULT_SERVICE_START_STOP_TIMEOUT,):       df=ingest_data()   # Чистим данные и разделяем на тренировочные и тестовые наборы   X_train,X_test,Y_train,Y_test=clean_df(df)   model=train_model(X_train,X_test,Y_train,Y_test)   evaluation_metrics=evaluate_model(model,X_test,Y_test)   deployment_decision=deployment_trigger(evaluation_metrics)       mlflow_model_deployer_step(      model=model,      deploy_decision=deployment_decision,      workers=workers,      timeout=timeout,    )

Здесь, в этом `continuous_deployment_pipeline()`, мы считываем данные, очищаем их, обучаем модель, оцениваем ее и деплоим модель только в том случае, если она проходит условие `deployment_trigger()`. Таким образом, мы можем быть уверены, что новая модель будет выполняться только в случае превышения точности предсказания предыдущей модели, которая является пороговым значением. Вот как работает `continous_deployment_pipeline()`.

`Caching` относится к сохранению результатов предыдущих выполненных шагов в pipeline. Результаты хранятся в хранилище артефактов. Мы используем кэширование в параметре pipeline, чтобы указать, что не было изменений в выходных данных в предыдущих запусках и текущих запусках этапов, поэтому zenML будет повторно использовать предыдущий результат. Включение кэширования ускоряет процесс выполнения pipeline и экономит вычислительные ресурсы. Но иногда, в ситуациях, когда нам нужно выполнять pipeline со сменой входных данных, параметров, выхода, как наш `continuous_deployment_pipeline()`, отключение кэширования – это хорошо. Поэтому мы написали `enable_cache=False` здесь.

Pipeline для вывода

Мы используем pipeline вывода для получения прогнозов на новых данных на основе задеплоенной модели. Давайте посмотрим, как мы использовали этот pipeline в нашем проекте.

`inference_pipeline()`

@pipeline(enable_cache=False,settings={"docker":docker_settings})def inference_pipeline(pipeline_name: str, pipeline_step_name:str):   data=dynamic_importer()   #print("Data Shape for Inference:", data.shape)  # Печатаем форму данных для вывода   service=prediction_service_loader(      pipeline_name=pipeline_name,      pipeline_step_name=pipeline_step_name,      running=False,      )   prediction=predictor(service=service,data=data)   return prediction  

Здесь функция inference_pipeline() выполняется в следующем порядке:

  • dynamic_importer()– Сначала dynamic_importer() загружает новые данные и подготавливает их.
  • prediction_service_loader()prediction_service_loader() загружает развернутую модель на основе имени конвейера и имени шага.
  • predictor()-Затем predictor() используется для прогнозирования новых данных на основе развернутой модели.

Давайте рассмотрим каждую из этих функций ниже:

dynamic importer()

@step(enable_cache=False)def dynamic_importer()->str:   data=get_data_for_test()   return data  

Здесь вызывается get_data_for_test() в utils.py, который загружает новые данные, обрабатывает их и возвращает данные.

prediction_service_loader()

@step(enable_cache=False)def prediction_service_loader(   pipeline_name: str,   pipeline_step_name: str,   running:bool=True,   model_name: str="model", )->MLFlowDeploymentService:   mlflow_model_deployer_component=MLFlowModelDeployer.get_active_model_deployer()   existing_services=mlflow_model_deployer_component.find_model_server(   pipeline_name=pipeline_name,   pipeline_step_name=pipeline_step_name,   model_name=model_name,   running=running,)   if not existing_services:      raise RuntimeError(         f"Не найдено службы развертывания MLFlow для конвейера {pipeline_name}, шага {pipeline_step_name} и модели {model_name}, а также конвейер для модели {model_name} в настоящее время работает"      )

Здесь, в функции prediction_service_loader(), мы загружаем службу развертывания в зависимости от развернутой модели на основе параметров. Служба развертывания – это среда выполнения, в которой наша развернутая модель готова принимать запросы на вывод для прогнозирования новых данных. Строка existing_services=mlflow_model_deployer_component.find_model_server() ищет доступные службы развертывания на основе заданных параметров, таких как имя конвейера и имя шага конвейера, если доступных служб нет, значит, конвейер развертывания еще не выполнялся или есть проблема с конвейером развертывания, поэтому вызывается Runtime Error.

predictor()

@stepdef predictor(    service: MLFlowDeploymentService,    data: str,) -> np.ndarray:        """Выполнение запроса вывода на службу прогнозирования"""    service.start(timeout=21)  # should be a NOP if already started    data = json.loads(data)    data.pop("columns")    data.pop("index")    columns_for_df = [        0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,"Age","DailyRate","DistanceFromHome","Education","EnvironmentSatisfaction","HourlyRate","JobInvolvement","JobLevel","JobSatisfaction","MonthlyIncome","MonthlyRate","NumCompaniesWorked","Over18","OverTime","PercentSalaryHike","PerformanceRating","RelationshipSatisfaction","StockOptionLevel","TotalWorkingYears","TrainingTimesLastYear","WorkLifeBalance","YearsAtCompany","YearsInCurrentRole","YearsSinceLastPromotion","YearsWithCurrManager",    ]    df = pd.DataFrame(data["data"], columns=columns_for_df)    json_list = json.loads(json.dumps(list(df.T.to_dict().values())))    data = np.array(json_list)    prediction = service.predict(data)    return prediction

После того, как развернутая модель и новые данные у нас есть, мы можем использовать predictor() для прогнозирования.

Чтобы визуально увидеть непрерывное развертывание и конвейер вывода, нам нужно запустить run_deployment.py, где определены настройки для развертывания и прогнозирования.

@click.option(    "--config",    type=click.Choice([DEPLOY, PREDICT, DEPLOY_AND_PREDICT]),    default=DEPLOY_AND_PREDICT,    help="По желанию вы можете выбрать только запуск конвейера развертывания для обучения и развертывания модели (`deploy`), или только выполнение прогноза для развернутой модели (`predict`). По умолчанию будут запущены оба (`deploy_and_predict`).",)

Здесь мы можем выполнить непрерывный конвейер развертывания или конвейер вывода, следуя этим командам,

#The continuous deployment pipelinepython run_deployment.py#To see the inference Pipeline(that is to deploy and predict)python run_deployment.py --config predict

После выполнения команд вы можете увидеть URL-адрес панели инструментов zenML, подобный этому

URL-адрес панели инструментов: http://127.0.0.1:8237/workspaces/default/pipelines/b437cf1a-971c-4a23-a3b6-c296c1cdf8ca/runs/58826e07-6139-453d-88f9-b3c771bb6695/dag

Наслаждайтесь визуализацией вашего конвейера на панели инструментов:

Непрерывный конвейер развертывания

Непрерывный конвейер развертывания (от обработки данных до шага mlflow_model_deployer) выглядит так:

Конвейер вывода

Построение приложения Streamlit

Streamlit – потрясающий фреймворк с открытым исходным кодом, основанный на Python, используемый для создания пользовательских интерфейсов (UI). Мы можем использовать Streamlit для быстрого создания веб-приложений, не зная разработки backend или frontend. Сначала нам нужно установить Streamlit на компьютер. Команды для установки и запуска локального сервера Streamlit в нашей системе:

#install streamlit in our local PCpip install streamlit#to run the streamlit local web serverstreamlit run streamlit_app.py

Код:

import jsonimport numpy as npimport pandas as pdimport streamlit as stfrom PIL import Imagefrom pipelines.deployment_pipeline import prediction_service_loaderfrom run_deployment import main# Определите глобальную переменную для отслеживания состояния службыservice_started = Falsedef start_service():    global service_started    service = prediction_service_loader(        pipeline_name="continuous_deployment_pipeline",        pipeline_step_name="mlflow_model_deployer_step",        running=False,    )    service.start(timeout=21)  # Запустить службу    service_started = True    return servicedef stop_service(service):    global service_started    service.stop()  # Остановить службу    service_started = Falsedef main():    st.title("Прогнозирование выбытия сотрудников")    age = st.sidebar.slider("Возраст", 18, 65, 30)    monthly_income = st.sidebar.slider("Ежемесячный доход", 0, 20000, 5000)    total_working_years = st.sidebar.slider("Общий стаж работы", 0, 40, 10)    years_in_current_role = st.sidebar.slider("Лет в текущей должности", 0, 20, 5)    years_since_last_promotion = st.sidebar.slider("Лет с последнего повышения", 0, 15, 2)    if st.button("Предсказать"):        global service_started        if not service_started:            service = start_service()        input_data = {            "Age": [age],            "MonthlyIncome": [monthly_income],            "TotalWorkingYears": [total_working_years],            "YearsInCurrentRole": [years_in_current_role],            "YearsSinceLastPromotion": [years_since_last_promotion],        }        df = pd.DataFrame(input_data)        json_list = json.loads(json.dumps(list(df.T.to_dict().values())))        data = np.array(json_list)        pred = service.predict(data)        st.success(            "Предсказанная вероятность выбытия сотрудника (0 - 1): {:.2f}".format(                pred[0]            )        )        # Остановить службу после предсказания        if service_started:            stop_service(service)if __name__ == "__main__":    main()

Здесь мы создали веб-приложение Streamlit с названием «Прогнозирование текучести кадров», в котором пользователи могут вводить данные, такие как возраст, месячный доход и т. д., чтобы сделать прогноз. Когда пользователь нажимает кнопку «Предсказать», введенные данные отправляются в развернутую модель, делается прогноз и отображается для пользователя. Вот как работает наше приложение streamlit_app. Когда мы запускаем файл streamlit_app.py, мы получаем сетевой URL вот такой:

Нажав на сетевой URL, мы можем увидеть потрясающий пользовательский интерфейс Streamlit, используемый для прогнозирования.

Вы можете просмотреть все ваши стеки, использованные компоненты, количество выполненных конвейеров в панели инструментов ZenML, что сделает ваш путь к MLOps проще.

Панель инструментов ZenML:

Стеки:

Компоненты:

Количество конвейеров:

Количество запусков:

Заключение

Мы успешно создали проект MLOps по прогнозированию текучести кадров от начала до конца. Мы получили данные, очистили их, обучили модель, оценили модель, запустили развертывание, развернули модель, сделали прогноз модели, получили ввод пользователя из веб-приложения Streamlit и сделали прогнозы, что поможет отделу кадров принимать обоснованные решения на основе данных.

Код на GitHub: https://github.com/VishalKumar-S/Employee-attrition-rate-MLOps-Project

Основные выводы

  • ZenML служит мощным инструментом оркестрации с интеграцией других ML-инструментов.
  • Непрерывный конвейер разработки обеспечивает развертывание только лучших моделей, помогает предсказывать с высокой точностью.
  • Кэширование помогает нам экономить ресурсы, а журналирование помогает нам отслеживать конвейер, отлаживать и прослеживать ошибки.
  • Инструменты позволяют нам ясно видеть рабочий процесс ML-конвейера.

Часто задаваемые вопросы

Изображения, показанные в этой статье, не принадлежат Analytics Vidhya и используются по усмотрению автора.