בחר קורס יסודות בינה מלאכותית RB26-17 : נארף בינה מלאכותית NeRF (Neural Radiance Fields

מחבר:admin
פורסם:יולי 15, 2025
קטגוריה:רובוטרוניקס כללי
תגובות:אין תגובות

בחר קורס יסודות בינה מלאכותית RB26-17 : נארף בינה מלאכותית NeRF (Neural Radiance Fields

NERF A.I – NeRF (Neural Radiance Fields

NeRF (Neural Radiance Fields) היא טכניקה מתקדמת בתחום הבינה המלאכותית והראייה הממוחשבת, שנועדה ליצור מודל תלת־ממדי מציאותי מתמונות דו־ממדיות

NeRF משתמש ברשת נוירונים כדי ללמוד איך אור מתפזר ונפלט מנקודות שונות במרחב. הוא מאפשר לייצר הדמיה תלת־ממדית ריאליסטית מתוך כמה תמונות סטטיות בלבד

אפשר להגיד ש־NeRF עושה פרדיקציה (חיזוי) של מה שהפיקסל "היה רואה" מזווית חדשה שלא צולמה.

איך זה קורה בפועל:

הרשת למדה מתוך תמונות אמיתיות: איפה יש עצמים, מה צבעים, ומה שקיפות.
עכשיו, כשאנחנו "שואלים" אותה על פיקסל מזווית שלא קיימת –
היא מדמה את התשובה לפי מה שלמדה → זה בדיוק פרדיקציה

מטרת הרשת NeRF:

לחזות צבע ו־שקיפות של נקודה במרחב לפי מיקומה וכיוון ההסתכלות.

קלט (Input) של הרשת:

מיקום במרחב – נקודה תלת־ממדית:

$x=(x,y,z)\mathbf{x} = (x, y, z)$
כיוון ההסתכלות – וקטור שמייצג לאן המצלמה מסתכלת:

$\mathbf{d} = (\theta, \phi) \quad \text{או} \quad (dx, dy, dz)$

כלומר: איפה אתה במרחב, ולאן אתה מסתכל משם.

וקטור כיווני בקרטזי (Cartesian):

$d=(dx,dy,dz)\mathbf{d} = (dx, dy, dz)$

מייצג את כיוון הקרן במרחב (3D direction vector).
זו הצורה הנפוצה בפועל באימון NeRF.

2. זוויות כדוריות (Spherical angles):

$d=(θ,ϕ)\mathbf{d} = (\theta, \phi)$

פלט (Output) של הרשת:

צבע (RGB) – הצבע שהקרן "רואה" באותה נקודה:

$(r, g, b)$
שקיפות / צפיפות (σ) – כמה "חומר" יש שם:

$σ=density\sigma = \text{density}$

זה קורה אלפי פעמים:

הרשת בודקת הרבה נקודות לאורך כל קרן, וכל פיקסל בתמונה הסופית נבנה משקלול הפלטים של כל הנקודות האלה.

למה צריך קרן אור?

כשאנחנו יוצרים תמונה חדשה מזווית שלא צולמה, המחשב צריך "לדמיין" איך היא הייתה נראית.
הוא עושה זאת בעזרת קרניים וירטואליות שיוצאות מהמצלמה (כמו בעין שלנו) אל תוך הסצנה

מה זו קרן אור ב־NeRF?

זו קו דמיוני שיוצא מכל פיקסל בתמונה (שאנחנו רוצים ליצור) ונכנס לסצנה התלת־ממדית.
בפועל – לכל פיקסל בתמונה החדשה → שולחים קרן לתוך המרחב.

הקרניים יוצאות מהמצלמה" – למה הכוונה?

ב־NeRF (ובגרפיקה בכלל), כשאומרים "קרניים יוצאות מהמצלמה", מתכוונים לזה:

המצלמה היא נקודת המבט – כאילו אנחנו מסתכלים על הסצנה.
כל פיקסל בתמונה שאנו רוצים ליצור מייצג קרן אור שיוצאת מהמצלמה לתוך העולם.

כלומר, אנחנו לא מתחילים מתמונה קיימת, אלא ממיקום של מצלמה מדומיינת, ושואלים:

"אם הייתי עומד פה, ומסתכל לכיוון הזה – מה הייתי רואה שם?

מה האלגוריתם עושה עם הקרן?

דוגם לאורך הקרן – כל כמה מילימטרים הוא בודק נקודה לאורך הקרן.
שואל את הרשת הנוירונית:
- מה הצבע בנקודה הזו (אם יש שם חומר)?
- כמה שקיפות/חומר יש שם (density)?
משקלל את כל התשובות לאורך הקרן:
- אם הקרן עברה דרך אוויר → שקוף → ממשיכים.
- אם הקרן עברה דרך חומר אטום → נוצר צבע → זה יהיה הפיקסל בתמונה.
מה יוצא מזה?

הרכבת הצבעים לאורך כל הקרן = פיקסל אחד בתמונה.
אם תעשה את זה לכל הקרניים → תקבל תמונה חדשה מלאה מזווית שלא הייתה קודם

דוגמה קטנה:

אתה מייצר תמונה מזווית חדשה.
הקרן יוצאת מפיקסל שמכוון לפינה של שולחן.
הרשת אומרת:
- לאורך הקרן, יש עץ בגובה 1.2 מטר, צבע חום, שקיפות נמוכה → הפיקסל יהיה חום.
כך תבנה את התמונה כולה, פיקסל אחר פיקסל.

שימושים:

יצירת סצנות תלת־ממדיות מציאותיות ממשלוש תמונות בלבד
אנימציה, AR/VR
סריקה תלת־ממדית ללא צורך בלידאר
משחקים, קולנוע, Google Maps (למשל בתוך המבנים)

🔧 כלים פופולריים:

Instant-NGP (NVIDIA) – מימוש מהיר של NeRF בזמן אמת
Colmap + NeRF – זיהוי מצלמות ואז בניית מודל
Luma AI – אפליקציה נוחה לטלפון ליצירת NeRF

אז איך זה קורה הכי מהר שיש

לא להתבלבל Photogrammetry 3D

The Difference Between NeRF And Photogrammetry 3D Scan

LUMA שלב אחרי שלב

אימון מודל NeRF:

✅ שלב 1: איסוף תמונות

מצלם את אותו אובייקט או סצנה מזוויות שונות.
כל תמונה חייבת לכלול:
- מיקום המצלמה (position)
- כיוון המצלמה (orientation / pose)

משתמשים בכלים כמו COLMAP כדי לחשב את מיקום וזווית המצלמה עבור כל תמונה.

✅ שלב 2: הכנת דאטה לאימון

לכל תמונה:

מחשבים קרניים – Ray per pixel.
כל קרן היא:
- נקודת התחלה (מצלמה)
- כיוון (לפי הפיקסל)
לדוגמה: קרן שמתחילה מהמצלמה והולכת דרך הפיקסל ה־(x, y)

✅ שלב 3: דגימה לאורך הקרניים

לכל קרן:

דוגמים הרבה נקודות (במרחקים שונים לאורך הקרן)
לכל נקודה מזינים לרשת:
- $x, y, z$
- כיוון הקרן $d$
הרשת מחזירה:
- (r, g, b) – צבע
- σ (density) – שקיפות / כמות חומר

✅ שלב 4: חישוב צבע סופי לקרן

משקללים את כל הצבעים והשקיפויות לאורך הקרן לפי מודל אופטיקה (volume rendering).
מקבלים צבע סופי של פיקסל.

✅ שלב 5: חישוב שגיאה (Loss)

משווים את הצבע שחזה המודל לצבע האמיתי בתמונה.
מחשבים Loss (MSE) בין הפיקסלים.
משתמשים ב־Backpropagation כדי לעדכן את המשקלים של הרשת.

✅ שלב 6: חוזרים על זה…

חוזרים על התהליך הזה עבור עשרות אלפי קרניים מכל התמונות.
עד שהרשת "לומדת" לייצר כל נקודת מבט בצורה ריאליסטית.

COLMAP – אם חסרות זוויות (למשל אין תמונות מהצד האחורי), התוצאה תהיה חלקית או חסרה

COLMAP צריך תמונות מכל הצדדים:

כדי ש-COLMAP יוכל לבנות מודל תלת־ממדי מלא, הוא צריך:

תמונות מזוויות רבות ושונות – לפחות 3–5 מכל צד.
חפיפות בין התמונות – כלומר שיהיו אזורים משותפים בין התמונות, כדי שיוכל לזהות נקודות תואמות.
תאורה עקבית תורמת לדיוק, אבל לא חובה.

הבדלים COLMAP VS NeRF

ב־COLMAP אנחנו בונים תמונה תלת־ממדית על בסיס תמונות דו־ממדיות רבות שצולמו מזוויות שונות. אם חסרות תמונות מזוויות מסוימות – המודל התלת־ממדי יהיה חלקי או לא מדויק. COLMAP אינו משתמש בבינה מלאכותית, אלא באלגוריתמים גיאומטריים בלבד, ואינו מבצע פרדיקציה (חיזוי).

לעומת זאת, ב־NeRF מצלמים רק מספר תמונות מזוויות שונות סביב האובייקט, גם אם אין חפיפה מלאה ביניהן. המודל מבוסס על בינה מלאכותית, והוא מבצע פרדיקציה כדי להשלים מידע חסר. לכן, גם אם לא צילמנו את האובייקט מכל כיוון, NeRF ידע להשלים את התמונה ולייצר הדמיה תלת־ממדית מלאה וריאליסטית של הסצנה.

העשרה :

Understanding 3D Reconstruction with COLMAP

תוכנות לשימוש ב NERF

כלים אונליין להתנסות ב-NeRF:

1. Luma AI – יצירת מודל תלת־ממדי בצורה קלה ומהירה:
🔗 https://lumalabs.ai

2. Nerfstudio בגוגל קולאב – הרצת NeRF דרך Colab עם GPU חינמי:
🔗 https://colab.research.google.com/github/nerfstudio-project/nerfstudio/blob/main/examples/notebooks/Nerfstudio-COLMAP.ipynb

3. Kiri Engine – אפליקציית מובייל לסריקה תלת־ממדית:
🔗 https://www.kiriengine.app

חלק ב

יסודות בינה מלאכותית : 02-RB27 – מבוא ל YOLO – זיהוי אובייקטים

יסודות בינה מלאכותית : 04-RB27 – זיהוי אובייקטים ואימון מודל

YOLO

חלק 2 :

1

pip install ultralytics opencv–python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from ultralytics import YOLO
from pathlib import Path
# Load the YOLOv8 model pre-trained on COCO dataset
model = YOLO('yolov8m.pt')  # 'yolov8n.pt' is the nano version; you can use 'yolov8s.pt' for the small version
# Define the image path
image_path = Path(r'd:\temp\1.jpg')
# Run YOLOv8 for human detection on the image
results = model(image_path)
# Filter results to include only humans (class label '0' for person in COCO dataset)
humans = [res for res in results[0].boxes if res.cls[0] == 0]
# Display detection results
results[0].show()  # This will open the image with bounding boxes for detected humans

ספירה של אנשים בתמונה

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from ultralytics import YOLO
# Load YOLOv8 model and run detection
model = YOLO('yolov8n.pt')
results = model(r'd:\temp\1.jpg')
# Initialize people count
people_count = 0
# Use a for loop to count people (class '0' is "person")
for box in results[0].boxes:
    if box.cls[0] == 0:  # Class '0' corresponds to "person"
        people_count += 1
# Print the count and appropriate message
print("Low people" if people_count < 4 else "Many people")

ספירה של אנשים מתקדם

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from ultralytics import YOLO
import cv2
# Load YOLOv8 model and run detection
model = YOLO('yolov8n.pt')
results = model(r'd:\temp\many-car.jpeg')
# Initialize people count and create an empty list for person boxes
people_count = 0
person_boxes = []
# Use a for loop to count people with confidence > 60% and collect their boxes
for box in results[0].boxes:
    if box.cls[0] == 0 and box.conf[0] > 0.6:  # Class '0' is "person" and confidence > 60%
        people_count += 1
        person_boxes.append(box)  # Keep only high-confidence person boxes
# Plot only the high-confidence person boxes
annotated_img = results[0].orig_img.copy()
for person_box in person_boxes:
    x1, y1, x2, y2 = map(int, person_box.xyxy[0])  # Convert to integer coordinates
    cv2.rectangle(annotated_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
# Add the people count to the image
cv2.putText(
    annotated_img,
    f'People Count: {people_count}',
    (10, 30),
    cv2.FONT_HERSHEY_SIMPLEX,
    1,
    (0, 255, 0),
    2
)
# Display the annotated image
cv2.imshow("People Detection", annotated_img)
cv2.waitKey(0)  # Wait until a key is pressed
cv2.destroyAllWindows()  # Close the window

זיהוי בוידאו :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

from ultralytics import YOLO
import cv2
from IPython.display import display, clear_output
from PIL import Image
import numpy as np
# Load YOLOv8 model pre-trained on the COCO dataset
model = YOLO('yolov8m.pt')
# Load video file
video_path = r'd:\temp\AK4.mp4'
cap = cv2.VideoCapture(video_path)
# Check if the video opened successfully
if not cap.isOpened():
    print("Error opening video file")
# Process video frame-by-frame
frame_count = 0
while cap.isOpened() and frame_count < 100:  # Limiting to 100 frames for notebook display purposes
    ret, frame = cap.read()
    if not ret:
        break
    # Run YOLO detection on the frame
    results = model(frame)
    # Process each detected box and draw red rectangles for people above 60% confidence
    for box in results[0].boxes:
        if box.cls[0] == 0 and box.conf[0] > 0.6:  # Class '0' is "person", confidence > 60%
            # Get the bounding box coordinates
            x1, y1, x2, y2 = map(int, box.xyxy[0])  # Convert to integer coordinates
            
            # Draw a red rectangle (bounding box) on the frame
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 2)
            # Prepare the confidence text
            confidence_text = f"{box.conf[0] * 100:.1f}%"  # Convert confidence to percentage with 1 decimal
            # Position the text slightly above the bounding box
            text_x, text_y = x1, y1 – 10  # Position above top-left corner of the bounding box
            cv2.putText(
                frame,
                confidence_text,
                (text_x, text_y),
                cv2.FONT_HERSHEY_SIMPLEX,
                0.5,
                (0, 0, 255),  # Red color for the text
                2
            )
    # Convert the frame from BGR to RGB for Jupyter display
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    pil_img = Image.fromarray(frame_rgb)
    # Display the frame in the notebook
    clear_output(wait=True)
    display(pil_img)
    
    frame_count += 1  # Increase frame count to limit displayed frames
# Release video capture
cap.release()