ریجننگ کوڈنگ ماسٹر: ایک جامع گائیڈ

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

# نمونہ ڈیٹا تخلیق کریں
X, y = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)

# ٹرین اور ٹیسٹ سیٹ میں تقسیم کریں
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ماڈل کو انیشی ایٹ اور ٹرین کریں
model = LinearRegression()
model.fit(X_train, y_train)

# اسکور حاصل کریں
score = model.score(X_test, y_test)
print(f"R² اسکور: {score:.4f}")

from sklearn.linear_model import Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# ایک پائپ لائن بنائیں جو اسکیلنگ اور رجحان ریجننگ کو جوڑتی ہے
ridge_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('regressor', Ridge(alpha=1.0))
])

# ماڈل کو ٹرین کریں
ridge_pipeline.fit(X_train, y_train)

# پرفارمنس چیک کریں
ridge_score = ridge_pipeline.score(X_test, y_test)
print(f"Ridge R² اسکور: {ridge_score:.4f}")

from sklearn.linear_model import Lasso

# لاسو ماڈل
lasso = Lasso(alpha=0.1)
lasso.fit(X_train, y_train)

# غیر صفر کوآفیشنٹس کی تعداد
non_zero_coef = np.sum(lasso.coef_ != 0)
print(f"غیر صفر کوآفیشنٹس: {non_zero_coef}")

from sklearn.linear_model import ElasticNet

# ایلاسٹک نیٹ ماڈل
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5)
elastic_net.fit(X_train, y_train)

from sklearn.metrics import mean_squared_error

y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f"MSE: {mse:.4f}")

rmse = np.sqrt(mse)
print(f"RMSE: {rmse:.4f}")

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_test, y_pred)
print(f"MAE: {mae:.4f}")

from sklearn.metrics import r2_score

r2 = r2_score(y_test, y_pred)
print(f"R²: {r2:.4f}")

def adjusted_r2_score(r2, n, p):
    """Adjusted R² حساب کریں"""
    return 1 - (1 - r2) * (n - 1) / (n - p - 1)

n = len(y_test)  # نمونوں کی تعداد
p = X_test.shape[1]  # فیچرز کی تعداد
adj_r2 = adjusted_r2_score(r2, n, p)
print(f"Adjusted R²: {adj_r2:.4f}")

import pandas as pd
import numpy as np

# نمونہ ڈیٹا فریم
df = pd.DataFrame({
    'feature1': [1, 2, np.nan, 4, 5],
    'feature2': [2, np.nan, 4, 5, 6],
    'target': [10, 20, 30, np.nan, 50]
})

# مفقود قدروں کی تعداد چیک کریں
print(df.isnull().sum())

# مفقود قدروں کو ہینڈل کرنے کے طریقے

# طریقہ 1: میڈن سے بھرنا
df_median = df.fillna(df.median())

# طریقہ 2: میعار سے بھرنا
df_mean = df.fillna(df.mean())

# طریقہ 3: فارورڈ/بیك وارڈ فل
df_ffill = df.fillna(method='ffill')
df_bfill = df.fillna(method='bfill')

# طریقہ 4: انٹرپولیشن
df_interpolated = df.interpolate()

# طریقہ 5: KNN امپوٹیشن
from sklearn.impute import KNNImputer

imputer = KNNImputer(n_neighbors=3)
df_knn = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)

from scipy import stats
import matplotlib.pyplot as plt

# زد سے زیادہ قدریں (Z-score) کے ذریعے آؤٹ لائرز کا پتہ لگانا
z_scores = np.abs(stats.zscore(df.select_dtypes(include=[np.number])))
outliers_z = (z_scores > 3).any(axis=1)

# انٹرکوارٹائل رینج (IQR) طریقہ
Q1 = df.quantile(0.25)
Q3 = df.quantile(0.75)
IQR = Q3 - Q1
outliers_iqr = ((df < (Q1 - 1.5 * IQR)) | (df > (Q3 + 1.5 * IQR))).any(axis=1)

# آؤٹ لائرز کو ہینڈل کرنا
# طریقہ 1: ہٹانا
df_no_outliers = df[~outliers_iqr]

# طریقہ 2: کیپنگ
df_capped = df.copy()
for col in df.columns:
    if df[col].dtype in ['float64', 'int64']:
        percentiles = df[col].quantile([0.01, 0.99])
        df_capped[col] = df[col].clip(percentiles[0.01], percentiles[0.99])

# ڈپلیکیٹس چیک کریں
duplicates = df[df.duplicated()]

# ڈپلیکیٹس ہٹائیں
df_no_duplicates = df.drop_duplicates()

from sklearn.preprocessing import StandardScaler

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

from sklearn.preprocessing import MinMaxScaler

minmax_scaler = MinMaxScaler(feature_range=(0, 1))
X_minmax = minmax_scaler.fit_transform(X)

from sklearn.preprocessing import RobustScaler

robust_scaler = RobustScaler()
X_robust = robust_scaler.fit_transform(X)

from sklearn.preprocessing import MaxAbsScaler

maxabs_scaler = MaxAbsScaler()
X_maxabs = maxabs_scaler.fit_transform(X)

from sklearn.preprocessing import LabelEncoder

# نمونہ ڈیٹا
data = pd.DataFrame({
    'category': ['A', 'B', 'C', 'A', 'B'],
    'target': [1, 2, 3, 4, 5]
})

# Label Encoding
le = LabelEncoder()
data['category_encoded'] = le.fit_transform(data['category'])

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# One-Hot Encoding
ohe = OneHotEncoder(sparse=False, drop='first')
ct = ColumnTransformer([('ohe', ohe, ['category'])], remainder='passthrough')
data_encoded = ct.fit_transform(data)

from category_encoders import TargetEncoder

# Target Encoding
te = TargetEncoder()
data['category_te'] = te.fit_transform(data['category'], data['target'])

# لاگ ٹرانسفارمیشن
df['log_feature'] = np.log1p(df['feature'])

from scipy import stats

# صرف مثبت قدریں
positive_data = df[df['feature'] > 0]['feature']
df['boxcox_feature'], _ = stats.boxcox(positive_data)

from sklearn.preprocessing import PowerTransformer

pt = PowerTransformer(method='yeo-johnson')
df['yeo_johnson'] = pt.fit_transform(df[['feature']])

from sklearn.preprocessing import PolynomialFeatures

# پولینومیل فیچرز تخلیق کریں
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
print(f"اصل فیچرز: {X.shape[1]}")
print(f"پولینومیل کے بعد: {X_poly.shape[1]}")

from sklearn.preprocessing import PolynomialFeatures

# صرف انٹرایکشن ٹرمز
interaction = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
X_interaction = interaction.fit_transform(X)

# نمونہ ڈیٹا فریم
df = pd.DataFrame({
    'length': [10, 20, 30],
    'width': [5, 10, 15],
    'height': [2, 4, 6]
})

# نئے فیچرز تخلیق کریں
df['volume'] = df['length'] * df['width'] * df['height']
df['surface_area'] = 2 * (df['length']*df['width'] + df['width']*df['height'] + df['height']*df['length'])
df['aspect_ratio'] = df['length'] / df['width']

from datetime import datetime

# نمونہ ڈیٹا
df = pd.DataFrame({
    'date': pd.date_range('2023-01-01', periods=100, freq='D'),
    'value': np.random.randn(100)
})

# ڈیٹا فیچرز
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['dayofweek'] = df['date'].dt.dayofweek
df['quarter'] = df['date'].dt.quarter
df['weekofyear'] = df['date'].dt.isocalendar().week
df['is_weekend'] = df['date'].dt.dayofweek.isin([5, 6]).astype(int)

# سائیکلیکل انکوڈنگ کے لیے
def cyclical_encoding(df, col, period):
    df[f'{col}_sin'] = np.sin(2 * np.pi * df[col] / period)
    df[f'{col}_cos'] = np.cos(2 * np.pi * df[col] / period)
    return df

# مہینے کے لیے سائیکلیکل انکوڈنگ
df = cyclical_encoding(df, 'month', 12)

# دن کے ہفتے کے لیے
df = cyclical_encoding(df, 'dayofweek', 7)

# برابر چوڑائی والے بن
df['age_bin'] = pd.cut(df['age'], bins=5, labels=['Very Young', 'Young', 'Middle', 'Old', 'Very Old'])

# برابر فریکوئنسی والے بن
df['income_bin'] = pd.qcut(df['income'], q=4, labels=['Low', 'Medium-Low', 'Medium-High', 'High'])

# کسٹم بن
bins = [0, 18, 35, 50, 65, 100]
labels = ['Child', 'Young Adult', 'Adult', 'Middle Age', 'Senior']
df['age_custom'] = pd.cut(df['age'], bins=bins, labels=labels)

from sklearn.feature_selection import SelectKBest, f_regression

# یونی ویرایٹ فیچر سلیکشن
selector = SelectKBest(score_func=f_regression, k=5)
X_selected = selector.fit_transform(X, y)

# منتخب فیچرز کے انڈیکس
selected_features = selector.get_support(indices=True)

from sklearn.feature_selection import RFE
from sklearn.linear_model import LinearRegression

# RFE
model = LinearRegression()
rfe = RFE(estimator=model, n_features_to_select=5)
rfe.fit(X, y)

# منتخب فیچرز
selected_features_rfe = rfe.support_

from sklearn.ensemble import RandomForestRegressor

# Random Forest فیچر اہمیت
rf = RandomForestRegressor(n_estimators=100, random_state=42)
rf.fit(X, y)

# فیچر اہمیت حاصل کریں
importances = rf.feature_importances_
feature_names = [f'feature_{i}' for i in range(X.shape[1])]
feature_importance_df = pd.DataFrame({'feature': feature_names, 'importance': importances})
feature_importance_df = feature_importance_df.sort_values('importance', ascending=False)

from sklearn.linear_model import LassoCV

# Lasso CV کے ذریعے فیچر سلیکشن
lasso_cv = LassoCV(cv=5, random_state=42)
lasso_cv.fit(X, y)

# غیر صفر کوآفیشنٹس
mask = lasso_cv.coef_ != 0
X_selected_lasso = X[:, mask]