ultralytics 8.2.2 replace COCO128 with COCO8 (#10167)

Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>

docs/en/integrations/clearml.md

@@ -80,7 +80,7 @@ Before diving into the usage instructions, be sure to check out the range of [YO
         model = YOLO(f'{model_variant}.pt')
 
         # Step 4: Setting Up Training Arguments
-        args = dict(data="coco128.yaml", epochs=16)
+        args = dict(data="coco8.yaml", epochs=16)
         task.connect(args)
 
         # Step 5: Initiating Model Training
@@ -97,7 +97,7 @@ Let’s understand the steps showcased in the usage code snippet above.
 
 **Step 3: Loading the YOLOv8 Model**: The selected YOLOv8 model is loaded using Ultralytics' YOLO class, preparing it for training.
 
-**Step 4: Setting Up Training Arguments**: Key training arguments like the dataset (`coco128.yaml`) and the number of epochs (`16`) are organized in a dictionary and connected to the ClearML task. This allows for tracking and potential modification via the ClearML UI. For a detailed understanding of the model training process and best practices, refer to our [YOLOv8 Model Training guide](../modes/train.md).
+**Step 4: Setting Up Training Arguments**: Key training arguments like the dataset (`coco8.yaml`) and the number of epochs (`16`) are organized in a dictionary and connected to the ClearML task. This allows for tracking and potential modification via the ClearML UI. For a detailed understanding of the model training process and best practices, refer to our [YOLOv8 Model Training guide](../modes/train.md).
 
 **Step 5: Initiating Model Training**: The model training is started with the specified arguments. The results of the training process are captured in the `results` variable.
 

docs/en/integrations/comet.md

@@ -74,7 +74,7 @@ Before diving into the usage instructions, be sure to check out the range of [YO
 
         # train the model
         results = model.train(
-        data="coco128.yaml",
+        data="coco8.yaml",
         project="comet-example-yolov8-coco128",
         batch=32,
         save_period=1,

docs/en/integrations/index.md

@@ -71,8 +71,8 @@ Welcome to the Ultralytics Integrations page! This page provides an overview of
 
 - [TFLite Edge TPU](edge-tpu.md): Developed by [Google](https://www.google.com) for optimizing TensorFlow Lite models on Edge TPUs, this model format ensures high-speed, efficient edge computing.
 
-- [TF.js](tfjs.md): Developed by [Google](https://www.google.com) to facilitate machine learning in browsers and Node.js, TF.js allows JavaScript-based deployment of ML models. 
-  
+- [TF.js](tfjs.md): Developed by [Google](https://www.google.com) to facilitate machine learning in browsers and Node.js, TF.js allows JavaScript-based deployment of ML models.
+
 - [PaddlePaddle](paddlepaddle.md): An open-source deep learning platform by [Baidu](https://www.baidu.com/), PaddlePaddle enables the efficient deployment of AI models and focuses on the scalability of industrial applications.
 
 - [NCNN](ncnn.md): Developed by [Tencent](http://www.tencent.com/), NCNN is an efficient neural network inference framework tailored for mobile devices. It enables direct deployment of AI models into apps, optimizing performance across various mobile platforms.

docs/en/integrations/openvino.md

@@ -261,14 +261,14 @@ To reproduce the Ultralytics benchmarks above on all export [formats](../modes/e
         # Load a YOLOv8n PyTorch model
         model = YOLO('yolov8n.pt')
 
-        # Benchmark YOLOv8n speed and accuracy on the COCO128 dataset for all all export formats
-        results= model.benchmarks(data='coco128.yaml')
+        # Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
+        results= model.benchmarks(data='coco8.yaml')
         ```
     === "CLI"
 
         ```bash
-        # Benchmark YOLOv8n speed and accuracy on the COCO128 dataset for all all export formats
-        yolo benchmark model=yolov8n.pt data=coco128.yaml
+        # Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
+        yolo benchmark model=yolov8n.pt data=coco8.yaml
         ```
 
     Note that benchmarking results might vary based on the exact hardware and software configuration of a system, as well as the current workload of the system at the time the benchmarks are run. For the most reliable results use a dataset with a large number of images, i.e. `data='coco128.yaml' (128 val images), or `data='coco.yaml'` (5000 val images).

docs/en/integrations/ray-tune.md

@@ -112,13 +112,13 @@ In this example, we demonstrate how to use a custom search space for hyperparame
     model = YOLO("yolov8n.pt")
 
     # Run Ray Tune on the model
-    result_grid = model.tune(data="coco128.yaml",
+    result_grid = model.tune(data="coco8.yaml",
                              space={"lr0": tune.uniform(1e-5, 1e-1)},
                              epochs=50,
                              use_ray=True)
     ```
 
-In the code snippet above, we create a YOLO model with the "yolov8n.pt" pretrained weights. Then, we call the `tune()` method, specifying the dataset configuration with "coco128.yaml". We provide a custom search space for the initial learning rate `lr0` using a dictionary with the key "lr0" and the value `tune.uniform(1e-5, 1e-1)`. Finally, we pass additional training arguments, such as the number of epochs directly to the tune method as `epochs=50`.
+In the code snippet above, we create a YOLO model with the "yolov8n.pt" pretrained weights. Then, we call the `tune()` method, specifying the dataset configuration with "coco8.yaml". We provide a custom search space for the initial learning rate `lr0` using a dictionary with the key "lr0" and the value `tune.uniform(1e-5, 1e-1)`. Finally, we pass additional training arguments, such as the number of epochs directly to the tune method as `epochs=50`.
 
 ## Processing Ray Tune Results
 

docs/en/integrations/tensorboard.md

@@ -67,7 +67,7 @@ Before diving into the usage instructions, be sure to check out the range of [YO
        model = YOLO('yolov8n.pt')
 
        # Train the model
-       results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
+       results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
        ```
 
 Upon running the usage code snippet above, you can expect the following output:

docs/en/integrations/tfjs.md

@@ -32,7 +32,7 @@ Here are the key features that make TF.js a powerful tool for developers:
 
 ## Deployment Options with TensorFlow.js
 
-Before we dive into the process of exporting YOLOv8 models to the TF.js format, let's explore some typical deployment scenarios where this format is used. 
+Before we dive into the process of exporting YOLOv8 models to the TF.js format, let's explore some typical deployment scenarios where this format is used.
 
 TF.js provides a range of options to deploy your machine learning models:
 

docs/en/integrations/weights-biases.md

@@ -72,7 +72,7 @@ Before diving into the usage instructions for YOLOv8 model training with Weights
 
        # Step 2: Define the YOLOv8 Model and Dataset
        model_name = "yolov8n"
-       dataset_name = "coco128.yaml"
+       dataset_name = "coco8.yaml"
        model = YOLO(f"{model_name}.pt")
 
        # Step 3: Add W&B Callback for Ultralytics