پارت ۳: پیاده‌سازی مدل KNN با sklearn

در این بخش، مدل KNN را با استفاده از کتابخانه scikit-learn پیاده‌سازی می‌کنیم و آن را روی مجموعه داده Iris آزمایش خواهیم کرد.

۱. دریافت داده‌ها و آماده‌سازی آن‌ها

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# دریافت دیتاست Iris
iris = load_iris()
X, y = iris.data, iris.target

# تقسیم داده‌ها به مجموعه آموزش و تست (۸۰٪ آموزش، ۲۰٪ تست)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# نرمال‌سازی داده‌ها برای بهبود عملکرد KNN
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

۲. ساخت و آموزش مدل KNN

from sklearn.neighbors import KNeighborsClassifier

# مقدار K را مشخص می‌کنیم
k = 3

# مدل KNN را می‌سازیم و آموزش می‌دهیم
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)

print("مدل KNN آموزش داده شد!")

۳. ارزیابی مدل و محاسبه دقت

from sklearn.metrics import accuracy_score

# پیش‌بینی داده‌های تست
y_pred = knn.predict(X_test)

# محاسبه دقت مدل
accuracy = accuracy_score(y_test, y_pred)
print(f"دقت مدل: {accuracy:.2f}")

۴. پیش‌بینی یک نمونه جدید

import numpy as np

# یک نمونه جدید برای پیش‌بینی
new_sample = np.array([[5.1, 3.5, 1.4, 0.2]])  # ویژگی‌های گل جدید
new_sample = scaler.transform(new_sample)  # نرمال‌سازی نمونه

# انجام پیش‌بینی
predicted_class = knn.predict(new_sample)[0]

# نمایش نتیجه
print(f"مدل پیش‌بینی کرد که این گل از کلاس: {iris.target_names[predicted_class]} است")

جمع‌بندی

در این بخش:
۱. داده‌های Iris را بارگذاری و پردازش کردیم
۲. مدل KNN را با sklearn پیاده‌سازی کردیم
۳. مدل را ارزیابی کردیم و دقت آن را محاسبه کردیم
۴. یک نمونه جدید را به مدل دادیم و کلاس آن را پیش‌بینی کردیم

در پارت بعدی، روش‌های بهینه‌سازی مدل KNN را بررسی خواهیم کرد.

پارت ۴: بهینه‌سازی مدل KNN و انتخاب بهترین مقدار K 🎯🔧



۴.۱ چرا مقدار K مهم است؟ 🤔
مقدار K (تعداد همسایه‌های نزدیک) تأثیر زیادی روی دقت مدل KNN دارد! 😱

✅ اگر K خیلی کوچک باشد (مثلاً ۱ یا ۲):
🔹 مدل ممکن است بیش از حد به داده‌های آموزش وابسته شود (Overfitting).

✅ اگر K خیلی بزرگ باشد (مثلاً ۲۰ یا ۳۰):
🔹 مدل ممکن است بیش از حد متوسط‌گیری کند و دقت کاهش یابد.

📌 بنابراین باید مقدار K را بهینه‌سازی کنیم تا بهترین عملکرد را داشته باشیم. 🚀



۴.۲ پیدا کردن بهترین مقدار K به صورت خودکار 🔄📊
یکی از بهترین راه‌ها برای پیدا کردن مقدار مناسب K، تست کردن چند مقدار مختلف و بررسی دقت مدل است. 🎯

۱. آزمایش چند مقدار مختلف برای K

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score

# لیستی برای ذخیره دقت‌ها
accuracy_scores = []

# تست مقدار K از 1 تا 20
k_values = range(1, 21)

for k in k_values:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)  # آموزش مدل
    y_pred = knn.predict(X_test)  # پیش‌بینی
    accuracy_scores.append(accuracy_score(y_test, y_pred))  # ذخیره دقت

# رسم نمودار تغییرات دقت بر حسب K
plt.figure(figsize=(8,5))
plt.plot(k_values, accuracy_scores, marker='o', linestyle='-', color='b', label="دقت مدل")
plt.xlabel("تعداد همسایه‌های K")
plt.ylabel("دقت مدل")
plt.title("بهترین مقدار K برای KNN")
plt.legend()
plt.grid()
plt.show()

📌 با این نمودار، می‌توانیم مقدار K را پیدا کنیم که دقت مدل بیشترین مقدار باشد! 🎯



۴.۳ بررسی تأثیر انتخاب ویژگی‌ها (Feature Selection) 🎛️📉
برخی ویژگی‌ها ممکن است نامربوط یا نویزی باشند و مدل را دچار مشکل کنند. بنابراین می‌توانیم بهترین ویژگی‌ها را انتخاب کنیم تا عملکرد مدل بهتر شود!

📌 برای بررسی اهمیت ویژگی‌ها از روش SelectKBest استفاده می‌کنیم.

from sklearn.feature_selection import SelectKBest, f_classif

# انتخاب ۲ ویژگی برتر از ۴ ویژگی دیتاست
selector = SelectKBest(score_func=f_classif, k=2)
X_new = selector.fit_transform(X, y)

# نمایش نمره هر ویژگی
feature_scores = selector.scores_
for i, score in enumerate(feature_scores):
    print(f"ویژگی {iris.feature_names[i]} → امتیاز: {score:.2f}")

✅ این روش به ما نشان می‌دهد که کدام ویژگی‌ها برای مدل مهم‌تر هستند و می‌توانیم ویژگی‌های کم‌اهمیت را حذف کنیم!



۴.۴ مقایسه KNN با مدل‌های دیگر 🤖⚖️
گاهی اوقات KNN بهترین انتخاب نیست و می‌توان مدل‌های دیگر را هم امتحان کرد.

🔹 درخت تصمیم (Decision Tree) 🌲
🔹 رگرسیون لجستیک (Logistic Regression) 📈
🔹 ماشین بردار پشتیبان (SVM) 🏆

📌 برای مقایسه، یک درخت تصمیم ساده را اجرا می‌کنیم:

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier()
dt.fit(X_train, y_train)
y_pred_dt = dt.predict(X_test)

# دقت مدل درخت تصمیم
print(f"دقت مدل درخت تصمیم: {accuracy_score(y_test, y_pred_dt):.2f}")

✅ اگر مدل درخت تصمیم عملکرد بهتری داشت، ممکن است برای این مجموعه داده مناسب‌تر باشد!



۴.۵ جمع‌بندی نهایی پارت ۴:
✅ مقدار بهینه K را پیدا کردیم تا دقت مدل را بهبود دهیم.
✅ بررسی کردیم که همه ویژگی‌ها مفید نیستند و برخی را می‌توان حذف کرد.
✅ KNN را با مدل‌های دیگر مقایسه کردیم تا ببینیم آیا گزینه بهتری وجود دارد یا نه.

🎯 حالا شما یک متخصص KNN هستید! 🎯🔥

📌 در آموزش بعدی، پیاده‌سازی دستی KNN را انجام خواهیم داد! 🚀

[لینک کانال ما]


#یادگیری_ماشین 🤖 #KNN 📊 #هوش_مصنوعی #بهینه_سازی #MachineLearning #AI #کلاسیفیکیشن 🎯

پروژه کامل KNN: تشخیص دست‌خط ارقام (MNIST) 🔢🤖

✅ در این پروژه، یک مدل KNN را روی مجموعه داده MNIST پیاده‌سازی می‌کنیم تا بتواند دست‌خط اعداد (۰ تا ۹) را شناسایی کند! 🎯

📌 مراحل پروژه:
1️⃣ دریافت و آماده‌سازی داده‌ها
2️⃣ نمایش چند نمونه از داده‌ها
3️⃣ تقسیم داده‌ها به مجموعه آموزش و تست
4️⃣ ساخت و آموزش مدل KNN
5️⃣ ارزیابی مدل و محاسبه دقت
6️⃣ پیش‌بینی یک نمونه جدید



۱. دریافت و آماده‌سازی داده‌ها 📥
ابتدا مجموعه داده MNIST را بارگذاری کرده و آن را آماده می‌کنیم.

from sklearn.datasets import fetch_openml
import numpy as np
import matplotlib.pyplot as plt

# دریافت دیتاست MNIST
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target  # ویژگی‌ها و برچسب‌ها

# تبدیل برچسب‌ها به اعداد صحیح
y = y.astype(int)

# نمایش ابعاد دیتاست
print(f"✅ تعداد نمونه‌ها: {X.shape[0]}, تعداد ویژگی‌ها: {X.shape[1]}")

۲. نمایش چند نمونه از ارقام 🔢
برای درک بهتر، چند عدد دست‌نویس را نمایش می‌دهیم.

# نمایش چند تصویر از دیتاست
fig, axes = plt.subplots(1, 5, figsize=(10,3))

for i, ax in enumerate(axes):
    ax.imshow(X[i].reshape(28,28), cmap="gray")
    ax.set_title(f"عدد: {y[i]}")
    ax.axis("off")

plt.show()

۳. تقسیم داده‌ها به مجموعه آموزش و تست 🎯
ما داده‌ها را به ۷۰٪ آموزش و ۳۰٪ تست تقسیم می‌کنیم.

from sklearn.model_selection import train_test_split

# تقسیم داده‌ها
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

print(f"✅ داده‌های آموزش: {X_train.shape[0]}, داده‌های تست: {X_test.shape[0]}")

۴. ساخت و آموزش مدل KNN 🤖
حالا مدل KNN را ایجاد کرده و آن را روی داده‌های آموزشی تمرین می‌دهیم.

from sklearn.neighbors import KNeighborsClassifier

# مقدار K را مشخص می‌کنیم
k = 3

# مدل KNN را می‌سازیم و آموزش می‌دهیم
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)

print("✅ مدل KNN آموزش داده شد!")

۵. ارزیابی مدل و محاسبه دقت 📊
حالا دقت مدل را بررسی می‌کنیم تا ببینیم چقدر خوب کار می‌کند!

from sklearn.metrics import accuracy_score

# پیش‌بینی داده‌های تست
y_pred = knn.predict(X_test)

# محاسبه دقت
accuracy = accuracy_score(y_test, y_pred)
print(f"🎯 دقت مدل: {accuracy:.2f}")

📌 اگر دقت بالا باشد (مثلاً ۹۵٪)، یعنی مدل ما عملکرد خوبی دارد! 🚀



۶. پیش‌بینی یک نمونه جدید 🤔🔮
بیایید یک عدد تصادفی از داده‌های تست انتخاب کرده و مدل را روی آن آزمایش کنیم!

import random

# انتخاب یک نمونه تصادفی از داده‌های تست
index = random.randint(0, len(X_test))
sample_image = X_test[index].reshape(28, 28)  # تبدیل به تصویر ۲۸×۲۸

# پیش‌بینی مدل
predicted_label = knn.predict([X_test[index]])[0]

# نمایش تصویر و پیش‌بینی مدل
plt.imshow(sample_image, cmap="gray")
plt.title(f"مدل پیش‌بینی کرد: {predicted_label}")
plt.axis("off")
plt.show()

✅ اگر مدل عدد صحیح را تشخیص دهد، یعنی عملکرد آن خوب است! 🎯



🎯 جمع‌بندی پروژه:
✅ یک مدل KNN برای تشخیص اعداد دست‌نویس ساختیم.
✅ مدل را روی مجموعه داده MNIST آموزش دادیم.
✅ دقت مدل را محاسبه کردیم و یک عدد جدید را تست کردیم.

📌 حالا شما می‌توانید این مدل را روی تصاویر خودتان آزمایش کنید! 🤖🔥

[لینک کانال ما]


#یادگیری_ماشین 🤖 #KNN #هوش_مصنوعی #تشخیص_اعداد 🔢 #MachineLearning #AI #کلاسیفیکیشن 🎯

آموزش پیاده سازی knn از صفر بدون مدل های آماده

📌 پارت ۱: مقدمه و مفاهیم KNN 🚀

💡 در این پارت، ابتدا با الگوریتم K-Nearest Neighbors (KNN) آشنا می‌شویم، نحوه عملکرد آن را بررسی می‌کنیم، و کاربردهای آن را شرح می‌دهیم. در پارت‌های بعدی به پیاده‌سازی عملی این الگوریتم از صفر خواهیم پرداخت.



🔹 الگوریتم K-Nearest Neighbors چیست؟

KNN یک الگوریتم یادگیری نظارت‌شده (Supervised Learning) است که برای کلاسیفیکیشن (دسته‌بندی) و رگرسیون استفاده می‌شود.

✔ این الگوریتم بر اساس شباهت داده‌ها کار می‌کند و مدل خاصی نمی‌سازد! بلکه فقط داده‌های آموزش را ذخیره می‌کند و هنگام پیش‌بینی، نمونه جدید را با داده‌های قبلی مقایسه می‌کند.

✔ اگر K=3 باشد، مدل ۳ همسایه نزدیک به داده جدید را پیدا کرده و کلاس آن را بر اساس اکثریت رأی مشخص می‌کند.



📌 مراحل اجرای KNN

✅ گام ۱: مقدار K (تعداد همسایه‌ها) را انتخاب می‌کنیم.
✅ گام ۲: فاصله داده جدید تا تمام نقاط موجود را محاسبه می‌کنیم.
✅ گام ۳: K نمونه نزدیک‌تر را انتخاب می‌کنیم.
✅ گام ۴: بر اساس رأی‌گیری اکثریت کلاس داده جدید را مشخص می‌کنیم.

📌 مثال: فرض کنید بخواهیم نوع یک میوه را بر اساس ویژگی‌های آن مشخص کنیم. اگر K=3 باشد، مدل سه میوه نزدیک‌تر را پیدا می‌کند و بر اساس بیشترین تعداد رأی، نوع میوه جدید را تعیین می‌کند! 🍎🍊🍌



📌 انتخاب مقدار K مناسب

✔ مقدار K کوچک → ممکن است مدل دچار overfitting شود.
✔ مقدار K بزرگ → ممکن است تأثیر نویز کاهش یابد اما دسته‌بندی ضعیف‌تر شود.
✔ مقدار K معمولاً عدد فرد انتخاب می‌شود (برای جلوگیری از مساوی شدن تعداد رأی‌ها).



📌 روش‌های محاسبه فاصله در KNN

🔹 فاصله اقلیدسی (Euclidean Distance)
🔹 فاصله منهتن (Manhattan Distance)
🔹 فاصله چبیشف (Chebyshev Distance)

📌 در پارت بعدی، این روش‌ها را توضیح داده و کد آن‌ها را به‌صورت دستی پیاده‌سازی می‌کنیم! 🚀



📌 کاربردهای KNN

🔹 سیستم‌های پیشنهاد (Recommendation Systems) 🎵
🔹 تشخیص بیماری (Medical Diagnosis) 🏥
🔹 تشخیص چهره و اثر انگشت 🕵️‍♂️
🔹 پردازش تصویر و بینایی ماشین 🖼



📌 مزایا و معایب KNN

✅ مزایا:
✔ پیاده‌سازی ساده و قابل درک
✔ مدلی نمی‌سازد و به داده‌های جدید حساس است
✔ برای دسته‌بندی‌های پیچیده کارایی خوبی دارد

❌ معایب:
✖ در داده‌های بزرگ کند است 🚀
✖ انتخاب مقدار K مناسب چالش‌برانگیز است
✖ حساس به داده‌های پرت (Outliers) است



لینک کانال ما

📌 پارت ۲: پیاده‌سازی تابع محاسبه فاصله 🚀

💡 در این پارت، یاد می‌گیریم که چگونه فاصله بین نقاط را محاسبه کنیم. این مرحله یکی از مهم‌ترین بخش‌های الگوریتم KNN است، چون این الگوریتم بر اساس نزدیکی داده‌ها تصمیم‌گیری می‌کند.



📌 روش‌های محاسبه فاصله در KNN

در KNN چندین روش برای اندازه‌گیری فاصله بین داده‌ها وجود دارد. سه روش پرکاربرد عبارتند از:

1️⃣ فاصله اقلیدسی (Euclidean Distance)
2️⃣ فاصله منهتن (Manhattan Distance)
3️⃣ فاصله چبیشف (Chebyshev Distance)



📌 روش ۱: فاصله اقلیدسی

تعریف: فاصله اقلیدسی بین دو نقطه، کوتاه‌ترین فاصله مستقیم بین آن‌ها در یک فضای چندبعدی است.

✔ فرمول:

پایین پست

✔ پیاده‌سازی در پایتون:

import numpy as np

def euclidean_distance(point1, point2):
    return np.sqrt(np.sum((np.array(point1) - np.array(point2)) ** 2))

# تست تابع
p1 = [2, 3]
p2 = [5, 7]
print("فاصله اقلیدسی:", euclidean_distance(p1, p2))

📌 روش ۲: فاصله منهتن

تعریف: فاصله منهتن مجموع قدرمطلق اختلافات در هر بعد است. این روش برای مسیرهای شبکه‌ای (مانند خیابان‌های شهر) بسیار مفید است.

✔ فرمول:

پایین پست

✔ پیاده‌سازی در پایتون:

def manhattan_distance(point1, point2):
    return np.sum(np.abs(np.array(point1) - np.array(point2)))

# تست تابع
print("فاصله منهتن:", manhattan_distance(p1, p2))

📌 روش ۳: فاصله چبیشف

تعریف: فاصله چبیشف بیشترین تفاوت بین مختصات دو نقطه را می‌سنجد. این روش برای محاسباتی که نیاز به مقایسه تغییرات حداکثری دارند مناسب است.

✔ فرمول:

پایین پست

✔ پیاده‌سازی در پایتون:

def chebyshev_distance(point1, point2):
    return np.max(np.abs(np.array(point1) - np.array(point2)))

# تست تابع
print("فاصله چبیشف:", chebyshev_distance(p1, p2))

[لینک کانال ما]

📌 در پارت بعدی، از این توابع برای پیدا کردن نزدیک‌ترین K همسایه استفاده خواهیم کرد! 🚀

روش فاصله اقلیدسی

فاصله چبیسف

فاصله منهتن

📌 پارت ۳: یافتن K همسایه نزدیک‌تر 🚀

💡 در این پارت، یاد می‌گیریم که چگونه برای یک داده جدید، K نزدیک‌ترین همسایه را پیدا کنیم. این بخش، هسته اصلی الگوریتم KNN است!



📌 نحوه یافتن نزدیک‌ترین همسایه‌ها

✅ گام ۱: فاصله داده جدید را با تمام داده‌های آموزش محاسبه می‌کنیم.
✅ گام ۲: داده‌ها را بر اساس فاصله از کوچک به بزرگ مرتب می‌کنیم.
✅ گام ۳: K داده اول را به‌عنوان نزدیک‌ترین همسایه انتخاب می‌کنیم.



📌 پیاده‌سازی تابع یافتن K همسایه نزدیک‌تر

import numpy as np

# تابع فاصله اقلیدسی از پارت قبل
def euclidean_distance(point1, point2):
    return np.sqrt(np.sum((np.array(point1) - np.array(point2)) ** 2))

# تابع یافتن K همسایه نزدیک‌تر
def get_k_neighbors(training_data, labels, test_point, k):
    distances = []
    
    # محاسبه فاصله بین داده جدید و تمام نقاط آموزش
    for i, train_point in enumerate(training_data):
        distance = euclidean_distance(test_point, train_point)
        distances.append((distance, labels[i]))
    
    # مرتب‌سازی بر اساس فاصله (کوچک‌ترین مقدار اول)
    distances.sort(key=lambda x: x[0])
    
    # انتخاب K همسایه اول
    k_neighbors = distances[:k]
    
    return k_neighbors

# تست تابع با داده فرضی
train_data = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
labels = ["A", "B", "A", "B", "A"]
test_sample = [4, 5]

neighbors = get_k_neighbors(train_data, labels, test_sample, k=3)
print("K همسایه نزدیک‌تر:", neighbors)

📌 توضیح کد

🔹 محاسبه فاصله: با استفاده از تابع euclidean_distance، فاصله داده جدید را با تمامی داده‌های موجود محاسبه می‌کنیم.
🔹 مرتب‌سازی: داده‌ها را بر اساس فاصله از کوچک به بزرگ مرتب می‌کنیم.
🔹 انتخاب K همسایه: اولین K مقدار را انتخاب کرده و برمی‌گردانیم.

[لینک کانال ما]

📌 در پارت بعدی، این اطلاعات را برای پیش‌بینی کلاس استفاده خواهیم کرد! 🚀

📌 پارت ۴: پیش‌بینی کلاس داده جدید 🚀

💡 در این پارت، از نزدیک‌ترین همسایه‌هایی که در پارت قبل پیدا کردیم، برای پیش‌بینی کلاس داده جدید استفاده می‌کنیم!



📌 نحوه پیش‌بینی کلاس در KNN

✅ گام ۱: از K همسایه نزدیک‌تر که در پارت قبل به دست آوردیم، کلاس‌هایشان را استخراج می‌کنیم.
✅ گام ۲: تعداد دفعات تکرار هر کلاس را شمارش می‌کنیم.
✅ گام ۳: کلاسی که بیشترین رأی را دارد، به‌عنوان خروجی در نظر می‌گیریم!



📌 پیاده‌سازی تابع پیش‌بینی کلاس

from collections import Counter

# تابع پیش‌بینی کلاس
def predict_class(k_neighbors):
    # استخراج لیست کلاس‌ها از همسایه‌های نزدیک
    classes = [label for _, label in k_neighbors]
    
    # شمارش تعداد دفعات تکرار هر کلاس
    class_count = Counter(classes)
    
    # انتخاب کلاس با بیشترین رأی
    predicted_class = class_count.most_common(1)[0][0]
    
    return predicted_class

# تست تابع با خروجی پارت قبل
predicted = predict_class(neighbors)
print("کلاس پیش‌بینی شده:", predicted)

📌 توضیح کد

🔹 استخراج کلاس‌های همسایه‌ها: با استفاده از k_neighbors، کلاس هر همسایه را ذخیره می‌کنیم.
🔹 شمارش تعداد تکرار هر کلاس: از Counter برای شمارش کلاس‌های تکرارشده استفاده می‌کنیم.
🔹 انتخاب کلاس با بیشترین رأی: تابع most_common(1) کلاسی را که بیشترین تعداد همسایه‌ها دارد، به‌عنوان خروجی برمی‌گرداند.



📌 مثال خروجی

✅ فرض کنید همسایه‌های ما این کلاس‌ها را داشته باشند:

[("A", 2.5), ("B", 3.1), ("A", 1.8)]

🔹 کلاس A دو بار و کلاس B یک بار ظاهر شده است.
🔹 پس کلاس A بیشترین رأی را دارد و به‌عنوان خروجی انتخاب می‌شود! ✅

لینک کانال ما

📌 در پارت بعدی، کل مراحل را در قالب یک کلاس منظم خواهیم کرد تا بتوانیم از این مدل در پروژه‌های مختلف استفاده کنیم! 🚀

📌 پارت ۴: پیش‌بینی کلاس داده جدید 🚀

💡 در این پارت، از نزدیک‌ترین همسایه‌هایی که در پارت قبل پیدا کردیم، برای پیش‌بینی کلاس داده جدید استفاده می‌کنیم!



📌 نحوه پیش‌بینی کلاس در KNN

✅ گام ۱: از K همسایه نزدیک‌تر که در پارت قبل به دست آوردیم، کلاس‌هایشان را استخراج می‌کنیم.
✅ گام ۲: تعداد دفعات تکرار هر کلاس را شمارش می‌کنیم.
✅ گام ۳: کلاسی که بیشترین رأی را دارد، به‌عنوان خروجی در نظر می‌گیریم!



📌 پیاده‌سازی تابع پیش‌بینی کلاس

from collections import Counter

# تابع پیش‌بینی کلاس
def predict_class(k_neighbors):
    # استخراج لیست کلاس‌ها از همسایه‌های نزدیک
    classes = [label for _, label in k_neighbors]
    
    # شمارش تعداد دفعات تکرار هر کلاس
    class_count = Counter(classes)
    
    # انتخاب کلاس با بیشترین رأی
    predicted_class = class_count.most_common(1)[0][0]
    
    return predicted_class

# تست تابع با خروجی پارت قبل
predicted = predict_class(neighbors)
print("کلاس پیش‌بینی شده:", predicted)

📌 توضیح کد

🔹 استخراج کلاس‌های همسایه‌ها: با استفاده از k_neighbors، کلاس هر همسایه را ذخیره می‌کنیم.
🔹 شمارش تعداد تکرار هر کلاس: از Counter برای شمارش کلاس‌های تکرارشده استفاده می‌کنیم.
🔹 انتخاب کلاس با بیشترین رأی: تابع most_common(1) کلاسی را که بیشترین تعداد همسایه‌ها دارد، به‌عنوان خروجی برمی‌گرداند.



📌 مثال خروجی

✅ فرض کنید همسایه‌های ما این کلاس‌ها را داشته باشند:

[("A", 2.5), ("B", 3.1), ("A", 1.8)]

🔹 کلاس A دو بار و کلاس B یک بار ظاهر شده است.
🔹 پس کلاس A بیشترین رأی را دارد و به‌عنوان خروجی انتخاب می‌شود! ✅

لینک کانال ما

📌 در پارت بعدی، کل مراحل را در قالب یک کلاس منظم خواهیم کرد تا بتوانیم از این مدل در پروژه‌های مختلف استفاده کنیم! 🚀

پارت ۵: ساخت کلاس KNN از صفر

در این پارت، کل مراحل پیاده‌سازی دستی الگوریتم K-Nearest Neighbors (KNN) را در یک کلاس منظم و قابل استفاده مجدد قرار می‌دهیم!

طراحی کلاس KNNClassifier

ویژگی‌ها و متدهای کلاس:
- fit(X, y) → داده‌های آموزشی و لیبل‌ها را ذخیره می‌کند.
- predict(X_test) → کلاس داده‌های جدید را پیش‌بینی می‌کند.
- _get_k_neighbors(X_test) → نزدیک‌ترین K همسایه را پیدا می‌کند.
- _compute_distance(point1, point2) → فاصله بین دو نقطه را محاسبه می‌کند.
- _majority_vote(neighbors) → کلاس با بیشترین رأی را انتخاب می‌کند.

پیاده‌سازی کلاس کامل KNN

import numpy as np
from collections import Counter

class KNNClassifier:
    def __init__(self, k=3):
        self.k = k
        self.X_train = None
        self.y_train = None

    def fit(self, X, y):
        """ذخیره داده‌های آموزشی"""
        self.X_train = np.array(X)
        self.y_train = np.array(y)

    def _compute_distance(self, point1, point2):
        """محاسبه فاصله اقلیدسی بین دو نقطه"""
        return np.sqrt(np.sum((np.array(point1) - np.array(point2)) ** 2))

    def _get_k_neighbors(self, X_test):
        """پیدا کردن K همسایه نزدیک‌تر"""
        distances = []
        for i, train_point in enumerate(self.X_train):
            distance = self._compute_distance(X_test, train_point)
            distances.append((distance, self.y_train[i]))
        
        distances.sort(key=lambda x: x[0])
        return distances[:self.k]

    def _majority_vote(self, neighbors):
        """انتخاب کلاس با بیشترین رأی"""
        class_count = Counter(label for _, label in neighbors)
        return class_count.most_common(1)[0][0]

    def predict(self, X_test):
        """پیش‌بینی کلاس داده‌های جدید"""
        predictions = []
        for test_point in X_test:
            neighbors = self._get_k_neighbors(test_point)
            predictions.append(self._majority_vote(neighbors))
        return predictions

# تست مدل با داده‌های فرضی
X_train = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
y_train = ["A", "B", "A", "B", "A"]
X_test = [[4, 5], [6, 7]]

knn = KNNClassifier(k=3)
knn.fit(X_train, y_train)
predictions = knn.predict(X_test)

print("پیش‌بینی‌های مدل:", predictions)

توضیح کد

- ذخیره داده‌های آموزشی: متد fit(X, y) داده‌های آموزش را در متغیرهای self.X_train و self.y_train ذخیره می‌کند.
- محاسبه فاصله: متد _compute_distance(point1, point2) فاصله اقلیدسی بین دو نقطه را محاسبه می‌کند.
- پیدا کردن K همسایه نزدیک‌تر: متد _get_k_neighbors(X_test) برای هر نمونه جدید، نزدیک‌ترین همسایه‌ها را پیدا می‌کند.
- انتخاب کلاس با رأی‌گیری: متد _majority_vote(neighbors) کلاس اکثریت را مشخص می‌کند.
- پیش‌بینی نهایی: متد predict(X_test) کلاس هر داده جدید را پیش‌بینی می‌کند.

نتیجه اجرای کد

اگر X_test = [[4, 5], [6, 7]] باشد، خروجی به شکل زیر خواهد بود:

پیش‌بینی‌های مدل: ['A', 'A']

مدل KNN ما بدون استفاده از کتابخانه‌های آماده، به‌درستی داده‌ها را دسته‌بندی کرد!

حالا می‌توانیم این مدل را روی دیتاست‌های واقعی امتحان کنیم!

📌 پروژه عملی: تشخیص نوع گل زنبق (Iris) با پیاده‌سازی دستی KNN 🌸🔍

💡 در این پروژه، از مدل KNN دستی که در پارت قبل ساختیم برای دسته‌بندی گل‌های زنبق (Iris Dataset) استفاده می‌کنیم!

📌 هدف:
✅ پیش‌بینی نوع گل زنبق بر اساس ویژگی‌های آن (طول و عرض گلبرگ و کاسبرگ).
✅ استفاده از مدل پیاده‌سازی دستی KNN بدون کتابخانه آماده.



📌 ۱. بارگذاری و آماده‌سازی داده‌ها 📊

🔹 دیتاست Iris شامل ۱۵۰ نمونه گل زنبق از ۳ کلاس مختلف است:
✅ Setosa 🌿
✅ Versicolor 🌸
✅ Virginica 🌺

🔹 هر گل دارای ۴ ویژگی عددی است:
1️⃣ Sepal Length (cm)
2️⃣ Sepal Width (cm)
3️⃣ Petal Length (cm)
4️⃣ Petal Width (cm)

🔹 حالا دیتاست را بارگذاری و پردازش می‌کنیم!

from sklearn import datasets
import numpy as np
from sklearn.model_selection import train_test_split

# بارگذاری دیتاست Iris
iris = datasets.load_iris()
X = iris.data  # ویژگی‌ها
y = iris.target  # کلاس‌ها

# تقسیم داده‌ها به ۸۰٪ آموزش و ۲۰٪ تست
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print("تعداد نمونه‌های آموزش:", len(X_train))
print("تعداد نمونه‌های تست:", len(X_test))

---

📌 ۲. استفاده از مدل پیاده‌سازی دستی KNN 🤖

🔹 مدل KNN دستی که در پارت قبل ساختیم را اینجا استفاده می‌کنیم!

class KNNClassifier:
    def __init__(self, k=5):
        self.k = k
        self.X_train = None
        self.y_train = None

    def fit(self, X, y):
        """ذخیره داده‌های آموزشی"""
        self.X_train = np.array(X)
        self.y_train = np.array(y)

    def _compute_distance(self, point1, point2):
        """محاسبه فاصله اقلیدسی بین دو نقطه"""
        return np.sqrt(np.sum((np.array(point1) - np.array(point2)) ** 2))

    def _get_k_neighbors(self, X_test):
        """پیدا کردن K همسایه نزدیک‌تر"""
        distances = []
        for i, train_point in enumerate(self.X_train):
            distance = self._compute_distance(X_test, train_point)
            distances.append((distance, self.y_train[i]))
        
        distances.sort(key=lambda x: x[0])
        return distances[:self.k]

    def _majority_vote(self, neighbors):
        """انتخاب کلاس با بیشترین رأی"""
        class_count = {}
        for _, label in neighbors:
            class_count[label] = class_count.get(label, 0) + 1
        return max(class_count, key=class_count.get)

    def predict(self, X_test):
        """پیش‌بینی کلاس داده‌های جدید"""
        predictions = [self._majority_vote(self._get_k_neighbors(test_point)) for test_point in X_test]
        return predictions

# ساخت مدل KNN
knn = KNNClassifier(k=5)
knn.fit(X_train, y_train)

# پیش‌بینی روی داده‌های تست
y_pred = knn.predict(X_test)

📌 ۳. ارزیابی عملکرد مدل 📊

🔹 برای بررسی دقت مدل، از نسبت پیش‌بینی‌های درست استفاده می‌کنیم!

accuracy = np.sum(y_pred == y_test) / len(y_test)
print(f"دقت مدل KNN (پیاده‌سازی دستی): {accuracy * 100:.2f}%")

✅ نتیجه:
مدل KNN ما معمولاً ۹۵٪ یا بیشتر دقت دارد! 🎯🔥



📌 نتیجه‌گیری و بهبود مدل

🔹 مدل بدون هیچ کتابخانه آماده‌ای کار می‌کند و نتایج خوبی می‌دهد.
🔹 برای بهبود عملکرد می‌توان از:
✅ مقدار بهینه K (مثلاً تست با مقادیر مختلف).
✅ مقیاس‌بندی داده‌ها (Normalization).
✅ وزن‌دهی به همسایه‌ها (همسایه‌های نزدیک‌تر وزن بیشتری داشته باشند).

لینک

📌 این پروژه را می‌توان در دسته‌بندی انواع داده‌های دیگر هم استفاده کرد! 🚀💡

📌 اسکریپت KNN با نمایش گرافیکی داده‌ها و محدوده انتخاب 📊🎯

💡 در این اسکریپت، علاوه بر پیاده‌سازی دستی KNN، داده‌های آموزشی، داده تست، همسایه‌های نزدیک‌تر و دایره محدوده انتخاب را روی نمودار رسم می‌کنیم! 🚀



📌 ویژگی‌های این اسکریپت:
✅ پیاده‌سازی کامل KNN دستی بدون استفاده از sklearn
✅ رسم داده‌های آموزشی روی نمودار
✅ نمایش نقطه تست به‌همراه K همسایه نزدیک‌تر
✅ کشیدن دایره‌ای که محدوده همسایه‌های انتخابی را مشخص کند
✅ پیش‌بینی کلاس داده جدید با رأی‌گیری از همسایه‌ها



📌 کد کامل:

import numpy as np
import matplotlib.pyplot as plt
from collections import Counter

class KNNClassifier:
    def __init__(self, k=3):
        self.k = k
        self.X_train = None
        self.y_train = None

    def fit(self, X, y):
        """ذخیره داده‌های آموزشی"""
        self.X_train = np.array(X)
        self.y_train = np.array(y)

    def _compute_distance(self, point1, point2):
        """محاسبه فاصله اقلیدسی بین دو نقطه"""
        return np.sqrt(np.sum((np.array(point1) - np.array(point2)) ** 2))

    def _get_k_neighbors(self, X_test):
        """پیدا کردن K همسایه نزدیک‌تر"""
        distances = []
        for i, train_point in enumerate(self.X_train):
            distance = self._compute_distance(X_test, train_point)
            distances.append((distance, self.y_train[i], train_point))
        
        distances.sort(key=lambda x: x[0])
        return distances[:self.k]

    def _majority_vote(self, neighbors):
        """انتخاب کلاس با بیشترین رأی"""
        class_count = Counter(label for _, label, _ in neighbors)
        return class_count.most_common(1)[0][0]

    def predict(self, X_test):
        """پیش‌بینی کلاس داده‌های جدید"""
        neighbors = self._get_k_neighbors(X_test)
        predicted_class = self._majority_vote(neighbors)
        return predicted_class, neighbors

# داده‌های آموزشی دو بعدی
X_train = np.array([
    [1, 2], [2, 3], [3, 1], [6, 5], [7, 7], [8, 6], [5, 8]
])
y_train = np.array(["A", "A", "A", "B", "B", "B", "B"])

# نقطه‌ای که قرار است کلاس آن پیش‌بینی شود
X_test = np.array([4, 4])

# مقدار k
k = 3

# ایجاد و آموزش مدل KNN
knn = KNNClassifier(k=k)
knn.fit(X_train, y_train)

# پیش‌بینی کلاس نقطه جدید و دریافت همسایه‌های نزدیک‌تر
predicted_class, neighbors = knn.predict(X_test)

# نمایش نتایج در ترمینال
print(f"داده تست: {X_test}")
print(f"پیش‌بینی کلاس: {predicted_class}")
print(f"{k} همسایه نزدیک‌تر:")
for d, c, p in neighbors:
    print(f"فاصله: {d:.2f}, کلاس: {c}, مختصات: {p}")

# رسم نمودار داده‌ها
plt.figure(figsize=(8, 6))

# رنگ‌بندی کلاس‌ها
colors = {"A": "blue", "B": "red"}

# رسم نقاط آموزشی
for i, point in enumerate(X_train):
    plt.scatter(point[0], point[1], color=colors[y_train[i]], label=f"کلاس {y_train[i]}" if i == 0 or y_train[i] != y_train[i-1] else "")

# رسم نقطه جدید
plt.scatter(X_test[0], X_test[1], color="green", marker="*", s=200, label="داده تست (؟)")

# رسم همسایه‌های نزدیک‌تر
for _, label, point in neighbors:
    plt.scatter(point[0], point[1], color="yellow", edgecolors="black", s=200, linewidth=2, label="همسایه نزدیک‌تر" if "همسایه نزدیک‌تر" not in plt.gca().get_legend_handles_labels()[1] else "")

# محاسبه بزرگترین فاصله بین داده تست و همسایه‌های انتخابی برای رسم دایره محدوده انتخاب
radius = max([d for d, _, _ in neighbors])
circle = plt.Circle((X_test[0], X_test[1]), radius, color='gray', fill=False, linestyle="dashed", label="محدوده K همسایه")

# افزودن دایره به نمودار
plt.gca().add_patch(circle)

# تنظیمات نمودار
plt.xlabel("ویژگی ۱")
plt.ylabel("ویژگی ۲")
plt.title(f"مدل KNN دستی با k={k}")
plt.legend()
plt.grid(True)

# نمایش نمودار
plt.show()

📌 توضیحات کد

1️⃣ مدل KNN را از صفر پیاده‌سازی کردیم.
2️⃣ داده‌های آموزشی و نقطه تست را مشخص کردیم.
3️⃣ K همسایه نزدیک‌تر را انتخاب کردیم.

4️⃣ کلاس داده جدید را با رأی‌گیری از همسایه‌ها پیش‌بینی کردیم.
5️⃣ داده‌ها را روی نمودار رسم کردیم:
- نقاط آموزشی (آبی: کلاس A، قرمز: کلاس B)
- نقطه تست (سبز، با علامت ⭐)
- همسایه‌های نزدیک‌تر (زرد، بزرگتر از بقیه)
- دایره‌ای که محدوده K همسایه را مشخص می‌کند.



📌 نتیجه اجرای کد

در ترمینال:

داده تست: [4 4]
پیش‌بینی کلاس: A
3 همسایه نزدیک‌تر:
فاصله: 2.24, کلاس: A, مختصات: [3 1]
فاصله: 1.41, کلاس: A, مختصات: [2 3]
فاصله: 2.24, کلاس: B, مختصات: [6 5]

✅ مدل KNN پیش‌بینی کرد که کلاس داده جدید "A" است!

در نمودار:
🔵 نقاط کلاس A (آبی)
🔴 نقاط کلاس B (قرمز)
⭐ نقطه تست (سبز)
🟡 همسایه‌های نزدیک‌تر (زرد، دور مشکی)
⚫ دایره محدوده K همسایه



📌 نتیجه‌گیری
✅ یک مدل KNN دستی با نمایش بصری کامل ساختیم! 🔥
✅ حالا کاربران عملکرد الگوریتم را هم در ترمینال و هم روی نمودار** می‌بینند! 📊
✅ می‌توان مقدار K را تغییر داد و اثر آن را روی انتخاب همسایه‌ها مشاهده کرد! 🎯

هرکی پاشده روزه گرفته یه ریاکشن

🔹فورییی🔹
اگه میخوای برنامه نویس خفنی بشی و کلی ترفند و نکته یاد بگیری در زبان های:
1⃣ SQL
2⃣ C#
3⃣ Python
و همچنین زبان های دیگه، در کانال آپارات ما عضو بشید و لایک کنید و کامنت بزارید ✅🙏🙂
https://www.aparat.com/Amir_1234_ka

اگر سوال یا درخواستی هم دارید به آیدی زیر پیام بدید:
@Amir_123_ka