קורס יסודות בינה מלאכותית RB27-12 – מבוא לרשתות ניירונים ובינה מלאכותית

תרגיל כיתה 1 : פיתווח מוצר בצורה מדעית והנדסית – מזווית מדעית תאורטית

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

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

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

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

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

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

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

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

הפלט ברשת סיווג הוא לרוב וקטור של הסתברויות לכל קטגוריה, והרשת בוחרת את ההסתברות הגבוהה ביותר.
לעומת זאת, ברגרסיה הפלט הוא פשוט מספר אחד.

SDR – Software Defined Radio

SDRA2021 Talks: Electrosense, Neural Network Signal Classification, gr-rpitx, Radio Astronomy and More

RF Training Data Generation for Machine Learning

Automatic Identification of 160 Shortwave RF Signals with Deep Learning

תרגיל כיתה 2.1 רשת ניירונים חיזוי קטגוריה

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

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

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

מטרה :

import numpy as np
import matplotlib.pyplot as plt

# Re-create data
np.random.seed(42)
red = np.random.normal(loc=[2, 2], scale=0.5, size=(100, 2))
green = np.random.normal(loc=[5, 5], scale=0.5, size=(100, 2))
blue = np.random.normal(loc=[8, 2], scale=0.5, size=(100, 2))

# Plot each group
plt.figure(figsize=(7, 5))

plt.scatter(red[:, 0], red[:, 1], color='red', label='Red Group', alpha=0.7)
plt.scatter(green[:, 0], green[:, 1], color='green', label='Green Group', alpha=0.7)
plt.scatter(blue[:, 0], blue[:, 1], color='blue', label='Blue Group', alpha=0.7)

plt.title('Color Group Clusters (2D)')
plt.xlabel('X1')
plt.ylabel('X2')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np

import matplotlib.pyplot as plt

# Re-create data

np.random.seed(42)

red = np.random.normal(loc=[2, 2], scale=0.5, size=(100, 2))

green = np.random.normal(loc=[5, 5], scale=0.5, size=(100, 2))

blue = np.random.normal(loc=[8, 2], scale=0.5, size=(100, 2))

# Plot each group

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

plt.scatter(red[:, 0], red[:, 1], color='red', label='Red Group', alpha=0.7)

plt.scatter(green[:, 0], green[:, 1], color='green', label='Green Group', alpha=0.7)

plt.scatter(blue[:, 0], blue[:, 1], color='blue', label='Blue Group', alpha=0.7)

plt.title('Color Group Clusters (2D)')

plt.xlabel('X1')

plt.ylabel('X2')

plt.legend()

plt.grid(True)

plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Re-create data
np.random.seed(42)
red = np.random.normal(loc=[2, 2], scale=1.8, size=(100, 2))
green = np.random.normal(loc=[5, 5], scale=1.8, size=(100, 2))
blue = np.random.normal(loc=[8, 2], scale=1.8, size=(100, 2))

# Plot each group
plt.figure(figsize=(7, 5))

plt.scatter(red[:, 0], red[:, 1], color='red', label='Red Group', alpha=0.7)
plt.scatter(green[:, 0], green[:, 1], color='green', label='Green Group', alpha=0.7)
plt.scatter(blue[:, 0], blue[:, 1], color='blue', label='Blue Group', alpha=0.7)

plt.title('Color Group Clusters (2D)')
plt.xlabel('X1')
plt.ylabel('X2')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np

import matplotlib.pyplot as plt

# Re-create data

np.random.seed(42)

red = np.random.normal(loc=[2, 2], scale=1.8, size=(100, 2))

green = np.random.normal(loc=[5, 5], scale=1.8, size=(100, 2))

blue = np.random.normal(loc=[8, 2], scale=1.8, size=(100, 2))

# Plot each group

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

plt.scatter(red[:, 0], red[:, 1], color='red', label='Red Group', alpha=0.7)

plt.scatter(green[:, 0], green[:, 1], color='green', label='Green Group', alpha=0.7)

plt.scatter(blue[:, 0], blue[:, 1], color='blue', label='Blue Group', alpha=0.7)

plt.title('Color Group Clusters (2D)')

plt.xlabel('X1')

plt.ylabel('X2')

plt.legend()

plt.grid(True)

plt.show()

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras.utils import to_categorical

# Create synthetic data (3 clusters)
np.random.seed(42)
red = np.random.normal(loc=[2, 2], scale=1.8, size=(100, 2))
green = np.random.normal(loc=[5, 5], scale=1.8, size=(100, 2))
blue = np.random.normal(loc=[8, 2], scale=1.8, size=(100, 2))

# Combine the data and labels
X = np.vstack((red, green, blue))
y = np.array(['R'] * 100 + ['G'] * 100 + ['B'] * 100)

# Encode labels
encoder = LabelEncoder()
y_encoded = encoder.fit_transform(y)
y_categorical = to_categorical(y_encoded)

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y_categorical, test_size=0.2, random_state=42)

# Build the model
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(2,)),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(12, activation='relu'),
    tf.keras.layers.Dense(3, activation='softmax')  # 3 output classes
])

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the model (increased epochs)
history = model.fit(X_train, y_train, epochs=150, batch_size=16, validation_data=(X_test, y_test))

# Plot training history
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Train Loss', color='red')
plt.plot(history.history['val_loss'], label='Val Loss', color='orange')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Model Loss over Epochs')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Train Accuracy', color='blue')
plt.plot(history.history['val_accuracy'], label='Val Accuracy', color='green')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.title('Model Accuracy over Epochs')
plt.legend()

plt.tight_layout()
plt.show()

# ---------------------
# 🔍 Prediction Examples
# ---------------------
test_points = np.array([
    [1, 1],     # Likely Red
    [5, 5],     # Likely Green
    [9, 1.5],   # Likely Blue
    [4, 4],     # Maybe Green
    [7, 2.5]    # Maybe Blue
])

preds = model.predict(test_points)
pred_labels = encoder.inverse_transform(np.argmax(preds, axis=1))

print("\nPrediction Examples:")
for point, label in zip(test_points, pred_labels):
    print(f"Point {point} → Predicted Color: {label}")

import numpy as np

import matplotlib.pyplot as plt

import tensorflow as tf

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import LabelEncoder

from tensorflow.keras.utils import to_categorical

# Create synthetic data (3 clusters)

np.random.seed(42)

red = np.random.normal(loc=[2, 2], scale=1.8, size=(100, 2))

green = np.random.normal(loc=[5, 5], scale=1.8, size=(100, 2))

blue = np.random.normal(loc=[8, 2], scale=1.8, size=(100, 2))

# Combine the data and labels

X = np.vstack((red, green, blue))

y = np.array(['R'] * 100 + ['G'] * 100 + ['B'] * 100)

# Encode labels

encoder = LabelEncoder()

y_encoded = encoder.fit_transform(y)

y_categorical = to_categorical(y_encoded)

# Split data

X_train, X_test, y_train, y_test = train_test_split(X, y_categorical, test_size=0.2, random_state=42)

# Build the model

model = tf.keras.Sequential([

tf.keras.layers.Input(shape=(2,)),

tf.keras.layers.Dense(16, activation='relu'),

tf.keras.layers.Dense(12, activation='relu'),

tf.keras.layers.Dense(3, activation='softmax') # 3 output classes

])

# Compile the model

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the model (increased epochs)

history = model.fit(X_train, y_train, epochs=150, batch_size=16, validation_data=(X_test, y_test))

# Plot training history

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

plt.subplot(1, 2, 1)

plt.plot(history.history['loss'], label='Train Loss', color='red')

plt.plot(history.history['val_loss'], label='Val Loss', color='orange')

plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.title('Model Loss over Epochs')

plt.legend()

plt.subplot(1, 2, 2)

plt.plot(history.history['accuracy'], label='Train Accuracy', color='blue')

plt.plot(history.history['val_accuracy'], label='Val Accuracy', color='green')

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.title('Model Accuracy over Epochs')

plt.legend()

plt.tight_layout()

plt.show()

# ---------------------

# 🔍 Prediction Examples

# ---------------------

test_points = np.array([

[1, 1], # Likely Red

[5, 5], # Likely Green

[9, 1.5], # Likely Blue

[4, 4], # Maybe Green

[7, 2.5] # Maybe Blue

])

preds = model.predict(test_points)

pred_labels = encoder.inverse_transform(np.argmax(preds, axis=1))

print("\nPrediction Examples:")

for point, label in zip(test_points, pred_labels):

print(f"Point {point} → Predicted Color: {label}")

במהלך אימון של רשת נוירונים, אנו מודדים שני מדדים חשובים:

אובדן אימון (Training Loss)

אובדן האימון מודד עד כמה המודל מצליח לחזות נכון את הדוגמאות שהוא ראה ולמד מהן בזמן האימון.

ו־אובדן ולידציה (Validation Loss).

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

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

תרגיל 2 : בנה רשת ניירונים colab בעזרת בינה מאלכותית TensorFlow עבור הפונקציה 1 משתנה

y=x^2+3

בנה את הפונקציה והצב לה ערכים מ -10 עד 10 בקפיצות של 1
הצג גרף של הפונקציה
בנה רשת בעזרת בינה מלאוכתית אשר מקבל את קלט ופלט ומאמנת את הרשת
בצע פרדיקציה עבור הערכים -2 , -3.45 ,7.45 והצג אותם ערכים לפי הנוסחה וערכים לפי פרדקציה של הרשת

תרגיל 3 : בנה רשת ניירונים colab בעזרת בינה מאלכותית TensorFlow עבור הפונקציה 2 משתנים

בנה את הפונקציה והצב לה ערכים m מ0 עד 10 בקפיצות של 1 , h מ 0 עד 10
הצג גרף של הפונקציה עבור m=2 h=0 to 10
בנה רשת בעזרת בינה מלאוכתית אשר מקבל את קלט ופלט ומאמנת את הרשת
בצע פרדיקציה עבור הערכים m=2 h=0.5 ; m=2 h=2.5

תרגיל כיתה 4 : :Car_Purchasing_Data

Customer Name
Customer e-mail
Country
Gender
Age
Annual Salary
Credit Card Debt
Net Worth

תרגיל כיתה עצמאי (ליווי מדריך) הרצה על מחשב מקומי הרצה באחת הסביבות TensorFlow

התקן ספריות ובדוק כל תקלה בעזרת בינה מלאוכתית TensorFlow

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

car_df = pd.read_csv('d:/temp/Car_Purchasing_Data.csv', encoding='ISO-8859-1')

1	car_df = pd.read_csv('d:/temp/Car_Purchasing_Data.csv', encoding='ISO-8859-1')

car_df

car_df

sns.pairplot(car_df)

1	sns.pairplot(car_df)

X = car_df.drop(['Customer Name', 'Customer e-mail', 'Country', 'Car Purchase Amount'], axis = 1)

1	X = car_df.drop(['Customer Name', 'Customer e-mail', 'Country', 'Car Purchase Amount'], axis = 1)

print(X)

print(X)

y = car_df['Car Purchase Amount']
print(y.shape)
print(type(y))

y = car_df['Car Purchase Amount']

print(y.shape)

print(type(y))

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

print("Max values per column:", scaler.data_max_)

print("Max values per column:", scaler.data_max_)

scaler.data_min_

print(X_scaled[:,1])

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

X_scaled = scaler.fit_transform(X)

print("Max values per column:", scaler.data_max_)

scaler.data_min_

print(X_scaled[:,1])

print(X_scaled[:,0])
print(X_scaled[:,1])

1 2	print(X_scaled[:,0]) print(X_scaled[:,1])

reshape(-1, 1) ממיר את המערך החד־ממדי (1D) למערך דו־ממדי (2D) עם עמודה אחת וכמות שורות

y = y.values.reshape(-1,1)

1	y = y.values.reshape(-1,1)

y_scaled = scaler.fit_transform(y)

1	y_scaled = scaler.fit_transform(y)

y_scaled

y_scaled

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled, test_size = 0.25)

1 2	from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled, test_size = 0.25)

import tensorflow.keras
from keras.models import Sequential
from keras.layers import Dense
from sklearn.preprocessing import MinMaxScaler

model = Sequential()
model.add(Dense(25, input_dim=5, activation='relu'))
model.add(Dense(25, activation='relu'))
model.add(Dense(1, activation='linear'))
model.summary()

import tensorflow.keras

from keras.models import Sequential

from keras.layers import Dense

from sklearn.preprocessing import MinMaxScaler

model = Sequential()

model.add(Dense(25, input_dim=5, activation='relu'))

model.add(Dense(25, activation='relu'))

model.add(Dense(1, activation='linear'))

model.summary()

model.compile(optimizer='adam', loss='mean_squared_error')

1	model.compile(optimizer='adam', loss='mean_squared_error')

epochs_hist = model.fit(X_train, y_train, epochs=20, batch_size=25,  verbose=1, validation_split=0.2)

1	epochs_hist = model.fit(X_train, y_train, epochs=20, batch_size=25, verbose=1, validation_split=0.2)

print(epochs_hist.history.keys())

1	print(epochs_hist.history.keys())

plt.plot(epochs_hist.history['loss'])
plt.plot(epochs_hist.history['val_loss'])

plt.title('Model Loss Progression During Training/Validation')
plt.ylabel('Training and Validation Losses')
plt.xlabel('Epoch Number')
plt.legend(['Training Loss', 'Validation Loss'])

plt.plot(epochs_hist.history['loss'])

plt.plot(epochs_hist.history['val_loss'])

plt.title('Model Loss Progression During Training/Validation')

plt.ylabel('Training and Validation Losses')

plt.xlabel('Epoch Number')

plt.legend(['Training Loss', 'Validation Loss'])

# Gender, Age, Annual Salary, Credit Card Debt, Net Worth

X_Testing = np.array([[1, 50, 50000, 10985, 629312]])

# Gender, Age, Annual Salary, Credit Card Debt, Net Worth

X_Testing = np.array([[1, 50, 50000, 10985, 629312]])

y_predict = model.predict(X_Testing)
y_predict.shape

1 2	y_predict = model.predict(X_Testing) y_predict.shape

print('Expected Purchase Amount=', y_predict[:,0])

1	print('Expected Purchase Amount=', y_predict[:,0])

קורס יסודות בינה מלאכותית RB27-12 – מבוא לרשתות ניירונים ובינה מלאכותית

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

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

SDR – Software Defined Radio

תרגיל כיתה 2.1 רשת ניירונים חיזוי קטגוריה

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

תרגיל 2 : בנה רשת ניירונים colab בעזרת בינה מאלכותית TensorFlow עבור הפונקציה 1 משתנה

y=x^2+3

תרגיל 3 : בנה רשת ניירונים colab בעזרת בינה מאלכותית TensorFlow עבור הפונקציה 2 משתנים

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

קורס – DSP-L1 – 002 ועיבוד קול ומוסיקה

ביורובוטיקס – רובוט חרק

קורס RB10 רובטיקס בלוקס 021 : אלגוריתם של בינה מלאכותית

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