Часть 2

1.0 Что такое API?

API — это своего рода мост между вашей моделью машинного обучения (ML) и вашим приложением. В контексте развертывания приложения машинного обучения для прогнозирования сепсиса, вот как это работает:

  1. Создайте приложение машинного обучения, которое использует обученную модель для прогнозирования сепсиса.
  2. Разверните API вместе с приложением.
  3. Приложение отправляет данные пациента в API.
  4. API перенаправляет данные в модель машинного обучения.
  5. Модель ML генерирует прогноз сепсиса.
  6. API отправляет прогноз обратно в приложение.
  7. Приложение отображает прогноз для пользователя.

Используя API, вы обеспечиваете бесперебойную связь и прогнозирование сепсиса в режиме реального времени между вашей моделью машинного обучения и приложением, что упрощает предоставление ценной информации пользователям.

1.1 обзор FastAPI и его преимуществ.

FastAPI — это веб-фреймворк Python, который помогает быстро и эффективно создавать API. Как начинающему аналитику данных, вот почему это выгодно для вас:

Скорость. FastAPI известен своей высокой производительностью, что позволяет быстро обрабатывать и анализировать данные.

Простота. Он прост в использовании, что делает его удобным и доступным для начинающих.

Подсказки типов: FastAPI использует подсказки типов, улучшая качество кода и обнаруживая ошибки на ранних этапах.

Автоматическая документация. Автоматически создает интерактивную документацию по API, упрощая понимание и тестирование API.

Безопасность: FastAPI предоставляет встроенные функции безопасности для защиты вашего API и обеспечения авторизованного доступа.

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

С FastAPI вы можете создавать эффективные, безопасные и хорошо задокументированные API для взаимодействия с вашими данными в качестве начинающего аналитика данных.

1.2 FastAPI: создание API

После импорта необходимых библиотек мы загружаем нашу модель и масштабатор с помощью pickle.

# Load the model and scaler
def load_model_and_scaler():
    with open("model.pkl", "rb") as f1, open("scaler.pkl", "rb") as f2:
        return pickle.load(f1), pickle.load(f2)
model, scaler = load_model_and_scaler()

Вот следующий блок кода:

Приведенный выше код определяет два класса: Patient и Patients, которые используются для представления данных, связанных с пациентами в контексте здравоохранения. Давайте разберем это в удобной для начинающих форме:

  1. Patient класс:
  • Класс Patient — это план для создания отдельных объектов пациентов.
  • Каждый объект пациента будет иметь несколько атрибутов, в которых хранится конкретная информация о пациенте.

2. Patients класс:

  • Класс Patients — это план для создания коллекции объектов пациентов.
  • Атрибут all_patients в классе Patients представляет собой список, который может содержать несколько объектов Patient.
  • Каждый элемент в списке all_patients представляет отдельного пациента с собственным набором атрибутов.

Таким образом, класс Patient определяет структуру и атрибуты одного пациента, а класс Patients обеспечивает способ группировки нескольких объектов пациентов вместе в списке под названием all_patients.

Класс BaseModel является частью библиотеки pydantic, которая обычно используется в Python для проверки и сериализации данных. В данном коде классы Patient и Patients наследуются от класса BaseModel.

Вот почему используется класс BaseModel:

Проверка данных. Унаследовав класс BaseModel, классы Patient и Patients автоматически получают возможности проверки данных. Это означает, что при создании объектов этих классов значения, присвоенные атрибутам, будут проверяться на основе указанных в них типов данных. Если какое-либо из значений не соответствует ожидаемому типу данных, будет выдано сообщение об ошибке, обеспечивающее раннее указание на потенциальные проблемы с данными.

Сериализация. Класс BaseModel обеспечивает функции сериализации, позволяя легко преобразовывать экземпляры классов Patient и Patients в JSON, который является распространенным форматом обмена данными, и из него. Это полезно для таких задач, как хранение данных, отправка данных по сети или взаимодействие с другими системами, которые ожидают данные в формате JSON.

Расширенная функциональность. Наследование от BaseModel также предоставляет дополнительные функции, такие как автоматическое создание методов __str__ и __repr__, что упрощает печать и отладку объектов этих классов.

В целом, с помощью класса BaseModel классы Patient и Patients обеспечивают проверку данных, сериализацию и расширенную функциональность, упрощая работу с данными пациентов и управление ими в структурированном и надежном виде.

Взгляните еще раз на класс пациентов:

Метод return_list_of_dict берет экземпляр класса Patients, перебирает его список all_patients, преобразует каждый объект Patient в словарь и возвращает список этих словарей, представляющих данные пациента.

# Endpoints
# Root Endpoint
@app.get("/")
def root():
    return {"API": "This is an API for sepsis prediction."}
# Prediction endpoint
@app.post("/predict")
def predict_sepsis(patient: Patient):
    # Make prediction
    data = pd.DataFrame(patient.dict(), index=[0])
    parsed = predict(df=data)
    return {"output": parsed}
# Multiple Prediction Endpoint
@app.post("/predict_multiple")
def predict_sepsis_for_multiple_patients(patients: Patients):
    """Make prediction with the passed data"""
    data = pd.DataFrame(Patients.return_list_of_dict(patients))
    parsed = predict(df=data, endpoint="multi")
    return {"output": parsed}

Конечные точки относятся к различным URL-адресам, которые API предоставляет клиентам для взаимодействия.

Конечные точки подобны разным дверям в здание. Каждая дверь ведет в определенную комнату или область, где вы можете делать что-то другое. В контексте API конечные точки подобны дверям, которые клиенты (пользователи или другие программы) могут использовать для взаимодействия с API и выполнения различных действий.

В приведенном выше коде есть три конечных точки:

  1. Корневая конечная точка: URL: /
  • Это как главный вход в здание.
  • Когда клиент отправляет запрос GET на эту конечную точку, он получает простой ответ, который гласит: «Это API для прогнозирования сепсиса». Это как вывеска на входе, дающая краткое введение в API.

2. Конечная точка прогнозирования: URL: /predict

  • Это похоже на комнату, где делается прогноз сепсиса для одного пациента.
  • Когда клиент отправляет запрос POST на эту конечную точку, ему необходимо предоставить информацию о пациенте в теле запроса.
  • API получает информацию об этом пациенте, выполняет прогнозирование сепсиса с использованием модели машинного обучения и возвращает прогнозируемый результат клиенту. Это похоже на получение результата прогноза для конкретного пациента.

3. Конечная точка множественного прогнозирования: URL: /predict_multiple

  • Это похоже на большую комнату, где прогнозы делаются для нескольких пациентов одновременно.
  • Когда клиент отправляет запрос POST на эту конечную точку, ему необходимо предоставить информацию о нескольких пациентах в теле запроса.
  • API берет этот список информации о пациентах, выполняет прогнозирование сепсиса для каждого пациента с использованием модели машинного обучения и возвращает проанализированные выходные данные с результатами прогнозирования для всех пациентов. Это как делать прогнозы для группы пациентов вместе.

Эти конечные точки предоставляют клиентам различные способы взаимодействия с API и выполнения определенных задач. В дополнение к упомянутым конечным точкам могут быть и другие типы, в зависимости от потребностей API. Некоторые распространенные типы конечных точек включают в себя:

  • Обновить конечную точку: используется для обновления существующих данных.
  • Удалить конечную точку: используется для удаления существующих данных.
  • Конечная точка списка: используется для получения списка ресурсов.
  • Конечная точка поиска: используется для поиска определенных ресурсов на основе критериев.
  • Конечная точка аутентификации: используется для аутентификации и авторизации пользователей.
  • Конечная точка загрузки/загрузки файлов: используется для загрузки или скачивания файлов.

Мы почти закончили. Следующим шагом является создание нашей функции прогнозирования.

def predict(df, endpoint="simple"):
    # Scaling
    scaled_df = scaler.transform(df)  # Scale the input data using a pre-defined scaler
    # Prediction
    prediction = model.predict_proba(scaled_df)  # Make predictions using a pre-trained model
    highest_proba = prediction.max(axis=1)  # Get the highest probability for each prediction
    # Assign predicted labels based on the highest probabilities
    predicted_labels = ["Patient does not have sepsis" if i == 0 else "Patient has sepsis" for i in highest_proba]
    print(f"Predicted labels: {predicted_labels}")  # Print the predicted labels
    print(highest_proba)  # Print the highest probabilities
    response = []
    for label, proba in zip(predicted_labels, highest_proba):
        # Create a response for each prediction with the predicted label and probability
        output = {
            "prediction": label,
            "probability of prediction": str(round(proba * 100)) + '%'  # Convert the probability to a percentage
        }
        response.append(output)  # Add the response to the list of responses
    return response  # Return the list of responses

Этот код позволяет прогнозировать сепсис и генерировать ответ с прогнозируемыми метками и вероятностями для каждого прогноза.

Наконец, мы добавим последний блок кода.

В Python, когда вы пишете скрипт, вы можете либо запустить его напрямую, либо импортировать как модуль в другой скрипт. Блок if __name__ == "__main__": помогает определить, выполняется ли сценарий напрямую.

Вот простая разбивка:

  1. Когда вы запускаете скрипт Python напрямую, он начинает выполняться сверху.
  2. Условие if __name__ == "__main__": проверяет, выполняется ли сценарий напрямую или импортируется.
  3. Если сценарий запускается напрямую, выполняется код внутри блока if.
  4. В нашем случае код uvicorn.run("main:app", reload=True) запускает веб-сервер Uvicorn и запускает приложение FastAPI.
  5. Приложение FastAPI определяет различные конечные точки, такие как /predict и /predict_multiple, которые выполняют определенные задачи.

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

Проще говоря, блок if __name__ == "__main__": гарантирует, что сервер запускается только при непосредственном запуске скрипта, что позволяет использовать функции приложения через определенные конечные точки.

Вопрос:

Итак, означает ли это, что код внутри оператора if будет выполняться только тогда, когда скрипт запускается напрямую, а если скрипт импортируется как модуль, код внутри оператора if не будет выполняться?

Ответ:

Да, вы правильно поняли!

Когда вы запускаете скрипт Python напрямую, код внутри блока `if __name__ == “__main__”:` будет выполнен. Это позволяет вам запускать определенный код или выполнять определенные действия, когда скрипт запускается напрямую.

Однако, когда скрипт импортируется как модуль в другой скрипт, код внутри блока `if` не будет выполняться. Это предотвращает любое непреднамеренное выполнение кода, когда сценарий используется в качестве модуля.

Цель использования `if __name__ == “__main__”:` состоит в том, чтобы предоставить способ различать запуск скрипта напрямую и его импорт в качестве модуля, позволяя вам контролировать поведение скрипта в зависимости от того, как он используется.

Итак, когда вы запускаете скрипт напрямую, он запускает сервер и делает приложение доступным для тестирования и взаимодействия через определенные конечные точки.

Чтобы запустить fastAPI, вставьте этот код в свой терминал: «uvicorn main:app — перезагрузить».

1.3 Тестирование и взаимодействие с API

Теперь пришло время протестировать наш API. Когда вы запускаете скрипт и запускаете веб-сервер с помощью Uvicorn, ваше приложение FastAPI становится доступным по адресу http://127.0.0.1:8000.

Чтобы получить доступ к документации вашего API, вы можете просто добавить /docs к URL-адресу: «http://127.0.0.1:8000/docs». Это приведет вас на веб-страницу, которая показывает всю информацию о вашем API. В нем объясняются доступные конечные точки, данные, которые они ожидают получить в качестве входных данных, и формат предоставляемых ими ответов.

Используя эту страницу документации, вы можете легко изучить и понять, как взаимодействовать с вашим API, не нуждаясь в отдельных файлах документации. Это удобный и удобный способ узнать о функциональности вашего API и эффективно его использовать.

Вот простое пошаговое руководство по тестированию вашего API с использованием интерфейса документации:

  1. Откройте URL-адрес http://127.0.0.1:8000/docs в вашем браузере. Здесь доступна документация вашего API.
  2. На странице документации вы увидите список доступных конечных точек, представляющих различные функции вашего API.
  3. Выберите конечную точку, которую хотите протестировать, нажав на нее. Это покажет вам подробную информацию об этой конечной точке, включая поддерживаемые методы HTTP (например, GET, POST).
  4. Найдите входные параметры, необходимые для этой конечной точки. Эти параметры определяют данные, которые необходимо предоставить API для выполнения желаемого действия.
  5. Заполните необходимые параметры соответствующими значениями. Вы также можете указать дополнительные параметры, если это необходимо.
  6. После того, как вы ввели параметры, нажмите кнопку «Попробовать». Это отправляет запрос к API с предоставленными параметрами.
  7. API обработает запрос и сгенерирует ответ. Вы увидите детали ответа, включая код состояния, текст ответа и любую дополнительную информацию, возвращаемую API.
  8. Вы можете повторить процесс, чтобы протестировать разные конечные точки, или изменить значения параметров, чтобы увидеть разные ответы.

Используя интерфейс документации, вы можете легко изучить и протестировать свой API, не выходя из браузера. Он предоставляет удобный способ взаимодействия с вашим API, понимание необходимых входных данных и просмотр выходных данных, возвращаемых API.

2.0 Развертывание модели с помощью Docker

Docker — это инструмент, который помогает разработчикам упаковывать свои приложения и все, что им нужно для работы в контейнере. Контейнеры подобны автономным средам для приложений, которые включают в себя все необходимое для запуска. Docker позволяет легко запускать приложения на разных компьютерах или серверах.

Ключевые моменты:

1. Изоляция. Контейнеры обеспечивают безопасное пространство для запуска приложений, не мешая другим приложениям или системе.

2. Мобильность. Контейнеры можно создавать на одном компьютере и запускать на разных компьютерах или в облаке, что упрощает развертывание приложений в любом месте.

3. Эффективность. Контейнеры легкие, быстро запускаются и используют меньше системных ресурсов по сравнению с виртуальными машинами.

4. Простое управление зависимостями: Docker помогает управлять программным обеспечением и зависимостями, упрощая совместное использование и воспроизведение сред приложений.

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

6. Оптимизированное развертывание: Docker интегрируется с конвейерами CI/CD, автоматизируя процесс развертывания и уменьшая количество ошибок.

Таким образом, Docker упрощает упаковку и запуск приложений в изолированных контейнерах, обеспечивая согласованность, переносимость и эффективность для разработчиков в разных средах.

2.1 Этапы докеризации проекта.

Используя Hugging Face Spaces, процесс докеризации вашего проекта упрощается. Объятие Face Spaces абстрагирует многие сложности, связанные с созданием и развертыванием контейнеров Docker, позволяя вам сосредоточиться на разработке и доставке приложений для машинного обучения.

Чтобы докеризировать проект с помощью Hugging Face Spaces, вы можете выполнить следующие шаги:

Зарегистрируйтесь в Hugging Face Spaces.

Создайте новое пространство докеров для своего проекта.

Определите зависимости вашего проекта в файле requirements.txt.

Загрузите файлы проекта (Dockerfile, model.pkl, scaler.pkl, main.py, requirements.txt) в пространство.

Hugging Face Spaces автоматически создаст образ Docker на основе ваших файлов.

Образ Docker будет использоваться для развертывания контейнера Docker для вашего проекта.

Вы можете получить доступ и протестировать свое приложение FastAPI, используя предоставленный URL-адрес или конечную точку.

Отслеживайте развернутый контейнер Docker и управляйте им с помощью Hugging Face Spaces.

Следуя этим шагам, вы можете докеризировать свой проект с помощью Hugging Face Spaces, что упрощает развертывание и управление вашим приложением машинного обучения.

# Use the official Python image as the base image
FROM python:3.9
# Set the working directory in the container
WORKDIR /app
# Copy the requirements.txt file to the container
COPY requirements.txt .
# Install the Python dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the model.pkl and scaler.pkl files to the container
COPY model.pkl scaler.pkl .
# Copy the FastAPI app code to the container
COPY main.py .
# Expose the port the FastAPI app will run on
EXPOSE 8000
# Start the FastAPI app with Uvicorn when the container starts
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
  • Dockerfile начинается с оператора FROM, который указывает базовый образ. Здесь мы используем официальный образ Python версии 3.9.
  • Оператор WORKDIR устанавливает рабочий каталог в контейнере на /app.
  • Операторы COPY используются для копирования необходимых файлов (requirements.txt, model.pkl, scaler.pkl и main.py) в рабочий каталог контейнера.
  • Оператор RUN устанавливает зависимости Python, указанные в requirements.txt, используя pip.
  • Оператор EXPOSE предоставляет порт 8000, который является портом, на котором будет работать приложение FastAPI.
  • Оператор CMD определяет команду, которая будет выполняться при запуске контейнера. Здесь он запускает приложение FastAPI с помощью Uvicorn.

Используя этот Dockerfile, вы можете создать образ Docker, включающий ваше приложение FastAPI и его зависимости. При запуске контейнера на основе этого образа приложение FastAPI запустится и будет доступно через порт 8000.

Нажмите на ссылку ниже, чтобы увидеть окончательное приложение.

Заключение:

В этой статье мы рассмотрели комплексный проект машинного обучения, ориентированный на прогнозирование сепсиса с использованием методов классификации. Используя FastAPI, мы смогли развернуть модель как удобный API, позволяющий делать прогнозы в реальном времени. Сочетание машинного обучения и веб-разработки имеет огромный потенциал в здравоохранении и может внести значительный вклад в раннее выявление сепсиса и уход за пациентами. Мы надеемся, что эта статья предоставила вам ценную информацию и вдохновение для реализации подобных проектов или изучения других областей, в которых пересекаются машинное обучение и разработка API.

Если вы не читали первую часть этого проекта, нажмите на ссылку ниже.



Классификация: прогнозирование сепсиса с помощью машинного обучения и FastAPI
Часть 1medium.com



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



GitHub — ikoghoemmanuell/Machine-Learning-API-using-FastAPI
Разработка API машинного обучения (интерфейс прикладного программирования) с использованием FastAPI. В этом проекте я создаю API, который…github.com