Add FAQs to Docs Datasets and Help sections (#14211)

Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com> Co-authored-by: UltralyticsAssistant <web@ultralytics.com>
2024-07-04 20:42:31 +02:00 · 2024-07-04 20:42:31 +02:00 · d5db9c916f
commit d5db9c916f
parent 64862f1b69
73 changed files with 3296 additions and 110 deletions
--- a/docs/en/datasets/classify/caltech101.md
+++ b/docs/en/datasets/classify/caltech101.md
@ -79,3 +79,71 @@ If you use the Caltech-101 dataset in your research or development work, please
        ```

 We would like to acknowledge Li Fei-Fei, Rob Fergus, and Pietro Perona for creating and maintaining the Caltech-101 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the Caltech-101 dataset and its creators, visit the [Caltech-101 dataset website](https://data.caltech.edu/records/mzrjq-6wc02).
+
+## FAQ
+
+### What is the Caltech-101 dataset used for in machine learning?
+
+The [Caltech-101](https://data.caltech.edu/records/mzrjq-6wc02) dataset is widely used in machine learning for object recognition tasks. It contains around 9,000 images across 101 categories, providing a challenging benchmark for evaluating object recognition algorithms. Researchers leverage it to train and test models, especially Convolutional Neural Networks (CNNs) and Support Vector Machines (SVMs), in computer vision.
+
+### How can I train an Ultralytics YOLO model on the Caltech-101 dataset?
+
+To train an Ultralytics YOLO model on the Caltech-101 dataset, you can use the provided code snippets. For example, to train for 100 epochs:
+
+!!! Example "Train Example"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+        # Train the model
+        results = model.train(data="caltech101", epochs=100, imgsz=416)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Start training from a pretrained *.pt model
+        yolo detect train data=caltech101 model=yolov8n-cls.pt epochs=100 imgsz=416
+        ```
+For more detailed arguments and options, refer to the model [Training](../../modes/train.md) page.
+
+### What are the key features of the Caltech-101 dataset?
+
+The Caltech-101 dataset includes:
+- Around 9,000 color images across 101 categories.
+- Categories covering a diverse range of objects, including animals, vehicles, and household items.
+- Variable number of images per category, typically between 40 and 800.
+- Variable image sizes, with most being medium resolution.
+
+These features make it an excellent choice for training and evaluating object recognition models in machine learning and computer vision.
+
+### Why should I cite the Caltech-101 dataset in my research?
+
+Citing the Caltech-101 dataset in your research acknowledges the creators' contributions and provides a reference for others who might use the dataset. The recommended citation is:
+
+!!! Quote ""
+
+    === "BibTeX"
+
+        ```bibtex
+        @article{fei2007learning,
+          title={Learning generative visual models from few training examples: An incremental Bayesian approach tested on 101 object categories},
+          author={Fei-Fei, Li and Fergus, Rob and Perona, Pietro},
+          journal={Computer vision and Image understanding},
+          volume={106},
+          number={1},
+          pages={59--70},
+          year={2007},
+          publisher={Elsevier}
+        }
+        ```
+Citing helps in maintaining the integrity of academic work and assists peers in locating the original resource.
+
+### Can I use Ultralytics HUB for training models on the Caltech-101 dataset?
+
+Yes, you can use Ultralytics HUB for training models on the Caltech-101 dataset. Ultralytics HUB provides an intuitive platform for managing datasets, training models, and deploying them without extensive coding. For a detailed guide, refer to the [how to train your custom models with Ultralytics HUB](https://www.ultralytics.com/blog/how-to-train-your-custom-models-with-ultralytics-hub) blog post.
--- a/docs/en/datasets/classify/caltech256.md
+++ b/docs/en/datasets/classify/caltech256.md
@ -76,3 +76,60 @@ If you use the Caltech-256 dataset in your research or development work, please
 We would like to acknowledge Gregory Griffin, Alex Holub, and Pietro Perona for creating and maintaining the Caltech-256 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the

 Caltech-256 dataset and its creators, visit the [Caltech-256 dataset website](https://data.caltech.edu/records/nyy15-4j048).
+
+## FAQ
+
+### What is the Caltech-256 dataset and why is it important for machine learning?
+
+The [Caltech-256](https://data.caltech.edu/records/nyy15-4j048) dataset is a large image dataset used primarily for object classification tasks in machine learning and computer vision. It consists of around 30,000 color images divided into 257 categories, covering a wide range of real-world objects. The dataset's diverse and high-quality images make it an excellent benchmark for evaluating object recognition algorithms, which is crucial for developing robust machine learning models.
+
+### How can I train a YOLO model on the Caltech-256 dataset using Python or CLI?
+
+To train a YOLO model on the Caltech-256 dataset for 100 epochs, you can use the following code snippets. Refer to the model [Training](../../modes/train.md) page for additional options.
+
+!!! Example "Train Example"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model
+
+        # Train the model
+        results = model.train(data="caltech256", epochs=100, imgsz=416)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Start training from a pretrained *.pt model
+        yolo detect train data=caltech256 model=yolov8n-cls.pt epochs=100 imgsz=416
+        ```
+
+### What are the most common use cases for the Caltech-256 dataset?
+
+The Caltech-256 dataset is widely used for various object recognition tasks such as:
+
+- Training Convolutional Neural Networks (CNNs)
+- Evaluating the performance of Support Vector Machines (SVMs)
+- Benchmarking new deep learning algorithms
+- Developing object detection models using frameworks like Ultralytics YOLO
+
+Its diversity and comprehensive annotations make it ideal for research and development in machine learning and computer vision.
+
+### How is the Caltech-256 dataset structured and split for training and testing?
+
+The Caltech-256 dataset does not come with a predefined split for training and testing. Users typically create their own splits according to their specific needs. A common approach is to randomly select a subset of images for training and use the remaining images for testing. This flexibility allows users to tailor the dataset to their specific project requirements and experimental setups.
+
+### Why should I use Ultralytics YOLO for training models on the Caltech-256 dataset?
+
+Ultralytics YOLO models offer several advantages for training on the Caltech-256 dataset:
+
+- **High Accuracy**: YOLO models are known for their state-of-the-art performance in object detection tasks.
+- **Speed**: They provide real-time inference capabilities, making them suitable for applications requiring quick predictions.
+- **Ease of Use**: With Ultralytics HUB, users can train, validate, and deploy models without extensive coding.
+- **Pretrained Models**: Starting from pretrained models, like `yolov8n-cls.pt`, can significantly reduce training time and improve model accuracy.
+
+For more details, explore our [comprehensive training guide](../../modes/train.md).
--- a/docs/en/datasets/classify/cifar10.md
+++ b/docs/en/datasets/classify/cifar10.md
@ -78,3 +78,81 @@ If you use the CIFAR-10 dataset in your research or development work, please cit
        ```

 We would like to acknowledge Alex Krizhevsky for creating and maintaining the CIFAR-10 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the CIFAR-10 dataset and its creator, visit the [CIFAR-10 dataset website](https://www.cs.toronto.edu/~kriz/cifar.html).
+
+## FAQ
+
+### How can I train a YOLO model on the CIFAR-10 dataset?
+
+To train a YOLO model on the CIFAR-10 dataset using Ultralytics, you can follow the examples provided for both Python and CLI. Here is a basic example to train your model for 100 epochs with an image size of 32x32 pixels:
+
+!!! Example
+
+    === "Python"
+
+    ```python
+    from ultralytics import YOLO
+
+    # Load a model
+    model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+    # Train the model
+    results = model.train(data="cifar10", epochs=100, imgsz=32)
+    ```
+
+    === "CLI"
+
+    ```bash
+    # Start training from a pretrained *.pt model
+    yolo detect train data=cifar10 model=yolov8n-cls.pt epochs=100 imgsz=32
+    ```
+
+For more details, refer to the model [Training](../../modes/train.md) page.
+
+### What are the key features of the CIFAR-10 dataset?
+
+The CIFAR-10 dataset consists of 60,000 color images divided into 10 classes. Each class contains 6,000 images, with 5,000 for training and 1,000 for testing. The images are 32x32 pixels in size and vary across the following categories:
+
+- Airplanes
+- Cars
+- Birds
+- Cats
+- Deer
+- Dogs
+- Frogs
+- Horses
+- Ships
+- Trucks
+
+This diverse dataset is essential for training image classification models in fields such as machine learning and computer vision. For more information, visit the CIFAR-10 sections on [dataset structure](#dataset-structure) and [applications](#applications).
+
+### Why use the CIFAR-10 dataset for image classification tasks?
+
+The CIFAR-10 dataset is an excellent benchmark for image classification due to its diversity and structure. It contains a balanced mix of 60,000 labeled images across 10 different categories, which helps in training robust and generalized models. It is widely used for evaluating deep learning models, including Convolutional Neural Networks (CNNs) and other machine learning algorithms. The dataset is relatively small, making it suitable for quick experimentation and algorithm development. Explore its numerous applications in the [applications](#applications) section.
+
+### How is the CIFAR-10 dataset structured?
+
+The CIFAR-10 dataset is structured into two main subsets:
+
+1. **Training Set**: Contains 50,000 images used for training machine learning models.
+2. **Testing Set**: Consists of 10,000 images for testing and benchmarking the trained models.
+
+Each subset comprises images categorized into 10 classes, with their annotations readily available for model training and evaluation. For more detailed information, refer to the [dataset structure](#dataset-structure) section.
+
+### How can I cite the CIFAR-10 dataset in my research?
+
+If you use the CIFAR-10 dataset in your research or development projects, make sure to cite the following paper:
+
+```bibtex
+@TECHREPORT{Krizhevsky09learningmultiple,
+            author={Alex Krizhevsky},
+            title={Learning multiple layers of features from tiny images},
+            institution={},
+            year={2009}
+}
+```
+
+Acknowledging the dataset's creators helps support continued research and development in the field. For more details, see the [citations and acknowledgments](#citations-and-acknowledgments) section.
+
+### What are some practical examples of using the CIFAR-10 dataset?
+
+The CIFAR-10 dataset is often used for training image classification models, such as Convolutional Neural Networks (CNNs) and Support Vector Machines (SVMs). These models can be employed in various computer vision tasks including object detection, image recognition, and automated tagging. To see some practical examples, check the code snippets in the [usage](#usage) section.
--- a/docs/en/datasets/classify/cifar100.md
+++ b/docs/en/datasets/classify/cifar100.md
@ -78,3 +78,53 @@ If you use the CIFAR-100 dataset in your research or development work, please ci
        ```

 We would like to acknowledge Alex Krizhevsky for creating and maintaining the CIFAR-100 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the CIFAR-100 dataset and its creator, visit the [CIFAR-100 dataset website](https://www.cs.toronto.edu/~kriz/cifar.html).
+
+## FAQ
+
+### What is the CIFAR-100 dataset and why is it significant?
+
+The [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html) is a large collection of 60,000 32x32 color images classified into 100 classes. Developed by the Canadian Institute For Advanced Research (CIFAR), it provides a challenging dataset ideal for complex machine learning and computer vision tasks. Its significance lies in the diversity of classes and the small size of the images, making it a valuable resource for training and testing deep learning models, like Convolutional Neural Networks (CNNs), using frameworks such as Ultralytics YOLO.
+
+### How do I train a YOLO model on the CIFAR-100 dataset?
+
+You can train a YOLO model on the CIFAR-100 dataset using either Python or CLI commands. Here's how:
+
+!!! Example "Train Example"
+
+    === "Python"
+    
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+        # Train the model
+        results = model.train(data="cifar100", epochs=100, imgsz=32)
+        ```
+
+    === "CLI"
+        
+        ```bash
+        # Start training from a pretrained *.pt model
+        yolo detect train data=cifar100 model=yolov8n-cls.pt epochs=100 imgsz=32
+        ```
+
+For a comprehensive list of available arguments, please refer to the model [Training](../../modes/train.md) page.
+
+### What are the primary applications of the CIFAR-100 dataset?
+
+The CIFAR-100 dataset is extensively used in training and evaluating deep learning models for image classification. Its diverse set of 100 classes, grouped into 20 coarse categories, provides a challenging environment for testing algorithms such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning approaches. This dataset is a key resource in research and development within machine learning and computer vision fields.
+
+### How is the CIFAR-100 dataset structured?
+
+The CIFAR-100 dataset is split into two main subsets:
+
+1. **Training Set**: Contains 50,000 images used for training machine learning models.
+2. **Testing Set**: Consists of 10,000 images used for testing and benchmarking the trained models.
+
+Each of the 100 classes contains 600 images, with 500 images for training and 100 for testing, making it uniquely suited for rigorous academic and industrial research.
+
+### Where can I find sample images and annotations from the CIFAR-100 dataset?
+
+The CIFAR-100 dataset includes a variety of color images of various objects, making it a structured dataset for image classification tasks. You can refer to the documentation page to see [sample images and annotations](#sample-images-and-annotations). These examples highlight the dataset's diversity and complexity, important for training robust image classification models.
--- a/docs/en/datasets/classify/fashion-mnist.md
+++ b/docs/en/datasets/classify/fashion-mnist.md
@ -88,3 +88,52 @@ The example showcases the variety and complexity of the images in the Fashion-MN
 ## Acknowledgments

 If you use the Fashion-MNIST dataset in your research or development work, please acknowledge the dataset by linking to the [GitHub repository](https://github.com/zalandoresearch/fashion-mnist). This dataset was made available by Zalando Research.
+
+## FAQ
+
+### What is the Fashion-MNIST dataset and how is it different from MNIST?
+
+The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is a collection of 70,000 grayscale images of Zalando's article images, intended as a modern replacement for the original MNIST dataset. It serves as a benchmark for machine learning models in the context of image classification tasks. Unlike MNIST, which contains handwritten digits, Fashion-MNIST consists of 28x28-pixel images categorized into 10 fashion-related classes, such as T-shirt/top, trouser, and ankle boot.
+
+### How can I train a YOLO model on the Fashion-MNIST dataset?
+
+To train an Ultralytics YOLO model on the Fashion-MNIST dataset, you can use both Python and CLI commands. Here's a quick example to get you started:
+
+!!! Example "Train Example"
+
+    === "Python"
+    
+        ```python
+        from ultralytics import YOLO
+
+        # Load a pretrained model
+        model = YOLO("yolov8n-cls.pt")
+
+        # Train the model on Fashion-MNIST
+        results = model.train(data="fashion-mnist", epochs=100, imgsz=28)
+        ```
+    
+
+    === "CLI"
+    
+        ```bash
+        yolo detect train data=fashion-mnist model=yolov8n-cls.pt epochs=100 imgsz=28
+        ```
+
+For more detailed training parameters, refer to the [Training page](../../modes/train.md).
+
+### Why should I use the Fashion-MNIST dataset for benchmarking my machine learning models?
+
+The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is widely recognized in the deep learning community as a robust alternative to MNIST. It offers a more complex and varied set of images, making it an excellent choice for benchmarking image classification models. The dataset's structure, comprising 60,000 training images and 10,000 testing images, each labeled with one of 10 classes, makes it ideal for evaluating the performance of different machine learning algorithms in a more challenging context.
+
+### Can I use Ultralytics YOLO for image classification tasks like Fashion-MNIST?
+
+Yes, Ultralytics YOLO models can be used for image classification tasks, including those involving the Fashion-MNIST dataset. YOLOv8, for example, supports various vision tasks such as detection, segmentation, and classification. To get started with image classification tasks, refer to the [Classification page](https://docs.ultralytics.com/tasks/classify/).
+
+### What are the key features and structure of the Fashion-MNIST dataset?
+
+The Fashion-MNIST dataset is divided into two main subsets: 60,000 training images and 10,000 testing images. Each image is a 28x28-pixel grayscale picture representing one of 10 fashion-related classes. The simplicity and well-structured format make it ideal for training and evaluating models in machine learning and computer vision tasks. For more details on the dataset structure, see the [Dataset Structure section](#dataset-structure).
+
+### How can I acknowledge the use of the Fashion-MNIST dataset in my research?
+
+If you utilize the Fashion-MNIST dataset in your research or development projects, it's important to acknowledge it by linking to the [GitHub repository](https://github.com/zalandoresearch/fashion-mnist). This helps in attributing the data to Zalando Research, who made the dataset available for public use.
--- a/docs/en/datasets/classify/imagenet.md
+++ b/docs/en/datasets/classify/imagenet.md
@ -91,3 +91,48 @@ If you use the ImageNet dataset in your research or development work, please cit
        ```

 We would like to acknowledge the ImageNet team, led by Olga Russakovsky, Jia Deng, and Li Fei-Fei, for creating and maintaining the ImageNet dataset as a valuable resource for the machine learning and computer vision research community. For more information about the ImageNet dataset and its creators, visit the [ImageNet website](https://www.image-net.org/).
+
+## FAQ
+
+### What is the ImageNet dataset and how is it used in computer vision?
+
+The [ImageNet dataset](https://www.image-net.org/) is a large-scale database consisting of over 14 million high-resolution images categorized using WordNet synsets. It is extensively used in visual object recognition research, including image classification and object detection. The dataset's annotations and sheer volume provide a rich resource for training deep learning models. Notably, models like AlexNet, VGG, and ResNet have been trained and benchmarked using ImageNet, showcasing its role in advancing computer vision.
+
+### How can I use a pretrained YOLO model for image classification on the ImageNet dataset?
+
+To use a pretrained Ultralytics YOLO model for image classification on the ImageNet dataset, follow these steps:
+
+!!! Example "Train Example"
+
+    === "Python"
+    
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+        # Train the model
+        results = model.train(data="imagenet", epochs=100, imgsz=224)
+        ```
+
+    === "CLI"
+    
+        ```bash
+        # Start training from a pretrained *.pt model
+        yolo train data=imagenet model=yolov8n-cls.pt epochs=100 imgsz=224
+        ```
+
+For more in-depth training instruction, refer to our [Training page](../../modes/train.md).
+
+### Why should I use the Ultralytics YOLOv8 pretrained models for my ImageNet dataset projects?
+
+Ultralytics YOLOv8 pretrained models offer state-of-the-art performance in terms of speed and accuracy for various computer vision tasks. For example, the YOLOv8n-cls model, with a top-1 accuracy of 69.0% and a top-5 accuracy of 88.3%, is optimized for real-time applications. Pretrained models reduce the computational resources required for training from scratch and accelerate development cycles. Learn more about the performance metrics of YOLOv8 models in the [ImageNet Pretrained Models section](#imagenet-pretrained-models).
+
+### How is the ImageNet dataset structured, and why is it important?
+
+The ImageNet dataset is organized using the WordNet hierarchy, where each node in the hierarchy represents a category described by a synset (a collection of synonymous terms). This structure allows for detailed annotations, making it ideal for training models to recognize a wide variety of objects. The diversity and annotation richness of ImageNet make it a valuable dataset for developing robust and generalizable deep learning models. More about this organization can be found in the [Dataset Structure](#dataset-structure) section.
+
+### What role does the ImageNet Large Scale Visual Recognition Challenge (ILSVRC) play in computer vision?
+
+The annual [ImageNet Large Scale Visual Recognition Challenge (ILSVRC)](https://image-net.org/challenges/LSVRC/) has been pivotal in driving advancements in computer vision by providing a competitive platform for evaluating algorithms on a large-scale, standardized dataset. It offers standardized evaluation metrics, fostering innovation and development in areas such as image classification, object detection, and image segmentation. The challenge has continuously pushed the boundaries of what is possible with deep learning and computer vision technologies.
--- a/docs/en/datasets/classify/imagenet10.md
+++ b/docs/en/datasets/classify/imagenet10.md
@ -75,3 +75,53 @@ If you use the ImageNet10 dataset in your research or development work, please c
        ```

 We would like to acknowledge the ImageNet team, led by Olga Russakovsky, Jia Deng, and Li Fei-Fei, for creating and maintaining the ImageNet dataset. The ImageNet10 dataset, while a compact subset, is a valuable resource for quick testing and debugging in the machine learning and computer vision research community. For more information about the ImageNet dataset and its creators, visit the [ImageNet website](https://www.image-net.org/).
+
+## FAQ
+
+### What is the ImageNet10 dataset and how is it different from the full ImageNet dataset?
+
+The [ImageNet10](https://github.com/ultralytics/yolov5/releases/download/v1.0/imagenet10.zip) dataset is a compact subset of the original [ImageNet](https://www.image-net.org/) database, created by Ultralytics for rapid CI tests, sanity checks, and training pipeline evaluations. ImageNet10 comprises only 20 images, representing the first image in the training and validation sets of the first 10 classes in ImageNet. Despite its small size, it maintains the structure and diversity of the full dataset, making it ideal for quick testing but not for benchmarking models.
+
+### How can I use the ImageNet10 dataset to test my deep learning model?
+
+To test your deep learning model on the ImageNet10 dataset with an image size of 224x224, use the following code snippets.
+
+!!! Example "Test Example"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+        # Train the model
+        results = model.train(data="imagenet10", epochs=5, imgsz=224)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Start training from a pretrained *.pt model
+        yolo train data=imagenet10 model=yolov8n-cls.pt epochs=5 imgsz=224
+        ```
+
+Refer to the [Training](../../modes/train.md) page for a comprehensive list of available arguments.
+
+### Why should I use the ImageNet10 dataset for CI tests and sanity checks?
+
+The ImageNet10 dataset is designed specifically for CI tests, sanity checks, and quick evaluations in deep learning pipelines. Its small size allows for rapid iteration and testing, making it perfect for continuous integration processes where speed is crucial. By maintaining the structural complexity and diversity of the original ImageNet dataset, ImageNet10 provides a reliable indication of a model's basic functionality and correctness without the overhead of processing a large dataset.
+
+### What are the main features of the ImageNet10 dataset?
+
+The ImageNet10 dataset has several key features:
+
+- **Compact Size**: With only 20 images, it allows for rapid testing and debugging.
+- **Structured Organization**: Follows the WordNet hierarchy, similar to the full ImageNet dataset.
+- **CI and Sanity Checks**: Ideally suited for continuous integration tests and sanity checks.
+- **Not for Benchmarking**: While useful for quick model evaluations, it is not designed for extensive benchmarking.
+
+### Where can I download the ImageNet10 dataset?
+
+You can download the ImageNet10 dataset from the [Ultralytics GitHub releases page](https://github.com/ultralytics/yolov5/releases/download/v1.0/imagenet10.zip). For more detailed information about its structure and applications, refer to the [ImageNet10 Dataset](imagenet10.md) page.
--- a/docs/en/datasets/classify/imagenette.md
+++ b/docs/en/datasets/classify/imagenette.md
@ -111,3 +111,83 @@ These smaller versions of the dataset allow for rapid iterations during the deve
 ## Citations and Acknowledgments

 If you use the ImageNette dataset in your research or development work, please acknowledge it appropriately. For more information about the ImageNette dataset, visit the [ImageNette dataset GitHub page](https://github.com/fastai/imagenette).
+
+## FAQ
+
+### What is the ImageNette dataset?
+
+The [ImageNette dataset](https://github.com/fastai/imagenette) is a simplified subset of the larger [ImageNet dataset](https://www.image-net.org/), featuring only 10 easily distinguishable classes such as tench, English springer, and French horn. It was created to offer a more manageable dataset for efficient training and evaluation of image classification models. This dataset is particularly useful for quick software development and educational purposes in machine learning and computer vision.
+
+### How can I use the ImageNette dataset for training a YOLO model?
+
+To train a YOLO model on the ImageNette dataset for 100 epochs, you can use the following commands. Make sure to have the Ultralytics YOLO environment set up.
+
+!!! Example "Train Example"
+
+    === "Python"
+
+    ```python
+    from ultralytics import YOLO
+
+    # Load a model
+    model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+    # Train the model
+    results = model.train(data="imagenette", epochs=100, imgsz=224)
+    ```
+
+    === "CLI"
+
+    ```bash
+    # Start training from a pretrained *.pt model
+    yolo detect train data=imagenette model=yolov8n-cls.pt epochs=100 imgsz=224
+    ```
+
+For more details, see the [Training](../../modes/train.md) documentation page.
+
+### Why should I use ImageNette for image classification tasks?
+
+The ImageNette dataset is advantageous for several reasons:
+
+- **Quick and Simple**: It contains only 10 classes, making it less complex and time-consuming compared to larger datasets.
+- **Educational Use**: Ideal for learning and teaching the basics of image classification since it requires less computational power and time.
+- **Versatility**: Widely used to train and benchmark various machine learning models, especially in image classification.
+  
+For more details on model training and dataset management, explore the [Dataset Structure](#dataset-structure) section.
+
+### Can the ImageNette dataset be used with different image sizes?
+
+Yes, the ImageNette dataset is also available in two resized versions: ImageNette160 and ImageNette320. These versions help in faster prototyping and are especially useful when computational resources are limited. 
+
+!!! Example "Train Example with ImageNette160"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")
+
+        # Train the model with ImageNette160
+        results = model.train(data="imagenette160", epochs=100, imgsz=160)
+        ```
+
+    === "CLI"
+    
+        ```bash
+        # Start training from a pretrained *.pt model with ImageNette160
+        yolo detect train data=imagenette160 model=yolov8n-cls.pt epochs=100 imgsz=160
+        ```
+
+For more information, refer to [Training with ImageNette160 and ImageNette320](#imagenette160-and-imagenette320).
+
+### What are some practical applications of the ImageNette dataset?
+
+The ImageNette dataset is extensively used in:
+
+- **Educational Settings**: To educate beginners in machine learning and computer vision.
+- **Software Development**: For rapid prototyping and development of image classification models.
+- **Deep Learning Research**: To evaluate and benchmark the performance of various deep learning models, especially Convolutional Neural Networks (CNNs).
+
+Explore the [Applications](#applications) section for detailed use cases.
--- a/docs/en/datasets/classify/imagewoof.md
+++ b/docs/en/datasets/classify/imagewoof.md
@ -87,3 +87,51 @@ The example showcases the subtle differences and similarities among the differen
 If you use the ImageWoof dataset in your research or development work, please make sure to acknowledge the creators of the dataset by linking to the [official dataset repository](https://github.com/fastai/imagenette).

 We would like to acknowledge the FastAI team for creating and maintaining the ImageWoof dataset as a valuable resource for the machine learning and computer vision research community. For more information about the ImageWoof dataset, visit the [ImageWoof dataset repository](https://github.com/fastai/imagenette).
+
+## FAQ
+
+### What is the ImageWoof dataset in Ultralytics?
+
+The [ImageWoof](https://github.com/fastai/imagenette) dataset is a challenging subset of ImageNet focusing on 10 specific dog breeds. Created to push the limits of image classification models, it features breeds like Beagle, Shih-Tzu, and Golden Retriever. The dataset includes images at various resolutions (full size, 320px, 160px) and even noisy labels for more realistic training scenarios. This complexity makes ImageWoof ideal for developing more advanced deep learning models.
+
+### How can I train a model using the ImageWoof dataset with Ultralytics YOLO?
+
+To train a Convolutional Neural Network (CNN) model on the ImageWoof dataset using Ultralytics YOLO for 100 epochs at an image size of 224x224, you can use the following code:
+
+!!! Example "Train Example"
+
+    === "Python"
+    
+        ```python
+        from ultralytics import YOLO
+
+        model = YOLO("yolov8n-cls.pt")  # Load a pretrained model
+        results = model.train(data="imagewoof", epochs=100, imgsz=224)
+        ```
+    
+
+    === "CLI"
+    
+        ```bash
+        yolo detect train data=imagewoof model=yolov8n-cls.pt epochs=100 imgsz=224
+        ```
+
+For more details on available training arguments, refer to the [Training](../../modes/train.md) page.
+
+### What versions of the ImageWoof dataset are available?
+
+The ImageWoof dataset comes in three sizes:
+
+1. **Full Size (imagewoof)**: Ideal for final training and benchmarking, containing full-sized images.
+2. **Medium Size (imagewoof320)**: Resized images with a maximum edge length of 320 pixels, suited for faster training.
+3. **Small Size (imagewoof160)**: Resized images with a maximum edge length of 160 pixels, perfect for rapid prototyping.
+
+Use these versions by replacing 'imagewoof' in the dataset argument accordingly. Note, however, that smaller images may yield lower classification accuracy but can be useful for quicker iterations.
+
+### How do noisy labels in the ImageWoof dataset benefit training?
+
+Noisy labels in the ImageWoof dataset simulate real-world conditions where labels might not always be accurate. Training models with this data helps develop robustness and generalization in image classification tasks. This prepares the models to handle ambiguous or mislabeled data effectively, which is often encountered in practical applications.
+
+### What are the key challenges of using the ImageWoof dataset?
+
+The primary challenge of the ImageWoof dataset lies in the subtle differences among the dog breeds it includes. Since it focuses on 10 closely related breeds, distinguishing between them requires more advanced and fine-tuned image classification models. This makes ImageWoof an excellent benchmark to test the capabilities and improvements of deep learning models.
--- a/docs/en/datasets/classify/index.md
+++ b/docs/en/datasets/classify/index.md
@ -8,7 +8,7 @@ keywords: YOLO, image classification, dataset structure, CIFAR-10, Ultralytics,

 ### Dataset Structure for YOLO Classification Tasks

-For [Ultralytics](https://ultralytics.com) YOLO classification tasks, the dataset must be organized in a specific split-direcotry structure under the `root` directory to facilitate proper training, testing, and optional validation processes. This structure includes separate directories for training (`train`) and testing (`test`) phases, with an optional directory for validation (`val`).
+For [Ultralytics](https://ultralytics.com) YOLO classification tasks, the dataset must be organized in a specific split-directory structure under the `root` directory to facilitate proper training, testing, and optional validation processes. This structure includes separate directories for training (`train`) and testing (`test`) phases, with an optional directory for validation (`val`).

 Each of these directories should contain one subdirectory for each class in the dataset. The subdirectories are named after the corresponding class and contain all the images for that class. Ensure that each image file is named uniquely and stored in a common format such as JPEG or PNG.

@ -91,6 +91,7 @@ This structured approach ensures that the model can effectively learn from well-
        # Train the model
        results = model.train(data="path/to/dataset", epochs=100, imgsz=640)
        ```
+
    === "CLI"

        ```bash
@ -116,3 +117,103 @@ Ultralytics supports the following datasets with automatic download:
 ### Adding your own dataset

 If you have your own dataset and would like to use it for training classification models with Ultralytics, ensure that it follows the format specified above under "Dataset format" and then point your `data` argument to the dataset directory.
+
+## FAQ
+
+### How do I structure my dataset for YOLO classification tasks?
+
+To structure your dataset for Ultralytics YOLO classification tasks, you should follow a specific split-directory format. Organize your dataset into separate directories for `train`, `test`, and optionally `val`. Each of these directories should contain subdirectories named after each class, with the corresponding images inside. This facilitates smooth training and evaluation processes. For an example, consider the CIFAR-10 dataset format:
+
+```
+cifar-10-/
+|-- train/
+|   |-- airplane/
+|   |-- automobile/
+|   |-- bird/
+|   ...
+|-- test/
+|   |-- airplane/
+|   |-- automobile/
+|   |-- bird/
+|   ...
+|-- val/ (optional)
+|   |-- airplane/
+|   |-- automobile/
+|   |-- bird/
+|   ...
+```
+
+For more details, visit [Dataset Structure for YOLO Classification Tasks](#dataset-structure-for-yolo-classification-tasks).
+
+### What datasets are supported by Ultralytics YOLO for image classification?
+
+Ultralytics YOLO supports automatic downloading of several datasets for image classification, including:
+
+- [Caltech 101](caltech101.md)
+- [Caltech 256](caltech256.md)
+- [CIFAR-10](cifar10.md)
+- [CIFAR-100](cifar100.md)
+- [Fashion-MNIST](fashion-mnist.md)
+- [ImageNet](imagenet.md)
+- [ImageNet-10](imagenet10.md)
+- [Imagenette](imagenette.md)
+- [Imagewoof](imagewoof.md)
+- [MNIST](mnist.md)
+
+These datasets are structured in a way that makes them easy to use with YOLO. Each dataset's page provides further details about its structure and applications.
+
+### How do I add my own dataset for YOLO image classification?
+
+To use your own dataset with Ultralytics YOLO, ensure it follows the specified directory format required for the classification task, with separate `train`, `test`, and optionally `val` directories, and subdirectories for each class containing the respective images. Once your dataset is structured correctly, point the `data` argument to your dataset's root directory when initializing the training script. Here's an example in Python:
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+# Train the model
+results = model.train(data="path/to/your/dataset", epochs=100, imgsz=640)
+```
+
+More details can be found in the [Adding your own dataset](#adding-your-own-dataset) section.
+
+### Why should I use Ultralytics YOLO for image classification?
+
+Ultralytics YOLO offers several benefits for image classification, including:
+
+- **Pretrained Models**: Load pretrained models like `yolov8n-cls.pt` to jump-start your training process.
+- **Ease of Use**: Simple API and CLI commands for training and evaluation.
+- **High Performance**: State-of-the-art accuracy and speed, ideal for real-time applications.
+- **Support for Multiple Datasets**: Seamless integration with various popular datasets like CIFAR-10, ImageNet, and more.
+- **Community and Support**: Access to extensive documentation and an active community for troubleshooting and improvements.
+
+For additional insights and real-world applications, you can explore [Ultralytics YOLO](https://www.ultralytics.com/yolo).
+
+### How can I train a model using Ultralytics YOLO?
+
+Training a model using Ultralytics YOLO can be done easily in both Python and CLI. Here's an example:
+
+!!! Example
+
+    === "Python"
+    
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model
+
+        # Train the model
+        results = model.train(data="path/to/dataset", epochs=100, imgsz=640)
+        ```
+    
+
+    === "CLI"
+    
+        ```bash
+        # Start training from a pretrained *.pt model
+        yolo detect train data=path/to/data model=yolov8n-cls.pt epochs=100 imgsz=640
+        ```
+
+These examples demonstrate the straightforward process of training a YOLO model using either approach. For more information, visit the [Usage](#usage) section.
--- a/docs/en/datasets/classify/mnist.md
+++ b/docs/en/datasets/classify/mnist.md
@ -84,3 +84,44 @@ research or development work, please cite the following paper:
        ```

 We would like to acknowledge Yann LeCun, Corinna Cortes, and Christopher J.C. Burges for creating and maintaining the MNIST dataset as a valuable resource for the machine learning and computer vision research community. For more information about the MNIST dataset and its creators, visit the [MNIST dataset website](http://yann.lecun.com/exdb/mnist/).
+
+## FAQ
+
+### What is the MNIST dataset, and why is it important in machine learning?
+
+The [MNIST](http://yann.lecun.com/exdb/mnist/) dataset, or Modified National Institute of Standards and Technology dataset, is a widely-used collection of handwritten digits designed for training and testing image classification systems. It includes 60,000 training images and 10,000 testing images, all of which are grayscale and 28x28 pixels in size. The dataset's importance lies in its role as a standard benchmark for evaluating image classification algorithms, helping researchers and engineers to compare methods and track progress in the field.
+
+### How can I use Ultralytics YOLO to train a model on the MNIST dataset?
+
+To train a model on the MNIST dataset using Ultralytics YOLO, you can follow these steps:
+
+!!! Example "Train Example"
+
+    === "Python"
+    
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)
+
+        # Train the model
+        results = model.train(data="mnist", epochs=100, imgsz=32)
+        ```
+
+    === "CLI"
+    
+        ```bash
+        # Start training from a pretrained *.pt model
+        cnn detect train data=mnist model=yolov8n-cls.pt epochs=100 imgsz=28
+        ```
+
+For a detailed list of available training arguments, refer to the [Training](../../modes/train.md) page.
+
+### What is the difference between the MNIST and EMNIST datasets?
+
+The MNIST dataset contains only handwritten digits, whereas the Extended MNIST (EMNIST) dataset includes both digits and uppercase and lowercase letters. EMNIST was developed as a successor to MNIST and utilizes the same 28x28 pixel format for the images, making it compatible with tools and models designed for the original MNIST dataset. This broader range of characters in EMNIST makes it useful for a wider variety of machine learning applications.
+
+### Can I use Ultralytics HUB to train models on custom datasets like MNIST?
+
+Yes, you can use Ultralytics HUB to train models on custom datasets like MNIST. Ultralytics HUB offers a user-friendly interface for uploading datasets, training models, and managing projects without needing extensive coding knowledge. For more details on how to get started, check out the [Ultralytics HUB Quickstart](https://docs.ultralytics.com/hub/quickstart/) page.