feat: initial HSAP platform
Huaxu Sentinel Active Safety Platform with embedded algorithm code, Docker Compose setup, and vendored dataset scaffolds for clone-and-run. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
@@ -0,0 +1,110 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover how to set up and run Ultralytics YOLOv5 on AWS Deep Learning Instances. Follow our comprehensive guide to get started quickly and cost-effectively.
|
||||
keywords: YOLOv5, AWS, Deep Learning, Machine Learning, AWS EC2, YOLOv5 setup, Deep Learning Instances, AI, Object Detection, Ultralytics
|
||||
---
|
||||
|
||||
# Ultralytics YOLOv5 🚀 on AWS Deep Learning Instance: Your Complete Guide
|
||||
|
||||
Setting up a high-performance [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) environment can seem daunting, especially for newcomers. But fear not! 🛠️ This guide provides a step-by-step walkthrough for getting [Ultralytics YOLOv5](https://docs.ultralytics.com/models/yolov5/) up and running on an AWS Deep Learning instance. By leveraging the power of Amazon Web Services (AWS), even those new to [machine learning (ML)](https://www.ultralytics.com/glossary/machine-learning-ml) can start quickly and cost-effectively. The [scalability](https://www.ultralytics.com/glossary/scalability) of the AWS platform makes it ideal for both experimentation and production [deployment](https://docs.ultralytics.com/guides/model-deployment-options/).
|
||||
|
||||
Other quickstart options for YOLOv5 include our [Google Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>, [Kaggle environments](https://www.kaggle.com/models/ultralytics/yolov5) <a href="https://www.kaggle.com/models/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>, [GCP Deep Learning VM](./google_cloud_quickstart_tutorial.md), and our pre-built Docker image available on [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) <a href="https://hub.docker.com/r/ultralytics/yolov5"><img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"></a>.
|
||||
|
||||
## Step 1: AWS Console Sign-In
|
||||
|
||||
Begin by creating an account or signing in to the [AWS Management Console](https://aws.amazon.com/console/). Once logged in, navigate to the **EC2** service dashboard, where you can manage your virtual servers (instances).
|
||||
|
||||
|
||||
|
||||
## Step 2: Launch Your Instance
|
||||
|
||||
From the EC2 dashboard, click the **Launch Instance** button. This initiates the process of creating a new virtual server tailored to your needs.
|
||||
|
||||
|
||||
|
||||
### Selecting the Right Amazon Machine Image (AMI)
|
||||
|
||||
Choosing the correct AMI is crucial. This determines the operating system and pre-installed software for your instance. In the search bar, type '[Deep Learning](https://aws.amazon.com/ai/machine-learning/amis/)' and select the latest Ubuntu-based Deep Learning AMI (unless you have specific requirements for a different OS). Amazon's Deep Learning AMIs come pre-configured with popular [deep learning frameworks](https://aws.amazon.com/ai/machine-learning/amis/#Frameworks_and_Interface) (like [PyTorch](https://pytorch.org/), used by YOLOv5) and necessary [GPU drivers](https://developer.nvidia.com/cuda-downloads), significantly streamlining the setup process.
|
||||
|
||||
|
||||
|
||||
### Picking an Instance Type
|
||||
|
||||
For demanding tasks like training deep learning models, selecting a GPU-accelerated instance type is highly recommended. GPUs can dramatically reduce the time required for model training compared to CPUs. When choosing an instance size, ensure its memory capacity (RAM) is sufficient for your model and dataset.
|
||||
|
||||
**Note:** The size of your model and dataset are critical factors. If your ML task requires more memory than the selected instance provides, you'll need to choose a larger instance type to avoid performance issues or errors.
|
||||
|
||||
Explore the available GPU instance types on the [EC2 Instance Types page](https://aws.amazon.com/ec2/instance-types/), particularly under the **Accelerated Computing** category.
|
||||
|
||||
|
||||
|
||||
For detailed information on monitoring and optimizing GPU usage, refer to the AWS guide on [GPU Monitoring and Optimization](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-gpu.html). Compare costs using [On-Demand Pricing](https://aws.amazon.com/ec2/pricing/on-demand/) and explore potential savings with [Spot Instance Pricing](https://aws.amazon.com/ec2/spot/pricing/).
|
||||
|
||||
### Configuring Your Instance
|
||||
|
||||
Consider using Amazon EC2 Spot Instances for a more cost-effective approach. Spot Instances allow you to bid on unused EC2 capacity, often at a significant discount compared to On-Demand prices. For tasks that require persistence (saving data even if the Spot Instance is interrupted), choose a **persistent request**. This ensures your storage volume persists.
|
||||
|
||||
|
||||
|
||||
Proceed through Steps 4-7 of the instance launch wizard to configure storage, add tags, set up security groups (ensure SSH port 22 is open from your IP), and review your settings before clicking **Launch**. You'll also need to create or select an existing key pair for secure SSH access.
|
||||
|
||||
## Step 3: Connect to Your Instance
|
||||
|
||||
Once your instance state shows as 'running', select it from the EC2 dashboard. Click the **Connect** button to view connection options. Use the provided SSH command example in your local terminal (like Terminal on macOS/Linux or PuTTY/WSL on Windows) to establish a secure connection. You'll need the private key file (`.pem`) you created or selected during launch.
|
||||
|
||||
|
||||
|
||||
## Step 4: Running Ultralytics YOLOv5
|
||||
|
||||
Now that you're connected via SSH, you can set up and run YOLOv5. First, clone the official YOLOv5 repository from [GitHub](https://github.com/ultralytics/yolov5) and navigate into the directory. Then, install the required dependencies using `pip`. It's recommended to use a [Python](https://www.python.org/) 3.8 environment or later. The necessary models and datasets will be downloaded automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases) when you run commands like training or detection.
|
||||
|
||||
```bash
|
||||
# Clone the YOLOv5 repository
|
||||
git clone https://github.com/ultralytics/yolov5
|
||||
cd yolov5
|
||||
|
||||
# Install required packages
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
With the environment ready, you can start using YOLOv5 for various tasks:
|
||||
|
||||
```bash
|
||||
# Train a YOLOv5 model on a custom dataset (e.g., coco128.yaml)
|
||||
python train.py --data coco128.yaml --weights yolov5s.pt --img 640
|
||||
|
||||
# Validate the performance (Precision, Recall, mAP) of a trained model (e.g., yolov5s.pt)
|
||||
python val.py --weights yolov5s.pt --data coco128.yaml --img 640
|
||||
|
||||
# Run inference (object detection) on images or videos using a trained model
|
||||
python detect.py --weights yolov5s.pt --source path/to/your/images_or_videos/ --img 640
|
||||
|
||||
# Export the trained model to various formats like ONNX, CoreML, TFLite for deployment
|
||||
# See https://docs.ultralytics.com/modes/export/ for more details
|
||||
python export.py --weights yolov5s.pt --include onnx coreml tflite --img 640
|
||||
```
|
||||
|
||||
Refer to the Ultralytics documentation for detailed guides on [Training](https://docs.ultralytics.com/modes/train/), [Validation](https://docs.ultralytics.com/modes/val/), [Prediction (Inference)](https://docs.ultralytics.com/modes/predict/), and [Exporting](https://docs.ultralytics.com/modes/export/).
|
||||
|
||||
## Optional Extras: Increasing Swap Memory
|
||||
|
||||
If you're working with very large datasets or encounter memory limitations during training, increasing the swap memory on your instance can sometimes help. Swap space allows the system to use disk space as virtual RAM.
|
||||
|
||||
```bash
|
||||
# Allocate a 64GB swap file (adjust size as needed)
|
||||
sudo fallocate -l 64G /swapfile
|
||||
|
||||
# Set correct permissions
|
||||
sudo chmod 600 /swapfile
|
||||
|
||||
# Set up the file as a Linux swap area
|
||||
sudo mkswap /swapfile
|
||||
|
||||
# Enable the swap file
|
||||
sudo swapon /swapfile
|
||||
|
||||
# Verify the swap memory is active
|
||||
free -h
|
||||
```
|
||||
|
||||
Congratulations! 🎉 You have successfully set up an AWS Deep Learning instance, installed Ultralytics YOLOv5, and are ready to perform [object detection](https://www.ultralytics.com/glossary/object-detection) tasks. Whether you're experimenting with pretrained models or [training](https://docs.ultralytics.com/modes/train/) on your own data, this powerful setup provides a scalable foundation for your [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) projects. Should you encounter any issues, consult the extensive [AWS documentation](https://docs.aws.amazon.com/) and the helpful Ultralytics community resources like the [FAQ](https://docs.ultralytics.com/help/FAQ/). Happy detecting!
|
||||
@@ -0,0 +1,147 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to set up and run Ultralytics YOLOv5 on AzureML. Follow this quickstart guide for easy configuration and model training on an AzureML compute instance.
|
||||
keywords: YOLOv5, AzureML, machine learning, compute instance, quickstart, model training, virtual environment, Python, AI, deep learning, Ultralytics
|
||||
---
|
||||
|
||||
# Ultralytics YOLOv5 🚀 on AzureML Quickstart
|
||||
|
||||
Welcome to the Ultralytics [YOLOv5](../../models/yolov5.md) quickstart guide for Microsoft Azure Machine Learning (AzureML)! This guide will walk you through setting up YOLOv5 on an AzureML compute instance, covering everything from creating a virtual environment to training and running inference with the model.
|
||||
|
||||
## What is Azure?
|
||||
|
||||
[Azure](https://azure.microsoft.com/) is Microsoft's comprehensive [cloud computing](https://www.ultralytics.com/glossary/cloud-computing) platform. It offers a vast array of services, including computing power, databases, analytics tools, [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) capabilities, and networking solutions. Azure enables organizations to build, deploy, and manage applications and services through Microsoft-managed data centers, facilitating the migration of workloads from on-premises infrastructure to the cloud.
|
||||
|
||||
## What is Azure Machine Learning (AzureML)?
|
||||
|
||||
[Azure Machine Learning](https://azure.microsoft.com/products/machine-learning) (AzureML) is a specialized cloud service designed for developing, training, and deploying machine learning models. It provides a collaborative environment with tools suitable for data scientists and developers of all skill levels. Key features include [automated machine learning (AutoML)](https://www.ultralytics.com/glossary/automated-machine-learning-automl), a drag-and-drop interface for model creation, and a powerful [Python](https://www.python.org/) SDK for more granular control over the ML lifecycle. AzureML simplifies the process of embedding [predictive modeling](https://www.ultralytics.com/glossary/predictive-modeling) into applications.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
To follow this guide, you'll need an active [Azure subscription](https://azure.microsoft.com/free/) and access to an [AzureML workspace](https://learn.microsoft.com/azure/machine-learning/concept-workspace?view=azureml-api-2). If you don't have a workspace set up, please refer to the official [Azure documentation](https://learn.microsoft.com/azure/machine-learning/quickstart-create-resources?view=azureml-api-2) to create one.
|
||||
|
||||
## Create a Compute Instance
|
||||
|
||||
A compute instance in AzureML provides a managed cloud-based workstation for data scientists.
|
||||
|
||||
1. Navigate to your AzureML workspace.
|
||||
2. On the left pane, select **Compute**.
|
||||
3. Go to the **Compute instances** tab and click **New**.
|
||||
4. Configure your instance by selecting the appropriate CPU or [GPU](https://www.ultralytics.com/glossary/gpu-graphics-processing-unit) resources based on your needs for training or inference.
|
||||
|
||||
<img width="1741" alt="Azure ML create compute instance interface" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/create-compute-arrow.avif">
|
||||
|
||||
## Open a Terminal
|
||||
|
||||
Once your compute instance is running, you can access its terminal directly from the AzureML studio.
|
||||
|
||||
1. Go to the **Notebooks** section in the left pane.
|
||||
2. Find your compute instance in the top dropdown menu.
|
||||
3. Click on the **Terminal** option below the file browser to open a command-line interface to your instance.
|
||||
|
||||
|
||||
|
||||
## Setup and Run YOLOv5
|
||||
|
||||
Now, let's set up the environment and run Ultralytics YOLOv5.
|
||||
|
||||
### 1. Create a Virtual Environment
|
||||
|
||||
It's best practice to use a virtual environment to manage dependencies. We'll use [Conda](https://docs.conda.io/en/latest/), which is pre-installed on AzureML compute instances. For a detailed Conda setup guide, see the Ultralytics [Conda Quickstart Guide](../../guides/conda-quickstart.md).
|
||||
|
||||
Create a Conda environment (e.g., `yolov5env`) with a specific Python version and activate it:
|
||||
|
||||
```bash
|
||||
conda create --name yolov5env -y python=3.10 # Create a new Conda environment
|
||||
conda activate yolov5env # Activate the environment
|
||||
conda install pip -y # Ensure pip is installed
|
||||
```
|
||||
|
||||
### 2. Clone YOLOv5 Repository
|
||||
|
||||
Clone the official Ultralytics YOLOv5 repository from [GitHub](https://github.com/) using [Git](https://git-scm.com/):
|
||||
|
||||
```bash
|
||||
git clone https://github.com/ultralytics/yolov5 # Clone the repository
|
||||
cd yolov5 # Navigate into the directory
|
||||
# Initialize submodules (if any, though YOLOv5 typically doesn't require this step)
|
||||
# git submodule update --init --recursive
|
||||
```
|
||||
|
||||
### 3. Install Dependencies
|
||||
|
||||
Install the necessary Python packages listed in the `requirements.txt` file. We also install [ONNX](https://www.ultralytics.com/glossary/onnx-open-neural-network-exchange) for model export capabilities.
|
||||
|
||||
```bash
|
||||
pip install -r requirements.txt # Install core dependencies
|
||||
pip install "onnx>=1.12.0" # Install ONNX for exporting
|
||||
```
|
||||
|
||||
### 4. Perform YOLOv5 Tasks
|
||||
|
||||
With the setup complete, you can now train, validate, perform inference, and export your YOLOv5 model.
|
||||
|
||||
- **Train** the model on a dataset like [COCO128](../../datasets/detect/coco128.md). Check the [Training Mode](../../modes/train.md) documentation for more details.
|
||||
|
||||
```bash
|
||||
# Start training using yolov5s pretrained weights on the COCO128 dataset
|
||||
python train.py --data coco128.yaml --weights yolov5s.pt --img 640 --epochs 10 --batch 16
|
||||
```
|
||||
|
||||
- **Validate** the trained model's performance using metrics like [Precision](https://www.ultralytics.com/glossary/precision), [Recall](https://www.ultralytics.com/glossary/recall), and [mAP](https://www.ultralytics.com/glossary/mean-average-precision-map). See the [Validation Mode](../../modes/val.md) guide for options.
|
||||
|
||||
```bash
|
||||
# Validate the yolov5s model on the COCO128 validation set
|
||||
python val.py --weights yolov5s.pt --data coco128.yaml --img 640
|
||||
```
|
||||
|
||||
- **Run Inference** on new images or videos. Explore the [Prediction Mode](../../modes/predict.md) documentation for various inference sources.
|
||||
|
||||
```bash
|
||||
# Run inference with yolov5s on sample images
|
||||
python detect.py --weights yolov5s.pt --source data/images --img 640
|
||||
```
|
||||
|
||||
- **Export** the model to different formats like ONNX, [TensorRT](https://www.ultralytics.com/glossary/tensorrt), or [CoreML](https://docs.ultralytics.com/integrations/coreml/) for deployment. Refer to the [Export Mode](../../modes/export.md) guide and the [ONNX Integration](../../integrations/onnx.md) page.
|
||||
|
||||
```bash
|
||||
# Export yolov5s to ONNX format
|
||||
python export.py --weights yolov5s.pt --include onnx --img 640
|
||||
```
|
||||
|
||||
## Using a Notebook
|
||||
|
||||
If you prefer an interactive experience, you can run these commands within an AzureML Notebook. You'll need to create a custom [IPython kernel](https://ipython.readthedocs.io/en/stable/install/kernel_install.html) linked to your Conda environment.
|
||||
|
||||
### Create a New IPython Kernel
|
||||
|
||||
Run the following commands in your compute instance terminal:
|
||||
|
||||
```bash
|
||||
# Ensure your Conda environment is active
|
||||
# conda activate yolov5env
|
||||
|
||||
# Install ipykernel if not already present
|
||||
conda install ipykernel -y
|
||||
|
||||
# Create a new kernel linked to your environment
|
||||
python -m ipykernel install --user --name yolov5env --display-name "Python (yolov5env)"
|
||||
```
|
||||
|
||||
After creating the kernel, refresh your browser. When you open or create a `.ipynb` notebook file, select your new kernel ("Python (yolov5env)") from the kernel dropdown menu at the top right.
|
||||
|
||||
### Running Commands in Notebook Cells
|
||||
|
||||
- **Python Cells:** Code in Python cells will automatically execute using the selected `yolov5env` kernel.
|
||||
|
||||
- **Bash Cells:** To run shell commands, use the `%%bash` magic command at the beginning of the cell. Remember to activate your Conda environment within each bash cell, as they don't automatically inherit the notebook's kernel environment context.
|
||||
|
||||
```bash
|
||||
%%bash
|
||||
source activate yolov5env # Activate environment within the cell
|
||||
|
||||
# Example: Run validation using the activated environment
|
||||
python val.py --weights yolov5s.pt --data coco128.yaml --img 640
|
||||
```
|
||||
|
||||
Congratulations! You've successfully set up and run Ultralytics YOLOv5 on AzureML. For further exploration, consider checking out other [Ultralytics Integrations](../../integrations/index.md) or the detailed [YOLOv5 documentation](../index.md). You might also find the [AzureML documentation](https://learn.microsoft.com/en-us/azure/machine-learning/?view=azureml-api-2) useful for advanced scenarios like distributed training or model deployment as an endpoint.
|
||||
@@ -0,0 +1,205 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to set up and run YOLOv5 in a Docker container with step-by-step instructions for CPU and GPU environments, mounting volumes, and using display servers.
|
||||
keywords: YOLOv5, Docker, Ultralytics, setup, guide, tutorial, machine learning, deep learning, AI, GPU, NVIDIA, container, X11, Wayland
|
||||
---
|
||||
|
||||
# Get Started with YOLOv5 🚀 in Docker
|
||||
|
||||
Welcome to the Ultralytics YOLOv5 Docker Quickstart Guide! This tutorial provides step-by-step instructions for setting up and running [YOLOv5](../../models/yolov5.md) within a [Docker](https://www.ultralytics.com/glossary/docker) container. Using Docker enables you to run YOLOv5 in an isolated, consistent environment, simplifying deployment and dependency management across different systems. This approach leverages [containerization](https://www.ultralytics.com/glossary/containerization) to package the application and its dependencies together.
|
||||
|
||||
For alternative setup methods, consider our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/models/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>, [GCP Deep Learning VM](./google_cloud_quickstart_tutorial.md), or [Amazon AWS](./aws_quickstart_tutorial.md) guides. For a general overview of Docker usage with Ultralytics models, see the [Ultralytics Docker Quickstart Guide](../../guides/docker-quickstart.md).
|
||||
|
||||
## Prerequisites
|
||||
|
||||
Before you begin, ensure you have the following installed:
|
||||
|
||||
1. **Docker**: Download and install Docker from the [official Docker website](https://docs.docker.com/get-started/get-docker/). Docker is essential for creating and managing containers.
|
||||
2. **NVIDIA Drivers** (Required for [GPU](https://www.ultralytics.com/glossary/gpu-graphics-processing-unit) support): Ensure you have NVIDIA drivers version 455.23 or higher installed. You can download the latest drivers from [NVIDIA's website](https://www.nvidia.com/Download/index.aspx).
|
||||
3. **NVIDIA Container Toolkit** (Required for GPU support): This toolkit allows Docker containers to access your host machine's NVIDIA GPUs. Follow the official [NVIDIA Container Toolkit installation guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) for detailed instructions.
|
||||
|
||||
### Setting up NVIDIA Container Toolkit (GPU Users)
|
||||
|
||||
First, verify that your NVIDIA drivers are installed correctly by running:
|
||||
|
||||
```bash
|
||||
nvidia-smi
|
||||
```
|
||||
|
||||
This command should display information about your GPU(s) and the installed driver version.
|
||||
|
||||
Next, install the NVIDIA Container Toolkit. The commands below are typical for Debian-based systems like Ubuntu and RHEL-based systems like Fedora/CentOS, but refer to the official guide linked above for instructions specific to your distribution:
|
||||
|
||||
=== "Ubuntu/Debian"
|
||||
|
||||
```bash
|
||||
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
|
||||
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
|
||||
| sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
|
||||
| sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
|
||||
```
|
||||
|
||||
Update the package lists and install the nvidia-container-toolkit package:
|
||||
|
||||
```bash
|
||||
sudo apt-get update
|
||||
```
|
||||
|
||||
Install Latest version of nvidia-container-toolkit:
|
||||
|
||||
```bash
|
||||
sudo apt-get install -y nvidia-container-toolkit \
|
||||
nvidia-container-toolkit-base libnvidia-container-tools \
|
||||
libnvidia-container1
|
||||
```
|
||||
|
||||
??? info "Optional: Install specific version of nvidia-container-toolkit"
|
||||
|
||||
Optionally, you can install a specific version of the nvidia-container-toolkit by setting the `NVIDIA_CONTAINER_TOOLKIT_VERSION` environment variable:
|
||||
|
||||
```bash
|
||||
export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.17.8-1
|
||||
sudo apt-get install -y \
|
||||
nvidia-container-toolkit=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
|
||||
nvidia-container-toolkit-base=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
|
||||
libnvidia-container-tools=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
|
||||
libnvidia-container1=${NVIDIA_CONTAINER_TOOLKIT_VERSION}
|
||||
```
|
||||
|
||||
```bash
|
||||
sudo nvidia-ctk runtime configure --runtime=docker
|
||||
sudo systemctl restart docker
|
||||
```
|
||||
|
||||
=== "RHEL/CentOS/Fedora/Amazon Linux"
|
||||
|
||||
```bash
|
||||
curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo \
|
||||
| sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo
|
||||
```
|
||||
|
||||
Update the package lists and install the nvidia-container-toolkit package:
|
||||
|
||||
```bash
|
||||
sudo dnf clean expire-cache
|
||||
sudo dnf check-update
|
||||
```
|
||||
|
||||
```bash
|
||||
sudo dnf install \
|
||||
nvidia-container-toolkit \
|
||||
nvidia-container-toolkit-base \
|
||||
libnvidia-container-tools \
|
||||
libnvidia-container1
|
||||
```
|
||||
|
||||
??? info "Optional: Install specific version of nvidia-container-toolkit"
|
||||
|
||||
Optionally, you can install a specific version of the nvidia-container-toolkit by setting the `NVIDIA_CONTAINER_TOOLKIT_VERSION` environment variable:
|
||||
|
||||
```bash
|
||||
export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.17.8-1
|
||||
sudo dnf install -y \
|
||||
nvidia-container-toolkit-${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
|
||||
nvidia-container-toolkit-base-${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
|
||||
libnvidia-container-tools-${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
|
||||
libnvidia-container1-${NVIDIA_CONTAINER_TOOLKIT_VERSION}
|
||||
```
|
||||
|
||||
```bash
|
||||
sudo nvidia-ctk runtime configure --runtime=docker
|
||||
sudo systemctl restart docker
|
||||
```
|
||||
|
||||
### Verify NVIDIA Runtime with Docker
|
||||
|
||||
Run `docker info | grep -i runtime` to ensure that `nvidia` appears in the list of runtimes:
|
||||
|
||||
```bash
|
||||
docker info | grep -i runtime
|
||||
```
|
||||
|
||||
You should see `nvidia` listed as one of the available runtimes.
|
||||
|
||||
## Step 1: Pull the YOLOv5 Docker Image
|
||||
|
||||
Ultralytics provides official YOLOv5 images on [Docker Hub](https://hub.docker.com/). The `latest` tag tracks the most recent repository commit, ensuring you always get the newest version. Pull the image using the following command:
|
||||
|
||||
```bash
|
||||
# Define the image name with tag
|
||||
t=ultralytics/yolov5:latest
|
||||
|
||||
# Pull the latest YOLOv5 image from Docker Hub
|
||||
sudo docker pull $t
|
||||
```
|
||||
|
||||
You can browse all available images at the [Ultralytics YOLOv5 Docker Hub repository](https://hub.docker.com/r/ultralytics/yolov5).
|
||||
|
||||
## Step 2: Run the Docker Container
|
||||
|
||||
Once the image is pulled, you can run it as a container.
|
||||
|
||||
### Using CPU Only
|
||||
|
||||
To run an interactive container instance using only the CPU, use the `-it` flag. The `--ipc=host` flag allows sharing of host IPC namespace, which is important for shared memory access.
|
||||
|
||||
```bash
|
||||
# Run an interactive container instance using CPU
|
||||
sudo docker run -it --runtime=nvidia --ipc=host $t
|
||||
```
|
||||
|
||||
### Using GPU
|
||||
|
||||
To enable GPU access within the container, use the `--gpus` flag. This requires the NVIDIA Container Toolkit to be installed correctly.
|
||||
|
||||
```bash
|
||||
# Run with access to all available GPUs
|
||||
sudo docker run -it --runtime=nvidia --ipc=host --gpus all $t
|
||||
|
||||
# Run with access to specific GPUs (e.g., GPUs 2 and 3)
|
||||
sudo docker run -it --runtime=nvidia --ipc=host --gpus '"device=2,3"' $t
|
||||
```
|
||||
|
||||
Refer to the [Docker run reference](https://docs.docker.com/engine/containers/run/) for more details on command options.
|
||||
|
||||
### Mounting Local Directories
|
||||
|
||||
To work with your local files (datasets, model weights, etc.) inside the container, use the `-v` flag to mount a host directory into the container:
|
||||
|
||||
```bash
|
||||
# Mount /path/on/host (your local machine) to /path/in/container (inside the container)
|
||||
sudo docker run -it --runtime=nvidia --ipc=host --gpus all -v /path/on/host:/path/in/container $t
|
||||
```
|
||||
|
||||
Replace `/path/on/host` with the actual path on your machine and `/path/in/container` with the desired path inside the Docker container (e.g., `/usr/src/datasets`).
|
||||
|
||||
## Step 3: Use YOLOv5 🚀 within the Docker Container
|
||||
|
||||
You are now inside the running YOLOv5 Docker container! From here, you can execute standard YOLOv5 commands for various [Machine Learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [Deep Learning](https://www.ultralytics.com/glossary/deep-learning-dl) tasks like [Object Detection](https://www.ultralytics.com/glossary/object-detection).
|
||||
|
||||
```bash
|
||||
# Train a YOLOv5 model on your custom dataset (ensure data is mounted or downloaded)
|
||||
python train.py --data your_dataset.yaml --weights yolov5s.pt --img 640 # Start training
|
||||
|
||||
# Validate the trained model's performance (Precision, Recall, mAP)
|
||||
python val.py --weights path/to/your/best.pt --data your_dataset.yaml # Validate accuracy
|
||||
|
||||
# Run inference on images or videos using a trained model
|
||||
python detect.py --weights yolov5s.pt --source path/to/your/images_or_videos # Perform detection
|
||||
|
||||
# Export the trained model to various formats like ONNX, CoreML, or TFLite for deployment
|
||||
python export.py --weights yolov5s.pt --include onnx coreml tflite # Export model
|
||||
```
|
||||
|
||||
Explore the documentation for detailed usage of different modes:
|
||||
|
||||
- [Train](../../modes/train.md)
|
||||
- [Validate](../../modes/val.md)
|
||||
- [Predict](../../modes/predict.md)
|
||||
- [Export](../../modes/export.md)
|
||||
|
||||
Learn more about evaluation metrics like [Precision](https://www.ultralytics.com/glossary/precision), [Recall](https://www.ultralytics.com/glossary/recall), and [mAP](https://www.ultralytics.com/glossary/mean-average-precision-map). Understand different export formats like [ONNX](../../integrations/onnx.md), [CoreML](../../integrations/coreml.md), and [TFLite](../../integrations/tflite.md), and explore various [Model Deployment Options](../../guides/model-deployment-options.md). Remember to manage your [model weights](https://www.ultralytics.com/glossary/model-weights) effectively.
|
||||
|
||||
<p align="center"><img width="1000" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/gcp-running-docker.avif" alt="Running YOLOv5 inside a Docker container on GCP"></p>
|
||||
|
||||
You have successfully set up and run YOLOv5 within a Docker container.
|
||||
@@ -0,0 +1,130 @@
|
||||
---
|
||||
comments: true
|
||||
description: Master Ultralytics YOLOv5 deployment on Google Cloud Platform Deep Learning VM. Perfect for AI beginners and experts to achieve high-performance object detection.
|
||||
keywords: YOLOv5, Google Cloud Platform, GCP, Deep Learning VM, object detection, AI, machine learning, tutorial, cloud computing, GPU acceleration, Ultralytics
|
||||
---
|
||||
|
||||
# Mastering YOLOv5 Deployment on Google Cloud Platform (GCP) Deep Learning VM
|
||||
|
||||
Embarking on the journey of [artificial intelligence (AI)](https://www.ultralytics.com/glossary/artificial-intelligence-ai) and [machine learning (ML)](https://www.ultralytics.com/glossary/machine-learning-ml) can be exhilarating, especially when you leverage the power and flexibility of a [cloud computing](https://www.ultralytics.com/glossary/cloud-computing) platform. Google Cloud Platform (GCP) offers robust tools tailored for ML enthusiasts and professionals alike. One such tool is the Deep Learning VM, preconfigured for data science and ML tasks. In this tutorial, we will navigate the process of setting up [Ultralytics YOLOv5](../../models/yolov5.md) on a [GCP Deep Learning VM](https://docs.cloud.google.com/deep-learning-vm/docs). Whether you're taking your first steps in ML or you're a seasoned practitioner, this guide provides a clear pathway to implementing [object detection](https://www.ultralytics.com/glossary/object-detection) models powered by YOLOv5.
|
||||
|
||||
🆓 Plus, if you're a new GCP user, you're in luck with a [$300 free credit offer](https://cloud.google.com/free/docs/free-cloud-features#free-trial) to kickstart your projects.
|
||||
|
||||
In addition to GCP, explore other accessible quickstart options for YOLOv5, like our [Google Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"> for a browser-based experience, or the scalability of [Amazon AWS](./aws_quickstart_tutorial.md). Furthermore, container aficionados can utilize our official Docker image available on [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) <img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"> for an encapsulated environment, following our [Docker Quickstart Guide](../../guides/docker-quickstart.md).
|
||||
|
||||
## Step 1: Create and Configure Your Deep Learning VM
|
||||
|
||||
Let's begin by creating a virtual machine optimized for [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl):
|
||||
|
||||
1. Navigate to the [GCP marketplace](https://cloud.google.com/marketplace) and select the **Deep Learning VM**.
|
||||
2. Choose an **n1-standard-8** instance; it offers a balance of 8 vCPUs and 30 GB of memory, suitable for many ML tasks.
|
||||
3. Select a [GPU](https://www.ultralytics.com/glossary/gpu-graphics-processing-unit). The choice depends on your workload; even a basic T4 GPU will significantly accelerate model training.
|
||||
4. Check the box for 'Install NVIDIA GPU driver automatically on first startup?' for a seamless setup.
|
||||
5. Allocate a 300 GB SSD Persistent Disk to prevent I/O bottlenecks.
|
||||
6. Click 'Deploy' and allow GCP to provision your custom Deep Learning VM.
|
||||
|
||||
This VM comes pre-loaded with essential tools and frameworks, including the [Anaconda](https://www.anaconda.com/) Python distribution, which conveniently bundles many necessary dependencies for YOLOv5.
|
||||
|
||||
|
||||
|
||||
## Step 2: Prepare the VM for YOLOv5
|
||||
|
||||
After setting up the environment, let's get YOLOv5 installed and ready:
|
||||
|
||||
```bash
|
||||
# Clone the YOLOv5 repository
|
||||
git clone https://github.com/ultralytics/yolov5
|
||||
cd yolov5
|
||||
|
||||
# Install dependencies
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
This setup process ensures you have a Python environment version 3.8.0 or newer and [PyTorch](https://www.ultralytics.com/glossary/pytorch) 1.8 or later. Our scripts automatically download [models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases), simplifying the process of starting model training.
|
||||
|
||||
## Step 3: Train and Deploy Your YOLOv5 Models
|
||||
|
||||
With the setup complete, you are ready to [train](../../modes/train.md), [validate](../../modes/val.md), [predict](../../modes/predict.md), and [export](../../modes/export.md) with YOLOv5 on your GCP VM:
|
||||
|
||||
```bash
|
||||
# Train a YOLOv5 model on your dataset (e.g., yolov5s)
|
||||
python train.py --data coco128.yaml --weights yolov5s.pt --img 640
|
||||
|
||||
# Validate the trained model to check Precision, Recall, and mAP
|
||||
python val.py --weights yolov5s.pt --data coco128.yaml
|
||||
|
||||
# Run inference using the trained model on images or videos
|
||||
python detect.py --weights yolov5s.pt --source path/to/your/images_or_videos
|
||||
|
||||
# Export the trained model to various formats like ONNX, CoreML, TFLite for deployment
|
||||
python export.py --weights yolov5s.pt --include onnx coreml tflite
|
||||
```
|
||||
|
||||
Using just a few commands, YOLOv5 enables you to train custom [object detection](https://docs.ultralytics.com/tasks/detect/) models tailored to your specific needs or utilize pretrained weights for rapid results across various tasks. Explore different [model deployment options](../../guides/model-deployment-options.md) after exporting.
|
||||
|
||||
|
||||
|
||||
## Allocate Swap Space (Optional)
|
||||
|
||||
If you are working with particularly large datasets that might exceed your VM's RAM, consider adding swap space to prevent memory errors:
|
||||
|
||||
```bash
|
||||
# Allocate a 64GB swap file
|
||||
sudo fallocate -l 64G /swapfile
|
||||
|
||||
# Set the correct permissions for the swap file
|
||||
sudo chmod 600 /swapfile
|
||||
|
||||
# Set up the Linux swap area
|
||||
sudo mkswap /swapfile
|
||||
|
||||
# Enable the swap file
|
||||
sudo swapon /swapfile
|
||||
|
||||
# Verify the swap space allocation (should show increased swap memory)
|
||||
free -h
|
||||
```
|
||||
|
||||
## Training Custom Datasets
|
||||
|
||||
To train YOLOv5 on your custom dataset within GCP, follow these general steps:
|
||||
|
||||
1. Prepare your dataset according to the YOLOv5 format (images and corresponding label files). See our [datasets overview](../../datasets/index.md) for guidance.
|
||||
2. Upload your dataset to your GCP VM using `gcloud compute scp` or the web console's SSH feature.
|
||||
3. Create a dataset configuration YAML file (`custom_dataset.yaml`) that specifies the paths to your training and validation data, the number of classes, and class names.
|
||||
4. Begin the [training process](../../modes/train.md) using your custom dataset YAML and potentially starting from pretrained weights:
|
||||
|
||||
```bash
|
||||
# Example: Train YOLOv5s on a custom dataset for 100 epochs
|
||||
python train.py --img 640 --batch 16 --epochs 100 --data custom_dataset.yaml --weights yolov5s.pt
|
||||
```
|
||||
|
||||
For comprehensive instructions on preparing data and training with custom datasets, consult the [Ultralytics YOLOv5 Train documentation](../../modes/train.md).
|
||||
|
||||
## Leveraging Cloud Storage
|
||||
|
||||
For efficient data management, especially with large datasets or numerous experiments, integrate your YOLOv5 workflow with [Google Cloud Storage](https://cloud.google.com/storage):
|
||||
|
||||
```bash
|
||||
# Ensure Google Cloud SDK is installed and initialized
|
||||
# If not installed: curl https://sdk.cloud.google.com/ | bash
|
||||
# Then initialize: gcloud init
|
||||
|
||||
# Example: Copy your dataset from a GCS bucket to your VM
|
||||
gsutil cp -r gs://your-data-bucket/my_dataset ./datasets/
|
||||
|
||||
# Example: Copy trained model weights from your VM to a GCS bucket
|
||||
gsutil cp -r ./runs/train/exp/weights gs://your-models-bucket/yolov5_custom_weights/
|
||||
```
|
||||
|
||||
This approach allows you to store large datasets and trained models securely and cost-effectively in the cloud, minimizing the storage requirements on your VM instance.
|
||||
|
||||
## Concluding Thoughts
|
||||
|
||||
Congratulations! You are now equipped to harness the capabilities of Ultralytics YOLOv5 combined with the computational power of Google Cloud Platform. This setup provides scalability, efficiency, and versatility for your object detection projects. Whether for personal exploration, academic research, or building industrial [solutions](../../solutions/index.md), you have taken a significant step into the world of AI and ML on the cloud.
|
||||
|
||||
Consider using [Ultralytics Platform](../../platform/index.md) for a streamlined, no-code experience to train and manage your models.
|
||||
|
||||
Remember to document your progress, share insights with the vibrant Ultralytics community, and utilize resources like [GitHub discussions](https://github.com/ultralytics/yolov5/discussions) for collaboration and support. Now, go forth and innovate with YOLOv5 and GCP!
|
||||
|
||||
Want to continue enhancing your ML skills? Dive into our [documentation](../../quickstart.md) and explore the [Ultralytics Blog](https://www.ultralytics.com/blog) for more tutorials and insights. Let your AI adventure continue!
|
||||
Reference in New Issue
Block a user