myawesomepkg 0.1.8__py3-none-any.whl

myawesomepkg/TSAPY1/P4-1-different_distance_methods_(euclidean)_with_prediction,_test_score_and_confusion_matrix1.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+"""different Distance methods (Euclidean) with Prediction, Test Score and Confusion Matrix1.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1FAIOs_ScwVaM7Q1T7kf39YA35Jjte2Pd
+"""
+
+# Importing required libraries
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
+
+# Load the dataset
+data = pd.read_csv("/content/Irisdata.csv")
+
+# Selecting features and target
+X = data.iloc[:, [1, 2, 3, 4]].values
+y = data.iloc[:, 5].values
+
+# Encoding target labels
+le = LabelEncoder()
+y = le.fit_transform(y)
+
+# Splitting data into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Creating KNN model using Euclidean distance
+model = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
+model.fit(X_train, y_train)
+
+# Making predictions
+y_pred = model.predict(X_test)
+
+# Evaluating model performance
+cm = confusion_matrix(y_test, y_pred)
+acc = accuracy_score(y_test, y_pred)
+
+print("Confusion Matrix:\n", cm)
+print("\nAccuracy Score:", round(acc * 100, 2), "%")
+print("\nClassification Report:\n", classification_report(y_test, y_pred, target_names=le.classes_))
+
+# Example prediction
+sample = [[5.1, 3.5, 1.4, 0.2]]
+predicted_class = model.predict(sample)
+print("\nPredicted Class for", sample, ":", le.inverse_transform(predicted_class)[0])
+
+# ---- Visualization of KNN Results ----
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Only for 2D plotting (we'll use the first two features: SepalLength and SepalWidth)
+X_plot = X_train[:, :2]
+y_plot = y_train
+
+# Train again using only first 2 features (for visualization)
+model_2d = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
+model_2d.fit(X_plot, y_plot)
+
+# Create a meshgrid for background decision boundary
+x_min, x_max = X_plot[:, 0].min() - 1, X_plot[:, 0].max() + 1
+y_min, y_max = X_plot[:, 1].min() - 1, X_plot[:, 1].max() + 1
+xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
+                     np.arange(y_min, y_max, 0.1))
+
+# Predict for each point in meshgrid
+Z = model_2d.predict(np.c_[xx.ravel(), yy.ravel()])
+Z = Z.reshape(xx.shape)
+
+# Plot decision boundary and training points
+plt.figure(figsize=(8,6))
+plt.contourf(xx, yy, Z, alpha=0.3)
+plt.scatter(X_plot[:, 0], X_plot[:, 1], c=y_plot, s=40, edgecolor='k')
+plt.title("KNN Classification (Euclidean Distance)")
+plt.xlabel("Sepal Length")
+plt.ylabel("Sepal Width")
+plt.show()
+
+
+
+#second code 
+
+4.a Euclidean
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import confusion_matrix, accuracy_score
+
+# --- Step 1: Sample dataset ---
+# For simplicity, use an example dataset
+from sklearn.datasets import load_iris
+data = load_iris()
+X = data.data
+y = data.target
+
+# --- Step 2: Split into training and testing ---
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# --- Step 3: Define a function for Euclidean distance ---
+def euclidean_distance(x1, x2):
+    return np.sqrt(np.sum((x1 - x2)**2))
+
+# --- Step 4: Implement KNN manually using Euclidean distance ---
+def knn_predict(X_train, y_train, X_test, k=3):
+    predictions = []
+    for test_point in X_test:
+        # Calculate all distances
+        distances = [euclidean_distance(test_point, x_train) for x_train in X_train]
+        # Get indices of k nearest neighbors
+        k_indices = np.argsort(distances)[:k]
+        # Get the labels of k nearest points
+        k_neighbor_labels = [y_train[i] for i in k_indices]
+        # Take the majority vote
+        most_common = max(set(k_neighbor_labels), key=k_neighbor_labels.count)
+        predictions.append(most_common)
+    return np.array(predictions)
+
+# --- Step 5: Make predictions ---
+y_pred = knn_predict(X_train, y_train, X_test, k=3)
+
+# --- Step 6: Evaluate model ---
+acc = accuracy_score(y_test, y_pred)
+cm = confusion_matrix(y_test, y_pred)
+
+print("Predictions:", y_pred)
+print("\nTest Accuracy:", acc)
+print("\nConfusion Matrix:\n", cm)
+

myawesomepkg/TSAPY1/P4-2-k_means_clustering_with_prediction,_test_score_and_confusion_matrix2.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+"""K-Means clustering with Prediction, Test Score and Confusion Matrix2.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1PhxwPtvymskRZcO18J6px8vkMhN1KNUR
+"""
+
+# Importing required libraries
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import confusion_matrix, accuracy_score
+
+# Load the Iris dataset
+data = pd.read_csv("/content/Irisdata.csv")
+
+# Selecting features (independent variables)
+X = data.iloc[:, [1, 2, 3, 4]].values
+
+# Extracting actual target labels (species)
+y = data.iloc[:, 5].values
+
+# Encoding string labels into numbers
+le = LabelEncoder()
+y_encoded = le.fit_transform(y)
+
+# Finding the optimal number of clusters using the Elbow method
+wcss = []
+for i in range(1, 11):
+    kmeans = KMeans(n_clusters=i, init='k-means++', max_iter=300, n_init=10, random_state=0)
+    kmeans.fit(X)
+    wcss.append(kmeans.inertia_)
+
+# Plotting the Elbow graph
+plt.plot(range(1, 11), wcss, marker='o')
+plt.title('The Elbow Method')
+plt.xlabel('Number of Clusters')
+plt.ylabel('WCSS (Within Cluster Sum of Squares)')
+plt.show()
+
+# Applying K-Means with 3 clusters (based on Elbow method)
+kmeans = KMeans(n_clusters=3, init='k-means++', max_iter=300, n_init=10, random_state=0)
+y_kmeans = kmeans.fit_predict(X)
+
+# Aligning K-Means cluster labels with actual species labels
+from scipy.stats import mode
+
+labels = np.zeros_like(y_kmeans)
+for i in range(3):
+    mask = (y_kmeans == i)
+    labels[mask] = mode(y_encoded[mask])[0]
+
+# Calculating confusion matrix and accuracy
+cm = confusion_matrix(y_encoded, labels)
+acc = accuracy_score(y_encoded, labels)
+
+print("\nConfusion Matrix:\n", cm)
+print("\nAccuracy Score:", round(acc * 100, 2), "%")
+
+# Visualizing the clusters
+plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s=100, c='red', label='Cluster 1')
+plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s=100, c='blue', label='Cluster 2')
+plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s=100, c='green', label='Cluster 3')
+
+# Plotting centroids
+plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
+            s=200, c='yellow', label='Centroids', marker='X')
+
+plt.title('K-Means Clustering (Iris Dataset)')
+plt.xlabel('Sepal Length')
+plt.ylabel('Sepal Width')
+plt.legend()
+plt.show()
+
+# Example Prediction
+sample = [[5.1, 3.5, 1.4, 0.2]]
+pred_cluster = kmeans.predict(sample)
+print("\nPredicted Cluster for sample", sample, ":", pred_cluster[0])
+
+
+
+#second code+++++++++++++++++++++++++++++++++++++++++++=
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn.cluster import KMeans
+
+# Load dataset
+dataset = pd.read_csv('/content/Irisdata.csv')
+print(dataset.head())
+
+# Select features (make sure to exclude ID or non-numeric columns)
+X = dataset.iloc[:, [1, 2, 3, 4]].values
+
+# Elbow method to find optimal number of clusters
+wcss = []
+for i in range(1, 11):
+    kmeans = KMeans(
+        n_clusters=i, 
+        init='k-means++', 
+        max_iter=300, 
+        n_init=10, 
+        random_state=0
+    )
+    kmeans.fit(X)
+    wcss.append(kmeans.inertia_)
+
+# Plot Elbow Curve
+plt.figure(figsize=(8, 5))
+plt.plot(range(1, 11), wcss, marker='o')
+plt.title('Elbow Method for Optimal k')
+plt.xlabel('Number of Clusters')
+plt.ylabel('WCSS (Within Cluster Sum of Squares)')
+plt.grid(True)
+plt.show()
+
+# Applying KMeans with optimal clusters (3 for Iris)
+kmeans = KMeans(
+    n_clusters=3, 
+    init='k-means++', 
+    max_iter=300, 
+    n_init=10, 
+    random_state=0
+)
+y_kmeans = kmeans.fit_predict(X)
+
+# Plot the clusters (using the first two features for 2D visualization)
+plt.figure(figsize=(8, 6))
+plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s=100, c='red', label='Iris-setosa')
+plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s=100, c='blue', label='Iris-versicolour')
+plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s=100, c='green', label='Iris-virginica')
+
+# Plot centroids
+plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
+            s=200, c='yellow', edgecolor='black', marker='X', label='Centroids')
+
+plt.title('Clusters of Iris Species')
+plt.xlabel('Feature 1')
+plt.ylabel('Feature 2')
+plt.legend()
+plt.grid(True)
+plt.show()
+
+