mlextend 0.1.0__py3-none-any.whl

mlextend/__init__.py

@@ -0,0 +1,51 @@
+"""mlextend - ready-to-copy source code of 10 machine learning practicals.
+
+    import mlextend
+    mlextend.list_experiments()
+    mlextend.exp1.print()      # print the full code
+    mlextend.exp1.code         # the code as a string
+    mlextend.exp1.show()       # syntax-highlighted in Jupyter
+    mlextend.exp1.save()       # write exp1.py
+
+Retrieving code never executes it.
+"""
+
+from ._experiment import Experiment
+
+__version__ = "0.1.0"
+
+_TITLES = {
+    1: "Data Pre-processing and Exploratory Data Analysis (EDA)",
+    2: "Simple Linear Regression",
+    3: "Multiple Linear Regression (House Price Prediction)",
+    4: "Logistic Regression for Heart Disease Prediction",
+    5: "K-Nearest Neighbors (KNN) Classifier for Credit Risk Rating",
+    6: "Decision Tree Classifier for Multi-Class Credit Risk Assessment",
+    7: "K-Means Clustering for Customer Profiling",
+    8: "Dimensionality Reduction using PCA",
+    9: "Apriori Algorithm for Association Rule Mining",
+    10: "Q-Learning Algorithm for Grid World Environment",
+}
+
+EXPERIMENTS = {f"exp{n}": Experiment(n, t) for n, t in _TITLES.items()}
+
+exp1 = EXPERIMENTS["exp1"]
+exp2 = EXPERIMENTS["exp2"]
+exp3 = EXPERIMENTS["exp3"]
+exp4 = EXPERIMENTS["exp4"]
+exp5 = EXPERIMENTS["exp5"]
+exp6 = EXPERIMENTS["exp6"]
+exp7 = EXPERIMENTS["exp7"]
+exp8 = EXPERIMENTS["exp8"]
+exp9 = EXPERIMENTS["exp9"]
+exp10 = EXPERIMENTS["exp10"]
+
+
+def list_experiments():
+    """Print all available experiments and return their names."""
+    for name, exp in EXPERIMENTS.items():
+        print(f"{name:<6} {exp.title}")
+    return list(EXPERIMENTS)
+
+
+__all__ = ["Experiment", "EXPERIMENTS", "list_experiments", *EXPERIMENTS]

mlextend/_experiment.py

@@ -0,0 +1,70 @@
+"""The Experiment class: read-only access to a practical's source code.
+
+Nothing in this module ever executes, imports or compiles the practical code.
+The code is stored as plain text files inside the package and only read.
+"""
+
+from __future__ import annotations
+
+import builtins
+import os
+from importlib.resources import files
+
+_CODES = "codes"
+
+
+class Experiment:
+    """One practical. Use ``.print()``, ``.code``, ``.show()`` and ``.save()``."""
+
+    def __init__(self, number: int, title: str) -> None:
+        self.number = number
+        self.name = f"exp{number}"
+        self.title = title
+        self._resource = f"exp{number:02d}.txt"
+        self._code: str | None = None
+
+    @property
+    def code(self) -> str:
+        """The complete source code of the practical, as a string."""
+        if self._code is None:
+            path = files(__package__).joinpath(_CODES).joinpath(self._resource)
+            self._code = path.read_text(encoding="utf-8")
+        return self._code
+
+    def print(self) -> None:
+        """Print the complete source code as plain text, ready to copy."""
+        builtins.print(self.code, end="")
+
+    def show(self) -> None:
+        """Display the code in a readable format.
+
+        In Jupyter / IPython the code is rendered with syntax highlighting;
+        anywhere else it is printed as plain text.
+        """
+        try:
+            from IPython import get_ipython
+            from IPython.display import Markdown, display
+
+            shell = get_ipython()
+            if shell is not None and shell.__class__.__name__ == "ZMQInteractiveShell":
+                display(Markdown(f"```python\n{self.code}```"))
+                return
+        except ImportError:
+            pass
+        self.print()
+
+    def save(self, path: str | os.PathLike | None = None, overwrite: bool = False) -> str:
+        """Save the code to a ``.py`` file and return its path.
+
+        Defaults to ``exp<N>.py`` in the current directory. An existing file is
+        not replaced unless ``overwrite=True``.
+        """
+        path = os.fspath(path) if path is not None else f"{self.name}.py"
+        if os.path.exists(path) and not overwrite:
+            raise FileExistsError(f"{path} already exists; pass overwrite=True to replace it")
+        with open(path, "w", encoding="utf-8", newline="\n") as fh:
+            fh.write(self.code)
+        return path
+
+    def __repr__(self) -> str:
+        return f"<{self.name}: {self.title}>"

mlextend/codes/exp01.txt

@@ -0,0 +1,110 @@
+# Experiment 1: Data Pre-processing and Exploratory Data Analysis (EDA)
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.preprocessing import LabelEncoder, MinMaxScaler
+
+# ==========================================
+# STEP 1: Loading the Dataset
+# ==========================================
+# Raw retail customer dataset (from the problem statement).
+# To use your own data instead, uncomment the next line:
+# CHANGE THIS PATH TO YOUR DATASET
+# df = pd.read_csv("your_dataset.csv")
+df = pd.DataFrame({
+    'CustomerID': [101, 102, 103, 104, 105, 106, 107],
+    'Age': [23, 45, np.nan, 31, 22, 54, 38],
+    'Annual_Income_k': [50, 85, 62, np.nan, 45, 120, 350],
+    'City': ['New York', 'Paris', 'New York', 'London', np.nan, 'London', 'Paris']
+})
+
+print("--- Raw Dataset ---")
+print(df)
+
+# ==========================================
+# STEP 2: Data Inspection & Handling Missing Values
+# ==========================================
+print("\n--- Dataset Info ---")
+df.info()
+
+print("\n--- Missing Values per Column ---")
+print(df.isnull().sum())
+
+# Numerical columns -> Median imputation (robust to outliers)
+for col in ['Age', 'Annual_Income_k']:
+    df[col] = df[col].fillna(df[col].median())
+
+# Categorical column -> Mode imputation
+df['City'] = df['City'].fillna(df['City'].mode()[0])
+
+print("\n--- Dataset after Imputation ---")
+print(df)
+
+# ==========================================
+# STEP 3: Outlier Detection & Treatment (IQR Capping)
+# ==========================================
+Q1 = df['Annual_Income_k'].quantile(0.25)
+Q3 = df['Annual_Income_k'].quantile(0.75)
+IQR = Q3 - Q1
+lower_bound = Q1 - 1.5 * IQR
+upper_bound = Q3 + 1.5 * IQR
+
+print(f"\nIQR Bounds for Annual_Income_k: [{lower_bound:.2f}, {upper_bound:.2f}]")
+outliers = df[(df['Annual_Income_k'] < lower_bound) | (df['Annual_Income_k'] > upper_bound)]
+print("Detected Outliers:")
+print(outliers)
+
+# Boxplot before capping
+plt.figure(figsize=(6, 4))
+sns.boxplot(x=df['Annual_Income_k'])
+plt.title('Annual Income (Before Outlier Capping)')
+plt.show()
+
+# Cap values outside the IQR bounds
+df['Annual_Income_k'] = df['Annual_Income_k'].clip(lower=lower_bound, upper=upper_bound)
+
+print("\n--- Dataset after Outlier Capping ---")
+print(df)
+
+# ==========================================
+# STEP 4: Categorical Encoding & Feature Scaling
+# ==========================================
+# Encode City names into integer identifiers
+le = LabelEncoder()
+df['City_Encoded'] = le.fit_transform(df['City'])
+print("\nCity Encoding:", dict(zip(le.classes_, le.transform(le.classes_))))
+
+# Normalize Age and Income to the range [0, 1]
+scaler = MinMaxScaler()
+df[['Age_Scaled', 'Income_Scaled']] = scaler.fit_transform(df[['Age', 'Annual_Income_k']])
+
+print("\n--- Final Pre-processed Dataset ---")
+print(df)
+
+# ==========================================
+# STEP 5: Exploratory Data Analysis (EDA) - Heatmaps & Histograms
+# ==========================================
+# Histograms: distribution of Age and Income
+fig, axes = plt.subplots(1, 2, figsize=(12, 4))
+sns.histplot(df['Age'], bins=5, kde=True, ax=axes[0], color='skyblue')
+axes[0].set_title('Age Distribution')
+sns.histplot(df['Annual_Income_k'], bins=5, kde=True, ax=axes[1], color='salmon')
+axes[1].set_title('Annual Income Distribution (k)')
+plt.tight_layout()
+plt.show()
+
+# Scatter plot: demographic clusters by City
+plt.figure(figsize=(6, 4))
+sns.scatterplot(data=df, x='Age', y='Annual_Income_k', hue='City', s=100)
+plt.title('Age vs Annual Income by City')
+plt.show()
+
+# Correlation heatmap
+numeric_cols = ['Age', 'Annual_Income_k', 'City_Encoded']
+plt.figure(figsize=(6, 5))
+sns.heatmap(df[numeric_cols].corr(), annot=True, cmap='coolwarm', fmt='.2f')
+plt.title('Feature Correlation Heatmap')
+plt.show()

mlextend/codes/exp02.txt

@@ -0,0 +1,89 @@
+# Experiment 2: Simple Linear Regression
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+
+# ==========================================
+# STEP 1: Generate the Data
+# ==========================================
+# Synthetic data: Years of Experience vs Salary, with random noise.
+np.random.seed(42)
+n_samples = 100
+
+experience = np.random.uniform(0, 15, n_samples)
+noise = np.random.normal(0, 5000, n_samples)
+salary = 30000 + 4500 * experience + noise
+
+data = pd.DataFrame({'YearsExperience': experience, 'Salary': salary})
+data.to_csv('simple_linear_regression_data.csv', index=False)
+
+# Load the saved CSV
+# CHANGE THIS PATH TO YOUR DATASET (and the column names below)
+df = pd.read_csv('simple_linear_regression_data.csv')
+print("--- Dataset Head ---")
+print(df.head())
+
+X = df[['YearsExperience']]   # Feature matrix (2D)
+y = df['Salary']              # Target vector
+
+# ==========================================
+# STEP 2: Splitting Data into Training and Testing Sets (80/20)
+# ==========================================
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+print(f"\nTraining Set Shape: {X_train.shape}")
+print(f"Testing Set Shape:  {X_test.shape}")
+
+# ==========================================
+# STEP 3: Training the Simple Linear Regression Model
+# ==========================================
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+print(f"\nIntercept (beta_0): {model.intercept_:.2f}")
+print(f"Slope     (beta_1): {model.coef_[0]:.2f}")
+
+# ==========================================
+# STEP 4: Making Predictions & Model Evaluation
+# ==========================================
+y_pred = model.predict(X_test)
+
+mse = mean_squared_error(y_test, y_pred)
+rmse = np.sqrt(mse)
+r2 = r2_score(y_test, y_pred)
+
+print("\n--- MODEL PERFORMANCE METRICS ---")
+print(f"Mean Squared Error (MSE)       : {mse:.2f}")
+print(f"Root Mean Squared Error (RMSE) : {rmse:.2f}")
+print(f"R^2 Score                      : {r2:.4f}")
+
+# ==========================================
+# STEP 5: Visualizing Results
+# ==========================================
+fig, axes = plt.subplots(1, 2, figsize=(12, 5))
+
+# Training set
+sns.scatterplot(x=X_train['YearsExperience'], y=y_train, ax=axes[0], color='blue', label='Actual')
+axes[0].plot(X_train['YearsExperience'], model.predict(X_train), color='red', label='Regression Line')
+axes[0].set_title('Training Set: Salary vs Experience')
+axes[0].set_xlabel('Years of Experience')
+axes[0].set_ylabel('Salary')
+axes[0].legend()
+
+# Testing set
+sns.scatterplot(x=X_test['YearsExperience'], y=y_test, ax=axes[1], color='green', label='Actual')
+axes[1].plot(X_train['YearsExperience'], model.predict(X_train), color='red', label='Regression Line')
+axes[1].set_title('Testing Set: Salary vs Experience')
+axes[1].set_xlabel('Years of Experience')
+axes[1].set_ylabel('Salary')
+axes[1].legend()
+
+plt.tight_layout()
+plt.show()

mlextend/codes/exp03.txt

@@ -0,0 +1,110 @@
+# Experiment 3: Multiple Linear Regression (House Price Prediction)
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn statsmodels
+
+# Step 1: Environment Setup & Synthetic Data Generation
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+from statsmodels.stats.outliers_influence import variance_inflation_factor
+import statsmodels.api as sm
+
+# Set random seed for reproducibility
+np.random.seed(42)
+n_samples = 500
+
+# Generate synthetic features
+sqft = np.random.normal(2100, 500, n_samples).clip(800, 4500)
+bedrooms = np.random.choice([1, 2, 3, 4, 5], size=n_samples, p=[0.1, 0.25, 0.4, 0.2, 0.05])
+dist_transit = np.random.exponential(scale=4.0, size=n_samples).clip(0.5, 20.0)
+age = np.random.uniform(1, 40, n_samples)
+school_rating = np.random.uniform(3.0, 9.8, n_samples)
+
+# True linear relationship + Gaussian noise
+noise = np.random.normal(0, 25000, n_samples)
+price = (150 * sqft) + (12000 * bedrooms) - (8500 * dist_transit) - (1500 * age) + (9000 * school_rating) + 50000 + noise
+
+# Construct DataFrame
+df = pd.DataFrame({
+    'Square_Footage': sqft,
+    'Number_of_Bedrooms': bedrooms,
+    'Distance_to_Transit_km': dist_transit,
+    'Age_of_Property': age,
+    'School_Rating': school_rating,
+    'House_Price': price
+})
+
+print("Dataset Head:")
+print(df.head())
+
+# Step 2: Train-Test Split (80:20)
+# Define Independent Features (X) and Target Variable (Y)
+X = df[['Square_Footage', 'Number_of_Bedrooms', 'Distance_to_Transit_km', 'Age_of_Property', 'School_Rating']]
+Y = df['House_Price']
+
+# Split data into 80% training and 20% testing sets
+X_train, X_test, Y_train, Y_test = train_test_split(
+    X, Y, test_size=0.20, random_state=42
+)
+
+print(f"Training Set Shape: {X_train.shape}")
+print(f"Testing Set Shape:  {X_test.shape}")
+
+# Step 3: Model Fitting & Parameter Estimation
+# Instantiate and fit Linear Regression model
+model = LinearRegression()
+model.fit(X_train, Y_train)
+
+# Extract intercept and slope coefficients
+intercept = model.intercept_
+coefficients = pd.DataFrame({
+    'Feature': X.columns,
+    'Coefficient (Beta)': model.coef_
+})
+
+print(f"Intercept (Beta_0): ${intercept:,.2f}\n")
+print("Learned Feature Coefficients:")
+print(coefficients.to_string(index=False))
+
+# Step 4: Predictions & Quantitative Performance Evaluation
+# Model Predictions on Test Data
+Y_pred = model.predict(X_test)
+
+# Calculate Evaluation Metrics
+mae = mean_absolute_error(Y_test, Y_pred)
+mse = mean_squared_error(Y_test, Y_pred)
+rmse = np.sqrt(mse)
+r2 = r2_score(Y_test, Y_pred)
+
+# Adjusted R-Squared
+n = len(Y_test)
+p = X_test.shape[1]
+adj_r2 = 1 - (1 - r2) * (n - 1) / (n - p - 1)
+
+print("--- MODEL PERFORMANCE METRICS ---")
+print(f"Mean Absolute Error (MAE)      : ${mae:,.2f}")
+print(f"Mean Squared Error (MSE)        : ${mse:,.2f}")
+print(f"Root Mean Squared Error (RMSE)  : ${rmse:,.2f}")
+print(f"R-squared Score (R²)            : {r2:.4f}")
+print(f"Adjusted R-squared Score       : {adj_r2:.4f}")
+
+# Step 5: Residual Diagnostics & VIF Check
+# Calculate Residuals
+residuals = Y_test - Y_pred
+
+# Calculate Variance Inflation Factor (VIF) for Multicollinearity
+vif_data = pd.DataFrame()
+vif_data["Feature"] = X.columns
+vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]
+
+print("--- VARIANCE INFLATION FACTOR (VIF) ---")
+print(vif_data.to_string(index=False))
+
+# Statsmodels OLS detailed summary
+X_train_sm = sm.add_constant(X_train)
+ols_model = sm.OLS(Y_train, X_train_sm).fit()
+print(ols_model.summary())

mlextend/codes/exp04.txt

@@ -0,0 +1,104 @@
+# Experiment 4: Logistic Regression for Heart Disease Prediction
+# Requirements: pip install pandas matplotlib scikit-learn
+
+# Heart Disease Prediction using Logistic Regression
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score,
+    f1_score, roc_auc_score, confusion_matrix,
+    ConfusionMatrixDisplay, RocCurveDisplay
+)
+
+# 1. Load the dataset
+# Replace the file name with the location of your dataset.
+# CHANGE THIS PATH TO YOUR DATASET
+data = pd.read_csv("heart_disease.csv")
+
+# 2. Select input features and target variable
+features = [
+    "Age",
+    "Resting_Blood_Pressure",
+    "Cholesterol",
+    "Maximum_Heart_Rate",
+    "Exercise_Induced_Angina"
+]
+
+X = data[features]
+y = data["Heart_Disease"]   # 0 = No Heart Disease, 1 = Heart Disease
+
+# 3. Split data into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y,
+    test_size=0.20,
+    random_state=42,
+    stratify=y
+)
+
+# 4. Standardize numerical features
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+# 5. Train Logistic Regression model
+model = LogisticRegression(random_state=42)
+model.fit(X_train_scaled, y_train)
+
+# 6. Predict class labels and probabilities
+y_pred = model.predict(X_test_scaled)
+y_prob = model.predict_proba(X_test_scaled)[:, 1]
+
+# 7. Calculate evaluation metrics
+accuracy = accuracy_score(y_test, y_pred)
+precision = precision_score(y_test, y_pred, zero_division=0)
+recall = recall_score(y_test, y_pred, zero_division=0)
+f1 = f1_score(y_test, y_pred, zero_division=0)
+roc_auc = roc_auc_score(y_test, y_prob)
+
+print("Model Performance")
+print("-----------------")
+print("Accuracy :", round(accuracy, 4))
+print("Precision:", round(precision, 4))
+print("Recall   :", round(recall, 4))
+print("F1-Score :", round(f1, 4))
+print("ROC-AUC  :", round(roc_auc, 4))
+
+# 8. Display confusion matrix
+cm = confusion_matrix(y_test, y_pred)
+print("\nConfusion Matrix:\n", cm)
+
+ConfusionMatrixDisplay(confusion_matrix=cm).plot()
+plt.title("Confusion Matrix - Heart Disease Prediction")
+plt.show()
+
+# 9. Plot ROC curve
+RocCurveDisplay.from_predictions(y_test, y_prob)
+plt.title("ROC Curve - Heart Disease Prediction")
+plt.show()
+
+# 10. Predict for a new patient
+new_patient = pd.DataFrame([{
+    "Age": 55,
+    "Resting_Blood_Pressure": 140,
+    "Cholesterol": 240,
+    "Maximum_Heart_Rate": 150,
+    "Exercise_Induced_Angina": 1
+}])
+
+new_patient_scaled = scaler.transform(new_patient)
+prediction = model.predict(new_patient_scaled)[0]
+probability = model.predict_proba(new_patient_scaled)[0, 1]
+
+print("\nNew Patient Prediction")
+print("----------------------")
+print("Probability of Heart Disease:", round(probability, 4))
+
+if prediction == 1:
+    print("Prediction: Heart Disease Present")
+else:
+    print("Prediction: No Heart Disease")

mlextend/codes/exp05.txt

@@ -0,0 +1,67 @@
+# Experiment 5: K-Nearest Neighbors (KNN) Classifier for Credit Risk Rating
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn
+
+# Import essential libraries
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, roc_auc_score
+
+# 1. Generate Synthetic Dataset for Credit Risk Rating
+np.random.seed(42)
+n_samples = 1000
+
+data = {
+    'Debt_to_Income_Ratio': np.random.uniform(0.1, 0.8, n_samples),
+    'Credit_Score': np.random.randint(300, 850, n_samples),
+    'Annual_Income': np.random.uniform(20000, 150000, n_samples),
+    'Total_Assets': np.random.uniform(5000, 500000, n_samples)
+}
+df = pd.DataFrame(data)
+
+# Generate Multi-class Target Variable: Credit_Risk_Rating (0=Low, 1=Moderate, 2=High)
+risk_score = (df['Debt_to_Income_Ratio'] * 3.0) - (df['Credit_Score'] / 250.0) - (df['Annual_Income'] / 100000.0)
+df['Credit_Risk_Rating'] = pd.qcut(risk_score, q=3, labels=[0, 1, 2]).astype(int)
+
+# 2. Train-Test Split and Feature Scaling
+X = df[['Debt_to_Income_Ratio', 'Credit_Score', 'Annual_Income', 'Total_Assets']]
+y = df['Credit_Risk_Rating']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42, stratify=y)
+
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+# 3. Hyperparameter Tuning: Finding Optimal K
+k_range = range(1, 26)
+cv_scores = []
+
+for k in k_range:
+    knn = KNeighborsClassifier(n_neighbors=k, metric='minkowski', p=2)
+    scores = cross_val_score(knn, X_train_scaled, y_train, cv=5, scoring='accuracy')
+    cv_scores.append(scores.mean())
+
+optimal_k = k_range[np.argmax(cv_scores)]
+print(f'Optimal Neighborhood Parameter (K): {optimal_k}')
+
+# 4. Train Final KNN Model with Optimal K
+knn_optimal = KNeighborsClassifier(n_neighbors=optimal_k, weights='distance')
+knn_optimal.fit(X_train_scaled, y_train)
+
+# 5. Prediction and Evaluation
+y_pred = knn_optimal.predict(X_test_scaled)
+y_probs = knn_optimal.predict_proba(X_test_scaled)
+
+print('\n--- Confusion Matrix ---')
+print(confusion_matrix(y_test, y_pred))
+
+print('\n--- Classification Report ---')
+print(classification_report(y_test, y_pred, target_names=['Low Risk', 'Moderate Risk', 'High Risk']))
+
+auc_score = roc_auc_score(y_test, y_probs, multi_class='ovr')
+print(f'Multi-class ROC-AUC Score (OvR): {auc_score:.4f}')

mlextend/codes/exp06.txt

@@ -0,0 +1,63 @@
+# Experiment 6: Decision Tree Classifier for Multi-Class Credit Risk Assessment
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn
+
+# Import required libraries
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, roc_auc_score
+
+# 1. Generate Synthetic Dataset for Credit Risk Assessment
+np.random.seed(42)
+n_samples = 1000
+
+data = {
+    'Debt_to_Income_Ratio': np.random.uniform(0.1, 0.8, n_samples),
+    'Credit_Score': np.random.randint(300, 850, n_samples),
+    'Annual_Income': np.random.uniform(20000, 150000, n_samples),
+    'Missed_Payments_Count': np.random.randint(0, 10, n_samples)
+}
+df = pd.DataFrame(data)
+
+# Define target: Credit_Risk_Rating (0 = Low Risk, 1 = Moderate Risk, 2 = High Risk)
+risk_index = (df['Debt_to_Income_Ratio'] * 2.5) + (df['Missed_Payments_Count'] * 0.4) - (df['Credit_Score'] / 300.0)
+df['Credit_Risk_Rating'] = pd.qcut(risk_index, q=3, labels=[0, 1, 2]).astype(int)
+
+# 2. Train-Test Split (80:20 Stratified Ratio)
+X = df[['Debt_to_Income_Ratio', 'Credit_Score', 'Annual_Income', 'Missed_Payments_Count']]
+y = df['Credit_Risk_Rating']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42, stratify=y)
+
+# 3. Train Decision Tree Model with Pre-Pruning (Hyperparameter Control)
+dt_model = DecisionTreeClassifier(
+    criterion='gini',
+    max_depth=4,
+    min_samples_split=10,
+    min_samples_leaf=5,
+    random_state=42
+)
+dt_model.fit(X_train, y_train)
+
+# 4. Model Prediction and Performance Evaluation
+y_pred = dt_model.predict(X_test)
+y_probs = dt_model.predict_proba(X_test)
+
+print('--- Confusion Matrix ---')
+print(confusion_matrix(y_test, y_pred))
+
+print('\n--- Classification Report ---')
+print(classification_report(y_test, y_pred, target_names=['Low Risk', 'Moderate Risk', 'High Risk']))
+
+# 5. Feature Importance Analysis
+feature_imp = pd.Series(dt_model.feature_importances_, index=X.columns).sort_values(ascending=False)
+print('\n--- Feature Importances ---')
+print(feature_imp)
+
+# 6. Decision Rules Extraction (Text-based)
+tree_rules = export_text(dt_model, feature_names=list(X.columns))
+print('\n--- Decision Tree Rules ---')
+print(tree_rules[:500])  # Print top rule paths

mlextend/codes/exp07.txt

@@ -0,0 +1,98 @@
+# Experiment 7: K-Means Clustering for Customer Profiling
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn
+
+# ==========================================
+# STEP 1: Import Libraries & Load Dataset
+# ==========================================
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import silhouette_score
+
+# Load Dataset
+# CHANGE THIS PATH TO YOUR DATASET (Mall_Customers.csv)
+df = pd.read_csv('Mall_Customers.csv')
+
+print("--- Dataset Head ---")
+print(df.head())
+print("\n--- Dataset Info ---")
+print(df.info())
+
+# Select relevant numerical features
+X = df[['Annual Income (k$)', 'Spending Score (1-100)']].values
+
+# STEP 2: Feature Scaling
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# STEP 3: Find Optimal K
+wcss = []
+silhouette_scores = []
+K_range = range(2, 11)
+
+for k in K_range:
+    kmeans = KMeans(n_clusters=k, init='k-means++',
+                    random_state=42, n_init=10)
+    kmeans.fit(X_scaled)
+    wcss.append(kmeans.inertia_)
+    silhouette_scores.append(
+        silhouette_score(X_scaled, kmeans.labels_)
+    )
+
+plt.figure(figsize=(12, 5))
+
+plt.subplot(1, 2, 1)
+plt.plot(range(2, 11), wcss, marker='o', color='b')
+plt.title('Elbow Method for Optimal K')
+plt.xlabel('Number of Clusters (K)')
+plt.ylabel('WCSS (Inertia)')
+plt.grid(True)
+
+plt.subplot(1, 2, 2)
+plt.plot(range(2, 11), silhouette_scores, marker='s', color='g')
+plt.title('Silhouette Score Analysis')
+plt.xlabel('Number of Clusters (K)')
+plt.ylabel('Silhouette Score')
+plt.grid(True)
+
+plt.tight_layout()
+plt.show()
+
+# STEP 4: Train K-Means with Optimal K
+optimal_k = 5
+kmeans = KMeans(n_clusters=optimal_k, init='k-means++',
+                random_state=42, n_init=10)
+y_kmeans = kmeans.fit_predict(X_scaled)
+df['Cluster'] = y_kmeans
+
+# STEP 5: Visualize Customer Profiles
+plt.figure(figsize=(9, 6))
+colors = ['red', 'blue', 'green', 'cyan', 'magenta']
+labels = ['Cluster 1', 'Cluster 2', 'Cluster 3', 'Cluster 4', 'Cluster 5']
+
+for i in range(optimal_k):
+    plt.scatter(X_scaled[y_kmeans == i, 0],
+                X_scaled[y_kmeans == i, 1],
+                s=50, c=colors[i], label=labels[i])
+
+plt.scatter(kmeans.cluster_centers_[:, 0],
+            kmeans.cluster_centers_[:, 1],
+            s=200, c='yellow', edgecolors='black',
+            marker='*', label='Centroids')
+
+plt.title('Customer Segments (K-Means Clustering)')
+plt.xlabel('Annual Income (Scaled)')
+plt.ylabel('Spending Score (Scaled)')
+plt.legend()
+plt.grid(True)
+plt.show()
+
+# Display summary metrics per cluster
+profile = df.groupby('Cluster')[
+    ['Annual Income (k$)', 'Spending Score (1-100)', 'Age']
+].mean()
+print(profile)

mlextend/codes/exp08.txt

@@ -0,0 +1,82 @@
+# Experiment 8: Dimensionality Reduction using Principal Component Analysis (PCA)
+# Requirements: pip install numpy pandas matplotlib seaborn scikit-learn
+
+# ==========================================
+# STEP 1: Import Libraries & Load Dataset
+# ==========================================
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.datasets import load_breast_cancer
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+
+# Load High-Dimensional Dataset (Breast Cancer Dataset - 30 features)
+data = load_breast_cancer()
+X = data.data
+y = data.target
+feature_names = data.feature_names
+
+df = pd.DataFrame(X, columns=feature_names)
+print("--- Dataset Shape ---")
+print(df.shape)
+print("\n--- Dataset Head ---")
+print(df.head())
+
+# ==========================================
+# STEP 2: Feature Standardization
+# ==========================================
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# ==========================================
+# STEP 3: Full PCA & Scree Plot Analysis
+# ==========================================
+pca_full = PCA()
+pca_full.fit(X_scaled)
+
+cum_variance = np.cumsum(pca_full.explained_variance_ratio_)
+
+plt.figure(figsize=(12, 5))
+
+plt.subplot(1, 2, 1)
+plt.bar(range(1, len(pca_full.explained_variance_ratio_) + 1),
+        pca_full.explained_variance_ratio_, alpha=0.6, align='center',
+        label='Individual Explained Variance')
+plt.step(range(1, len(cum_variance) + 1), cum_variance, where='mid',
+         color='red', label='Cumulative Explained Variance')
+plt.axhline(y=0.90, color='g', linestyle='--', label='90% Variance Threshold')
+plt.title('Scree Plot & Cumulative Explained Variance')
+plt.xlabel('Principal Component Index')
+plt.ylabel('Explained Variance Ratio')
+plt.legend(loc='best')
+plt.grid(True)
+
+# ==========================================
+# STEP 4: PCA Reduction to 2 Components
+# ==========================================
+pca_2d = PCA(n_components=2)
+X_pca_2d = pca_2d.fit_transform(X_scaled)
+
+print("\n--- Explained Variance Ratio (Top 2 Components) ---")
+print(f"PC1 Variance Ratio: {pca_2d.explained_variance_ratio_[0]:.4f}")
+print(f"PC2 Variance Ratio: {pca_2d.explained_variance_ratio_[1]:.4f}")
+print(f"Total Preserved Variance: {np.sum(pca_2d.explained_variance_ratio_):.4f}")
+
+# STEP 5: Visualize Reduced Data Space
+plt.subplot(1, 2, 2)
+scatter = plt.scatter(X_pca_2d[:, 0], X_pca_2d[:, 1], c=y, cmap='coolwarm', alpha=0.8, edgecolors='k')
+plt.title('2D PCA Projection of Dataset')
+plt.xlabel('Principal Component 1')
+plt.ylabel('Principal Component 2')
+plt.legend(handles=scatter.legend_elements()[0], labels=['Malignant', 'Benign'])
+plt.grid(True)
+
+plt.tight_layout()
+plt.show()
+
+# Display Component Loadings
+df_comp = pd.DataFrame(pca_2d.components_, columns=feature_names, index=['PC1', 'PC2'])
+print("\n--- Component Loadings (Top Features Contribution) ---")
+print(df_comp.iloc[:, :5])

mlextend/codes/exp09.txt

@@ -0,0 +1,87 @@
+# Experiment 9: Apriori Algorithm for Association Rule Mining
+# Requirements: pip install pandas mlxtend
+
+# ==========================================
+# STEP 1: Import Libraries & Create Dataset
+# ==========================================
+import pandas as pd
+from mlxtend.preprocessing import TransactionEncoder
+from mlxtend.frequent_patterns import apriori, association_rules
+
+transactions = [
+    ['Milk', 'Bread', 'Butter'],
+    ['Bread', 'Butter'],
+    ['Milk', 'Bread'],
+    ['Milk', 'Bread', 'Butter', 'Eggs'],
+    ['Bread', 'Eggs'],
+    ['Milk', 'Bread', 'Eggs'],
+    ['Milk', 'Butter'],
+    ['Bread', 'Butter', 'Eggs'],
+    ['Milk', 'Bread', 'Butter'],
+    ['Bread', 'Milk']
+]
+
+# Convert transactions into one-hot encoded format
+te = TransactionEncoder()
+te_array = te.fit(transactions).transform(transactions)
+df = pd.DataFrame(te_array, columns=te.columns_)
+
+print("--- Transaction Dataset ---")
+print(df.astype(int))
+
+# ==========================================
+# STEP 2: Generate Frequent Itemsets
+# ==========================================
+min_support = 0.30
+
+frequent_itemsets = apriori(
+    df,
+    min_support=min_support,
+    use_colnames=True
+)
+
+frequent_itemsets['itemset_size'] = frequent_itemsets[
+    'itemsets'
+].apply(len)
+
+print("\n--- Frequent Itemsets ---")
+print(frequent_itemsets.sort_values(
+    by=['itemset_size', 'support'],
+    ascending=[True, False]
+))
+
+# ==========================================
+# STEP 3: Generate Association Rules
+# ==========================================
+min_confidence = 0.60
+
+rules = association_rules(
+    frequent_itemsets,
+    metric="confidence",
+    min_threshold=min_confidence
+)
+
+rules = rules.sort_values(
+    by=['lift', 'confidence'],
+    ascending=False
+)
+
+print("\n--- Association Rules ---")
+print(rules[
+    ['antecedents', 'consequents',
+     'support', 'confidence', 'lift']
+])
+
+# ==========================================
+# STEP 4: Display Strong Rules
+# ==========================================
+strong_rules = rules[
+    (rules['confidence'] >= min_confidence) &
+    (rules['lift'] > 1)
+]
+
+print("\n--- Strong Positive Association Rules ---")
+print(strong_rules[
+    ['antecedents', 'consequents',
+     'support', 'confidence', 'lift']
+])

mlextend/codes/exp10.txt

@@ -0,0 +1,134 @@
+# Experiment 10: Q-Learning Algorithm for Grid World Environment
+# Requirements: pip install numpy pandas
+
+# ==========================================
+# STEP 1: Import Libraries & Environment Setup
+# ==========================================
+import numpy as np
+import pandas as pd
+
+# Define Grid Dimensions
+GRID_ROWS = 4
+GRID_COLS = 4
+
+# Special States & Rewards
+START = (3, 0)
+GOAL = (0, 3)
+WALL = (1, 1)
+
+REWARD_GOAL = 10.0
+REWARD_WALL = -1.0
+REWARD_DEFAULT = 0.0
+
+# Hyperparameters
+ALPHA = 0.5   # Learning rate
+GAMMA = 0.9   # Discount factor
+EPISODES = 2000
+
+# Actions: 0: Up, 1: Down, 2: Left, 3: Right
+ACTIONS = ['Up', 'Down', 'Left', 'Right']
+ACTION_MOVES = {
+    'Up': (-1, 0),
+    'Down': (1, 0),
+    'Left': (0, -1),
+    'Right': (0, 1)
+}
+
+# ==========================================
+# STEP 2: Environment Step Function
+# ==========================================
+def step(state, action_idx):
+    if state == GOAL:
+        return state, 0, True
+
+    action_name = ACTIONS[action_idx]
+    dr, dc = ACTION_MOVES[action_name]
+    next_r = state[0] + dr
+    next_c = state[1] + dc
+
+    # Check boundary collision
+    if next_r < 0 or next_r >= GRID_ROWS or next_c < 0 or next_c >= GRID_COLS:
+        next_state = state
+    else:
+        next_state = (next_r, next_c)
+
+    # Determine reward and terminal condition
+    if next_state == WALL:
+        # Wall penalty; agent hits wall
+        reward = REWARD_WALL
+        is_terminal = False
+    elif next_state == GOAL:
+        reward = REWARD_GOAL
+        is_terminal = True
+    else:
+        reward = REWARD_DEFAULT
+        is_terminal = False
+
+    return next_state, reward, is_terminal
+
+# ==========================================
+# STEP 3: Q-Learning Algorithm Implementation
+# ==========================================
+def run_q_learning():
+    # Initialize Q-table with zeros: shape (4, 4, 4)
+    q_table = np.zeros((GRID_ROWS, GRID_COLS, len(ACTIONS)))
+
+    for episode in range(EPISODES):
+        state = START
+        is_terminal = False
+
+        while not is_terminal:
+            # Epsilon-greedy action selection
+            epsilon = max(0.1, 1.0 - episode / 1000)
+            if np.random.rand() < epsilon:
+                action_idx = np.random.choice(len(ACTIONS))
+            else:
+                action_idx = np.argmax(q_table[state[0], state[1]])
+
+            next_state, reward, is_terminal = step(state, action_idx)
+
+            # Target Q-value calculation
+            if is_terminal:
+                max_next_q = 0.0
+            else:
+                max_next_q = np.max(q_table[next_state[0], next_state[1]])
+
+            td_target = reward + GAMMA * max_next_q
+            td_error = td_target - q_table[state[0], state[1], action_idx]
+
+            # Q-value update rule
+            q_table[state[0], state[1], action_idx] += ALPHA * td_error
+
+            state = next_state
+
+    return q_table
+
+# Run training
+q_table = run_q_learning()
+
+# ==========================================
+# STEP 4: Formatted Q-Table Display
+# ==========================================
+rows = []
+for r in range(GRID_ROWS):
+    for c in range(GRID_COLS):
+        state = (r, c)
+        if state == GOAL:
+            rows.append({"State (r,c)": f"({r},{c}) [Goal]", "Up": "-", "Down": "-", "Left": "-", "Right": "-", "Optimal Action": "Terminal"})
+        elif state == WALL:
+            rows.append({"State (r,c)": f"({r},{c}) [Wall]", "Up": "-", "Down": "-", "Left": "-", "Right": "-", "Optimal Action": "Obstacle"})
+        else:
+            q_vals = q_table[r, c]
+            best_a = ACTIONS[np.argmax(q_vals)]
+            rows.append({
+                "State (r,c)": f"({r},{c})",
+                "Up": f"{q_vals[0]:.4f}",
+                "Down": f"{q_vals[1]:.4f}",
+                "Left": f"{q_vals[2]:.4f}",
+                "Right": f"{q_vals[3]:.4f}",
+                "Optimal Action": best_a
+            })
+
+df_qtable = pd.DataFrame(rows)
+print("--- CONVERGED Q-TABLE ---")
+print(df_qtable.to_string(index=False))

mlextend-0.1.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.5
+Name: mlextend
+Version: 0.1.0
+Summary: Ready-to-copy source code of 10 machine learning practicals (EDA, regression, KNN, decision tree, K-Means, PCA, Apriori, Q-Learning).
+License-Expression: MIT
+License-File: LICENSE
+Keywords: education,lab,machine learning,practicals,scikit-learn,source code
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# mlextend
+
+Ready-to-copy source code for 10 machine learning practicals.
+
+`mlextend` does **not** run anything. Each experiment only gives you its complete
+Python code as plain text. Copy it into Jupyter Notebook, VS Code or any other
+Python environment and run it there.
+
+## Installation
+
+```bash
+pip install mlextend
+```
+
+The package itself has no dependencies. Each practical lists the libraries it needs
+in its first comment lines, for example:
+
+```bash
+pip install numpy pandas matplotlib seaborn scikit-learn statsmodels mlxtend
+```
+
+## Usage
+
+```python
+import mlextend
+
+mlextend.list_experiments()   # list all experiments
+
+mlextend.exp1.print()         # print the complete code of Experiment 1
+```
+
+Or import single experiments:
+
+```python
+from mlextend import exp3, exp7
+
+exp3.print()
+```
+
+| Call | What it does |
+|---|---|
+| `exp1.print()` | Prints the complete code as plain text, ready to copy |
+| `exp1.code` | Returns the complete code as a Python string |
+| `exp1.show()` | Shows syntax-highlighted code in Jupyter (plain text elsewhere) |
+| `exp1.save("exp1.py")` | Saves the code to a `.py` file (default name: `exp1.py`) |
+
+`save()` will not replace an existing file unless you pass `overwrite=True`:
+
+```python
+mlextend.exp1.save("exp1.py", overwrite=True)
+```
+
+None of these calls execute, import or compile the practical code.
+
+## Using your own dataset
+
+Where a practical reads a file, the line just above it is marked:
+
+```python
+# CHANGE THIS PATH TO YOUR DATASET
+data = pd.read_csv("heart_disease.csv")
+```
+
+Replace the file name with the path to your own CSV, and make sure the column names
+match the ones used in the code. No datasets are bundled with this package.
+
+| Experiment | File needed | Required columns |
+|---|---|---|
+| exp4 | `heart_disease.csv` | `Age, Resting_Blood_Pressure, Cholesterol, Maximum_Heart_Rate, Exercise_Induced_Angina, Heart_Disease` |
+| exp7 | `Mall_Customers.csv` | `Age, Annual Income (k$), Spending Score (1-100)` |
+
+All other experiments generate their own data or use a dataset built into scikit-learn.
+exp1 and exp2 also show where to plug in your own CSV.
+
+## Experiments
+
+| Name | Topic | Libraries |
+|---|---|---|
+| `exp1` | Data Pre-processing and Exploratory Data Analysis (EDA) | numpy, pandas, matplotlib, seaborn, scikit-learn |
+| `exp2` | Simple Linear Regression | numpy, pandas, matplotlib, seaborn, scikit-learn |
+| `exp3` | Multiple Linear Regression (House Price Prediction) | numpy, pandas, matplotlib, seaborn, scikit-learn, statsmodels |
+| `exp4` | Logistic Regression for Heart Disease Prediction | pandas, matplotlib, scikit-learn |
+| `exp5` | K-Nearest Neighbors (KNN) Classifier for Credit Risk Rating | numpy, pandas, matplotlib, seaborn, scikit-learn |
+| `exp6` | Decision Tree Classifier for Multi-Class Credit Risk Assessment | numpy, pandas, matplotlib, seaborn, scikit-learn |
+| `exp7` | K-Means Clustering for Customer Profiling | numpy, pandas, matplotlib, seaborn, scikit-learn |
+| `exp8` | Dimensionality Reduction using PCA | numpy, pandas, matplotlib, seaborn, scikit-learn |
+| `exp9` | Apriori Algorithm for Association Rule Mining | pandas, mlxtend |
+| `exp10` | Q-Learning Algorithm for Grid World Environment | numpy, pandas |
+
+## License
+
+MIT

mlextend-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mlextend/__init__.py,sha256=sCfVf8NtVXKc2Ym-XJJV9qzEgrvcheQIZBaUyy_zEe8,1663
+mlextend/_experiment.py,sha256=Q1Y3wlBpxSE1NE4uBpoCSNjBZJgJ1kuJ8rvXKfK7SUE,2464
+mlextend/codes/exp01.txt,sha256=I6INK3Mql-bOvsrsG9MMm6wPG5JtYss3EutEifbtj0A,3845
+mlextend/codes/exp02.txt,sha256=tf1jDOTVxcQA16xJEry9LWUyjKU7DMZwdIU_zK_BQ5o,3187
+mlextend/codes/exp03.txt,sha256=uAItQ9NIo1Aq6I2rCOSEdARDF1oCmEpcupUjghz1H8A,3700
+mlextend/codes/exp04.txt,sha256=iEYZU-zlip7ysx0VfRJa-zG6prydAg5IJKSOGIhgmrw,3050
+mlextend/codes/exp05.txt,sha256=a43OqILiMQrFc5h0aRFpu_vECPuFg6PiIQ9x9TDoB5g,2612
+mlextend/codes/exp06.txt,sha256=1_didZMLmHsOG2Jx568gzQhXa3x3TQnmR_CULDR1pBM,2450
+mlextend/codes/exp07.txt,sha256=P3wFIkflfum8t-QJTlKVRkYCBr_VQB3xC0yVnAcuL2U,2780
+mlextend/codes/exp08.txt,sha256=hL3pb7i3b1WNDarl3aYmdHDC81Qp2focmYNMYHyDf1Q,2964
+mlextend/codes/exp09.txt,sha256=kjRRITb9AeRFTGpv1kIkXR3x5g_qOAH0uKqt0Eozyl8,2228
+mlextend/codes/exp10.txt,sha256=vdldFThC7h55ZOOCiB-OLrQHnKPP-jhz_LlB50IrSTM,3989
+mlextend-0.1.0.dist-info/METADATA,sha256=bVRUjhngoorfJ5kO0xtucZLDNFmX-HQrwBeDtGgLi-A,3868
+mlextend-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+mlextend-0.1.0.dist-info/licenses/LICENSE,sha256=eliHYRuSwg2O43tpLudXWMp93YF3SbH_NKQcKNm8w14,1082
+mlextend-0.1.0.dist-info/RECORD,,

mlextend-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mlextend-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The mlextend contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.