יסודות בינה מלאכותית : RB29-10 – אימון בינה מלאוכתית YOLO8

חלק א : אימון yolo colab

1.1 קישור לתוכנה לסימון תוויות עבור YOLO מודל : https://www.makesense.ai/

תרגיל כיתה 2

YOLO מודל

יש לעבוד לפי הסרטון שלב אחרי שלב .
הסרטון הוא המשך של הרצאה RB23-09 RB23-08 שם מוספר שלב אחרי שלב של התקנת הסביבה פיתוח , תוספים

תרגיל כיתה 2

YOLO מודל

אימון רשת זיהוי טנק

2.1 נעבור על הקוד שלב אחרי שלב

סביבת קולאב COLAB : – YOLO מודל yolo

שלב 1 : התקנת הסיפריות (עושים פעם אחת בלבד בסביבת הפיתוח)

בסוף התקנת הספריות אם אין שגיעות נקבל הודעת DONE כלומר סיים להתקין

שימו לב : סיבבת הפיתוח הקבצים תראה כך לפני ההתקנה

אנחנו עובדים על ספריית CONTENT

שלב 2 : יצירת קובץ yaml

לאחר ההתקנה נקבל

ואפשר לראות את תוכן הקובץ – קליל כפול עם העכבר על שם הקובץ

חילוץ הקובץ מ RAR :

לאחר החילוץ RAR ולחיצה על TANK

שלב 3 : התקנת קבצי התמונות והתוויות – (labels) בסביבת – אימון

נתקין את התונות על יהיה העתקה או יבואו או הורדה לסביבית הפיתוח שנאמן את הבינה המלאכותית – חייב להיות מאוד מדוייק – טעות הכי קטנה וזה לא יעבוד . . סביבת האימון יכולה להיות COLAB או ANACONDA או אחר ?

………………………………………………………………………………………………

נוריד מ GOOGLE DRIVE קובץ RAR שמכיל תמונות ו LABELS במבנה הנכון – חובה מבנה נכון

חילוץ קובץ RAR

https://colab.research.google.com/gist/RoboWild/19deff31306d95d2e315a9e1d331f156/yolo-train.ipynb

שלב 4 : אימון בינה מלאכותית מודל YOLO

יבוא ספריות , ויבוא המודל

נקבל את הספריות הבאות שימו לב על קובץ YOLOV8M.PT

אימון הבינה מלאכותית לפי קובץ YAML – זה המקום שהבינה מלאכותית לומדת

בסוף האימון של הבינה מלאכותית נקבל את הפלט הבא :

פעולת האימון של הבינה מלאכותית הסתיימה

מודל שלנו מאומן

שלב 5: בדיקה איך הבינה שלנו למדה ניתוח הליך הלימוד – נילמד בהמשך

שלב 6 : הרצה של קובץ של המודל שאומן

נחפש בתוך ספריית RUN את ה DETECT האחרון אם נרית כמה פעמים המספר יכול להשתנות של DETECT

נגדיר אובייקט PRE לפי המיקום של הקובץ BEST.PT

שימו לב : המיקום עשוי להשתנות בנתיב לפי שינוי בשם DETECT

ואז ניטען אותו – אפשר להעביר למחשבים אחרים או מיקרו מעבדים שונים

הרצה של הבינה מלאכותית – שורת קוד אחת בלבד ! כל השאר קוד פייתון

את התוצאה נקבל לתוך ספריה

קוד מתקדם יותר

https://colab.research.google.com/drive/1Iim5HYrT0wGJyEc6SHFkiZtkRmlLiv70#scrollTo=PQXWhPmU5NBk

%pip install ultralytics
import ultralytics
ultralytics.checks()
!pip install opencv-python-headless
print (" **** done **** ")

%pip install ultralytics

import ultralytics

ultralytics.checks()

!pip install opencv-python-headless

print (" **** done **** ")

!touch data.yaml
# Open a new file called data.yaml in write mode
with open('data.yaml', 'w') as file:
    # Write the specified content to the file
    file.write("""
train: /content/tanks/train
val: /content/tanks/val

nc: 4

names: ["tank", "car", "APC", "truck"]
""")

# Verify the content of the data.yaml file
with open('data.yaml', 'r') as file:
    print(file.read())

!touch data.yaml

# Open a new file called data.yaml in write mode

with open('data.yaml', 'w') as file:

# Write the specified content to the file

file.write("""

train: /content/tanks/train

val: /content/tanks/val

nc: 4

names: ["tank", "car", "APC", "truck"]

""")

# Verify the content of the data.yaml file

with open('data.yaml', 'r') as file:

print(file.read())

!apt-get install -y unrar

1	!apt-get install -y unrar

import os

from google.colab import files

# Upload the rar file
uploaded = files.upload()
# List the uploaded files
uploaded_files = list(uploaded.keys())
print(f'Uploaded files: {uploaded_files}')

# Assuming the rar file is the first (and only) uploaded file
rar_file = uploaded_files[0]

# Create a directory to extract the rar file
extract_dir = rar_file.replace('.rar', '')
os.makedirs(extract_dir, exist_ok=True)

# Extract the rar file
!unrar x {rar_file} {extract_dir}

# List the contents of the extracted directory
print(f'Contents of the extracted directory ({extract_dir}):')
print(os.listdir(extract_dir))

import os

from google.colab import files

# Upload the rar file

uploaded = files.upload()

# List the uploaded files

uploaded_files = list(uploaded.keys())

print(f'Uploaded files: {uploaded_files}')

# Assuming the rar file is the first (and only) uploaded file

rar_file = uploaded_files[0]

# Create a directory to extract the rar file

extract_dir = rar_file.replace('.rar', '')

os.makedirs(extract_dir, exist_ok=True)

# Extract the rar file

!unrar x {rar_file} {extract_dir}

# List the contents of the extracted directory

print(f'Contents of the extracted directory ({extract_dir}):')

print(os.listdir(extract_dir))

from ultralytics import YOLO
import ultralytics
print(ultralytics.__version__)

model=YOLO("yolov8m.pt")

from ultralytics import YOLO

import ultralytics

print(ultralytics.__version__)

model=YOLO("yolov8m.pt")

# train the a.i model to detect tanks

model.train(data="/content/data.yaml",batch=16, epochs=10)

# train the a.i model to detect tanks

model.train(data="/content/data.yaml",batch=16, epochs=10)

pre=YOLO("/content/runs/detect/train3/weights/best.pt")

1	pre=YOLO("/content/runs/detect/train3/weights/best.pt")

pre.predict("/content/tanks/val/images/tanks-dessert-79.jpg",save=True, conf=0.3)

1	pre.predict("/content/tanks/val/images/tanks-dessert-79.jpg",save=True, conf=0.3)

תרגיל כיתה 3 :

1.מטרה היכרות ראשונית של סביבית לימוד סביבת אנאקונדה – גוביפטר נודבוק (מקבילה לקולאב – מתחרה שלה) – לא להתבלב

2. תרגול קוד פייטון

# Program to read two numbers from user input, calculate their average, and print the larger number
# The result will be rounded to 2 decimal places

# Taking input for two numbers and converting to float
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Calculating the average and rounding to 2 decimal places
average = round((num1 + num2) / 2, 2)

# Printing the average
print(f"The average of {num1} and {num2} is: {average}")

# Checking which number is larger and rounding the comparison output
if round(num1, 2) > round(num2, 2):
    print(f"The larger number is: {round(num1, 2)}")
elif round(num2, 2) > round(num1, 2):
    print(f"The larger number is: {round(num2, 2)}")
else:
    print("Both numbers are equal.")

# Program to read two numbers from user input, calculate their average, and print the larger number

# The result will be rounded to 2 decimal places

# Taking input for two numbers and converting to float

num1 = float(input("Enter the first number: "))

num2 = float(input("Enter the second number: "))

# Calculating the average and rounding to 2 decimal places

average = round((num1 + num2) / 2, 2)

# Printing the average

print(f"The average of {num1} and {num2} is: {average}")

# Checking which number is larger and rounding the comparison output

if round(num1, 2) > round(num2, 2):

print(f"The larger number is: {round(num1, 2)}")

elif round(num2, 2) > round(num1, 2):

print(f"The larger number is: {round(num2, 2)}")

else:

print("Both numbers are equal.")

# List of items
items = ["drone", "kite", "plane", "helicopter"]

# Loop through each item in the list and print it
for item in items:
    print(item)

# List of items

items = ["drone", "kite", "plane", "helicopter"]

# Loop through each item in the list and print it

for item in items:

print(item)

# List of items correctly defined
items = ["drone", "kite", "plane", "uav", "helicopter"]

# Loop through each item in the list and print it
for item in items:
    if item == "drone":
        print("Alert: Drone found!")  # Special message if the item is "drone"
    print(f"{item} - Target is O.K.")  # Print this message for every item

# List of items correctly defined

items = ["drone", "kite", "plane", "uav", "helicopter"]

# Loop through each item in the list and print it

for item in items:

if item == "drone":

print("Alert: Drone found!") # Special message if the item is "drone"

print(f"{item} - Target is O.K.") # Print this message for every item

# List of items to loop through
items = ["drone", "kite", "plane", "helicopter"]

# Loop through the list and print the 2nd and 4th items
for index, item in enumerate(items):
    if index == 1 or index == 3:  # Python indexing starts at 0, so index 1 is the 2nd item, and index 3 is the 4th
        print(item)

# List of items to loop through

items = ["drone", "kite", "plane", "helicopter"]

# Loop through the list and print the 2nd and 4th items

for index, item in enumerate(items):

if index == 1 or index == 3: # Python indexing starts at 0, so index 1 is the 2nd item, and index 3 is the 4th

print(item)

תרגיל 3 OPENCV

נעבוד על התמונה :

התקנה של הספריות בפייטון

!pip install opencv-python
!pip install numpy
!pip install matplotlib
!pip install requests

!pip install opencv-python

!pip install numpy

!pip install matplotlib

!pip install requests

import cv2
import numpy as np
import matplotlib.pyplot as plt
import requests

# URL of the image
url = 'https://robotronix.co.il/wp-content/uploads/2024/06/Pasted-3-298x300.png'

# Fetch the image from the URL
resp = requests.get(url, stream=True).raw
image_array = np.asarray(bytearray(resp.read()), dtype=np.uint8)

# Decode the image as it's read in bytes
img = cv2.imdecode(image_array, cv2.IMREAD_COLOR)

# Convert the image from BGR (OpenCV default) to RGB
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Convert the image to Grayscale
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Display the images using Matplotlib
plt.figure(figsize=(10, 5))

# Display RGB Image
plt.subplot(1, 2, 1)
plt.imshow(img_rgb)
plt.title('RGB Image')
plt.axis('off')

# Display Grayscale Image
plt.subplot(1, 2, 2)
plt.imshow(img_gray, cmap='gray')
plt.title('Grayscale Image')
plt.axis('off')

plt.show()

import cv2

import numpy as np

import matplotlib.pyplot as plt

import requests

# URL of the image

url = 'https://robotronix.co.il/wp-content/uploads/2024/06/Pasted-3-298x300.png'

# Fetch the image from the URL

resp = requests.get(url, stream=True).raw

image_array = np.asarray(bytearray(resp.read()), dtype=np.uint8)

# Decode the image as it's read in bytes

img = cv2.imdecode(image_array, cv2.IMREAD_COLOR)

# Convert the image from BGR (OpenCV default) to RGB

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Convert the image to Grayscale

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Display the images using Matplotlib

plt.figure(figsize=(10, 5))

# Display RGB Image

plt.subplot(1, 2, 1)

plt.imshow(img_rgb)

plt.title('RGB Image')

plt.axis('off')

# Display Grayscale Image

plt.subplot(1, 2, 2)

plt.imshow(img_gray, cmap='gray')

plt.title('Grayscale Image')

plt.axis('off')

plt.show()

פילטרים :

import cv2
import numpy as np
import matplotlib.pyplot as plt
import requests

# URL of the image
url = 'https://robotronix.co.il/wp-content/uploads/2024/06/Pasted-3-298x300.png'

# Fetch the image from the URL
resp = requests.get(url, stream=True).raw
image_array = np.asarray(bytearray(resp.read()), dtype=np.uint8)

# Decode the image as it's read in bytes
img = cv2.imdecode(image_array, cv2.IMREAD_COLOR)

# Convert the image from BGR (OpenCV default) to RGB
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Convert the image to Grayscale
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Apply Gaussian Blur to smooth the image
img_blur = cv2.GaussianBlur(img_gray, (5, 5), 0)

# Apply the Canny filter to detect edges
img_canny = cv2.Canny(img_blur, 50, 150)

# Display the images using Matplotlib
plt.figure(figsize=(15, 5))

# Display RGB Image
plt.subplot(1, 3, 1)
plt.imshow(img_rgb)
plt.title('RGB Image')
plt.axis('off')

# Display Grayscale Image
plt.subplot(1, 3, 2)
plt.imshow(img_gray, cmap='gray')
plt.title('Grayscale Image')
plt.axis('off')

# Display Canny Edge Image
plt.subplot(1, 3, 3)
plt.imshow(img_canny, cmap='gray')
plt.title('Canny Edge Detection')
plt.axis('off')

plt.show()

import cv2

import numpy as np

import matplotlib.pyplot as plt

import requests

# URL of the image

url = 'https://robotronix.co.il/wp-content/uploads/2024/06/Pasted-3-298x300.png'

# Fetch the image from the URL

resp = requests.get(url, stream=True).raw

image_array = np.asarray(bytearray(resp.read()), dtype=np.uint8)

# Decode the image as it's read in bytes

img = cv2.imdecode(image_array, cv2.IMREAD_COLOR)

# Convert the image from BGR (OpenCV default) to RGB

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Convert the image to Grayscale

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Apply Gaussian Blur to smooth the image

img_blur = cv2.GaussianBlur(img_gray, (5, 5), 0)

# Apply the Canny filter to detect edges

img_canny = cv2.Canny(img_blur, 50, 150)

# Display the images using Matplotlib

plt.figure(figsize=(15, 5))

# Display RGB Image

plt.subplot(1, 3, 1)

plt.imshow(img_rgb)

plt.title('RGB Image')

plt.axis('off')

# Display Grayscale Image

plt.subplot(1, 3, 2)

plt.imshow(img_gray, cmap='gray')

plt.title('Grayscale Image')

plt.axis('off')

# Display Canny Edge Image

plt.subplot(1, 3, 3)

plt.imshow(img_canny, cmap='gray')

plt.title('Canny Edge Detection')

plt.axis('off')

plt.show()

חלק ב : אימון YOLO אנקונדה

קישור לתוכנה לסימון תוויות עבור YOLO מודל : https://www.makesense.ai/

pip install ultralytics

1	pip install ultralytics

import os

base_path = r"D:\temp40\cams-1"

# Define required folders
folders = [
    'train/images',
    'train/labels',
    'val/images',
    'val/labels'
]

# Create all folders
for folder in folders:
    os.makedirs(os.path.join(base_path, folder), exist_ok=True)




print("YOLOv8 folder structure created in:", base_path)

import os

base_path = r"D:\temp40\cams-1"

# Define required folders

folders = [

'train/images',

'train/labels',

'val/images',

'val/labels'

]

# Create all folders

for folder in folders:

os.makedirs(os.path.join(base_path, folder), exist_ok=True)

print("YOLOv8 folder structure created in:", base_path)

import os

# Define the base path
base_path = r"D:\temp40\cams-1"

# Create the data.yaml content
yaml_content = f"""
path: {base_path.replace("\\", "/")}
train: train
val: val
names:
  0: cam1
"""

# Save the YAML file
yaml_path = os.path.join(base_path, "data.yaml")
with open(yaml_path, "w") as f:
    f.write(yaml_content)

print(f"data.yaml created at: {yaml_path}")

import os

# Define the base path

base_path = r"D:\temp40\cams-1"

# Create the data.yaml content

yaml_content = f"""

path: {base_path.replace("\\", "/")}

train: train

val: val

names:

0: cam1

"""

# Save the YAML file

yaml_path = os.path.join(base_path, "data.yaml")

with open(yaml_path, "w") as f:

f.write(yaml_content)

print(f"data.yaml created at: {yaml_path}")

from ultralytics import YOLO
import os

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

model = YOLO('yolov8n.pt')  # Load YOLOv8 model

# Train the model
results = model.train(
    data=r"D:\temp40\cams-1\data.yaml",
    epochs=100,
    batch=4,
    device="cpu",
    project=r"D:\temp40\cams-1\run",  # Custom base directory
    name="train_results"              # Subfolder name for this run
)

# Dynamically get path to saved weights
save_dir = model.trainer.save_dir if hasattr(model, 'trainer') else results.save_dir
best_path = os.path.join(save_dir, "weights", "best.pt")
last_path = os.path.join(save_dir, "weights", "last.pt")

print("Training completed!")
print(f"Best model saved to: {best_path}")
print(f"Last model saved to: {last_path}")

from ultralytics import YOLO

import os

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

model = YOLO('yolov8n.pt') # Load YOLOv8 model

# Train the model

results = model.train(

data=r"D:\temp40\cams-1\data.yaml",

epochs=100,

batch=4,

device="cpu",

project=r"D:\temp40\cams-1\run", # Custom base directory

name="train_results" # Subfolder name for this run

)

# Dynamically get path to saved weights

save_dir = model.trainer.save_dir if hasattr(model, 'trainer') else results.save_dir

best_path = os.path.join(save_dir, "weights", "best.pt")

last_path = os.path.join(save_dir, "weights", "last.pt")

print("Training completed!")

print(f"Best model saved to: {best_path}")

print(f"Last model saved to: {last_path}")

TensorFlow or PyTorch, in YOLOv8, the box_loss, cls_loss, and dfl_loss are error/loss

Concept	TensorFlow / PyTorch	YOLOv8 Equivalent
Loss Function	`loss = error between y_pred & y_true`	`box_loss`, `cls_loss`, `dfl_loss`
Training Goal	Minimize the loss	Minimize YOLO losses
High Loss	Model is not learning well	Same meaning in YOLO
Low Loss	Model is making better predictions	Same

In YOLO, these loss values are just split into parts specific to object detection:

box_loss = position error
cls_loss = label/class error
dfl_loss = precision of bounding box edges

All together, they behave like a regular total loss in TensorFlow.

values.

Loss Type	What It Measures	Meaning of High Value	Goal
box_loss	Error in the predicted box position & size	Boxes are inaccurate	↓ Lower is better
cls_loss	Error in predicting the correct object class	AI is guessing wrong labels	↓ Lower is better
dfl_loss	Precision error in box shape (Distribution Focal Loss)	Shape/edges of box are off	↓ Lower is better

🔧 In simple terms:

Loss is the AI’s mistake counter.
The higher the value = the more wrong the AI is.
During training, loss should go down. If it stays high, something is wrong (not learning).

Parameter	Your Value	What It Means (Simple)	Bad Value	Good Value	Best Value	Your Rating
Epoch	100/100	How many rounds the AI trained. More rounds = better learning, but too much can be bad.	<50 or >300	50–300	100–200	✅ Good
GPU_mem	0G	Shows if the AI used a fast brain (GPU). If 0G, it used a slow one (CPU).	0	>0	4G–12G+	❌ Bad
box_loss	0.8291	Measures how wrong the AI is at drawing boxes around objects. Lower is better.	>0.5	<0.5	<0.2	❌ Bad
cls_loss	0.9094	Measures how wrong the AI is at naming what it sees (dog, cat, etc.). Lower is better.	>0.5	<0.3	<0.1	❌ Bad
dfl_loss	1.021	Checks how well the AI guesses the exact size/shape of objects. Lower is better.	>0.5	<0.3	<0.1	❌ Bad
Instances	4	Average number of objects per image the AI sees.	N/A	Info only	Info only	ℹ️ Info
Size	640	Size of input image (in pixels). Bigger = more details, but slower.	<416	640–1280	960–1280	✅ Good
Box(P)	0.46	How many of the AI's guesses were right. (Precision) Higher = better.	<0.5	>0.5	>0.8	⚠️ Avg
R (Recall)	0.857	How many real objects the AI found. Higher = better.	<0.6	>0.7	>0.9	✅ Good
mAP50	0.409	Overall score (at easy difficulty). Combines accuracy and detection.	<0.4	>0.6	>0.8	⚠️ Avg
mAP50-95	0.279	Overall score (at hard difficulty). Measures true AI skill.	<0.3	>0.4	>0.6	❌ Ba

from ultralytics import YOLO
import os
import cv2
import matplotlib.pyplot as plt
import glob

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

# Load your trained YOLO model
model = YOLO(r"D:\temp40\cams-1\run\train_results\weights\best.pt")

# Perform detection and save results to a fixed path
results = model.predict(
    source=r"D:\temp40\dataset\raw1\t1.jpg",
    save=True,
    project=r"D:\temp40\cams-1\run",
    name="predict"  # Subfolder to keep predictions separate
)

# Get the output directory where YOLO saves detections
output_dir = results[0].save_dir

# Find the processed image in the output directory
saved_image_path = glob.glob(os.path.join(output_dir, "*.jpg"))

if saved_image_path:
    image_path = saved_image_path[0]
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    plt.figure(figsize=(10, 6))
    plt.imshow(image)
    plt.axis("off")
    plt.show()
else:
    print("No output image found. Check the YOLO output folder:", output_dir)

from ultralytics import YOLO

import os

import cv2

import matplotlib.pyplot as plt

import glob

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

# Load your trained YOLO model

model = YOLO(r"D:\temp40\cams-1\run\train_results\weights\best.pt")

# Perform detection and save results to a fixed path

results = model.predict(

source=r"D:\temp40\dataset\raw1\t1.jpg",

save=True,

project=r"D:\temp40\cams-1\run",

name="predict" # Subfolder to keep predictions separate

)

# Get the output directory where YOLO saves detections

output_dir = results[0].save_dir

# Find the processed image in the output directory

saved_image_path = glob.glob(os.path.join(output_dir, "*.jpg"))

if saved_image_path:

image_path = saved_image_path[0]

image = cv2.imread(image_path)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(10, 6))

plt.imshow(image)

plt.axis("off")

plt.show()

else:

print("No output image found. Check the YOLO output folder:", output_dir)

קורס יסודות בינה מלאכותית : RB26-00 קישורים

תרגיל כיתה 2

סביבת קולאב COLAB : – YOLO מודל yolo

שלב 1 : התקנת הסיפריות (עושים פעם אחת בלבד בסביבת הפיתוח)

שימו לב : סיבבת הפיתוח הקבצים תראה כך לפני ההתקנה

שלב 2 : יצירת קובץ yaml

חילוץ הקובץ מ RAR :

שלב 3 : התקנת קבצי התמונות והתוויות – (labels) בסביבת – אימון

שלב 4 : אימון בינה מלאכותית מודל YOLO

פעולת האימון של הבינה מלאכותית הסתיימה

תרגיל כיתה 3 :

תרגיל 3 OPENCV

חלק ב : אימון YOLO אנקונדה

🔧 In simple terms:

אולי תאהב/י גם

פיתוח בינה מלאכותית : רשת CNN חלק 3

מערכת בקרת טמפרטורה 8 ערוצים

לימוד ארדואינו : שיעור 18 – פונקציות – מתקדם – קורס C506

כתיבת תגובה לבטל