sckitlearn 1.0.0__py3-none-any.whl

sckitlearn/PR1.py

@@ -0,0 +1,40 @@
+import random
+
+temp = round(random.uniform(20,40),1)
+motion = input("Motion detected (yes/no: )").lower()
+dark = input("Is it dark (yes/no)").lower()
+smoke = input("Smoke detected (yess/no)").lower()
+occupancy = input("House occupied(yes/no)").lower()
+
+if temp > 30:
+    ac="ON"
+else:
+    ac="OF"
+
+if motion == "yes" and dark == "yes":
+    light = "ON"
+else:
+    light = "OF"
+
+if smoke == "Yes":
+    alarm = "ON"
+else:
+    alarm = "OF"
+
+if occupancy == "no":
+    door = "Locked"
+else:
+    door = "Unlocked"
+
+print("\n Smart Home report")
+print("Temp:" , temp)
+print("Motion:", motion)
+print("Dark:", dark)
+print("Smoke:", smoke)
+print("Occupancy:", occupancy)
+
+print("\n--- ACTIONS ---")
+print("AC:", ac)
+print("Lights:", light)
+print("Alarm:", alarm)
+print("Door:", door)

sckitlearn/PR10.py

@@ -0,0 +1,47 @@
+import matplotlib.pyplot as plt
+
+from sklearn.datasets import load_breast_cancer
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score
+
+data = load_breast_cancer()
+X = data.data
+y = data.target
+
+sc = StandardScaler()
+X = sc.fit_transform(X)
+
+pca = PCA(n_components=2)
+X_pca = pca.fit_transform(X)
+
+print("Before PCA:", X.shape)
+print("After PCA:", X_pca.shape)
+
+plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y)
+plt.xlabel("PC1")
+plt.ylabel("PC2")
+plt.title("PCA Visualization")
+plt.show()
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+model = LogisticRegression(max_iter=5000)
+model.fit(X_train, y_train)
+pred = model.predict(X_test)
+
+print("Accuracy before PCA:", accuracy_score(y_test, pred))
+
+# PCA data
+Xp_train, Xp_test, yp_train, yp_test = train_test_split(
+    X_pca, y, test_size=0.2, random_state=42
+)
+
+model.fit(Xp_train, yp_train)
+pred_pca = model.predict(Xp_test)
+
+print("Accuracy after PCA:", accuracy_score(yp_test, pred_pca))

sckitlearn/PR11.py

@@ -0,0 +1,56 @@
+# PR11: Advanced ML and Model Optimization
+
+import pandas as pd
+from sklearn.datasets import load_breast_cancer
+from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
+from sklearn.svm import SVC
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
+from sklearn.metrics import accuracy_score
+
+# Load dataset
+data = load_breast_cancer()
+X = data.data
+y = data.target
+
+# Split data
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Models
+models = {
+    "SVM": SVC(),
+    "Random Forest": RandomForestClassifier(random_state=42),
+    "AdaBoost": AdaBoostClassifier(random_state=42)
+}
+
+# Compare before optimization
+for name, model in models.items():
+
+    model.fit(X_train, y_train)
+    pred = model.predict(X_test)
+
+    cv = cross_val_score(model, X_train, y_train, cv=5)
+
+    print("\n", name)
+    print("Before Optimization:", accuracy_score(y_test, pred))
+    print("Cross Validation:", cv.mean())
+
+# Hyperparameter tuning
+params = {
+    "SVM": {"C": [0.1, 1, 10]},
+    "Random Forest": {"n_estimators": [50, 100]},
+    "AdaBoost": {"n_estimators": [50, 100]}
+}
+
+# Grid Search and comparison
+for name, model in models.items():
+
+    grid = GridSearchCV(model, params[name], cv=5)
+    grid.fit(X_train, y_train)
+
+    pred = grid.predict(X_test)
+
+    print("\n", name)
+    print("Best Parameters:", grid.best_params_)
+    print("After Optimization:", accuracy_score(y_test, pred))

sckitlearn/PR2.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+from collections import deque
+
+
+# ----------------------------------------------------
+# MAZE
+# 0 = Path
+# 1 = Obstacle
+# * = Start
+# # = End
+# ----------------------------------------------------
+
+maze = [
+   ["*" , "0","1","0"],
+   ["1" , "0" ,"1" ,"0"],
+   ["0" , "0" , "0" , "0"],
+   ["1" , "1" , "0" , "#"]
+]
+
+
+# ----------------------------------------------------
+# HARD-CODED START AND END POSITIONS
+# ----------------------------------------------------
+
+start = (0, 0)
+end = (3, 3)
+
+rows = len(maze)
+cols = len(maze[0])
+
+
+# ----------------------------------------------------
+# VISITED ARRAY
+# ----------------------------------------------------
+
+visited = [[False for _ in range(cols)] for _ in range(rows)]           
+
+
+# ----------------------------------------------------
+# PARENT ARRAY
+#
+# parent[row][col] stores the previous cell from
+# which we reached the current cell.
+# ----------------------------------------------------
+
+parent = [[None for _ in range(cols)] for _ in range(rows)]                
+# ----------------------------------------------------
+# DIRECTIONS
+#
+# Up    = (-1,From (0,0):
+# Down  = (1, 0)
+# Left  = (0, -1)
+# Right = (0, 1)
+# ----------------------------------------------------
+
+directions = [
+    (-1, 0),
+    (1, 0),
+    (0, -1),
+    (0, 1)
+]
+
+
+# ----------------------------------------------------
+# BFS QUEUE
+# ----------------------------------------------------
+
+queue = deque()
+
+queue.append(start)
+visited[start[0]][start[1]] = True
+
+found = False
+
+
+# ----------------------------------------------------
+# BFS ALGORITHM
+# ----------------------------------------------------
+
+while queue:
+
+    current_row, current_col = queue.popleft()
+
+    # If we reached the destination
+    if (current_row, current_col) == end:
+        found = True
+        break
+
+    # Check all four directions
+    for dr, dc in directions:
+
+        new_row = current_row + dr
+        new_col = current_col + dc
+
+        # Check whether the new position is inside the maze
+        if (0 <= new_row < rows and
+                0 <= new_col < cols):
+
+            # Check whether:
+            # 1. The cell has not been visited
+            # 2. The cell is not an obstacle
+            if (not visited[new_row][new_col] and
+                    maze[new_row][new_col] != '1'):
+
+                # Mark as visited
+                visited[new_row][new_col] = True
+
+                # Store the previous cell
+                parent[new_row][new_col] = (
+                    current_row,
+                    current_col
+                )
+
+                # Add the cell to the queue
+                queue.append((new_row, new_col))
+
+
+# ----------------------------------------------------
+# CHECK WHETHER A PATH EXISTS
+# ----------------------------------------------------
+
+if not found:
+
+    print("No path exists from Start (*) to End (#).")
+
+else:
+
+    # ------------------------------------------------
+    # RECONSTRUCT THE SHORTEST PATH
+    # ------------------------------------------------
+
+    current = end
+
+    while current != start:
+
+        row, col = current
+
+        # Mark shortest path
+        maze[row][col] = '.'
+
+        # Move to the previous cell
+        current = parent[row][col]
+
+
+    # Keep start and end symbols
+    maze[start[0]][start[1]] = '*'
+    maze[end[0]][end[1]] = '#'
+
+
+    # ------------------------------------------------
+    # PRINT THE SOLVED MAZE
+    # ------------------------------------------------
+
+    print("\nSolved Maze:\n")
+
+    for row in maze:
+        print(" ".join(row))
+
+
+    #DFS
+    #!/usr/bin/env python3
+
+
+# ----------------------------------------------------
+# MAZE
+# 0 = Path
+# 1 = Obstacle
+# * = Start
+# # = End
+# ----------------------------------------------------
+
+maze = [
+    ['*', '0', '1', '0'],
+    ['1', '0', '1', '0'],
+    ['0', '0', '0', '0'],
+    ['1', '1', '0', '#']
+]
+
+
+# ----------------------------------------------------
+# HARD-CODED START AND END POSITIONS
+# ----------------------------------------------------
+
+start = (0, 0)
+end = (3, 3)
+
+rows = len(maze)
+cols = len(maze[0])
+
+
+# ----------------------------------------------------
+# VISITED ARRAY
+# ----------------------------------------------------
+
+visited = [[False for _ in range(cols)] for _ in range(rows)]
+
+
+# ----------------------------------------------------
+# PARENT ARRAY
+#
+# parent[row][col] stores the previous cell from
+# which we reached the current cell.
+# ----------------------------------------------------
+
+parent = [[None for _ in range(cols)] for _ in range(rows)]
+
+
+# ----------------------------------------------------
+# DIRECTIONS
+#
+# Up    = (-1, 0)
+# Down  = (1, 0)
+# Left  = (0, -1)
+# Right = (0, 1)
+# ----------------------------------------------------
+
+directions = [
+    (-1, 0),
+    (1, 0),
+    (0, -1),
+    (0, 1)
+]
+
+
+# ----------------------------------------------------
+# DFS STACK
+# ----------------------------------------------------
+
+stack = []
+
+stack.append(start)
+visited[start[0]][start[1]] = True
+
+found = False
+
+
+# ----------------------------------------------------
+# DFS ALGORITHM
+# ----------------------------------------------------
+
+while stack:
+
+    # Take the TOP element from the stack
+    current_row, current_col = stack.pop()
+
+    # If we reached the destination
+    if (current_row, current_col) == end:
+        found = True
+        break
+
+    # Check all four directions
+    for dr, dc in directions:
+
+        new_row = current_row + dr
+        new_col = current_col + dc
+
+        # Check whether the new position is inside the maze
+        if (0 <= new_row < rows and
+                0 <= new_col < cols):
+
+            # Check whether:
+            # 1. The cell has not been visited
+            # 2. The cell is not an obstacle
+            if (not visited[new_row][new_col] and
+                    maze[new_row][new_col] != '1'):
+
+                # Mark as visited
+                visited[new_row][new_col] = True
+
+                # Store the previous cell
+                parent[new_row][new_col] = (
+                    current_row,
+                    current_col
+                )
+
+                # Add the cell to the stack
+                stack.append((new_row, new_col))
+
+
+# ----------------------------------------------------
+# CHECK WHETHER A PATH EXISTS
+# ----------------------------------------------------
+
+if not found:
+
+    print("No path exists from Start (*) to End (#).")
+
+else:
+
+    # ------------------------------------------------
+    # RECONSTRUCT THE PATH
+    # ------------------------------------------------
+
+    current = end
+
+    while current != start:
+
+        row, col = current
+
+        # Mark shortest/path found by DFS
+        maze[row][col] = '.'
+
+        # Move to the previous cell
+        current = parent[row][col]
+
+
+    # Keep start and end symbols
+    maze[start[0]][start[1]] = '*'
+    maze[end[0]][end[1]] = '#'
+
+
+    # ------------------------------------------------
+    # PRINT THE SOLVED MAZE
+    # ------------------------------------------------
+
+    print("\nDFS Path:\n")
+
+    for row in maze:
+        print(" ".join(row))

sckitlearn/PR3.py

@@ -0,0 +1,191 @@
+import heapq
+import time
+
+graph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('D', 2), ('E', 5)],
+    'C': [('F', 1)],
+    'D': [('G', 3)],
+    'E': [('G', 1)],
+    'F': [('G', 2)],
+    'G': []
+}
+
+heuristic = {
+    'A': 6,
+    'B': 4,
+    'C': 3,
+    'D': 3,
+    'E': 1,
+    'F': 2,
+    'G': 0
+}
+
+
+def display_tree():
+    print("\n========== COMPLETE TREE ==========\n")
+
+    print("                 A(6)")
+    print("                /    \\")
+    print("             B(4)    C(3)")
+    print("             /  \\       \\")
+    print("          D(3)  E(1)    F(2)")
+    print("            |      |       |")
+    print("          G(0)   G(0)    G(0)")
+
+    print("\n====================================")
+    print("Format: Node(Heuristic)")
+
+
+def greedy_best_first_search(start, goal):
+
+    priority_queue = []
+    visited = set()
+    nodes_explored = 0
+
+    heapq.heappush(priority_queue, (heuristic[start], start, [start]))
+
+    while priority_queue:
+
+        h, current, path = heapq.heappop(priority_queue)
+
+        if current in visited:
+            continue
+
+        visited.add(current)
+        nodes_explored += 1
+
+        if current == goal:
+            return path, nodes_explored
+
+        for neighbor, cost in graph[current]:
+            if neighbor not in visited:
+                heapq.heappush(
+                    priority_queue,
+                    (heuristic[neighbor], neighbor, path + [neighbor])
+                )
+
+    return None, nodes_explored
+
+
+def find_cost(path):
+
+    cost = 0
+
+    for i in range(len(path) - 1):
+        for neighbor, edge_cost in graph[path[i]]:
+            if neighbor == path[i + 1]:
+                cost += edge_cost
+
+    return cost
+
+
+display_tree()
+
+start_time = time.perf_counter()
+
+path, nodes = greedy_best_first_search('A', 'G')
+
+end_time = time.perf_counter()
+
+execution_time = end_time - start_time
+
+
+print("\n====== GREEDY BEST FIRST SEARCH ======\n")
+
+print("Start Node      :", "A")
+print("Goal Node       :", "G")
+
+if path:
+    print("Path            :", " -> ".join(path))
+    print("Path Cost       :", find_cost(path))
+    print("Nodes Explored  :", nodes)
+    print("Execution Time  :", round(execution_time, 6), "seconds")
+else:
+    print("No path found")
+
+print("\n======================================")
+
+#A*
+import heapq
+import time
+
+graph = {
+    'A': [('B', 1), ('C', 1), ('D', 1)],
+    'B': [('E', 1), ('F', 1)],
+    'C': [('F', 1)],
+    'D': [('G', 1)],
+    'E': [('G', 1)],
+    'F': [('G', 1)],
+    'G': []
+}
+
+heuristic = {
+    'A': 40,
+    'B': 32,
+    'C': 25,
+    'D': 35,
+    'E': 19,
+    'F': 17,
+    'G': 0
+}
+
+
+def a_star_search(start, goal):
+
+    visited = set()
+    priority_queue = []
+    nodes_explored = 0
+
+    heapq.heappush(
+        priority_queue,
+        (heuristic[start], 0, start, [start])
+    )
+
+    while priority_queue:
+
+        f, g, current, path = heapq.heappop(priority_queue)
+
+        if current in visited:
+            continue
+
+        visited.add(current)
+        nodes_explored += 1
+
+        if current == goal:
+            return path, g, nodes_explored
+
+        for neighbor, cost in graph[current]:
+
+            if neighbor not in visited:
+
+                new_g = g + cost
+                new_f = new_g + heuristic[neighbor]
+
+                heapq.heappush(
+                    priority_queue,
+                    (new_f, new_g, neighbor, path + [neighbor])
+                )
+
+    return None, 0, nodes_explored
+
+
+start_time = time.perf_counter()
+
+path, cost, nodes = a_star_search('A', 'G')
+
+end_time = time.perf_counter()
+
+execution_time = end_time - start_time
+
+
+if path:
+
+    print("A* Search")
+    print("Path:", " -> ".join(path))
+    print("Path Cost:", cost)
+    print("Nodes Explored:", nodes)
+    print("Execution Time:", f"{execution_time:.2f}", "seconds")
+
+else:
+    print("No path found")

sckitlearn/PR4.py

@@ -0,0 +1,58 @@
+# PR4: Knowledge Representation and Expert System
+
+# Knowledge Base (IF-THEN rules)
+rules = {
+    "fever": ["flu"],
+    "cough": ["flu"],
+    "flu": ["take_rest"],
+    "take_rest": ["recover"]
+}
+
+# Forward Chaining
+def forward_chaining(facts):
+    print("\nForward Chaining:")
+
+    for fact in facts:
+        print("Known:", fact)
+
+    changed = True
+
+    while changed:
+        changed = False
+
+        for condition, results in rules.items():
+            if condition in facts:
+                for result in results:
+                    if result not in facts:
+                        facts.append(result)
+                        print("Inferred:", result)
+                        changed = True
+
+    print("Final Facts:", facts)
+
+
+# Backward Chaining
+def backward_chaining(goal, facts):
+    if goal in facts:
+        return True
+
+    for condition, results in rules.items():
+        if goal in results:
+            if backward_chaining(condition, facts):
+                return True
+
+    return False
+
+
+# Main Program
+facts = ["fever", "cough"]
+
+forward_chaining(facts.copy())
+
+goal = "recover"
+
+print("\nBackward Chaining:")
+if backward_chaining(goal, facts):
+    print(goal, "can be achieved")
+else:
+    print(goal, "cannot be achieved")

sckitlearn/PR5.py

@@ -0,0 +1,64 @@
+# PR5: Data Preprocessing and EDA
+
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.datasets import fetch_openml
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+# Load Titanic dataset
+data = fetch_openml("titanic", version=1, as_frame=True)
+df = data.frame
+
+# Select useful columns
+df = df[["pclass", "sex", "age", "fare", "embarked", "survived"]]
+
+# Data cleaning
+df.drop_duplicates(inplace=True)
+
+# Missing value handling
+df["age"] = df["age"].fillna(df["age"].mean())
+df["fare"] = df["fare"].fillna(df["fare"].mean())
+df["embarked"] = df["embarked"].fillna(df["embarked"].mode()[0])
+
+# Label Encoding
+le = LabelEncoder()
+df["sex"] = le.fit_transform(df["sex"])
+df["survived"] = le.fit_transform(df["survived"])
+
+# One-Hot Encoding
+df = pd.get_dummies(df, columns=["embarked"], dtype=int)
+
+# Statistical analysis
+print("\nStatistical Analysis:")
+print(df.describe())
+
+# Histogram
+df.hist(figsize=(10, 8))
+plt.tight_layout()
+plt.show()
+
+# Boxplot
+plt.figure(figsize=(8, 5))
+sns.boxplot(data=df[["age", "fare"]])
+plt.show()
+
+# Split features and target
+X = df.drop("survived", axis=1)
+y = df["survived"]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Feature Scaling
+sc = StandardScaler()
+X_train = sc.fit_transform(X_train)
+X_test = sc.transform(X_test)
+
+print("\nTraining data:", X_train.shape)
+print("Testing data:", X_test.shape)
+
+print("\nPreprocessing Completed!")

sckitlearn/PR6.py

@@ -0,0 +1,54 @@
+
+import numpy as np
+from sklearn.datasets import load_diabetes
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+
+data = load_diabetes()
+
+X = data.data[:, 2:3]
+y = data.target
+
+print("Dataset Loaded Successfully")
+print("Shape:", X.shape)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+lr = LinearRegression()
+
+lr.fit(X_train, y_train)
+
+lr_pred = lr.predict(X_test)
+
+print("Linear Regression")
+print("MSE:", mean_squared_error(y_test, lr_pred))
+print("MAE:", mean_absolute_error(y_test, lr_pred))
+print("R2 Score:", r2_score(y_test, lr_pred))
+
+poly = PolynomialFeatures(degree=2)
+
+X_train_poly = poly.fit_transform(X_train)
+X_test_poly = poly.transform(X_test)
+
+pr = LinearRegression()
+
+pr.fit(X_train_poly, y_train)
+
+pr_pred = pr.predict(X_test_poly)
+
+print("Polynomial Regression")
+print("MSE:", mean_squared_error(y_test, pr_pred))
+print("MAE:", mean_absolute_error(y_test, pr_pred))
+print("R2 Score:", r2_score(y_test, pr_pred))
+
+print("Linear Regression R2:", r2_score(y_test, lr_pred))
+print("Polynomial Regression R2:", r2_score(y_test, pr_pred))
+
+if r2_score(y_test, lr_pred) > r2_score(y_test, pr_pred):
+    print("Linear Regression is better")
+else:
+    print("Polynomial Regression is better")

sckitlearn/PR7.py

@@ -0,0 +1,79 @@
+# S1: To perform Logistic Regression and K-Nearest Neighbors
+import pandas as pd
+from sklearn.datasets import load_breast_cancer
+
+data = load_breast_cancer(as_frame=True)
+df = data.frame
+
+print("Successfully loaded dataset")
+print(df.head())
+print("Shape of dataset:", df.shape)
+
+# S2: Separate X and Y
+X = df.drop(columns='target')
+y = df["target"]
+
+print("X shape:", X.shape)
+print("y shape:", y.shape)
+
+# S3: Train-Test Split
+from sklearn.model_selection import train_test_split
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y,
+    test_size=0.2,
+    random_state=42,
+    stratify=y
+)
+
+print("X_train shape:", X_train.shape)
+print("X_test shape:", X_test.shape)
+print("y_train shape:", y_train.shape)
+print("y_test shape:", y_test.shape)
+
+# S4: Feature Scaling
+from sklearn.preprocessing import StandardScaler
+
+scaler = StandardScaler()
+
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+print("Before scaling:")
+print(X_train.head())
+
+print("\nAfter scaling:")
+print(X_train_scaled[:5])
+
+# S5: Logistic Regression
+from sklearn.linear_model import LogisticRegression
+
+log_model = LogisticRegression(max_iter=1000)
+log_model.fit(X_train_scaled, y_train)
+
+y_pred_log = log_model.predict(X_test_scaled)
+
+print("Logistic Regression completed")
+print("Predicted values:", y_pred_log[:10])
+
+# Evaluation
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+import matplotlib.pyplot as plt
+
+accuracy_l = accuracy_score(y_test, y_pred_log)
+precision_l = precision_score(y_test, y_pred_log)
+recall_l = recall_score(y_test, y_pred_log)
+f1_l = f1_score(y_test, y_pred_log)
+
+print("\nLogistic Regression")
+print("Accuracy :", accuracy_l)
+print("Precision:", precision_l)
+print("Recall   :", recall_l)
+print("F1 Score :", f1_l)
+
+cm = confusion_matrix(y_test, y_pred_log)
+disp = ConfusionMatrixDisplay(confusion_matrix=cm)
+disp.plot()
+plt.title("Logistic Regression Confusion Matrix")
+plt.show()

sckitlearn/PR8.py

@@ -0,0 +1,47 @@
+import pandas as pd
+from sklearn.datasets import load_breast_cancer
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score
+
+# Load Dataset
+data = load_breast_cancer()
+
+X = data.data
+y = data.target
+
+print("Dataset Loaded Successfully")
+print("Shape:", X.shape)
+
+# Train-Test Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Decision Tree
+dt = DecisionTreeClassifier()
+
+dt.fit(X_train, y_train)
+
+dt_pred = dt.predict(X_test)
+
+print("Decision Tree Accuracy:", accuracy_score(y_test, dt_pred))
+
+# Naive Bayes
+nb = GaussianNB()
+
+nb.fit(X_train, y_train)
+
+nb_pred = nb.predict(X_test)
+
+print("Naive Bayes Accuracy:", accuracy_score(y_test, nb_pred))
+
+# Comparison
+print("Decision Tree:", accuracy_score(y_test, dt_pred))
+print("Naive Bayes:", accuracy_score(y_test, nb_pred))
+
+if accuracy_score(y_test, dt_pred) > accuracy_score(y_test, nb_pred):
+    print("Decision Tree is better")
+else:
+    print("Naive Bayes is better")

sckitlearn/PR9.py

@@ -0,0 +1,64 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from sklearn.datasets import load_iris
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from scipy.cluster.hierarchy import dendrogram, linkage
+
+# Load dataset
+iris = load_iris()
+X = iris.data
+
+# Scaling
+sc = StandardScaler()
+X = sc.fit_transform(X)
+
+# Elbow Method
+wcss = []
+
+for i in range(1, 11):
+    km = KMeans(n_clusters=i, random_state=42, n_init=10)
+    km.fit(X)
+    wcss.append(km.inertia_)
+
+plt.plot(range(1, 11), wcss, marker='o')
+plt.xlabel("Number of Clusters")
+plt.ylabel("WCSS")
+plt.title("Elbow Method")
+plt.show()
+
+# K-Means Clustering
+km = KMeans(n_clusters=3, random_state=42, n_init=10)
+
+y = km.fit_predict(X)
+
+print("K-Means Clusters:")
+print(y)
+
+# Dendrogram
+z = linkage(X, method='ward')
+
+dendrogram(z, truncate_mode='lastp', p=20)
+
+plt.title("Dendrogram")
+plt.xlabel("Data Points")
+plt.ylabel("Distance")
+plt.show()
+
+# Hierarchical Clustering
+hc = AgglomerativeClustering(n_clusters=3)
+
+y_hc = hc.fit_predict(X)
+
+print("Hierarchical Clusters:")
+print(y_hc)
+
+# Analyze Generated Clusters
+df = pd.DataFrame(iris.data, columns=iris.feature_names)
+
+df['KMeans'] = y
+df['Hierarchical'] = y_hc
+
+print(df.groupby('KMeans').mean())
+print(df.groupby('Hierarchical').mean())

sckitlearn-1.0.0.dist-info/METADATA

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: sckitlearn
+Version: 1.0.0

sckitlearn-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+sckitlearn/PR1.py,sha256=t0qltNYCEWiuCkbrUAADey8MMSEpkkzQ842Hz_yxy4Y,811
+sckitlearn/PR10.py,sha256=LmOMT8LrAGo8kpefQSO1SYip6qbGGgg2uusM_uPq8-Q,1213
+sckitlearn/PR11.py,sha256=qe_XeZqzDxcZ2k2Jh9UYb6dXIvaWioe_MLzmdxeDQ9w,1530
+sckitlearn/PR2.py,sha256=X8jSC3JfSlSucPO2V7HKV4kXYYBsD4bquc7tv3_ONoE,7445
+sckitlearn/PR3.py,sha256=-WQLB_xxHpcnLSGcdfEJJr1tBGDpGQ0LVCHiBgnX3kI,4000
+sckitlearn/PR4.py,sha256=qiKkvoVEnAh37XyEPukfOIbPH5tsxcnBsbNMkDLgtCo,1299
+sckitlearn/PR5.py,sha256=KkxRADppzz7BZeM5WogrMkn2hlATSfKqvaHwPXaPJqs,1594
+sckitlearn/PR6.py,sha256=YfdPmrIGRvdXHKEleAH1YUZj5M81EnrKCpzd-p3_PpQ,1494
+sckitlearn/PR7.py,sha256=NV8LcYvX7BUu4-Z5GLam1HGsTXEmbhcZLf49usOJsqY,2116
+sckitlearn/PR8.py,sha256=_oTe9yxLwwz4jT1mWydAIIqIQRNP_CyBO7hI1bp_1TI,1153
+sckitlearn/PR9.py,sha256=FO7Zo8flcM5i98RsgDIKSODm6BJd9wD4L3obgkswUpw,1365
+sckitlearn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sckitlearn-1.0.0.dist-info/METADATA,sha256=wIK2qk9bdXaPOVDhEmWsPzV9bpT5JN6QaM2NAK1SbMQ,57
+sckitlearn-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+sckitlearn-1.0.0.dist-info/top_level.txt,sha256=gIRLo_ZXJphWnYz5vD0J6kkJSen2Ste5NSyeBm_oPHU,11
+sckitlearn-1.0.0.dist-info/RECORD,,

sckitlearn-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sckitlearn-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sckitlearn