مفاهیم تخصصی ml در هوش مصنوعی
- پنجشنبه, ۲۸ آذر ۱۴۰۴، ۰۸:۱۸ ب.ظ
مفاهیم تخصصی یادگیری ماشین در هوش مصنوعی
1. مفاهیم پایه و بنیادی
1.1 برازش بیش از حد (Overfitting)
· تعریف: زمانی که مدل بر روی دادههای آموزشی بیش از حد تطبیق مییابد و الگوهای تصادفی (نویز) را نیز یاد میگیرد
· علائم: عملکرد عالی روی دادههای آموزشی، عملکرد ضعیف روی دادههای تست
· راههای مقابله:
· منظمسازی (Regularization)
· حذف ویژگیها (Feature Selection)
· جمعآوری دادههای بیشتر
· تقلیل ابعاد (Dimensionality Reduction)
```python
# تشخیص Overfitting
from sklearn.model_selection import learning_curve
train_sizes, train_scores, test_scores = learning_curve(
model, X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)
```
1.2 برازش کمتر از حد (Underfitting)
· تعریف: زمانی که مدل نمیتواند رابطههای اساسی موجود در دادهها را یاد بگیرد
· علائم: عملکرد ضعیف هم روی دادههای آموزشی و هم روی دادههای تست
· راههای حل:
· افزایش پیچیدگی مدل
· اضافه کردن ویژگیهای مرتبط
· کاهش محدودیتهای مدل (مانند کاهش درجه منظمسازی)
1.3 منظمسازی (Regularization)
· هدف: جلوگیری از Overfitting با اضافه کردن جریمه به پارامترهای مدل
· انواع:
· L1 (Lasso): ∣w∣ - تولید مدلهای پراکنده
· L2 (Ridge): w² - توزیع وزنها به صورت یکنواختتر
· Elastic Net: ترکیب L1 و L2
```python
from sklearn.linear_model import Lasso, Ridge, ElasticNet
# L1 Regularization
lasso = Lasso(alpha=0.1)
# L2 Regularization
ridge = Ridge(alpha=0.1)
# Elastic Net
elastic = ElasticNet(alpha=0.1, l1_ratio=0.5)
```
1.4 اعتبارسنجی متقابل (Cross-Validation)
· تعریف: تکنیکی برای ارزیابی عملکرد مدل با تقسیم دادهها به چند زیرمجموعه
· انواع:
· K-Fold: تقسیم داده به K بخش مساوی
· Stratified K-Fold: حفظ توزیع کلاسها
· Leave-One-Out: هر نمونه یک بار به عنوان داده تست
```python
from sklearn.model_selection import cross_val_score, StratifiedKFold
# 5-Fold Cross Validation
cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
# Stratified K-Fold برای دادههای نامتوازن
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
```
2. مفاهیم ارزیابی مدل
2.1 ماتریس درهمریختگی (Confusion Matrix)
```python
# محاسبه ماتریس درهمریختگی
from sklearn.metrics import confusion_matrix
import seaborn as sns
cm = confusion_matrix(y_true, y_pred)
sns.heatmap(cm, annot=True, fmt='d')
# شاخصهای استخراج شده از ماتریس
TN, FP, FN, TP = cm.ravel()
accuracy = (TP + TN) / (TP + TN + FP + FN)
precision = TP / (TP + FP) if (TP + FP) > 0 else 0
recall = TP / (TP + FN) if (TP + FN) > 0 else 0
f1_score = 2 * (precision * recall) / (precision + recall)
```
2.2 منحنی ROC و AUC
· ROC Curve: نمایش عملکرد طبقهبند در آستانههای مختلف طبقهبندی
· AUC: مساحت زیر منحنی ROC (بین 0.5 تا 1)
```python
from sklearn.metrics import roc_curve, auc
fpr, tpr, thresholds = roc_curve(y_true, y_scores)
roc_auc = auc(fpr, tpr)
plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.3f}')
plt.plot([0, 1], [0, 1], 'k--') # خط مبنا
```
2.3 منحنی PR (Precision-Recll)
· کاربرد: مناسب برای دادههای نامتوازن
· تفاوت با ROC: حساس به توزیع کلاسها
2.4 نمره F1 (F1-Score)
· تعریف: میانگین هارمونیک Precision و Recall
· فرمول: F1 = 2 × (Precision × Recall) / (Precision + Recall)
2.5 Cohen's Kappa
· تعریف: اندازهگیری توافق بین پیشبینیها و واقعیت، با در نظر گرفتن توافق تصادفی
· محدوده: -1 تا 1 (مقادیر بالاتر بهتر)
3. مفاهیم پیشپردازش داده
3.1 کدگذاری متغیرهای کیفی (Encoding)
· One-Hot Encoding: برای متغیرهای اسمی بدون ترتیب
· Label Encoding: برای متغیرهای ترتیبی
· Target Encoding: جایگزین کردن مقادیر با میانگین متغیر هدف
```python
# One-Hot Encoding
from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
encoded = encoder.fit_transform(X_categorical)
# Target Encoding (برای طبقهبندی)
import category_encoders as ce
target_encoder = ce.TargetEncoder()
X_encoded = target_encoder.fit_transform(X_categorical, y)
```
3.2 نرمالسازی و استانداردسازی
```python
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
# Standardization (Z-score normalization)
scaler_std = StandardScaler()
X_std = scaler_std.fit_transform(X)
# Min-Max Scaling
scaler_mm = MinMaxScaler(feature_range=(0, 1))
X_mm = scaler_mm.fit_transform(X)
# Robust Scaling (مقاوم به outlier)
scaler_robust = RobustScaler()
X_robust = scaler_robust.fit_transform(X)
```
3.3 مدیریت مقادیر گمشده
· حذف: Drop rows/columns with missing values
· پر کردن: با میانگین، میانه، مقدار پرتکرار
· پیشبینی: استفاده از مدلهای یادگیری ماشین
```python
# با Scikit-learn
from sklearn.impute import SimpleImputer, KNNImputer
# پر کردن با میانگین
imputer_mean = SimpleImputer(strategy='mean')
X_imputed = imputer_mean.fit_transform(X)
# KNN Imputation
imputer_knn = KNNImputer(n_neighbors=5)
X_knn_imputed = imputer_knn.fit_transform(X)
```
3.4 تشخیص و مدیریت دادههای پرت (Outlier)
```python
# روشهای تشخیص Outlier
from sklearn.ensemble import IsolationForest
from sklearn.covariance import EllipticEnvelope
from sklearn.neighbors import LocalOutlierFactor
# Isolation Forest
iso_forest = IsolationForest(contamination=0.1)
outliers = iso_forest.fit_predict(X)
# Z-score method
z_scores = np.abs(stats.zscore(X))
outliers_z = (z_scores > 3).any(axis=1)
# IQR method
Q1 = X.quantile(0.25)
Q3 = X.quantile(0.75)
IQR = Q3 - Q1
outliers_iqr = ((X < (Q1 - 1.5 * IQR)) | (X > (Q3 + 1.5 * IQR))).any(axis=1)
```
3.5 تولید ویژگی (Feature Engineering)
```python
# ایجاد ویژگیهای جدید
def create_features(df):
# ویژگیهای تعاملی
df['feature_interaction'] = df['feature1'] * df['feature2']
# ویژگیهای چندجملهای
df['feature_squared'] = df['feature1'] ** 2
df['feature_sqrt'] = np.sqrt(df['feature2'])
# ویژگیهای زمانی
df['hour'] = df['timestamp'].dt.hour
df['day_of_week'] = df['timestamp'].dt.dayofweek
# ویژگیهای آماری پنجرهای
df['rolling_mean'] = df['value'].rolling(window=7).mean()
df['expanding_sum'] = df['value'].expanding().sum()
return df
```
4. مفاهیم انتخاب ویژگی
4.1 تحلیل واریانس (ANOVA)
· هدف: انتخاب ویژگیهایی که بیشترین تفاوت بین گروهها را ایجاد میکنند
```python
from sklearn.feature_selection import f_classif, SelectKBest
selector = SelectKBest(score_func=f_classif, k=10)
X_selected = selector.fit_transform(X, y)
```
4.2 اهمیت ویژگیها (Feature Importance)
```python
# با مدلهای درختی
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100)
model.fit(X, y)
importances = model.feature_importances_
# با Permutation Importance
from sklearn.inspection import permutation_importance
result = permutation_importance(model, X_test, y_test, n_repeats=10)
```
4.3 حذف ویژگیهای با واریانس کم
```python
from sklearn.feature_selection import VarianceThreshold
selector = VarianceThreshold(threshold=0.01)
X_selected = selector.fit_transform(X)
```
4.4 انتخاب ویژگیهای بازگشتی (RFE)
```python
from sklearn.feature_selection import RFE
selector = RFE(estimator=model, n_features_to_select=10)
selector = selector.fit(X, y)
selected_features = X.columns[selector.support_]
```
4.5 تحلیل همبستگی ویژگیها
```python
# محاسبه ماتریس همبستگی
correlation_matrix = X.corr()
# حذف ویژگیهای با همبستگی بالا
def remove_highly_correlated_features(df, threshold=0.8):
corr_matrix = df.corr().abs()
upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
to_drop = [column for column in upper.columns if any(upper[column] > threshold)]
return df.drop(columns=to_drop)
```
5. مفاهیم تقلیل ابعاد
5.1 تحلیل مؤلفههای اصلی (PCA)
```python
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
# نرمالسازی دادهها
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# اعمال PCA
pca = PCA(n_components=0.95) # حفظ 95% واریانس
X_pca = pca.fit_transform(X_scaled)
# واریانس توضیح داده شده
explained_variance = pca.explained_variance_ratio_
cumulative_variance = np.cumsum(explained_variance)
```
5.2 تحلیل مؤلفههای مستقل (ICA)
· هدف: جداسازی سیگنالهای مستقل از یکدیگر
```python
from sklearn.decomposition import FastICA
ica = FastICA(n_components=10, random_state=42)
X_ica = ica.fit_transform(X_scaled)
```
5.3 t-SNE (t-distributed Stochastic Neighbor Embedding)
· کاربرد: مصورسازی دادههای با ابعاد بالا در ۲ یا ۳ بعد
```python
from sklearn.manifold import TSNE
tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_tsne = tsne.fit_transform(X)
```
5.4 UMAP (Uniform Manifold Approximation and Projection)
· مزایا: سریعتر از t-SNE و حفظ ساختارهای سراسری بهتر
```python
import umap
umap_model = umap.UMAP(n_components=2, random_state=42)
X_umap = umap_model.fit_transform(X)
```
5.5 عامل پنهان دیریشله (LDA برای تقلیل ابعاد)
· هدف: یافتن مؤلفههایی که بیشترین تمایز بین کلاسها را ایجاد میکنند
```python
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X, y)
```
6. مفاهیم یادگیری عمیق
6.1 انتشار پسرو (Backpropagation)
· الگوریتم: محاسبه گرادیانها با استفاده از قاعده زنجیرهای
6.2 بهینهسازها (Optimizers)
```python
from tensorflow.keras.optimizers import Adam, SGD, RMSprop, Adagrad
# Adam Optimizer
optimizer_adam = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999)
# SGD with Momentum
optimizer_sgd = SGD(learning_rate=0.01, momentum=0.9, nesterov=True)
# RMSprop
optimizer_rms = RMSprop(learning_rate=0.001, rho=0.9)
```
6.3 نرخ یادگیری (Learning Rate)
· Learning Rate Schedulers:
· Step Decay: کاهش در مراحل مشخص
· Exponential Decay: کاهش نمایی
· Cosine Annealing: کاهش کسینوسی
```python
from tensorflow.keras.callbacks import ReduceLROnPlateau, LearningRateScheduler
# کاهش نرخ یادگیری بر اساس عملکرد
reduce_lr = ReduceLROnPlateau(
monitor='val_loss',
factor=0.5,
patience=5,
min_lr=1e-6
)
# Scheduler سفارشی
def scheduler(epoch, lr):
if epoch < 10:
return lr
else:
return lr * tf.math.exp(-0.1)
lr_scheduler = LearningRateScheduler(scheduler)
```
6.4 Dropout
· هدف: جلوگیری از Overfitting با غیرفعال کردن تصادفی نورونها
```python
from tensorflow.keras.layers import Dropout
from tensorflow.keras import regularizers
# اضافه کردن Dropout
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
# اضافه کردن منظمسازی
model.add(Dense(64, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
```
6.5 Batch Normalization
· هدف: نرمالسازی خروجی هر لایه برای تسریع آموزش و بهبود پایداری
```python
from tensorflow.keras.layers import BatchNormalization
# معماری با BatchNorm
model.add(Dense(128))
model.add(BatchNormalization())
model.add(Activation('relu'))
```
7. مفاهیم یادگیری بدون نظارت
7.1 الگوریتم K-Means
```python
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
# تعیین تعداد خوشههای بهینه
silhouette_scores = []
for k in range(2, 11):
kmeans = KMeans(n_clusters=k, random_state=42)
kmeans.fit(X)
score = silhouette_score(X, kmeans.labels_)
silhouette_scores.append(score)
# خوشهبندی نهایی
optimal_k = np.argmax(silhouette_scores) + 2
kmeans_final = KMeans(n_clusters=optimal_k, random_state=42)
labels = kmeans_final.fit_predict(X)
```
7.2 DBSCAN
· مزایا: تشخیص خوشههای با شکلهای دلخواه و حذف نویز
```python
from sklearn.cluster import DBSCAN
dbscan = DBSCAN(eps=0.5, min_samples=5)
labels = dbscan.fit_predict(X)
# نقاط نویز (برچسب -1)
noise_points = X[labels == -1]
```
7.3 سلسله مراتب خوشهبندی (Hierarchical Clustering)
```python
from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.cluster import AgglomerativeClustering
# ایجاد دندروگرام
linked = linkage(X, method='ward')
dendrogram(linked)
# خوشهبندی سلسلهمراتبی
cluster = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')
labels = cluster.fit_predict(X)
```
7.4 Gaussian Mixture Models
· تعریف: مدل احتمالاتی برای خوشهبندی نرم
```python
from sklearn.mixture import GaussianMixture
gmm = GaussianMixture(n_components=3, random_state=42)
gmm.fit(X)
labels = gmm.predict(X)
probabilities = gmm.predict_proba(X) # احتمالات تعلق به هر خوشه
```
7.5 مدلهای موضوعی (Topic Modeling)
```python
# LDA برای مدلسازی موضوعی
from sklearn.decomposition import LatentDirichletAllocation
from sklearn.feature_extraction.text import CountVectorizer
# تبدیل متن به ماتریس تعداد
vectorizer = CountVectorizer(max_df=0.95, min_df=2, stop_words='english')
X_counts = vectorizer.fit_transform(texts)
# LDA
lda = LatentDirichletAllocation(n_components=10, random_state=42)
lda.fit(X_counts)
# نمایش موضوعات
feature_names = vectorizer.get_feature_names_out()
for topic_idx, topic in enumerate(lda.components_):
top_words_idx = topic.argsort()[-10:][::-1]
top_words = [feature_names[i] for i in top_words_idx]
print(f"Topic {topic_idx}: {', '.join(top_words)}")
```
8. مفاهیم پیشرفته
8.1 Bagging و Boosting
```python
# Bagging (Bootstrap Aggregating)
from sklearn.ensemble import BaggingClassifier
bagging = BaggingClassifier(
base_estimator=DecisionTreeClassifier(),
n_estimators=100,
max_samples=0.8,
bootstrap=True
)
# Boosting
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
# AdaBoost
adaboost = AdaBoostClassifier(
base_estimator=DecisionTreeClassifier(max_depth=1),
n_estimators=100,
learning_rate=0.1
)
# Gradient Boosting
gb = GradientBoostingClassifier(
n_estimators=100,
learning_rate=0.1,
max_depth=3
)
```
8.2 XGBoost, LightGBM, CatBoost
```python
import xgboost as xgb
import lightgbm as lgb
from catboost import CatBoostClassifier
# XGBoost
xgb_model = xgb.XGBClassifier(
n_estimators=100,
learning_rate=0.1,
max_depth=6,
subsample=0.8,
colsample_bytree=0.8
)
# LightGBM
lgb_model = lgb.LGBMClassifier(
n_estimators=100,
learning_rate=0.1,
num_leaves=31,
subsample=0.8
)
# CatBoost
cat_model = CatBoostClassifier(
iterations=100,
learning_rate=0.1,
depth=6,
verbose=0
)
```
8.3 معماریهای پیشرفته یادگیری عمیق
شبکههای عصبی کانولوشنی (CNN)
```python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D((2, 2)),
Flatten(),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])
```
شبکههای عصبی بازگشتی (RNN/LSTM)
```python
from tensorflow.keras.layers import LSTM, GRU, Bidirectional
# LSTM
model.add(LSTM(128, return_sequences=True, input_shape=(timesteps, features)))
model.add(LSTM(64))
model.add(Dense(1))
# Bidirectional LSTM
model.add(Bidirectional(LSTM(64, return_sequences=True)))
```
مکانیزم توجه (Attention Mechanism)
```python
from tensorflow.keras.layers import Attention, AdditiveAttention
# Self-Attention
attention_layer = Attention(use_scale=True)
attention_output = attention_layer([query, key, value])
# Multi-Head Attention
from tensorflow.keras.layers import MultiHeadAttention
mha = MultiHeadAttention(num_heads=8, key_dim=64)
mha_output = mha(query, key, value)
```
8.4 انتقال یادگیری (Transfer Learning)
```python
from tensorflow.keras.applications import VGG16, ResNet50, EfficientNetB0
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
# استفاده از مدل از پیش آموزش دیده
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
# فریز کردن لایههای پایه
for layer in base_model.layers:
layer.trainable = False
# اضافه کردن لایههای جدید
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
```
8.5 تشخیص ناهنجاری (Anomaly Detection)
```python
# روشهای مختلف تشخیص ناهنجاری
from pyod.models.knn import KNN
from pyod.models.auto_encoder import AutoEncoder
from pyod.models.combination import aom, moa, average
# ترکیب چند مدل
clfs = [KNN(), AutoEncoder(hidden_neurons=[64, 32, 32, 64])]
scores = np.zeros([X_test.shape[0], len(clfs)])
for i, clf in enumerate(clfs):
clf.fit(X_train)
scores[:, i] = clf.decision_function(X_test)
# ترکیب امتیازات
combined_scores = average(scores)
```
8.6 یادگیری تقویتی (Reinforcement Learning)
```python
# Q-Learning
class QLearningAgent:
def __init__(self, state_size, action_size, learning_rate=0.1, discount_factor=0.9):
self.q_table = np.zeros((state_size, action_size))
self.lr = learning_rate
self.gamma = discount_factor
def update(self, state, action, reward, next_state):
current_q = self.q_table[state, action]
next_max_q = np.max(self.q_table[next_state])
new_q = current_q + self.lr * (reward + self.gamma * next_max_q - current_q)
self.q_table[state, action] = new_q
```
8.7 یادگیری نیمه نظارتی (Semi-Supervised Learning)
```python
from sklearn.semi_supervised import LabelPropagation, LabelSpreading
# Label Propagation
label_prop = LabelPropagation(kernel='knn', n_neighbors=7)
label_prop.fit(X_labeled, y_labeled)
# پیشبینی برچسب برای دادههای بدون برچسب
y_unlabeled_pred = label_prop.predict(X_unlabeled)
```
8.8 یادگیری چندوظیفهای (Multi-Task Learning)
```python
from tensorflow.keras import Model
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras import backend as K
# ساخت مدل چندوظیفهای
input_layer = Input(shape=(input_dim,))
shared_layer = Dense(64, activation='relu')(input_layer)
# شاخه اول (وظیفه اول)
task1_output = Dense(32, activation='relu')(shared_layer)
task1_output = Dense(1, name='task1')(task1_output)
# شاخه دوم (وظیفه دوم)
task2_output = Dense(32, activation='relu')(shared_layer)
task2_output = Dense(num_classes, activation='softmax', name='task2')(task2_output)
model = Model(inputs=input_layer, outputs=[task1_output, task2_output])
# تابع زیان ترکیبی
model.compile(
optimizer='adam',
loss={
'task1': 'mse',
'task2': 'categorical_crossentropy'
},
loss_weights={'task1': 0.5, 'task2': 0.5}
)
```
8.9 یادگیری فعال (Active Learning)
```python
from modAL.models import ActiveLearner
from modAL.uncertainty import uncertainty_sampling
# مدل یادگیری فعال
learner = ActiveLearner(
estimator=model,
query_strategy=uncertainty_sampling,
X_training=X_initial, y_training=y_initial
)
# پرسش برای برچسبگذاری جدید
query_idx, query_inst = learner.query(X_pool, n_instances=10)
# به روزرسانی مدل با دادههای جدید
learner.teach(X_pool[query_idx], y_new)
```
8.10 توضیحپذیری مدل (Model Explainability)
```python
import shap
import lime
from interpret import show
from interpret.glassbox import ExplainableBoostingClassifier
# SHAP
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test)
# LIME
explainer = lime.lime_tabular.LimeTabularExplainer(
X_train.values,
feature_names=feature_names,
class_names=class_names,
mode='classification'
)
exp = explainer.explain_instance(X_test.iloc[0], model.predict_proba)
# InterpretML
ebm = ExplainableBoostingClassifier()
ebm.fit(X_train, y_train)
show(ebm.explain_global())
```
9. مفاهیم بهینهسازی
9.1 جستجوی فراابتکاری (Metaheuristic Search)
```python
import optuna
from optuna.samplers import TPESampler
def objective(trial):
# تعریف فضای جستجوی هایپرپارامترها
n_estimators = trial.suggest_int('n_estimators', 100, 1000)
max_depth = trial.suggest_int('max_depth', 3, 10)
learning_rate = trial.suggest_float('learning_rate', 0.01, 0.3, log=True)
model = GradientBoostingClassifier(
n_estimators=n_estimators,
max_depth=max_depth,
learning_rate=learning_rate
)
score = cross_val_score(model, X, y, cv=5, scoring='accuracy').mean()
return score
# ایجاد مطالعه Optuna
study = optuna.create_study(direction='maximize', sampler=TPESampler())
study.optimize(objective, n_trials=100)
print(f"بهترین هایپرپارامترها: {study.best_params}")
print(f"بهترین score: {study.best_value}")
```
9.2 بهینهسازی بیزی (Bayesian Optimization)
```python
from skopt import BayesSearchCV
from skopt.space import Real, Categorical, Integer
# تعریف فضای جستجو
search_spaces = {
'n_estimators': Integer(100, 1000),
'max_depth': Integer(3, 10),
'learning_rate': Real(0.01, 0.3, prior='log-uniform'),
'subsample': Real(0.5, 1.0)
}
# جستجوی بیزی
opt = BayesSearchCV(
estimator=GradientBoostingClassifier(),
search_spaces=search_spaces,
n_iter=50,
cv=5,
random_state=42
)
opt.fit(X_train, y_train)
```
9.3 جستجوی شبکهای (Grid Search) و جستجوی تصادفی (Random Search)
```python
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import uniform, randint
# Grid Search
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [3, 5, 7],
'learning_rate': [0.01, 0.1, 0.2]
}
grid_search = GridSearchCV(
estimator=model,
param_grid=param_grid,
cv=5,
scoring='accuracy'
)
grid_search.fit(X_train, y_train)
# Random Search
param_dist = {
'n_estimators': randint(100, 1000),
'max_depth': randint(3, 10),
'learning_rate': uniform(0.01, 0.3)
}
random_search = RandomizedSearchCV(
estimator=model,
param_distributions=param_dist,
n_iter=50,
cv=5,
random_state=42
)
random_search.fit(X_train, y_train)
```
10. مفاهیم مدیریت مدل
10.1 MLOps و خط لوله یادگیری ماشین
```python
import mlflow
import dagshub
from sklearn.pipeline import Pipeline
# تنظیم MLflow
mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("hospital_finance")
# ایجاد خط لوله کامل
pipeline = Pipeline([
('scaler', StandardScaler()),
('pca', PCA(n_components=0.95)),
('classifier', RandomForestClassifier())
])
# ردیابی آزمایش با MLflow
with mlflow.start_run():
# ثبت هایپرپارامترها
mlflow.log_params({
'n_estimators': 100,
'max_depth': 10,
'random_state': 42
})
# آموزش مدل
pipeline.fit(X_train, y_train)
# ارزیابی
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
# ثبت متریکها
mlflow.log_metric("accuracy", accuracy)
# ثبت مدل
mlflow.sklearn.log_model(pipeline, "model")
```
10.2 نسخهگذاری داده و مدل
```python
import dvc.api
import pickle
import joblib
# ذخیره مدل
joblib.dump(model, 'model.pkl')
# ذخیره پیشپردازشگرها
with open('preprocessor.pkl', 'wb') as f:
pickle.dump(preprocessor, f)
# استفاده از DVC برای نسخهگذاری
# dvc add model.pkl
# dvc add preprocessor.pkl
```
10.3 نظارت بر مدل (Model Monitoring)
```python
# نظارت بر دریفت داده
from alibi_detect.cd import KSDrift, ChiSquareDrift
# تشخیص دریفت با آزمون KS
cd = KSDrift(X_ref, p_val=0.05)
preds = cd.predict(X_new)
# نظارت بر عملکرد مدل
def monitor_model_performance(y_true, y_pred, threshold=0.05):
current_accuracy = accuracy_score(y_true, y_pred)
baseline_accuracy = 0.85 # عملکرد پایه
if abs(current_accuracy - baseline_accuracy) > threshold:
print(f"هشدار: عملکرد مدل کاهش یافته است!")
print(f"پایه: {baseline_accuracy:.3f}, فعلی: {current_accuracy:.3f}")
return current_accuracy
```
10.4 انصاف و سوگیری مدل (Model Fairness)
```python
from fairlearn.metrics import demographic_parity_difference, equalized_odds_difference
from aif360.datasets import BinaryLabelDataset
from aif360.algorithms.preprocessing import Reweighing
# ارزیابی انصاف
dp_diff = demographic_parity_difference(
y_true, y_pred, sensitive_features=sensitive_features
)
eod_diff = equalized_odds_difference(
y_true, y_pred, sensitive_features=sensitive_features
)
print(f"اختلاف برابری دموگرافیک: {dp_diff:.3f}")
print(f"اختلاف شانس برابر: {eod_diff:.3f}")
# کاهش سوگیری با Reweighing
dataset = BinaryLabelDataset(
df=df,
label_names=['target'],
protected_attribute_names=['sensitive_attribute']
)
RW = Reweighing(unprivileged_groups=[{'sensitive_attribute': 0}],
privileged_groups=[{'sensitive_attribute': 1}])
dataset_transformed = RW.fit_transform(dataset)
```
10.5 فشردهسازی مدل (Model Compression)
```python
import tensorflow_model_optimization as tfmot
# Quantization پس از آموزش
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_model = converter.convert()
# Pruning
prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude
pruning_params = {
'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
initial_sparsity=0.0,
final_sparsity=0.5,
begin_step=0,
end_step=1000
)
}
model_for_pruning = prune_low_magnitude(model, **pruning_params)
```
نکات پایانی
این ۴۰ مفهوم تخصصی یادگیری ماشین، از مبانی تا پیشرفته را پوشش میدهند. برای تسلط بر هر مفهوم:
1. مطالعه نظری: درک ریاضیات و مفاهیم پایه
2. پیادهسازی عملی: کدنویسی و آزمایش با دادههای واقعی
3. بهینهسازی: تنظیم هایپرپارامترها و بهبود عملکرد
4. ارزیابی: سنجش مدل با معیارهای مناسب
5. مستندسازی: ثبت فرآیند و نتایج برای تکرارپذیری
هر پروژه یادگیری ماشین باید با درک صحیح از این مفاهیم و انتخاب مناسبترین تکنیکها برای مسئله خاص انجام شود.
