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

חלק א : מבוא לרשתות נוירונים קצת חומר תיאורטי – איך הכל עובד ?

תרגיל כיתה 1 : תרגול COLAB רשת נוירונים

התקן ספריות לפי הצורך

נתונה טבלה הבאה בנה קוד פייתון להצגי אותה כגרף

#	X	Y
1	-4.000	-1285.600
2	-3.837	-1056.338
3	-3.673	-859.830
4	-3.510	-692.529
5	-3.347	-551.145
6	-3.184	-432.619
7	-3.020	-333.606
8	-2.857	-251.001
9	-2.694	-181.925
10	-2.531	-123.737
11	-2.367	-74.024
12	-2.204	-30.599
13	-2.041	8.259
14	-1.878	43.950
15	-1.714	77.434
16	-1.551	109.240
17	-1.388	139.488
18	-1.224	167.912
19	-1.061	193.890
20	-0.898	216.475
21	-0.735	234.426
22	-0.571	246.237
23	-0.408	250.174
24	-0.245	244.325
25	-0.082	226.646
26	0.082	194.999
27	0.245	147.192
28	0.408	81.025
29	0.571	-5.592
30	0.735	-114.849
31	0.898	-249.536
32	1.061	-412.119
33	1.224	-604.807
34	1.388	-829.621
35	1.551	-1088.473
36	1.714	-1383.237
37	1.878	-1715.813
38	2.041	-2088.194
39	2.204	-2502.529
40	2.367	-2961.189
41	2.531	-3466.831
42	2.694	-4022.476
43	2.857	-4631.575
44	3.020	-5297.084
45	3.184	-6022.547
46	3.347	-6811.175
47	3.510	-7666.923
48	3.673	-8593.574
49	3.837	-9595.813
50	4.000	-10678.304

בנה בעזרת בינה מלאכותית – רשת ניירונים אשר מקבלת את הנתונים ומייצרת מודל
הצג איפוקס , בדוק עבור 20 , 100 , 350 . הצג גרף ERROR LOST
הרץ על המודל שאומן את המספרים בצעו פרדיקציה חשבו שגיע לפי נתוני TURE

-5 – 4.3 ,0 ,2,1.5

4.הצג את הנקודות על גרף הפונקציה

5.עבור סעיף 3 שאל את הבינה מלאכותית מה ניתן לשפר שהפרדיקציה תהייה טובה יותר

תרגיל 2

נתח בעזרת בינה מלאכותית את הקוד הבא , המה עושה ?
בקשת מהבינה מלאכותית לכתוב שוב אותו קוד עם הערות ובלוקים ומה עושה כל בלוק

# ==========================================
# AI MODEL TRAINING FOR X -> Z
# ==========================================

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf

# כדי לקבל תוצאה דומה בכל הרצה
np.random.seed(42)
tf.random.set_seed(42)

# ==========================================
# 1. DATASET
# ==========================================

data = {
    "X": [-4.0, -3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5,
          0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0],

    "Z": [25360, 12000, 4800, 1150, 0, -210, 0, 220,
          300, 300, 310, 400, 490, 300, -800, -3700, -10040]
}

df = pd.DataFrame(data)

print("Dataset:")
display(df)

# ==========================================
# 2. SHOW DATA GRAPH
# ==========================================

plt.figure(figsize=(8, 5))
plt.scatter(df["X"], df["Z"], label="Data Points")
plt.plot(df["X"], df["Z"], label="Original Data")
plt.xlabel("X")
plt.ylabel("Z")
plt.title("Original Dataset X -> Z")
plt.grid(True)
plt.legend()
plt.show()

# ==========================================
# 3. PREPARE DATA
# ==========================================

X = df["X"].values.reshape(-1, 1)
Z = df["Z"].values.reshape(-1, 1)

# Normalization
X_mean = X.mean()
X_std = X.std()

Z_mean = Z.mean()
Z_std = Z.std()

X_norm = (X - X_mean) / X_std
Z_norm = (Z - Z_mean) / Z_std

# ==========================================
# 4. BUILD AI MODEL
# ==========================================

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="tanh", input_shape=(1,)),
    tf.keras.layers.Dense(64, activation="tanh"),
    tf.keras.layers.Dense(64, activation="tanh"),
    tf.keras.layers.Dense(1)
])

model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
    loss="mse"
)

model.summary()

# ==========================================
# 5. TRAIN MODEL
# ==========================================

EPOCHS = 350

history = model.fit(
    X_norm,
    Z_norm,
    epochs=EPOCHS,
    verbose=1
)

# ==========================================
# 6. SHOW ERROR / LOSS GRAPH
# ==========================================

plt.figure(figsize=(8, 5))
plt.plot(history.history["loss"])
plt.xlabel("Epoch")
plt.ylabel("Loss / Error")
plt.title("Learning Error Graph")
plt.grid(True)
plt.show()

# ==========================================
# 7. PREDICTION TEST
# ==========================================

test_x = np.array([-5, -4.3, 0, 2, 1.5]).reshape(-1, 1)

# Normalize test input
test_x_norm = (test_x - X_mean) / X_std

# Predict normalized Z
pred_norm = model.predict(test_x_norm)

# Convert prediction back to real Z values
pred_z = pred_norm * Z_std + Z_mean

result = pd.DataFrame({
    "X": test_x.flatten(),
    "Predicted Z": pred_z.flatten()
})

print("Predictions:")
display(result)

# ==========================================
# 8. SHOW MODEL PREDICTION ON GRAPH
# ==========================================

x_curve = np.linspace(-5, 4.5, 300).reshape(-1, 1)
x_curve_norm = (x_curve - X_mean) / X_std

z_pred_norm = model.predict(x_curve_norm)
z_pred = z_pred_norm * Z_std + Z_mean

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

plt.scatter(X, Z, label="Original Data")
plt.plot(x_curve, z_pred, label="AI Prediction")

plt.scatter(test_x, pred_z, color="red", label="Test Predictions")

plt.xlabel("X")
plt.ylabel("Z")
plt.title("AI Model Prediction")
plt.grid(True)
plt.legend()
plt.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

# ==========================================

# AI MODEL TRAINING FOR X -> Z

# ==========================================

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import tensorflow as tf

# כדי לקבל תוצאה דומה בכל הרצה

np.random.seed(42)

tf.random.set_seed(42)

# ==========================================

# 1. DATASET

# ==========================================

data = {

"X": [-4.0, -3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5,

0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0],

"Z": [25360, 12000, 4800, 1150, 0, -210, 0, 220,

300, 300, 310, 400, 490, 300, -800, -3700, -10040]

}

df = pd.DataFrame(data)

print("Dataset:")

display(df)

# ==========================================

# 2. SHOW DATA GRAPH

# ==========================================

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

plt.scatter(df["X"], df["Z"], label="Data Points")

plt.plot(df["X"], df["Z"], label="Original Data")

plt.xlabel("X")

plt.ylabel("Z")

plt.title("Original Dataset X -> Z")

plt.grid(True)

plt.legend()

plt.show()

# ==========================================

# 3. PREPARE DATA

# ==========================================

X = df["X"].values.reshape(-1, 1)

Z = df["Z"].values.reshape(-1, 1)

# Normalization

X_mean = X.mean()

X_std = X.std()

Z_mean = Z.mean()

Z_std = Z.std()

X_norm = (X - X_mean) / X_std

Z_norm = (Z - Z_mean) / Z_std

# ==========================================

# 4. BUILD AI MODEL

# ==========================================

model = tf.keras.Sequential([

tf.keras.layers.Dense(64, activation="tanh", input_shape=(1,)),

tf.keras.layers.Dense(64, activation="tanh"),

tf.keras.layers.Dense(1)

])

model.compile(

optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),

loss="mse"

)

model.summary()

# ==========================================

# 5. TRAIN MODEL

# ==========================================

EPOCHS = 350

history = model.fit(

X_norm,

Z_norm,

epochs=EPOCHS,

verbose=1

)

# ==========================================

# 6. SHOW ERROR / LOSS GRAPH

# ==========================================

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

plt.plot(history.history["loss"])

plt.xlabel("Epoch")

plt.ylabel("Loss / Error")

plt.title("Learning Error Graph")

plt.grid(True)

plt.show()

# ==========================================

# 7. PREDICTION TEST

# ==========================================

test_x = np.array([-5, -4.3, 0, 2, 1.5]).reshape(-1, 1)

# Normalize test input

test_x_norm = (test_x - X_mean) / X_std

# Predict normalized Z

pred_norm = model.predict(test_x_norm)

# Convert prediction back to real Z values

pred_z = pred_norm * Z_std + Z_mean

result = pd.DataFrame({

"X": test_x.flatten(),

"Predicted Z": pred_z.flatten()

})

print("Predictions:")

display(result)

# ==========================================

# 8. SHOW MODEL PREDICTION ON GRAPH

# ==========================================

x_curve = np.linspace(-5, 4.5, 300).reshape(-1, 1)

x_curve_norm = (x_curve - X_mean) / X_std

z_pred_norm = model.predict(x_curve_norm)

z_pred = z_pred_norm * Z_std + Z_mean

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

plt.scatter(X, Z, label="Original Data")

plt.plot(x_curve, z_pred, label="AI Prediction")

plt.scatter(test_x, pred_z, color="red", label="Test Predictions")

plt.xlabel("X")

plt.ylabel("Z")

plt.title("AI Model Prediction")

plt.grid(True)

plt.legend()

plt.show()

רשת נוירונים — מהי?

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

לדוגמה:

קלט	פלט רצוי
תמונה של חתול	חתול
קול של רחפן	רחפן
טמפרטורה, לחות, אור	החלטה: להשקות / לא להשקות
תמונה מכביש	רכב / אדם / תמרור

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

אם יש אוזניים ושפם אז זה חתול

אלא היא לומדת לבד מתוך הרבה דוגמאות.

1. הרעיון הבסיסי (ללא ביאס וללא פונקציית אקטיבציה)

רשת נוירונים בנויה מיחידות קטנות שנקראות נוירונים.

X הוא הסכום של הקלט כפול המשקלים

כל נוירון מקבל מספרים, מבצע חישוב, ומוציא מספר חדש.

לדוגמה:

קלטים → חישוב → פלט

בצורה פשוטה:

x1, x2, x3 → neuron → y

2. מה יש בתוך נוירון?

כל נוירון עושה בערך את זה:

y = x1w1 + x2w2 + x3*w3 + b

פירוש:

סימן	משמעות
x	קלט
w	משקל
b	הטיה
y	תוצאה

המשקל w אומר לרשת כמה חשוב כל קלט.

3. דוגמה פשוטה — זיהוי כלב או חתול

נניח שהרשת צריכה להחליט האם בתמונה מופיע כלב או חתול.

הקלט הוא תמונה.

המטרה היא שהרשת תחזיר תשובה:

כלב

או:

חתול

בהתחלה הרשת לא יודעת כלום.

היא לא באמת מבינה מה זה כלב ומה זה חתול.

היא מקבלת אלפי תמונות לדוגמה:

תמונה	תשובה נכונה
תמונה 1	חתול
תמונה 2	כלב
תמונה 3	חתול
תמונה 4	כלב
תמונה 5	כלב

כל תמונה הופכת למספרים.

במחשב, תמונה היא אוסף גדול של פיקסלים.

כל פיקסל הוא מספר שמייצג צבע או עוצמת אור.

לדוגמה:

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

הרשת מסתכלת על אלפי תמונות של חתולים וכלבים.

לאט לאט היא לומדת תבניות.

למשל, היא יכולה ללמוד שבתמונות של חתולים יש לפעמים:

אוזניים מחודדות
עיניים מסוימות
שפם
מבנה פנים צר יותר
פרווה מסוימת

ובתמונות של כלבים יש לפעמים:

חוטם ארוך יותר
אוזניים שונות
מבנה גוף אחר
צורת פנים אחרת
מרקם פרווה שונה

אבל חשוב להבין:

הרשת לא לומדת כמו בן אדם.

היא לא אומרת לעצמה:

"ראיתי שפם, לכן זה חתול."

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

איך היא לומדת מתוך אלפי תמונות?

בכל פעם הרשת מקבלת תמונה אחת.

לדוגמה:

תמונה של חתול

הרשת נותנת ניחוש:

כלב: 0.70
חתול: 0.30

כלומר הרשת חושבת שזה כלב בסיכוי 70%.

אבל התשובה הנכונה היא חתול.

לכן יש שגיאה.

עכשיו הרשת מתקנת את המשקלים שלה.

בפעם הבאה שהיא תראה תמונה דומה, היא תנסה לתת תשובה טובה יותר.

אחרי אלפי תמונות, התהליך חוזר שוב ושוב:

הרשת מקבלת תמונה
הרשת נותנת ניחוש
בודקים מה התשובה הנכונה
מחשבים כמה הרשת טעתה
מתקנים את המשקלים
ממשיכים לתמונה הבאה

אחרי הרבה מאוד חזרות, הרשת משתפרת.

בסוף היא יכולה לקבל תמונה חדשה שהיא לא ראתה בזמן האימון, ולנסות לזהות אם זה כלב או חתול.

לדוגמה:

כלב: 0.04
חתול: 0.96

כלומר הרשת חושבת שיש סיכוי של 96% שזה חתול.

4. מהי שכבה ברשת?

רשת נוירונים כוללת כמה שכבות:

Input Layer → Hidden Layers → Output Layer

Input Layer

מקבלת את הנתונים.

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

פיקסלים של תמונה

Hidden Layers

מבצעות את הלמידה והחישובים.

בשכבות הראשונות הרשת יכולה ללמוד דברים פשוטים כמו:

קווים
קצוות
צבעים
בהירות

בשכבות עמוקות יותר היא יכולה ללמוד דברים מורכבים יותר כמו:

עיניים
אוזניים
פרווה
צורת פנים
מבנה גוף

Output Layer

נותנת את התוצאה.

לדוגמה:

חתול: 0.92
כלב: 0.08

הרשת אומרת: יש סיכוי של 92% שזה חתול.

5. איך הרשת לומדת?

הרשת מתחילה עם משקלים אקראיים.

בהתחלה היא טועה הרבה.

אחר כך היא עושה תהליך כזה:

מקבלת קלט
נותנת תשובה
משווה לתשובה הנכונה
מחשבת שגיאה
מתקנת את המשקלים
חוזרת על זה אלפי פעמים

זה נקרא Training — אימון.

6. מהי שגיאה?

אם התשובה הנכונה היא:

חתול

והרשת אמרה:

כלב

יש שגיאה גדולה.

אם הרשת אמרה:

חתול בסיכוי 90%

השגיאה קטנה.

המטרה של האימון היא:

להקטין את השגיאה כמה שיותר

7. מה הרשת באמת לומדת?

הרשת לא "מבינה" כמו בן אדם.

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

בתמונה היא יכולה ללמוד:

קצוות
צורות
צבעים
מרקמים
מבנה פנים
גלגלים
כנפיים

בקול היא יכולה ללמוד:

תדרים
קצב
עוצמה
תבנית רעש
שינוי בזמן

8. דוגמה: זיהוי לפי קול

הקלט:

קובץ קול

מעבדים אותו לתמונה שנקראת Spectrogram.

הרשת מקבלת את ה־Spectrogram ולומדת לזהות:

רכב
רוח
דיבור
רעש רקע

בסוף היא מחזירה:

Car: 0.79
Wind: 0.03

..
Speech: 0.02

כלומר הרשת חושבת שזה רכב

9. למה קוראים לזה רשת?

כי יש הרבה נוירונים מחוברים זה לזה.

דוגמה:

Input → Neuron → Neuron → Neuron → Output

ברשת גדולה יש אלפי, מיליוני, ואפילו מיליארדי חיבורים.

10. משפט חשוב לזכור

רשת נוירונים היא לא קסם.

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

היא לומדת בעזרת דוגמאות, טעויות ותיקונים.

סיכום קצר

רשת נוירונים היא מודל שלומד מדוגמאות.

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

Data → Neural Network → Prediction → Error → Correction → Better Prediction

3. תרגול : הרצת תרגיל (עם קוד פשוט ) רשתות נוירונים פרדיקציה

קישור :

https://colab.research.google.com/drive/1aS5y_LKPePjloHi57PZforMGqOESZGgX?usp=sharing

4. ,תרגיל כיתה : בניית רשת נוירונים בעזרת בינה מלאכותית

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

4.2 הצג את גרף הלמידה הפעל על 40 איפוקס , 100 איפוקס האם הרשת למדה או דרוש יותר אימון ?

4.3 נבא את התוצאות : הבאות

0.1 , 1.5 . -2.85 , 2.6

4.4 הצג את גרף הנתונים של סידרה a ואת הערכים לניסוי

נתונים ערכים לשאלה :

a = [

(0, 2107.063993),

(1, 1774.894936),

(2, 1750.009562),

(3, 1481.326385),

(4, 1396.077521),

(5, 1206.241582),

(6, 1226.093311),

(7, 1053.402700),

(8, 863.965419),

(9, 708.908089),

(10, 609.188688),

(11, 507.225962),

(12, 546.267593),

(13, 527.910129),

(14, 445.411797),

(15, 372.281130),

(16, 273.318001),

(17, 232.070553),

(18, 162.902607),

(19, 135.674182),

(20, 15.810602),

(21, 32.953371),

(22, –7.529706),

(23, –58.090834),

(24, 141.533792),

(25, 14.234175),

(26, 40.625799),

(27, –59.885817),

(28, 86.203475),

(29, 31.991252),

(30, 88.132789),

(31, 160.413156),

(32, –75.607018),

(33, 55.269403),

(34, –56.520119),

(35, –94.585288),

(36, 8.086607),

(37, –69.322549),

(38, 81.048572),

(39, 35.469407),

(40, 13.428026),

(41, 55.077948),

(42, –76.633790),

(43, 15.156530),

(44, –100.269949),

(45, 82.102218),

(46, –39.703165),

(47, –12.988640),

(48, –82.648318),

(49, –174.654761),

(50, –125.680074),

(51, 114.949028),

(52, 2.739873),

(53, 51.751231),

(54, 8.351202),

(55, –29.036185),

(56, –138.659365),

(57, 45.099863),

(58, 4.898423),

(59, –140.341615),

(60, 0.263349),

(61, –171.835728),

(62, –112.363502),

(63, 8.291108),

(64, 42.170526),

(65, –95.476512),

(66, 89.265808),

(67, 121.477131),

(68, 63.346685),

(69, 22.926077),

(70, –54.681239),

(71, –0.003649),

(72, –58.438858),

(73, 56.850423),

(74, –62.948579),

(75, 88.712425),

(76, –139.472977),

(77, –32.893119),

(78, 11.448258),

(79, –38.987336),

(80, 25.303369),

(81, –81.415682),

(82, –70.917732),

(83, 24.433327),

(84, 10.738649),

(85, –96.212815),

(86, –14.961291),

(87, –92.290469),

(88, –104.987551),

(89, 15.086477),

(90, –118.130072),

(91, –72.749843),

(92, –172.149650),

(93, –118.275654),

(94, –57.536845),

(95, 37.355310),

(96, –174.049250),

(97, 67.392092),

(98, –178.348884),

(99, 32.446615),

(100, 34.355661),

(101, –29.564107),

(102, –230.259215),

(103, –18.166889),

(104, –186.462794),

(105, –81.414764),

(106, –287.880945),

(107, –140.773498),

(108, –300.851027),

(109, –378.673102),

(110, –492.544540),

(111, –547.831068),

(112, –489.163215),

(113, –822.436100),

(114, –742.851594),

(115, –925.768624),

(116, –885.407152),

(117, –1112.968628),

(118, –1234.314197),

(119, –1212.259426),

(120, –1629.306669),

(121, –1508.318170),

(122, –1887.185332),

(123, –2070.217978),

]

רשתות ניירונים ANN בינה מלאכותית

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

רשת כזו שייכת למשפחת הרשתות העצביות המלאכותיות (Artificial Neural Networks), ובפרט – לרשתות מסוג Dense Feedforward, שבהן כל נוירון בשכבה אחת מחובר לכל הנוירונים בשכבה הבאה. הרשת מתבססת על למידה מפוקחת (Supervised Learning) – כלומר, היא לומדת מדוגמאות מתויגות מראש.

במה היא שונה מרשת שחוזה ערך כמו טמפרטורה?

רשת שמטרתה לחזות טמפרטורה (או כל ערך מספרי אחר) נקראת Regression Network (רשת רגרסיה). במקום לבחור קטגוריה, היא מנבאת ערך רציף אחד, למשל: 21.4 מעלות.

הבדל עיקרי בין סיווג לרגרסיה:

Classification – הפלט הוא אחת מתוך קבוצה סופית של אפשרויות (למשל: אדום, ירוק או כחול) , זהוי מילה שהוקלטה , קטגוריה של המוצר , קטגוריה של התקלה , האם האדם קופץ הולך , נופל מתגלגל .
הפלט ברשת סיווג הוא לרוב וקטור של הסתברויות לכל קטגוריה, והרשת בוחרת את ההסתברות הגבוהה ביותר.

Regression – הפלט הוא מספר ממשי אחד מתוך טווח בלתי מוגבל (למשל: חיזוי מחיר של מוצר, טמפרטורה , גובה , לחץ של תמיסה).
רגרסיה הפלט הוא פשוט מספר אחד – פלט אחד