scikit-lab-kit 0.1.0__tar.gz → 0.1.1__tar.gz

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-lab-kit
-Version: 0.1.0
+Version: 0.1.1
 Summary: Numbered DAML (scikit-learn) practicals: steps, code and short explanation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scikit-lab-kit"
-version = "0.1.0"
+version = "0.1.1"
 description = "Numbered DAML (scikit-learn) practicals: steps, code and short explanation"
 readme = "README.md"
 requires-python = ">=3.9"

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/01_data_cleaning_missing_values.txt

@@ -40,7 +40,6 @@ if 'Marks' in df.columns:
 print("\nDataFrame After Filling Missing Values:")
 print(df)
 if 'Marks' in df.columns and not df['Marks'].isna().all():
-    # Min-Max Scaling
     scaler = MinMaxScaler()
     df['Marks_MINMAX'] = scaler.fit_transform(df[['Marks']])
     zscaler = StandardScaler()

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/03_data_cleaning_on_dataset.txt

@@ -18,10 +18,9 @@ df=pd.read_csv('/content/sample_data/loan_credit_dataset_240_rows_with_outliers.
 print(df.head())
 print(df.info())
 print(df.describe())
-print(df.isnull().sum()) #missing value
-print("Duplicate rows:",df.duplicated().sum()) #duplicate values
+print(df.isnull().sum())
+print("Duplicate rows:",df.duplicated().sum())
 print(df.dtypes)
-#finding outliers in data
 print("Before removing outliers:")
 columns = [
     "AnnualIncome",

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/05_eda.txt

@@ -43,7 +43,6 @@ venue_wins = (
       .size()
       .reset_index(name='Wins')
 )
-# Select top 10 venues by number of matches
 top_venues = df['Venue_Name'].value_counts().head(10).index
 venue_wins = venue_wins[venue_wins['Venue_Name'].isin(top_venues)]
 plt.figure(figsize=(14,7))
@@ -78,9 +77,7 @@ team_id_name_pairs = pd.concat([
     df[['Match_Winner_Id', 'OpponentTeam name']].rename(columns={'Match_Winner_Id': 'Team_ID', 'OpponentTeam name': 'Team_Name'})
 ]).drop_duplicates().dropna(subset=['Team_ID', 'Team_Name'])
 team_map = team_id_name_pairs.groupby('Team_ID')['Team_Name'].first()
-# Add winner name column
 df['Match_Winner_Id'] = df['Match_Winner_Id'].map(team_map)
-# Home wins
 home_wins = df[df['OpponentTeam name'] == df['Match_Winner_Id']]
 home_win_counts = home_wins['OpponentTeam name'].value_counts()
 plt.figure(figsize=(8,8))
@@ -98,21 +95,17 @@ venue_wins = (
       .size()
       .reset_index(name='Wins')
 )
-# Top 10 venues
 top_venues = df['Venue_Name'].value_counts().head(10).index
 venue_wins = venue_wins[venue_wins['Venue_Name'].isin(top_venues)]
-# Convert venue names to numeric positions
 venue_positions = {venue: i for i, venue in enumerate(top_venues)}
 venue_wins['Venue_Pos'] = venue_wins['Venue_Name'].map(venue_positions)
-# Convert 'Match_Winner_Id' (team names) to numerical categories for plotting
 venue_wins['Team_Numeric_ID'], unique_teams = pd.factorize(venue_wins['Match_Winner_Id'])
-# Scatter Plot
 plt.figure(figsize=(14,7))
 scatter = plt.scatter(
     venue_wins['Venue_Pos'],
     venue_wins['Wins'],
     s=120,
-    c=venue_wins['Team_Numeric_ID'], # Use numerical IDs for coloring
+    c=venue_wins['Team_Numeric_ID'],
     cmap='tab20',
     alpha=0.8
 )
@@ -125,7 +118,6 @@ plt.xticks(
 plt.xlabel('Venue')
 plt.ylabel('Number of Wins')
 plt.title('Venue-wise Wins by Teams (Scatter Plot)')
-# Create a custom colorbar to show team names
 cbar = plt.colorbar(scatter, ticks=range(len(unique_teams)))
 cbar.set_ticklabels(unique_teams)
 cbar.set_label('Match Winner Team')
@@ -184,9 +176,7 @@ team_id_name_pairs = pd.concat([
     df[['Match_Winner_Id', 'OpponentTeam name']].rename(columns={'Match_Winner_Id': 'Team_ID', 'OpponentTeam name': 'Team_Name'})
 ]).drop_duplicates().dropna(subset=['Team_ID', 'Team_Name'])
 team_map = team_id_name_pairs.groupby('Team_ID')['Team_Name'].first()
-# Map winner IDs to team names
 df['Match_Winner_Name'] = df['Match_Winner_Id'].map(team_map)
-# Home wins
 home_wins = df[df['OpponentTeam name'] == df['Match_Winner_Name']]
 home_win_counts = home_wins['OpponentTeam name'].value_counts()
 plt.figure(figsize=(9,9))
@@ -213,14 +203,13 @@ plt.show()
 df['Venue_Code'] = df['Venue_Name'].astype('category').cat.codes
 df['Toss_Code'] = df['Toss_Decision'].astype('category').cat.codes
 df['WinType_Code'] = df['Win_Type'].astype('category').cat.codes
-# Create 3D Scatter Plot
 fig = plt.figure(figsize=(12,8))
 ax = fig.add_subplot(111, projection='3d')
 scatter = ax.scatter(
     df['Venue_Code'],
     df['Toss_Code'],
     df['WinType_Code'],
-    c=df['WinType_Code'],      # Color by Win Type
+    c=df['WinType_Code'],
     cmap='viridis',
     s=40,
     alpha=0.7
@@ -229,11 +218,9 @@ ax.set_title('3D Scatter Plot of Venue, Toss Decision and Win Type')
 ax.set_xlabel('Venue')
 ax.set_ylabel('Toss Decision')
 ax.set_zlabel('Win Type')
-# Show original category names on axes
 venue_labels = df['Venue_Name'].astype('category').cat.categories
 toss_labels = df['Toss_Decision'].astype('category').cat.categories
 win_labels = df['Win_Type'].astype('category').cat.categories
-# Limit x-axis labels to avoid clutter (top 10 venues)
 ax.set_xticks(range(min(10, len(venue_labels))))
 ax.set_xticklabels(venue_labels[:10], rotation=45, ha='right')
 ax.set_yticks(range(len(toss_labels)))

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/06_decision_tree.txt

@@ -19,19 +19,14 @@ import matplotlib.pyplot as plt
 import numpy as np
 filepath = "C:/Users/Admin/Downloads/diabetes.csv"
 data = pd.read_csv(filepath)
-# Binarize the outcome
 data['Outcome'] = data['Outcome'].apply(lambda x: 1 if x >= 0.5 else 0)
 X = data.drop(columns=['Outcome'])
 y = data['Outcome']
-# Split the dataset
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-# Initialize and train the model
 clf = DecisionTreeClassifier(random_state=42)
 clf.fit(X_train, y_train)
-# Get predictions and probabilities
 y_pred = clf.predict(X_test)
 y_pred_prob = clf.predict_proba(X_test)[:, 1]
-# Calculate metrics
 accuracy = accuracy_score(y_test, y_pred)
 conf_matrix = confusion_matrix(y_test, y_pred)
 precision = precision_score(y_test, y_pred)
@@ -40,10 +35,8 @@ TN = conf_matrix[0, 0]
 FP = conf_matrix[0, 1]
 specificity = TN / (TN + FP)
 standard_error = np.sqrt((accuracy * (1 - accuracy)) / len(y_test))
-# ROC and AUC
 fpr, tpr, _ = roc_curve(y_test, y_pred_prob)
 roc_auc = auc(fpr, tpr)
-# Plot ROC Curve
 plt.figure()
 plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
 plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
@@ -52,12 +45,10 @@ plt.ylabel('True Positive Rate')
 plt.title('Receiver Operating Characteristic')
 plt.legend(loc="lower right")
 plt.show()
-# Plot Decision Tree
 plt.figure(figsize=(12, 8))
 plot_tree(clf, feature_names=X.columns, class_names=['0', '1'], filled=True, max_depth=3)
 plt.title("Decision Tree (Max Depth = 3)")
 plt.show()
-# Print Results
 print("Predictions:", y_pred)
 print("Accuracy:", accuracy)
 print("Confusion Matrix:\n", conf_matrix)

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/07_compare_classification_models.txt

@@ -76,20 +76,15 @@ import matplotlib.pyplot as plt
 import numpy as np
 filepath = "C:/Users/Admin/Downloads/pulsar_stars.csv"
 data = pd.read_csv(filepath)
-# Binarize the target_class
 data['target_class'] = data['target_class'].apply(lambda x: 1 if x >= 0.5 else 0)
 X = data.drop(columns=['target_class'])
 y = data['target_class']
-# Split the dataset
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
 random_state=42)
-# Initialize and train the model
 clf = DecisionTreeClassifier(random_state=42)
 clf.fit(X_train, y_train)
-# Get predictions and probabilities
 y_pred = clf.predict(X_test)
 y_pred_prob = clf.predict_proba(X_test)[:, 1]
-# Calculate metrics
 accuracy = accuracy_score(y_test, y_pred)
 conf_matrix = confusion_matrix(y_test, y_pred)
 precision = precision_score(y_test, y_pred)
@@ -98,10 +93,8 @@ TN = conf_matrix[0, 0]
 FP = conf_matrix[0, 1]
 specificity = TN / (TN + FP)
 standard_error = np.sqrt((accuracy * (1 - accuracy)) / len(y_test))
-# ROC and AUC
 fpr, tpr, _ = roc_curve(y_test, y_pred_prob)
 roc_auc = auc(fpr, tpr)
-# Plot ROC Curve
 plt.figure()
 plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)'% roc_auc)
 plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
@@ -110,13 +103,11 @@ plt.ylabel('True Positive Rate')
 plt.title('Receiver Operating Characteristic')
 plt.legend(loc="lower right")
 plt.show()
-# Plot Decision Tree
 plt.figure(figsize=(12, 8))
 plot_tree(clf, feature_names=X.columns, class_names=['0', '1'], filled=True,
 max_depth=3)
 plt.title("Decision Tree (Max Depth = 3)")
 plt.show()
-# Print Results
 print("Predictions:", y_pred)
 print("Accuracy:", accuracy)
 print("Confusion Matrix:\n", conf_matrix)
@@ -137,7 +128,6 @@ EXPLANATION:
 3. NAIVE BAYES
 
 CODE:
-#Naive Bayes
 import pandas as pd
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
@@ -152,41 +142,28 @@ from sklearn.metrics import (
 )
 import matplotlib.pyplot as plt
 import numpy as np
-# Load the dataset
 file_path = "C:/Users/Admin/Downloads/pulsar_stars.csv"
 data = pd.read_csv(file_path)
-# Convert target_class to binary if it has continuous values
 data['target_class'] = data['target_class'].apply(lambda x: 1 if x >= 0.5 else 0)
-# Define features and target variable
 X = data.drop(columns=['target_class'])
 y = data['target_class']
-# Standardize the features
 scaler = StandardScaler()
 X_scaled = scaler.fit_transform(X)
-# Split the dataset (20% for test and 80% for train)
 X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
-# Create a Naive Bayes Classifier
 nb_model = GaussianNB()
-# Train the model
 nb_model.fit(X_train, y_train)
-# Make predictions
 y_pred = nb_model.predict(X_test)
 y_pred_prob = nb_model.predict_proba(X_test)[:, 1]
-# Calculate metrics
 accuracy = accuracy_score(y_test, y_pred)
 conf_matrix = confusion_matrix(y_test, y_pred)
 precision = precision_score(y_test, y_pred)
 sensitivity = recall_score(y_test, y_pred)
-# Specificity calculation
 TN = conf_matrix[0, 0]
 FP = conf_matrix[0, 1]
 specificity = TN / (TN + FP)
-# Standard error
 standard_error = np.sqrt((accuracy * (1 - accuracy)) / len(y_test))
-# Calculate ROC curve and AUC
 fpr, tpr, _ = roc_curve(y_test, y_pred_prob)
 roc_auc = auc(fpr, tpr)
-# Plot ROC curve
 plt.figure()
 plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
 plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
@@ -195,7 +172,6 @@ plt.ylabel('True Positive Rate')
 plt.title('Receiver Operating Characteristic - Naive Bayes')
 plt.legend(loc="lower right")
 plt.show()
-# Print results
 print("Predictions:", y_pred)
 print("Accuracy:", accuracy)
 print("Confusion Matrix:\n", conf_matrix)
@@ -224,28 +200,20 @@ from sklearn.linear_model import LogisticRegression
 from sklearn.metrics import accuracy_score
 import matplotlib.pyplot as plt
 import numpy as np
-# Load the dataset
 file_path = "C:/Users/Admin/Downloads/pulsar_stars.csv"
 data = pd.read_csv(file_path)
-# Convert target_class to binary if it has continuous values
 data['target_class'] = data['target_class'].apply(lambda x: 1 if x >= 0.5 else 0)
-# Define features and target variable
 X = data.drop(columns=['target_class'])
 y = data['target_class']
-# Standardize the features
 scaler = StandardScaler()
 X_scaled = scaler.fit_transform(X)
-# Apply PCA to reduce dimensionality
 n_components = 7
 pca = PCA(n_components=n_components)
 X_pca = pca.fit_transform(X_scaled)
-# Explained variance ratio for PCA
 explained_variance_ratio = pca.explained_variance_ratio_
 total_variance_explained = np.sum(explained_variance_ratio)
-# Print PCA results
 print("Explained Variance Ratio:", explained_variance_ratio)
 print("Total Variance Explained:", total_variance_explained)
-# Visualize the explained variance ratio
 plt.figure(figsize=(8, 5))
 plt.bar(range(1, n_components + 1), explained_variance_ratio, alpha=0.7, align='center', label='Individual Explained Variance')
 plt.step(range(1, n_components + 1), np.cumsum(explained_variance_ratio), where='mid', label='Cumulative Explained Variance')
@@ -254,16 +222,11 @@ plt.ylabel('Explained Variance Ratio')
 plt.title('PCA Explained Variance')
 plt.legend(loc='best')
 plt.show()
-# Split the dataset using PCA features
 X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)
-# Train a Logistic Regression model
 model = LogisticRegression()
 model.fit(X_train, y_train)
-# Make predictions
 y_pred = model.predict(X_test)
-# Calculate accuracy
 accuracy = accuracy_score(y_test, y_pred)
-# Print accuracy
 print("Accuracy:", accuracy)
 
 EXPLANATION:
@@ -301,14 +264,11 @@ svm_model = SVC(
     random_state=42
 )
 svm_model.fit(X_train_scaled, y_train)
-# Make Predictions
 y_pred = svm_model.predict(X_test_scaled)
 y_prob = svm_model.predict_proba(X_test_scaled)[:, 1]
-# Evaluate the Model
 print("--- Confusion Matrix ---")
 print(confusion_matrix(y_test, y_pred))
 print("\n--- Classification Report ---")
-# Focus heavily on Precision and Recall for Class 1 (Pulsars)
 print(classification_report(y_test, y_pred))
 print(f"ROC-AUC Score: {roc_auc_score(y_test, y_prob):.4f}")
 
@@ -333,16 +293,12 @@ df = pd.read_csv('C:/Users/Admin/Downloads/pulsar_stars.csv')
 df.columns = df.columns.str.strip()
 X = df.drop(columns=['target_class'])
 y = df['target_class']
-# Split into training and testing sets (Stratified to maintain class balance)
 X_train, X_test, y_train, y_test = train_test_split(
     X, y, test_size=0.3, random_state=42, stratify=y
 )
-# Feature Scaling
 scaler = StandardScaler()
 X_train_scaled = scaler.fit_transform(X_train)
 X_test_scaled = scaler.transform(X_test)
-# Initialize and Train Random Forest
-# class_weight='balanced' penalizes mistakes on the rare pulsar class heavily.
 rf_model = RandomForestClassifier(
     n_estimators=100,
     class_weight='balanced',
@@ -350,16 +306,13 @@ rf_model = RandomForestClassifier(
     n_jobs=-1
 )
 rf_model.fit(X_train_scaled, y_train)
-# Make Predictions
 y_pred = rf_model.predict(X_test_scaled)
-y_prob = rf_model.predict_proba(X_test_scaled)[:, 1] # Probability estimates for ROC-AUC
-# Evaluate the Model
+y_prob = rf_model.predict_proba(X_test_scaled)[:, 1]
 print("--- Confusion Matrix ---")
 print(confusion_matrix(y_test, y_pred))
 print("\n--- Classification Report ---")
 print(classification_report(y_test, y_pred))
 print(f"ROC-AUC Score: {roc_auc_score(y_test, y_prob):.4f}")
-# Feature Importance
 importances = pd.Series(rf_model.feature_importances_, index=X.columns)
 print("\n--- Feature Importances ---")
 print(importances.sort_values(ascending=False))

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/08_classification_improvement.txt

@@ -48,42 +48,31 @@ def main():
             df[col] = pd.to_numeric(df[col], errors='coerce')
             df[col] = df[col].fillna(df[col].median())
             feature_cols.append(col)
-    # Encode categorical features if available (e.g., 'brand')
     if 'brand' in df.columns:
         df = pd.get_dummies(df, columns=['brand'], drop_first=True)
-        # Add encoded brand columns to features list
         brand_cols = [c for c in df.columns if c.startswith('brand_')]
         feature_cols.extend(brand_cols)
-    # Target Encoding (Convert categorical classes to numeric labels)
     label_enc = LabelEncoder()
     y = label_enc.fit_transform(df[target_col].astype(str))
-    # Feature matrix (Ensure strictly numeric data types)
     X = df[feature_cols].select_dtypes(include=[np.number])
-    # Exploratory Data Analysis - Heatmap
     plt.figure(figsize=(12, 8))
     sns.heatmap(X.corr(numeric_only=True), annot=False, cmap='coolwarm')
     plt.title("EV Features Correlation Heatmap")
     plt.tight_layout()
     plt.show()
-    # Scaling
     standard_scaler = StandardScaler()
     minmax_scaler = MinMaxScaler()
     X_std = standard_scaler.fit_transform(X)
     X_mm = minmax_scaler.fit_transform(X)
-    # Train / Test Split
     X_train_std, X_test_std, y_train, y_test = train_test_split(
         X_std, y, test_size=0.2, random_state=69, stratify=y
     )
-    # Evaluation Function
     def evaluate_model(y_true, y_pred, y_prob):
         acc = accuracy_score(y_true, y_pred)
         cm = confusion_matrix(y_true, y_pred)
-        # Weighted precision and recall for multiclass/binary
         prec = precision_score(y_true, y_pred, average='weighted', zero_division=0)
         sens = recall_score(y_true, y_pred, average='weighted', zero_division=0)
-        # Standard Error of Accuracy
         se = np.sqrt((acc * (1 - acc)) / len(y_true))
-        # Multiclass/binary AUC calculation
         try:
             n_classes = len(np.unique(y_true))
             if n_classes == 2:
@@ -100,7 +89,6 @@ def main():
             'AUC': model_auc,
             'Confusion Matrix': cm
         }
-    # Model Initialization
     dt_bag = BaggingClassifier(
         estimator=DecisionTreeClassifier(random_state=69),
         n_estimators=50,
@@ -117,27 +105,22 @@ def main():
         n_estimators=50,
         random_state=69
     )
-    # Train Models
     dt_bag.fit(X_train_std, y_train)
     nb_bag.fit(X_train_std, y_train)
     log_reg.fit(X_train_std, y_train)
     dt_ada.fit(X_train_std, y_train)
-    # Predictions
     pred_dt_bag = dt_bag.predict(X_test_std)
     pred_nb_bag = nb_bag.predict(X_test_std)
     pred_log_reg = log_reg.predict(X_test_std)
     pred_dt_ada = dt_ada.predict(X_test_std)
-    # Results Compilation
     results = {
         'Bagging DT': evaluate_model(y_test, pred_dt_bag, dt_bag.predict_proba(X_test_std)),
         'Bagging NB': evaluate_model(y_test, pred_nb_bag, nb_bag.predict_proba(X_test_std)),
         'Logistic Regression': evaluate_model(y_test, pred_log_reg, log_reg.predict_proba(X_test_std)),
         'AdaBoost DT': evaluate_model(y_test, pred_dt_ada, dt_ada.predict_proba(X_test_std))
     }
-    # Cross-Validation Score
     cv = KFold(n_splits=5, shuffle=True, random_state=69)
     dt_cv_std = np.mean(cross_val_score(dt_bag, X_std, y, cv=cv, scoring='accuracy'))
-    # Print Summary Table
     summary_df = pd.DataFrame(results).T.drop(columns=['Confusion Matrix'])
     print("\n" + "="*65)
     print("      EV DATASET MODEL EVALUATION SUMMARY (STANDARDIZED)")
@@ -146,7 +129,6 @@ def main():
     print("-" * 65)
     print(f"Bagging DT 5-Fold Cross-Validation Accuracy: {dt_cv_std:.4f}")
     print("="*65 + "\n")
-    # Display Confusion Matrices with Class Names
     print("--- Detailed Confusion Matrices ---")
     for name, res in results.items():
         print(f"\n{name} Confusion Matrix:")

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/09_clustering.txt

@@ -22,14 +22,12 @@ from sklearn.datasets import load_wine
 from sklearn.decomposition import PCA
 from sklearn.metrics import silhouette_score
 from sklearn.preprocessing import StandardScaler
-# 1. Load the Wine Dataset
 wine = load_wine()
 wine_df = pd.DataFrame(data=wine.data, columns=wine.feature_names)
 print("Data Summary:")
 print(wine_df.describe())
 scaler = StandardScaler()
 X_scaled = scaler.fit_transform(wine_df)
-# 3. Elbow Method to Find Optimal K
 wss = []
 for k in range(1, 11):
     kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
@@ -41,15 +39,12 @@ plt.xlabel("Number of clusters k")
 plt.ylabel("Total within-cluster sum of squares (Inertia)")
 plt.title("Elbow Method for Optimal K")
 plt.show()
-# 4. K-Means Clustering (Using k=3 since Wine has 3 natural classes)
 kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
 wine_df["kmeans_cluster"] = kmeans.fit_predict(X_scaled)
-# Calculate Silhouette Score for K-Means
 silhouette_avg_kmeans = silhouette_score(X_scaled, wine_df["kmeans_cluster"])
 print(
     f"\nMean Silhouette Width for K-Means Clustering: {silhouette_avg_kmeans:.4f}"
 )
-# 5. Visualize K-Means with PCA (2D Projection)
 pca = PCA(n_components=2)
 X_pca = pca.fit_transform(X_scaled)
 plt.figure(figsize=(8, 5))
@@ -60,7 +55,6 @@ plt.title("K-Means Clustering (PCA Reduced)")
 plt.xlabel("Principal Component 1")
 plt.ylabel("Principal Component 2")
 plt.show()
-# 6. Hierarchical Clustering - Dendrogram
 linkage_matrix = linkage(X_scaled, method="ward")
 plt.figure(figsize=(10, 5))
 dendrogram(linkage_matrix)
@@ -68,17 +62,14 @@ plt.title("Hierarchical Clustering Dendrogram")
 plt.xlabel("Sample Index")
 plt.ylabel("Distance")
 plt.show()
-# 7. Agglomerative Clustering
 agglomerative = AgglomerativeClustering(n_clusters=3)
 wine_df["hierarchical_cluster"] = agglomerative.fit_predict(X_scaled)
-# Calculate Silhouette Score for Hierarchical Clustering
 silhouette_avg_hierarchical = silhouette_score(
     X_scaled, wine_df["hierarchical_cluster"]
 )
 print(
     f"Mean Silhouette Width for Hierarchical Clustering: {silhouette_avg_hierarchical:.4f}"
 )
-# 8. Visualize Hierarchical Clusters (e.g., Alcohol vs. Malic Acid)
 plt.figure(figsize=(8, 5))
 plt.scatter(
     wine_df["alcohol"],

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab/practicals/11_association_apriori_own_dataset.txt

@@ -56,7 +56,6 @@ df = pd.DataFrame(te_ary, columns=te.columns_)
 print("Encoded Dataset Shape:", df.shape)
 frequent_itemsets = apriori(df, min_support=0.05, use_colnames=True)
 print(f"Total Frequent Itemsets Generated: {len(frequent_itemsets)}")
-# Plot Top Itemsets
 plt.figure(figsize=(12, 6))
 top_itemsets = frequent_itemsets.nlargest(n=15, columns="support").copy()
 top_itemsets["itemsets_str"] = top_itemsets["itemsets"].apply(
@@ -74,12 +73,10 @@ plt.xticks(rotation=45, ha="right")
 plt.title("Top 15 Itemsets by Support")
 plt.tight_layout()
 plt.show()
-# Generate and Filter Association Rules
 rules = association_rules(frequent_itemsets, metric="lift", min_threshold=1.0)
 if not rules.empty:
     rules["antecedent_len"] = rules["antecedents"].apply(len)
     rules["consequent_len"] = rules["consequents"].apply(len)
-    # Convert frozensets to readable strings for display
     display_rules = rules.copy()
     display_rules["antecedents"] = display_rules["antecedents"].apply(
         lambda x: list(x)

{scikit_lab_kit-0.1.0 → scikit_lab_kit-0.1.1}/scikit_lab_kit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-lab-kit
-Version: 0.1.0
+Version: 0.1.1
 Summary: Numbered DAML (scikit-learn) practicals: steps, code and short explanation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown