๋จธ์ ๋ฌ๋ ๋ชจ๋ฒ ์ฌ๋ก ๋ฐ ๋ชจ๋ธ ํ์ต์ ์ํ ํ
์๊ฐ
์ปดํจํฐ ๋น์ ํ๋ก์ ํธ๋ฅผ ์งํํ ๋ ๊ฐ์ฅ ์ค์ํ ๋จ๊ณ ์ค ํ๋๋ ๋ชจ๋ธ ํ๋ จ์ ๋๋ค. ์ด ๋จ๊ณ์ ๋๋ฌํ๊ธฐ ์ ์ ๋ชฉํ๋ฅผ ์ ์ํ๊ณ ๋ฐ์ดํฐ๋ฅผ ์์งํ๊ณ ์ฃผ์์ ๋ฌ์์ผ ํฉ๋๋ค. ๋ฐ์ดํฐ๊ฐ ๊นจ๋ํ๊ณ ์ผ๊ด์ฑ์ด ์๋์ง ํ์ธํ๊ธฐ ์ํด ๋ฐ์ดํฐ๋ฅผ ์ ์ฒ๋ฆฌํ ํ์๋ ๋ชจ๋ธ ํ๋ จ์ผ๋ก ๋์ด๊ฐ ์ ์์ต๋๋ค.
Watch: Model Training Tips | How to Handle Large Datasets | Batch Size, GPU Utilization and [Mixed Precision](https://www.ultralytics.com/glossary/mixed-precision)
๊ทธ๋ ๋ค๋ฉด ๋ชจ๋ธ ํธ๋ ์ด๋์ด๋ ๋ฌด์์ธ๊ฐ์? ๋ชจ๋ธ ํธ๋ ์ด๋์ ๋ชจ๋ธ์ด ์๊ฐ์ ํจํด์ ์ธ์ํ๊ณ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ธกํ๋๋ก ๊ฐ๋ฅด์น๋ ํ๋ก์ธ์ค์ ๋๋ค. ์ด๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฑ๋ฅ๊ณผ ์ ํ๋์ ์ง์ ์ ์ธ ์ํฅ์ ๋ฏธ์นฉ๋๋ค. ์ด ๊ฐ์ด๋์์๋ ์ปดํจํฐ ๋น์ ๋ชจ๋ธ์ ํจ๊ณผ์ ์ผ๋ก ํ๋ จํ๋ ๋ฐ ๋์์ด ๋๋ ๋ชจ๋ฒ ์ฌ๋ก, ์ต์ ํ ๊ธฐ์ ๋ฐ ๋ฌธ์ ํด๊ฒฐ ํ์ ๋ค๋ฃน๋๋ค.
How to Train a Machine Learning Model
์ปดํจํฐ ๋น์ ๋ชจ๋ธ์ ์ค๋ฅ๋ฅผ ์ต์ํํ๊ธฐ ์ํด ๋ด๋ถ ๋งค๊ฐ๋ณ์๋ฅผ ์กฐ์ ํ์ฌ ํ์ตํฉ๋๋ค. ์ฒ์์๋ ๋ชจ๋ธ์ ๋ผ๋ฒจ์ด ์ง์ ๋ ๋๊ท๋ชจ ์ด๋ฏธ์ง ์ธํธ๊ฐ ์ ๊ณต๋ฉ๋๋ค. ์ด ์ด๋ฏธ์ง์ ๋ฌด์์ด ์๋์ง ์์ธกํ๊ณ ์์ธก์ ์ค์ ๋ผ๋ฒจ์ด๋ ๋ด์ฉ๊ณผ ๋น๊ตํ์ฌ ์ค์ฐจ๋ฅผ ๊ณ์ฐํฉ๋๋ค. ์ด๋ฌํ ์ค์ฐจ๋ ๋ชจ๋ธ์ ์์ธก์ด ์ค์ ๊ฐ๊ณผ ์ผ๋ง๋ ์ฐจ์ด๊ฐ ๋๋์ง๋ฅผ ๋ณด์ฌ์ค๋๋ค.
During training, the model iteratively makes predictions, calculates errors, and updates its parameters through a process called backpropagation. In this process, the model adjusts its internal parameters (weights and biases) to reduce the errors. By repeating this cycle many times, the model gradually improves its accuracy. Over time, it learns to recognize complex patterns such as shapes, colors, and textures.
This learning process makes it possible for the computer vision model to perform various tasks, including object detection, instance segmentation, and image classification. The ultimate goal is to create a model that can generalize its learning to new, unseen images so that it can accurately understand visual data in real-world applications.
์ด์ ๋ชจ๋ธ์ ํ๋ จํ ๋ ๋ค์์ ์ด๋ค ์ผ์ด ์ผ์ด๋๋์ง ์์์ผ๋ ๋ชจ๋ธ์ ํ๋ จํ ๋ ๊ณ ๋ คํด์ผ ํ ์ฌํญ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๋๊ท๋ชจ ๋ฐ์ดํฐ ์ธํธ์ ๋ํ ๊ต์ก
๋๊ท๋ชจ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ํ์ต์ํค๋ ค๋ ๊ฒฝ์ฐ ๊ณ ๋ คํด์ผ ํ ๋ช ๊ฐ์ง ์ธก๋ฉด์ด ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ๊ณ , GPU ํ์ฉ๋๋ฅผ ์ ์ดํ๊ณ , ๋ฉํฐ์ค์ผ์ผ ํ์ต์ ์ฌ์ฉํ๋๋ก ์ ํํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๊ฐ ์ต์ ์ ์์ธํ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๋ฐฐ์น ํฌ๊ธฐ ๋ฐ GPU ํ์ฉ๋
๋๊ท๋ชจ ๋ฐ์ดํฐ ์ธํธ์์ ๋ชจ๋ธ์ ํ์ตํ ๋๋ GPU ์ ํจ์จ์ ์ผ๋ก ํ์ฉํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ๋ฐฐ์น ํฌ๊ธฐ๋ ์ค์ํ ์์์ ๋๋ค. ๋ฐฐ์น ํฌ๊ธฐ๋ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ํ ๋ฒ์ ํ๋ จ ๋ฐ๋ณต์์ ์ฒ๋ฆฌํ๋ ๋ฐ์ดํฐ ์ํ์ ์์ ๋๋ค. GPU ์์ ์ง์ํ๋ ์ต๋ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ์ฌ์ฉํ๋ฉด ๊ธฐ๋ฅ์ ์ต๋ํ ํ์ฉํ๊ณ ๋ชจ๋ธ ํ์ต์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ค์ผ ์ ์์ต๋๋ค. ํ์ง๋ง GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํด์ง์ง ์๋๋ก ์ฃผ์ํด์ผ ํฉ๋๋ค. ๋ฉ๋ชจ๋ฆฌ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด ๋ชจ๋ธ์ด ์ํํ๊ฒ ํ์ตํ ๋๊น์ง ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ์ ์ง์ ์ผ๋ก ์ค์ด์ธ์.
With respect to YOLO11, you can set the batch_size
๋งค๊ฐ๋ณ์์ ๊ต์ก ๊ตฌ์ฑ ๋ฅผ GPU ์ฉ๋์ ๋ง๊ฒ ์ค์ ํ์ธ์. ๋ํ batch=-1
in your training script will automatically determine the batch size that can be efficiently processed based on your device's capabilities. By fine-tuning the batch size, you can make the most of your GPU resources and improve the overall training process.
ํ์ ์งํฉ ๊ต์ก
ํ์ ์งํฉ ํ์ต์ ๋ ํฐ ๋ฐ์ดํฐ ์งํฉ์ ๋ํ๋ด๋ ์์ ๋ฐ์ดํฐ ์งํฉ์ผ๋ก ๋ชจ๋ธ์ ํ์ต์ํค๋ ํ๋ช ํ ์ ๋ต์ ๋๋ค. ํนํ ์ด๊ธฐ ๋ชจ๋ธ ๊ฐ๋ฐ ๋ฐ ํ ์คํธ ์ค์ ์๊ฐ๊ณผ ๋ฆฌ์์ค๋ฅผ ์ ์ฝํ ์ ์์ต๋๋ค. ์๊ฐ์ด ๋ถ์กฑํ๊ฑฐ๋ ๋ค์ํ ๋ชจ๋ธ ๊ตฌ์ฑ์ ์คํํ๋ ๊ฒฝ์ฐ ํ์ ์งํฉ ํ์ต์ด ์ข์ ์ต์ ์ ๋๋ค.
When it comes to YOLO11, you can easily implement subset training by using the fraction
๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํฉ๋๋ค. ์ด ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ ์ธํธ์ ์ด๋ ๋ถ๋ถ์ ํ์ต์ ์ฌ์ฉํ ์ง ์ง์ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์ค์ fraction=0.1
๋ ๋ฐ์ดํฐ์ 10%์ ๋ํด ๋ชจ๋ธ์ ํ์ต์ํต๋๋ค. ์ ์ฒด ๋ฐ์ดํฐ ์งํฉ์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ํ์ต์ํค๊ธฐ ์ ์ ์ด ๊ธฐ์ ์ ์ฌ์ฉํ์ฌ ๋น ๋ฅด๊ฒ ๋ฐ๋ณตํ๊ณ ๋ชจ๋ธ์ ํ๋ํ ์ ์์ต๋๋ค. ํ์ ์งํฉ ํ์ต์ ๋น ๋ฅธ ์งํ์ ๋๊ณ ์ ์ฌ์ ์ธ ๋ฌธ์ ๋ฅผ ์กฐ๊ธฐ์ ์๋ณํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
๋ค์ค ๊ท๋ชจ ๊ต์ก
๋ฉํฐ์ค์ผ์ผ ํธ๋ ์ด๋์ ๋ค์ํ ํฌ๊ธฐ์ ์ด๋ฏธ์ง๋ก ๋ชจ๋ธ์ ํ๋ จํ์ฌ ์ผ๋ฐํ ๋ฅ๋ ฅ์ ํฅ์์ํค๋ ๊ธฐ์ ์ ๋๋ค. ๋ชจ๋ธ์ ๋ค์ํ ๊ท๋ชจ์ ๊ฑฐ๋ฆฌ์์ ๋ฌผ์ฒด๋ฅผ ๊ฐ์งํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ฌ ๋์ฑ ๊ฐ๋ ฅํด์ง ์ ์์ต๋๋ค.
For example, when you train YOLO11, you can enable multiscale training by setting the scale
๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํฉ๋๋ค. ์ด ๋งค๊ฐ๋ณ์๋ ํ๋ จ ์ด๋ฏธ์ง์ ํฌ๊ธฐ๋ฅผ ์ง์ ๋ ๊ณ์๋งํผ ์กฐ์ ํ์ฌ ๋ค์ํ ๊ฑฐ๋ฆฌ์ ์๋ ๋ฌผ์ฒด๋ฅผ ์๋ฎฌ๋ ์ด์
ํฉ๋๋ค. ์๋ฅผ ๋ค์ด scale=0.5
์ ์ด๋ฏธ์ง ํฌ๊ธฐ๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์ด๊ณ scale=2.0
๋ก ์ค์ ํ๋ฉด ๋ ๋ฐฐ๊ฐ ๋ฉ๋๋ค. ์ด ๋งค๊ฐ๋ณ์๋ฅผ ๊ตฌ์ฑํ๋ฉด ๋ชจ๋ธ์ด ๋ค์ํ ์ด๋ฏธ์ง ๋ฐฐ์จ์ ๊ฒฝํํ๊ณ ๋ค์ํ ๊ฐ์ฒด ํฌ๊ธฐ์ ์๋๋ฆฌ์ค์์ ๊ฐ์ง ๊ธฐ๋ฅ์ ํฅ์์ํฌ ์ ์์ต๋๋ค.
์บ์ฑ
์บ์ฑ์ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ ํ์ต์ ํจ์จ์ฑ์ ํฅ์์ํค๋ ์ค์ํ ๊ธฐ์ ์ ๋๋ค. ์บ์ฑ์ ์ฌ์ ์ฒ๋ฆฌ๋ ์ด๋ฏธ์ง๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํจ์ผ๋ก์จ GPU ์์ ๋์คํฌ์์ ๋ฐ์ดํฐ๊ฐ ๋ก๋๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์๊ฐ์ ์ค์ฌ์ค๋๋ค. ๋ชจ๋ธ์ ๋์คํฌ I/O ์์ ์ผ๋ก ์ธํ ์ง์ฐ ์์ด ์ง์์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์์ ํ ์ ์์ต๋๋ค.
Caching can be controlled when training YOLO11 using the cache
๋งค๊ฐ๋ณ์์
๋๋ค:
cache=True
: ๋ฐ์ดํฐ ์ธํธ ์ด๋ฏธ์ง๋ฅผ RAM์ ์ ์ฅํ์ฌ ๊ฐ์ฅ ๋น ๋ฅธ ์ก์ธ์ค ์๋๋ฅผ ์ ๊ณตํ์ง๋ง ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ์ฆ๊ฐํฉ๋๋ค.cache='disk'
: ์ด๋ฏธ์ง๋ฅผ ๋์คํฌ์ ์ ์ฅํ๋ฉฐ, RAM๋ณด๋ค๋ ๋๋ฆฌ์ง๋ง ๋งค๋ฒ ์ ๋ฐ์ดํฐ๋ฅผ ๋ก๋ํ๋ ๊ฒ๋ณด๋ค ๋น ๋ฆ ๋๋ค.cache=False
: ์บ์ฑ์ ๋นํ์ฑํํ์ฌ ๊ฐ์ฅ ๋๋ฆฐ ์ต์ ์ธ ๋์คํฌ I/O์๋ง ์์กดํฉ๋๋ค.
ํผํฉ ์ ๋ฐ ๊ต์ก
Mixed precision training uses both 16-bit (FP16) and 32-bit (FP32) floating-point types. The strengths of both FP16 and FP32 are leveraged by using FP16 for faster computation and FP32 to maintain precision where needed. Most of the neural network's operations are done in FP16 to benefit from faster computation and lower memory usage. However, a master copy of the model's weights is kept in FP32 to ensure accuracy during the weight update steps. You can handle larger models or larger batch sizes within the same hardware constraints.
To implement mixed precision training, you'll need to modify your training scripts and ensure your hardware (like GPUs) supports it. Many modern deep learning frameworks, such as Tensorflow, offer built-in support for mixed precision.
Mixed precision training is straightforward when working with YOLO11. You can use the amp
ํ๋๊ทธ๋ฅผ ์ค์ ํฉ๋๋ค. ์ค์ amp=True
๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ ํผํฉ ์ ๋ฐ๋(AMP) ํ๋ จ์ด ๊ฐ๋ฅํฉ๋๋ค. ํผํฉ ์ ๋ฐ๋ ํ๋ จ์ ๋ชจ๋ธ ํ๋ จ ํ๋ก์ธ์ค๋ฅผ ์ต์ ํํ๋ ๊ฐ๋จํ๋ฉด์๋ ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์
๋๋ค.
์ฌ์ ํ์ต๋ ๊ฐ์ค์น
Using pretrained weights is a smart way to speed up your model's training process. Pretrained weights come from models already trained on large datasets, giving your model a head start. Transfer learning adapts pretrained models to new, related tasks. Fine-tuning a pre-trained model involves starting with these weights and then continuing training on your specific dataset. This method of training results in faster training times and often better performance because the model starts with a solid understanding of basic features.
๊ทธ๋ฆฌ๊ณ pretrained
parameter makes transfer learning easy with YOLO11. Setting pretrained=True
๋ ๊ธฐ๋ณธ ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ๊ฑฐ๋ ์ฌ์ฉ์ ์ง์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๊ฒฝ๋ก๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค. ์ฌ์ ํ์ต๋ ๊ฐ์ค์น์ ์ ์ด ํ์ต์ ์ฌ์ฉํ๋ฉด ๋ชจ๋ธ์ ๊ธฐ๋ฅ์ ํจ๊ณผ์ ์ผ๋ก ํฅ์์ํค๊ณ ํ์ต ๋น์ฉ์ ์ ๊ฐํ ์ ์์ต๋๋ค.
๋๊ท๋ชจ ๋ฐ์ดํฐ ์งํฉ์ ์ฒ๋ฆฌํ ๋ ๊ณ ๋ คํด์ผ ํ ๊ธฐํ ๊ธฐ์
๋๊ท๋ชจ ๋ฐ์ดํฐ ์งํฉ์ ์ฒ๋ฆฌํ ๋ ๊ณ ๋ คํด์ผ ํ ๋ช ๊ฐ์ง ๋ค๋ฅธ ๊ธฐ์ ์ด ์์ต๋๋ค:
- Learning Rate Schedulers: Implementing learning rate schedulers dynamically adjusts the learning rate during training. A well-tuned learning rate can prevent the model from overshooting minima and improve stability. When training YOLO11, the
lrf
๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ต์ข ํ์ต๋ฅ ์ ์ด๊ธฐ ํ์ต๋ฅ ์ ์ผ๋ถ๋ถ์ผ๋ก ์ค์ ํ์ฌ ํ์ต๋ฅ ์ค์ผ์ค์ ๊ด๋ฆฌํ ์ ์์ต๋๋ค. - ๋ถ์ฐ ํ๋ จ: ๋๊ท๋ชจ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฒ๋ฆฌํ ๋ ๋ถ์ฐ ํ๋ จ์ ํ๋๋ฅผ ๋ฐ๊ฟ ์ ์์ต๋๋ค. ํธ๋ ์ด๋ ์ํฌ๋ก๋๋ฅผ ์ฌ๋ฌ GPU ๋๋ ๋จธ์ ์ ๋ถ์ฐํ์ฌ ํธ๋ ์ด๋ ์๊ฐ์ ๋จ์ถํ ์ ์์ต๋๋ค.
ํ๋ จํ ์ํฌํฌ ์
๋ชจ๋ธ์ ํ์ตํ ๋ ์ํฌํฌ๋ ์ ์ฒด ํ์ต ๋ฐ์ดํฐ ์ธํธ๋ฅผ ํ ๋ฒ ์์ ํ ํต๊ณผํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์ํฌํฌ ๋์ ๋ชจ๋ธ์ ํ์ต ์ธํธ์ ๊ฐ ์์๋ฅผ ํ ๋ฒ ์ฒ๋ฆฌํ๊ณ ํ์ต ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋ผ ๋งค๊ฐ ๋ณ์๋ฅผ ์ ๋ฐ์ดํธํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ์ด ์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ํ๋ผ๋ฏธํฐ๋ฅผ ํ์ตํ๊ณ ๊ฐ์ ํ๋ ค๋ฉด ์ฌ๋ฌ ๊ฐ์ ์ํฌํฌ๊ฐ ํ์ํฉ๋๋ค.
A common question that comes up is how to determine the number of epochs to train the model for. A good starting point is 300 epochs. If the model overfits early, you can reduce the number of epochs. If overfitting does not occur after 300 epochs, you can extend the training to 600, 1200, or more epochs.
However, the ideal number of epochs can vary based on your dataset's size and project goals. Larger datasets might require more epochs for the model to learn effectively, while smaller datasets might need fewer epochs to avoid overfitting. With respect to YOLO11, you can set the epochs
๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํฉ๋๋ค.
์กฐ๊ธฐ ์ค์ง
์กฐ๊ธฐ ์ค์ง๋ ๋ชจ๋ธ ํ์ต์ ์ต์ ํํ๋ ๋ฐ ์ ์ฉํ ๊ธฐ์ ์ ๋๋ค. ์ ํจ์ฑ ๊ฒ์ฌ ์ฑ๋ฅ์ ๋ชจ๋ํฐ๋งํ์ฌ ๋ชจ๋ธ ๊ฐ์ ์ด ์ค๋จ๋๋ฉด ํ๋ จ์ ์ค๋จํ ์ ์์ต๋๋ค. ๊ณ์ฐ ๋ฆฌ์์ค๋ฅผ ์ ์ฝํ๊ณ ๊ณผ์ ํฉ์ ๋ฐฉ์งํ ์ ์์ต๋๋ค.
The process involves setting a patience parameter that determines how many epochs to wait for an improvement in validation metrics before stopping training. If the model's performance does not improve within these epochs, training is stopped to avoid wasting time and resources.
For YOLO11, you can enable early stopping by setting the patience parameter in your training configuration. For example, patience=5
๋ 5ํ ์ฐ์์ผ๋ก ์ ํจ์ฑ ๊ฒ์ฌ ์งํ๊ฐ ๊ฐ์ ๋์ง ์์ผ๋ฉด ํธ๋ ์ด๋์ด ์ค๋จ๋จ์ ์๋ฏธํฉ๋๋ค. ์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ํธ๋ ์ด๋ ํ๋ก์ธ์ค๊ฐ ํจ์จ์ ์ผ๋ก ์ ์ง๋๊ณ ๊ณผ๋ํ ๊ณ์ฐ ์์ด ์ต์ ์ ์ฑ๋ฅ์ ๋ฌ์ฑํ ์ ์์ต๋๋ค.
ํด๋ผ์ฐ๋ ๊ต์ก๊ณผ ๋ก์ปฌ ๊ต์ก ์ค ์ ํ
๋ชจ๋ธ ํธ๋ ์ด๋์๋ ํด๋ผ์ฐ๋ ํธ๋ ์ด๋๊ณผ ๋ก์ปฌ ํธ๋ ์ด๋์ ๋ ๊ฐ์ง ์ต์ ์ด ์์ต๋๋ค.
ํด๋ผ์ฐ๋ ํธ๋ ์ด๋์ ํ์ฅ์ฑ๊ณผ ๊ฐ๋ ฅํ ํ๋์จ์ด๋ฅผ ์ ๊ณตํ๋ฉฐ ๋๊ท๋ชจ ๋ฐ์ดํฐ ์ธํธ์ ๋ณต์กํ ๋ชจ๋ธ์ ์ฒ๋ฆฌํ๋ ๋ฐ ์ด์์ ์ ๋๋ค. Google Cloud, AWS, Azure์ ๊ฐ์ ํ๋ซํผ์ ๊ณ ์ฑ๋ฅ GPU์ TPU์ ๋ํ ์จ๋๋งจ๋ ์ก์ธ์ค๋ฅผ ์ ๊ณตํ์ฌ ํธ๋ ์ด๋ ์๊ฐ์ ๋จ์ถํ๊ณ ๋๊ท๋ชจ ๋ชจ๋ธ์ ์คํํ ์ ์๋๋ก ์ง์ํฉ๋๋ค. ํ์ง๋ง ํด๋ผ์ฐ๋ ํธ๋ ์ด๋์ ํนํ ์ฅ๊ธฐ๊ฐ์ ๊ฑธ์ณ ๋น์ฉ์ด ๋ง์ด ๋ค ์ ์์ผ๋ฉฐ ๋ฐ์ดํฐ ์ ์ก์ผ๋ก ์ธํด ๋น์ฉ๊ณผ ์ง์ฐ ์๊ฐ์ด ๋์ด๋ ์ ์์ต๋๋ค.
๋ก์ปฌ ๊ต์ก์ ํตํด ์ ์ด ๋ฐ ์ฌ์ฉ์ ์ง์ ๊ธฐ๋ฅ์ ๊ฐํํ์ฌ ํน์ ์๊ตฌ ์ฌํญ์ ๋ง๊ฒ ํ๊ฒฝ์ ์กฐ์ ํ๊ณ ์ง์์ ์ธ ํด๋ผ์ฐ๋ ๋น์ฉ์ ํผํ ์ ์์ต๋๋ค. ์ฅ๊ธฐ ํ๋ก์ ํธ์ ๋ ๊ฒฝ์ ์ ์ผ ์ ์์ผ๋ฉฐ ๋ฐ์ดํฐ๊ฐ ์จํ๋ ๋ฏธ์ค์ ์ ์ง๋๋ฏ๋ก ๋ ์์ ํฉ๋๋ค. ํ์ง๋ง ๋ก์ปฌ ํ๋์จ์ด์๋ ๋ฆฌ์์ค ์ ํ์ด ์๊ณ ์ ์ง ๊ด๋ฆฌ๊ฐ ํ์ํ ์ ์์ผ๋ฏ๋ก ๋๊ท๋ชจ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ๊ต์ก ์๊ฐ์ด ๊ธธ์ด์ง ์ ์์ต๋๋ค.
์ต์ ํ ๋๊ตฌ ์ ํ
An optimizer is an algorithm that adjusts the weights of your neural network to minimize the loss function, which measures how well the model is performing. In simpler terms, the optimizer helps the model learn by tweaking its parameters to reduce errors. Choosing the right optimizer directly affects how quickly and accurately the model learns.
์ต์ ํ ๋๊ตฌ ๋งค๊ฐ๋ณ์๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ์ฌ ๋ชจ๋ธ ์ฑ๋ฅ์ ๊ฐ์ ํ ์๋ ์์ต๋๋ค. ํ์ต ์๋๋ฅผ ์กฐ์ ํ๋ฉด ๋งค๊ฐ๋ณ์๋ฅผ ์ ๋ฐ์ดํธํ ๋ ๋จ๊ณ์ ํฌ๊ธฐ๊ฐ ์ค์ ๋ฉ๋๋ค. ์์ ์ฑ์ ์ํด ์ ๋นํ ํ์ต ์๋๋ก ์์ํ์ฌ ์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ์ ์ฐจ์ ์ผ๋ก ํ์ต ์๋๋ฅผ ๋ฎ์ถ์ด ์ฅ๊ธฐ์ ์ธ ํ์ต์ ๊ฐ์ ํ ์ ์์ต๋๋ค. ๋ํ ๋ชจ๋ฉํ ์ ์ค์ ํ๋ฉด ๊ณผ๊ฑฐ ์ ๋ฐ์ดํธ๊ฐ ํ์ฌ ์ ๋ฐ์ดํธ์ ์ผ๋ง๋ ์ํฅ์ ๋ฏธ์น๋์ง ๊ฒฐ์ ํ ์ ์์ต๋๋ค. ๋ชจ๋ฉํ ์ ์ผ๋ฐ์ ์ธ ๊ฐ์ ์ฝ 0.9์ ๋๋ค. ์ด ๊ฐ์ ์ผ๋ฐ์ ์ผ๋ก ์ ์ ํ ๊ท ํ์ ์ ๊ณตํฉ๋๋ค.
์ผ๋ฐ์ ์ธ ์ต์ ํ ๋๊ตฌ
์ต์ ํ ๋๊ตฌ๋ง๋ค ๋ค์ํ ์ฅ๋จ์ ์ด ์์ต๋๋ค. ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ์ต์ ํ ๋๊ตฌ์ ๋ํด ๊ฐ๋ตํ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
-
SGD(ํ๋ฅ ์ ๊ทธ๋ผ๋ฐ์ด์ ํ๊ฐ):
- ๋งค๊ฐ๋ณ์์ ๋ํ ์์ค ํจ์์ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ ๋งค๊ฐ๋ณ์๋ฅผ ์ ๋ฐ์ดํธํฉ๋๋ค.
- ๊ฐ๋จํ๊ณ ํจ์จ์ ์ด์ง๋ง ์๋ ด ์๋๊ฐ ๋๋ฆฌ๊ณ ๋ก์ปฌ ์ต์๊ฐ์ ๊ฐํ ์ ์์ต๋๋ค.
-
์๋ด(์ ์ํ ์๊ฐ ์ถ์ ):
- SGD์ ๋ชจ๋ฉํ ๋ฐ RMSProp์ ์ฅ์ ์ ๊ฒฐํฉํฉ๋๋ค.
- ๊ธฐ์ธ๊ธฐ์ ์ฒซ ๋ฒ์งธ ๋ฐ ๋ ๋ฒ์งธ ๋ชจ๋ฉํธ์ ์ถ์ ์น๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ฐ ํ๋ผ๋ฏธํฐ์ ํ์ต ์๋๋ฅผ ์กฐ์ ํฉ๋๋ค.
- ๋ ธ์ด์ฆ๊ฐ ๋ง์ ๋ฐ์ดํฐ์ ํฌ๋ฐํ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ ํฉํฉ๋๋ค.
- Efficient and generally requires less tuning, making it a recommended optimizer for YOLO11.
-
RMSProp(๋ฃจํธ ํ๊ท ์ ๊ณฑ ์ ํ):
- ๊ธฐ์ธ๊ธฐ๋ฅผ ์ต๊ทผ ๊ธฐ์ธ๊ธฐ์ ํฌ๊ธฐ ํ๊ท ์ผ๋ก ๋๋์ด ๊ฐ ๋งค๊ฐ๋ณ์์ ๋ํ ํ์ต ์๋๋ฅผ ์กฐ์ ํฉ๋๋ค.
- Helps in handling the vanishing gradient problem and is effective for recurrent neural networks.
For YOLO11, the optimizer
ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด SGD, Adam, AdamW, NAdam, RAdam, RMSProp ๋ฑ ๋ค์ํ ์ต์ ํ ๋๊ตฌ ์ค์์ ์ ํํ๊ฑฐ๋ ๋ค์๊ณผ ๊ฐ์ด ์ค์ ํ ์ ์์ต๋๋ค. auto
๋ฅผ ํด๋ฆญํ์ฌ ๋ชจ๋ธ ๊ตฌ์ฑ์ ๋ฐ๋ผ ์๋์ผ๋ก ์ ํํ ์ ์์ต๋๋ค.
์ปค๋ฎค๋ํฐ์ ์ฐ๊ฒฐํ๊ธฐ
์ปดํจํฐ ๋น์ ์ ํธ๊ฐ ์ปค๋ฎค๋ํฐ์ ์ผ์์ด ๋๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ๋ ๋นจ๋ฆฌ ๋ฐฐ์ฐ๋ ๋ฐ ๋์์ด ๋ ์ ์์ต๋๋ค. ๋ค์์ ์ฐ๊ฒฐํ๊ณ , ๋์์ ๋ฐ๊ณ , ์์ด๋์ด๋ฅผ ๊ณต์ ํ๋ ๋ช ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋๋ค.
์ปค๋ฎค๋ํฐ ๋ฆฌ์์ค
- GitHub Issues: Visit the YOLO11 GitHub repository and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are very active and ready to help.
- Ultralytics ๋์ค์ฝ๋ ์๋ฒ: Ultralytics Discord ์๋ฒ์ ๊ฐ์ ํ์ฌ ๋ค๋ฅธ ์ฌ์ฉ์ ๋ฐ ๊ฐ๋ฐ์์ ์ฑํ ํ๊ณ , ์ง์์ ๋ฐ๊ณ , ๊ฒฝํ์ ๊ณต์ ํ์ธ์.
๊ณต์ ๋ฌธ์
- Ultralytics YOLO11 Documentation: Check out the official YOLO11 documentation for detailed guides and helpful tips on various computer vision projects.
์ด๋ฌํ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ์ปดํจํฐ ๋น์ ์ปค๋ฎค๋ํฐ์ ์ต์ ํธ๋ ๋์ ์ฌ๋ก๋ฅผ ์ต์ ์ํ๋ก ์ ์งํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
์ฃผ์ ๋ด์ฉ
Training computer vision models involves following good practices, optimizing your strategies, and solving problems as they arise. Techniques like adjusting batch sizes, mixed precision training, and starting with pre-trained weights can make your models work better and train faster. Methods like subset training and early stopping help you save time and resources. Staying connected with the community and keeping up with new trends will help you keep improving your model training skills.
์์ฃผ ๋ฌป๋ ์ง๋ฌธ
Ultralytics YOLO ๋ก ๋๊ท๋ชจ ๋ฐ์ดํฐ ์งํฉ์ ํ์ตํ ๋ GPU ํ์ฉ๋๋ฅผ ๋์ด๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?
GPU ํ์ฉ๋๋ฅผ ๋์ด๋ ค๋ฉด batch_size
parameter in your training configuration to the maximum size supported by your GPU. This ensures that you make full use of the GPU's capabilities, reducing training time. If you encounter memory errors, incrementally reduce the batch size until training runs smoothly. For YOLO11, setting batch=-1
๋ฅผ ๊ต์ก ์คํฌ๋ฆฝํธ์ ์ถ๊ฐํ๋ฉด ํจ์จ์ ์ธ ์ฒ๋ฆฌ๋ฅผ ์ํ ์ต์ ์ ๋ฐฐ์น ํฌ๊ธฐ๊ฐ ์๋์ผ๋ก ๊ฒฐ์ ๋ฉ๋๋ค. ์์ธํ ๋ด์ฉ์ ๊ต์ก ๊ตฌ์ฑ.
What is mixed precision training, and how do I enable it in YOLO11?
Mixed precision training utilizes both 16-bit (FP16) and 32-bit (FP32) floating-point types to balance computational speed and precision. This approach speeds up training and reduces memory usage without sacrificing model accuracy. To enable mixed precision training in YOLO11, set the amp
๋งค๊ฐ๋ณ์๋ฅผ True
์ ํธ๋ ์ด๋ ๊ตฌ์ฑ์ ์ถ๊ฐํฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์๋ ํผํฉ ์ ๋ฐ๋(AMP) ํ๋ จ์ด ํ์ฑํ๋ฉ๋๋ค. ์ด ์ต์ ํ ๊ธฐ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ ๊ต์ก ๊ตฌ์ฑ.
How does multiscale training enhance YOLO11 model performance?
Multiscale training enhances model performance by training on images of varying sizes, allowing the model to better generalize across different scales and distances. In YOLO11, you can enable multiscale training by setting the scale
๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด scale=0.5
์ ์ด๋ฏธ์ง ํฌ๊ธฐ๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์ด๊ณ scale=2.0
๋ฅผ ๋ ๋ฐฐ๋ก ๋๋ฆฝ๋๋ค. ์ด ๊ธฐ์ ์ ๋ค์ํ ๊ฑฐ๋ฆฌ์ ์๋ ๋ฌผ์ฒด๋ฅผ ์๋ฎฌ๋ ์ด์
ํ์ฌ ๋ค์ํ ์๋๋ฆฌ์ค์์ ๋ชจ๋ธ์ ๋์ฑ ๊ฐ๋ ฅํ๊ฒ ๋ง๋ญ๋๋ค. ์ค์ ๋ฐ ์์ธํ ๋ด์ฉ์ ๊ต์ก ๊ตฌ์ฑ.
How can I use pre-trained weights to speed up training in YOLO11?
Using pre-trained weights can significantly reduce training times and improve model performance by starting from a model that already understands basic features. In YOLO11, you can set the pretrained
๋งค๊ฐ๋ณ์๋ฅผ True
๋ฅผ ์ ํํ๊ฑฐ๋ ํ์ต ๊ตฌ์ฑ์์ ๋ฏธ๋ฆฌ ํ์ต๋ ์ฌ์ฉ์ ์ง์ ๊ฐ์ค์น์ ๋ํ ๊ฒฝ๋ก๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค. ์ ์ด ํ์ต์ด๋ผ๊ณ ํ๋ ์ด ์ ๊ทผ ๋ฐฉ์์ ๋๊ท๋ชจ ๋ฐ์ดํฐ ์ธํธ์ ์ง์์ ํ์ฉํ์ฌ ํน์ ์์
์ ๋ง๊ฒ ์กฐ์ ํฉ๋๋ค. ์ฌ์ ํ์ต๋ ๊ฐ์ค์น์ ๊ทธ ์ฅ์ ์ ๋ํด ์์ธํ ์์๋ณด๊ธฐ ์ฌ๊ธฐ.
What is the recommended number of epochs for training a model, and how do I set this in YOLO11?
The number of epochs refers to the complete passes through the training dataset during model training. A typical starting point is 300 epochs. If your model overfits early, you can reduce the number. Alternatively, if overfitting isn't observed, you might extend training to 600, 1200, or more epochs. To set this in YOLO11, use the epochs
๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํ์ธ์. ์ด์์ ์ธ ์ํฌํฌ ์๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์ถ๊ฐ ๋์๋ง์ ๋ค์ ์น์
์ ์ฐธ์กฐํ์ธ์. ์ํฌํฌ ์.