آموزش پیاده سازی 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

📌 آموزش SVM – پارت ۱: مقدمه، مفاهیم پایه و کاربردها 🚀

💡 ماشین بردار پشتیبان (SVM) یکی از قوی‌ترین الگوریتم‌های یادگیری ماشین برای طبقه‌بندی داده‌ها است که ابرصفحه‌ای (Hyperplane) ایجاد می‌کند تا داده‌ها را به بهترین شکل جدا کند! 😍



🔹 SVM چیست؟
SVM (Support Vector Machine) یک الگوریتم طبقه‌بندی است که هدف آن پیدا کردن بهترین مرز تصمیم‌گیری بین کلاس‌های مختلف داده‌ها است. این مرز به نام ابرصفحه جداکننده (Hyperplane) شناخته می‌شود.

✅ اگر داده‌ها کاملاً جداشدنی باشند:
SVM یک خط مستقیم (برای داده‌های ۲بعدی) یا یک صفحه (برای داده‌های ۳بعدی) پیدا می‌کند که کلاس‌ها را از هم جدا می‌کند.

✅ اگر داده‌ها هم‌پوشانی داشته باشند:
SVM بهترین خطی را پیدا می‌کند که بیشترین فاصله (Margin) را از کلاس‌ها داشته باشد!

✅ اگر داده‌ها غیرخطی باشند:
SVM می‌تواند با استفاده از کرنل (Kernel Trick) داده‌ها را به فضای بالاتری ببرد تا بتوان آن‌ها را جدا کرد! 😎



🔹 مفاهیم کلیدی در SVM
🔸 ابرصفحه جداکننده (Hyperplane): مرزی که کلاس‌های داده را از هم جدا می‌کند.
🔸 حاشیه (Margin): فاصله بین ابرصفحه جداکننده و نزدیک‌ترین نقاط هر کلاس (که به آن‌ها بردارهای پشتیبان (Support Vectors) می‌گویند).
🔸 بردارهای پشتیبان (Support Vectors): داده‌هایی که در مرز تصمیم‌گیری قرار دارند و تعیین‌کننده بهترین خط جداسازی هستند!
🔸 کرنل (Kernel Trick): تکنیکی که داده‌های غیرخطی را به فضای بالاتر نقشه‌برداری (Mapping) می‌کند تا بتوان با یک خط ساده آن‌ها را جدا کرد.



🔹 انواع مدل‌های SVM
🔹 SVM خطی (Linear SVM) → وقتی داده‌ها به‌راحتی با یک خط یا صفحه جدا می‌شوند.
🔹 SVM غیرخطی (Non-Linear SVM) → وقتی داده‌ها با یک مرز منحنی بهتر جدا می‌شوند. در این حالت از کرنل‌ها استفاده می‌کنیم.
🔹 SVM با کرنل‌های مختلف:
- کرنل چندجمله‌ای (Polynomial Kernel)
- کرنل شعاعی (RBF Kernel - Radial Basis Function)
- کرنل سیگموئید (Sigmoid Kernel)



🔹 کاربردهای SVM در دنیای واقعی
✅ تشخیص چهره (Face Recognition) 📸
✅ دسته‌بندی متن و ایمیل‌ها (Spam Detection) 📩
✅ تشخیص بیماری‌ها از روی داده‌های پزشکی 🏥
✅ سیستم‌های تشخیص تقلب در تراکنش‌های بانکی 💳
✅ شناسایی اشیاء در تصاویر و پردازش تصویر 🖼️



📌 نتیجه‌گیری
✅ SVM یکی از دقیق‌ترین الگوریتم‌های طبقه‌بندی است! 🔥
✅ بهترین گزینه برای داده‌های پیچیده‌ای است که به‌سختی قابل جداسازی هستند.
✅ با استفاده از کرنل‌ها، حتی در مسائل غیرخطی هم عالی عمل می‌کند!



📌 در پارت بعدی، SVM را با استفاده از sklearn پیاده‌سازی می‌کنیم و نحوه‌ی استفاده از آن در دنیای واقعی را یاد می‌گیریم! 🎯

ادامه دارد... 🚀

#یادگیری_ماشین #SVM #طبقه‌بندی #هوش_مصنوعی #الگوریتم_یادگیریری**

📌 آموزش SVM – پارت ۲: پیاده‌سازی با sklearn 🚀

حالا که با مفاهیم SVM (ماشین بردار پشتیبان) آشنا شدیم، وقتشه که این الگوریتم رو به‌صورت عملی پیاده‌سازی کنیم! 😍 توی این پارت با استفاده از کتابخانه sklearn یک مدل SVM می‌سازیم و داده‌ها رو طبقه‌بندی می‌کنیم.



🔹 نصب و وارد کردن کتابخانه‌های موردنیاز
قبل از شروع، مطمئن بشید که scikit-learn روی سیستم شما نصب هست. اگر نصب نیست، با این دستور نصبش کنید:

pip install scikit-learn numpy

حالا کتابخانه‌ها رو ایمپورت می‌کنیم:

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

🔹 آماده‌سازی داده‌ها
برای تمرین، از مجموعه داده‌ی معروف Iris Dataset استفاده می‌کنیم که شامل سه کلاس مختلف از گل زنبق (Setosa, Versicolor, Virginica) هست! 🌸

# بارگذاری مجموعه داده
iris = datasets.load_iris()

# دریافت ویژگی‌ها (X) و برچسب‌ها (y)
X = iris.data
y = iris.target

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

✅ حالا داده‌ها رو آماده کردیم و می‌تونیم مدل SVM رو روی این مجموعه اعمال کنیم! 😎



🔹 ساخت مدل SVM و آموزش آ
حالا یک مدل SVM با کرنل خطی (linear) ایجاد می‌کنیم و روی داده‌های آموزش فیت (fit) می‌کنیم:

# ایجاد مدل SVM
svm_model = SVC(kernel='linear')

# آموزش مدل روی داده‌های آموزشی
svm_model.fit(X_train, y_train)

✅ مدل ما الان آماده است! وقتشه که پیش‌بینی روی داده‌های تستی انجام بدیم.



🔹 پیش‌بینی و ارزیابی مدل
حالا با مدل آموزش‌دیده‌شده، داده‌های تستی رو پیش‌بینی می‌کنیم و دقت مدل رو محاسبه می‌کنیم:

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

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

📊 اگر دقت بالای ۹۰٪ بود، یعنی مدل عملکرد خیلی خوبی داشته! 🎯



📌 نتیجه‌گیری
✅ در این پارت یاد گرفتیم چطور با استفاده از sklearn یک مدل SVM بسازیم.
✅ نحوه‌ی آموزش و ارزیابی مدل رو بررسی کردیم.



📌 در پارت بعدی، میریم سراغ بررسی انواع کرنل‌ها در SVM و تأثیرشون روی مدل! 🚀

🛠️ ادامه دارد… 🎯

#SVM #ماشین_بردار_پشتیبان #یادگیری_ماشین #طبقه‌بندی #هوش_مصنوعی