์ฝ๋ฐฑ
์ฝ๋ฐฑ
Ultralytics ํ๋ ์์ํฌ๋ ํธ๋ ์ธ, ๋ฐธ, ๋ด๋ณด๋ด๊ธฐ, ์์ธก ๋ชจ๋์ ์ ๋ต์ ๋จ๊ณ์์ ์ฝ๋ฐฑ์ ์ง์
์ ์ผ๋ก ์ง์ํฉ๋๋ค. ๊ฐ ์ฝ๋ฐฑ์ Trainer
, Validator
๋๋ Predictor
๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๊ฐ์ฒด์ ๋ชจ๋ ์์ฑ์ ๋ฌธ์์ ์ฐธ์กฐ ์น์
์์ ์ฐพ์ ์ ์์ต๋๋ค.
Watch: ๋ง์คํฐ๋ง Ultralytics YOLO : ์ฝ๋ฐฑ
์์
์์ธก์ผ๋ก ์ถ๊ฐ ์ ๋ณด ๋ฐํ
์ด ์์ ์์๋ ๊ฐ ๊ฒฐ๊ณผ ๊ฐ์ฒด์ ํจ๊ป ์๋ณธ ํ๋ ์์ ๋ฐํํ๋ ค๊ณ ํฉ๋๋ค. ์ด๋ฅผ ์ํํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
from ultralytics import YOLO
def on_predict_batch_end(predictor):
"""Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
_, image, _, _ = predictor.batch
# Ensure that image is a list
image = image if isinstance(image, list) else [image]
# Combine the prediction results with the corresponding frames
predictor.results = zip(predictor.results, image)
# Create a YOLO model instance
model = YOLO("yolo11n.pt")
# Add the custom callback to the model
model.add_callback("on_predict_batch_end", on_predict_batch_end)
# Iterate through the results and frames
for result, frame in model.predict(): # or model.track()
pass
๋ชจ๋ ์ฝ๋ฐฑ
์ง์๋๋ ๋ชจ๋ ์ฝ๋ฐฑ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ์ฝ๋ฐฑ ์์ค ์ฝ๋๋ฅผ ์ฐธ์กฐํ์ธ์.
ํธ๋ ์ด๋ ์ฝ๋ฐฑ
์ฝ๋ฐฑ | ์ค๋ช |
---|---|
on_pretrain_routine_start |
์ฌ์ ํ๋ จ ๋ฃจํด์ด ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_pretrain_routine_end |
์ฌ์ ํ๋ จ ๋ฃจํด์ด ๋๋๋ฉด ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_train_start |
ํธ๋ ์ด๋ ์์ ์ ํธ๋ฆฌ๊ฑฐ๋จ |
on_train_epoch_start |
๊ฐ ํ๋ จ ์ํฌํฌ๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_train_batch_start |
๊ฐ ๊ต์ก ๋ฐฐ์น๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
optimizer_step |
์ตํฐ๋ง์ด์ ๋จ๊ณ์์ ํธ๋ฆฌ๊ฑฐ๋จ |
on_before_zero_grad |
๊ทธ๋ผ๋ฐ์ด์ ์ด 0์ด ๋๊ธฐ ์ ์ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_train_batch_end |
๊ฐ ๊ต์ก ๋ฐฐ์น๊ฐ ๋๋ ๋๋ง๋ค ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_train_epoch_end |
๊ฐ ํ๋ จ ์ํฌํฌ๊ฐ ๋๋ ๋๋ง๋ค ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_fit_epoch_end |
๊ฐ ํ ์ํฌํฌ๊ฐ ๋๋ ๋๋ง๋ค ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_model_save |
๋ชจ๋ธ์ด ์ ์ฅ๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_train_end |
๊ต์ก ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋๋ฉด ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_params_update |
๋ชจ๋ธ ํ๋ผ๋ฏธํฐ๊ฐ ์ ๋ฐ์ดํธ๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
teardown |
๊ต์ก ํ๋ก์ธ์ค๊ฐ ์ ๋ฆฌ ์ค์ผ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
์ ํจ์ฑ ๊ฒ์ฌ๊ธฐ ์ฝ๋ฐฑ
์ฝ๋ฐฑ | ์ค๋ช |
---|---|
on_val_start |
์ ํจ์ฑ ๊ฒ์ฌ๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_val_batch_start |
๊ฐ ์ ํจ์ฑ ๊ฒ์ฌ ๋ฐฐ์น๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_val_batch_end |
๊ฐ ์ ํจ์ฑ ๊ฒ์ฌ ๋ฐฐ์น๊ฐ ๋๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_val_end |
์ ํจ์ฑ ๊ฒ์ฌ๊ฐ ์ข ๋ฃ๋๋ฉด ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
์์ธก์ ์ฝ๋ฐฑ
์ฝ๋ฐฑ | ์ค๋ช |
---|---|
on_predict_start |
์์ธก ํ๋ก์ธ์ค๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_predict_batch_start |
๊ฐ ์์ธก ๋ฐฐ์น๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_predict_postprocess_end |
์์ธก ํ์ฒ๋ฆฌ ์ข ๋ฃ ์ ํธ๋ฆฌ๊ฑฐ๋จ |
on_predict_batch_end |
๊ฐ ์์ธก ๋ฐฐ์น๊ฐ ๋๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_predict_end |
์์ธก ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋๋ฉด ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
๋ด๋ณด๋ด๊ธฐ ์ฝ๋ฐฑ
์ฝ๋ฐฑ | ์ค๋ช |
---|---|
on_export_start |
๋ด๋ณด๋ด๊ธฐ ํ๋ก์ธ์ค๊ฐ ์์๋ ๋ ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
on_export_end |
๋ด๋ณด๋ด๊ธฐ ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋๋ฉด ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค. |
์์ฃผ ๋ฌป๋ ์ง๋ฌธ
Ultralytics ์ฝ๋ฐฑ์ด๋ ๋ฌด์์ด๋ฉฐ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์?
Ultralytics ์ฝ๋ฐฑ ์ ํ๋ จ, ์ ํจ์ฑ ๊ฒ์ฌ, ๋ด๋ณด๋ด๊ธฐ, ์์ธก๊ณผ ๊ฐ์ ๋ชจ๋ธ ์์
์ ์ฃผ์ ๋จ๊ณ์์ ํธ๋ฆฌ๊ฑฐ๋๋ ํน์ํ ์ง์
์ ์
๋๋ค. ์ด๋ฌํ ์ฝ๋ฐฑ์ ํตํด ํ๋ก์ธ์ค์ ํน์ ์ง์ ์์ ์ฌ์ฉ์ ์ง์ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก ์ํฌํ๋ก์ฐ๋ฅผ ๊ฐ์ ํ๊ณ ์์ ํ ์ ์์ต๋๋ค. ๊ฐ ์ฝ๋ฐฑ์ Trainer
, Validator
๋๋ Predictor
๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๊ฐ์ฒด์ ์์ธํ ์์ฑ์ ๋ํ ์์ธํ ๋ด์ฉ์ ์ฐธ์กฐ ์น์
.
์ฝ๋ฐฑ์ ์ฌ์ฉํ๋ ค๋ฉด ํจ์๋ฅผ ์ ์ํ ๋ค์ ๋ชจ๋ธ์ add_callback
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ธ์. ๋ค์์ ์์ธก ์ค์ ์ถ๊ฐ ์ ๋ณด๋ฅผ ๋ฐํํ๋ ๋ฐฉ๋ฒ์ ์์
๋๋ค:
from ultralytics import YOLO
def on_predict_batch_end(predictor):
"""Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
_, image, _, _ = predictor.batch
image = image if isinstance(image, list) else [image]
predictor.results = zip(predictor.results, image)
model = YOLO("yolo11n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
pass
์ฝ๋ฐฑ์ ์ฌ์ฉํ์ฌ Ultralytics ๊ต์ก ๋ฃจํด์ ์ฌ์ฉ์ ์ง์ ํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?
์ฝ๋ฐฑ์ ์ฌ์ฉํ์ฌ Ultralytics ๊ต์ก ๋ฃจํด์ ์ฌ์ฉ์ ์ง์ ํ๋ ค๋ฉด ๊ต์ก ํ๋ก์ธ์ค์ ํน์ ๋จ๊ณ์ ๋ก์ง์ ์ฝ์
ํ ์ ์์ต๋๋ค. Ultralytics YOLO ์์๋ ๋ค์๊ณผ ๊ฐ์ ๋ค์ํ ๊ต์ก ์ฝ๋ฐฑ์ ์ ๊ณตํฉ๋๋ค. on_train_start
, on_train_end
๋ฐ on_train_batch_end
. ์ด๋ฅผ ํตํด ์ฌ์ฉ์ ์ง์ ๋ฉํธ๋ฆญ, ์ฒ๋ฆฌ ๋๋ ๋ก๊น
์ ์ถ๊ฐํ ์ ์์ต๋๋ค.
Here's an example of how to freeze BatchNorm statistics when freezing layers with callbacks:
from ultralytics import YOLO
# Add a callback to put the frozen layers in eval mode to prevent BN values from changing
def put_in_eval_mode(trainer):
n_layers = trainer.args.freeze
if not isinstance(n_layers, int):
return
for i, (name, module) in enumerate(trainer.model.named_modules()):
if name.endswith("bn") and int(name.split(".")[1]) < n_layers:
module.eval()
module.track_running_stats = False
model = YOLO("yolo11n.pt")
model.add_callback("on_train_epoch_start", put_in_eval_mode)
model.train(data="coco.yaml", epochs=10)
๊ต์ก ์ฝ๋ฐฑ์ ํจ๊ณผ์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ ๊ต์ก ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํ์ธ์.
Ultralytics YOLO ์์ ์ ํจ์ฑ ๊ฒ์ฌ ์ค์ ์ฝ๋ฐฑ์ ์ฌ์ฉํด์ผ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
์ฌ์ฉ ์ ํจ์ฑ ๊ฒ์ฌ ์ค ์ฝ๋ฐฑ ์ Ultralytics YOLO ์์ ์ฌ์ฉ์ ์ง์ ์ฒ๋ฆฌ, ๋ก๊น
๋๋ ๋ฉํธ๋ฆญ ๊ณ์ฐ์ ํ์ฉํ์ฌ ๋ชจ๋ธ ํ๊ฐ๋ฅผ ํฅ์์ํฌ ์ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ ์ฝ๋ฐฑ on_val_start
, on_val_batch_end
๋ฐ on_val_end
์ฌ์ฉ์ ์ง์ ๋ก์ง์ ์ฝ์
ํ ์ ์๋ ์ง์
์ ์ ์ ๊ณตํ์ฌ ์์ธํ๊ณ ํฌ๊ด์ ์ธ ์ ํจ์ฑ ๊ฒ์ฌ ํ๋ก์ธ์ค๋ฅผ ๋ณด์ฅํฉ๋๋ค.
For instance, you might want to plot all the validation batches, instead of just the first 3. Here's how you can do that:
import inspect
from ultralytics import YOLO
def plot_samples(validator):
frame = inspect.currentframe().f_back.f_back
v = frame.f_locals
validator.plot_val_samples(v["batch"], v["batch_i"])
validator.plot_predictions(v["batch"], v["preds"], v["batch_i"])
model = YOLO("yolo11n.pt")
model.add_callback("on_val_batch_end", plot_samples)
model.val(data="coco.yaml")
์ ํจ์ฑ ๊ฒ์ฌ ํ๋ก์ธ์ค์ ์ฝ๋ฐฑ์ ํตํฉํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ ์ ํจ์ฑ ๊ฒ์ฌ ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์.
์์ธก ๋ชจ๋์ ๋ํ ์ฌ์ฉ์ ์ง์ ์ฝ๋ฐฑ์ Ultralytics YOLO ์ ์ด๋ป๊ฒ ์ฒจ๋ถํ๋์?
์ฌ์ฉ์ ์ง์ ์ฝ๋ฐฑ์ ์ฒจ๋ถํ๋ ค๋ฉด ์์ธก ๋ชจ๋ Ultralytics YOLO ์์ ์ฝ๋ฐฑ ํจ์๋ฅผ ์ ์ํ๊ณ ์์ธก ํ๋ก์ธ์ค์ ๋ฑ๋กํฉ๋๋ค. ์ผ๋ฐ์ ์ธ ์์ธก ์ฝ๋ฐฑ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. on_predict_start
, on_predict_batch_end
๋ฐ on_predict_end
. ์ด๋ฅผ ํตํด ์์ธก ์ถ๋ ฅ์ ์์ ํ๊ณ ๋ฐ์ดํฐ ๋ก๊น
๋๋ ๊ฒฐ๊ณผ ๋ณํ๊ณผ ๊ฐ์ ์ถ๊ฐ ๊ธฐ๋ฅ์ ํตํฉํ ์ ์์ต๋๋ค.
Here is an example where a custom callback is used to save predictions based on whether an object of a particular class is present:
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
class_id = 2
def save_on_object(predictor):
r = predictor.results[0]
if class_id in r.boxes.cls:
predictor.args.save = True
else:
predictor.args.save = False
model.add_callback("on_predict_postprocess_end", save_on_object)
results = model("pedestrians.mp4", stream=True, save=True)
for results in results:
pass
๋ณด๋ค ์์ธํ ์ฌ์ฉ๋ฒ์ ์์ธํ ์ง์นจ๊ณผ ์ถ๊ฐ ์ฌ์ฉ์ ์ง์ ์ต์ ์ด ํฌํจ๋ ์์ธก ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํ์ธ์.
Ultralytics YOLO ์์ ์ฝ๋ฐฑ์ ์ฌ์ฉํ๋ ๋ช ๊ฐ์ง ์ค์ ์๋ ๋ฌด์์ธ๊ฐ์?
Ultralytics YOLO ๋ ๊ต์ก, ๊ฒ์ฆ ๋ฐ ์์ธก๊ณผ ๊ฐ์ ๋ค์ํ ๋จ๊ณ๋ฅผ ๊ฐ์ ํ๊ณ ์ฌ์ฉ์ ์ง์ ํ๊ธฐ ์ํด ์ฝ๋ฐฑ์ ๋ค์ํ ์ค์ ๊ตฌํ์ ์ง์ํฉ๋๋ค. ๋ช ๊ฐ์ง ์ค์ฉ์ ์ธ ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
- ์ฌ์ฉ์ ์ง์ ์งํ ๋ก๊น : ๊ต์ก ์ข ๋ฃ ๋๋ ๊ฒ์ฆ ๊ธฐ๊ฐ๊ณผ ๊ฐ์ ๋ค์ํ ๋จ๊ณ์์ ์ถ๊ฐ ์งํ๋ฅผ ๊ธฐ๋กํฉ๋๋ค.
- ๋ฐ์ดํฐ ์ฆ๊ฐ: ์์ธก ๋๋ ํ์ต ๋ฐฐ์น ์ค์ ์ฌ์ฉ์ ์ง์ ๋ฐ์ดํฐ ๋ณํ ๋๋ ์ฆ๊ฐ์ ๊ตฌํํฉ๋๋ค.
- ์ค๊ฐ ๊ฒฐ๊ณผ: ์ถ๊ฐ ๋ถ์ ๋๋ ์๊ฐํ๋ฅผ ์ํด ์์ธก ๋๋ ํ๋ ์๊ณผ ๊ฐ์ ์ค๊ฐ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํฉ๋๋ค.
์์: ๋ค์์ ์ฌ์ฉํ์ฌ ์์ธก ์ค์ ํ๋ ์์ ์์ธก ๊ฒฐ๊ณผ์ ๊ฒฐํฉํ๊ธฐ on_predict_batch_end
:
from ultralytics import YOLO
def on_predict_batch_end(predictor):
"""Combine prediction results with frames."""
_, image, _, _ = predictor.batch
image = image if isinstance(image, list) else [image]
predictor.results = zip(predictor.results, image)
model = YOLO("yolo11n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
pass
์ ์ฒด ์ฝ๋ฐฑ ์ฐธ์กฐ๋ฅผ ์ดํด๋ณด๊ณ ๋ ๋ง์ ์ต์ ๊ณผ ์์๋ฅผ ์ฐพ์๋ณด์ธ์.