sklearne 1.0__py3-none-any.whl

sklearne/__init__.py

@@ -0,0 +1 @@
+from .loader import show_code

sklearne/data/A1.txt

@@ -0,0 +1,74 @@
+# A1
+# Design and implement pattern recognition system to identify and extract unique species patterns from the Iris dataset
+# Step 1: Import Required Libraries
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+
+# Step 2: Load Dataset
+iris = load_iris()
+X = iris.data
+y = iris.target
+feature_names = iris.feature_names
+target_names = iris.target_names
+
+# Create DataFrame for easier handling
+df = pd.DataFrame(X, columns=feature_names)
+df['species'] = pd.Series(y).map(dict(zip(range(3), target_names)))
+
+# Step 3: Feature Analysis (Pattern Recognition)
+print("Feature-wise Mean by Species:")
+print(df.groupby('species').mean())  # Summary of patterns
+
+# Step 4: Visualizations - Patterns between features
+sns.pairplot(df, hue='species', palette='Set2')
+plt.suptitle("Pairplot of Iris Features by Species", y=1.02)
+plt.show()
+
+# Step 5: PCA for Pattern Visualization (2D)
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+pca = PCA(n_components=2)
+X_pca = pca.fit_transform(X_scaled)
+
+plt.figure(figsize=(8, 6))
+for i, label in enumerate(np.unique(y)):
+    plt.scatter(X_pca[y == label, 0], X_pca[y == label, 1], label=target_names[label])
+plt.title("PCA of Iris Dataset")
+plt.xlabel("Principal Component 1")
+plt.ylabel("Principal Component 2")
+plt.legend()
+plt.grid(True)
+plt.show()
+
+# Step 6: Classification using KNN
+X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
+
+knn = KNeighborsClassifier(n_neighbors=5)
+knn.fit(X_train, y_train)
+
+y_pred = knn.predict(X_test)
+
+# Step 7: Evaluation
+print("\nClassification Report:")
+print(classification_report(y_test, y_pred, target_names=target_names))
+print(f"Accuracy: {accuracy_score(y_test, y_pred)*100:.2f}%")
+
+# Confusion Matrix
+cm = confusion_matrix(y_test, y_pred)
+plt.figure(figsize=(6, 5))
+sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=target_names, yticklabels=target_names)
+plt.title("Confusion Matrix")
+plt.xlabel("Predicted")
+plt.ylabel("True")
+plt.tight_layout()
+plt.show()

sklearne/data/A2.txt

@@ -0,0 +1,50 @@
+# A2
+# Develop a text classification model that can effectively identify, extract features, and classify documents from the 20 Newsgroups dataset into one of the 20 predefined categories using  pattern recognition techniques.
+# Import required libraries
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.datasets import fetch_20newsgroups
+from sklearn.model_selection import train_test_split
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
+
+# Step 1: Load the dataset
+newsgroups = fetch_20newsgroups(subset='all', shuffle=True, random_state=42)
+X = newsgroups.data
+y = newsgroups.target
+target_names = newsgroups.target_names
+
+# Step 2: Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Step 3: Feature Extraction using TF-IDF (Pattern Recognition Technique)
+vectorizer = TfidfVectorizer(stop_words='english', max_df=0.5)
+X_train_tfidf = vectorizer.fit_transform(X_train)
+X_test_tfidf = vectorizer.transform(X_test)
+
+# Step 4: Model Training using Naive Bayes
+model = MultinomialNB()
+model.fit(X_train_tfidf, y_train)
+
+# Step 5: Prediction
+y_pred = model.predict(X_test_tfidf)
+
+# Step 6: Evaluation
+print("Accuracy:", accuracy_score(y_test, y_pred))
+print("\nClassification Report:\n", classification_report(y_test, y_pred, target_names=target_names))
+
+# Step 7: Confusion Matrix Visualization
+conf_mat = confusion_matrix(y_test, y_pred)
+plt.figure(figsize=(12, 10))
+sns.heatmap(conf_mat, annot=False, cmap='Blues', xticklabels=target_names, yticklabels=target_names)
+plt.title("Confusion Matrix - 20 Newsgroups")
+plt.xlabel("Predicted")
+plt.ylabel("True")
+plt.xticks(rotation=90)
+plt.yticks(rotation=0)
+plt.tight_layout()
+plt.show()

sklearne/data/A3.txt

@@ -0,0 +1,44 @@
+# A3
+# Design a statistical model to analyze wine quality using Gaussian distribution methods. Utilize synthetic data generated with NumPy or the Wine Quality Dataset
+
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy.stats import norm
+
+# Generate synthetic wine data (only 3 features)
+n = 1000
+fixed_acidity = np.random.normal(7.0, 0.7, n)
+volatile_acidity = np.random.normal(0.5, 0.1, n)
+citric_acid = np.random.normal(0.3, 0.1, n)
+
+# Create DataFrame
+df = pd.DataFrame({"fixed_acidity": fixed_acidity, "volatile_acidity": volatile_acidity, "citric_acid": citric_acid})
+
+# Generate synthetic wine quality
+df["wine_quality"] = np.clip(
+    (0.3 * df["fixed_acidity"] + 1.5 * df["volatile_acidity"] + 0.8 * df["citric_acid"] + np.random.normal(0, 0.5, n)).round().astype(int),
+    3, 8
+)
+
+# Display summary
+print(df.describe())
+
+# Plot histogram for 'fixed_acidity' with Gaussian fit
+plt.figure(figsize=(10, 6))
+sns.histplot(df['fixed_acidity'], kde=True, stat="density", color="skyblue", bins=30)
+
+# Fit a Gaussian distribution to the data
+mu, std = norm.fit(df['fixed_acidity'])
+x = np.linspace(df['fixed_acidity'].min(), df['fixed_acidity'].max(), 100)
+plt.plot(x, norm.pdf(x, mu, std), 'k', lw=2)
+
+# Add title and labels
+plt.title(f"Fixed Acidity Distribution ~ N({mu:.2f}, {std:.2f})", fontsize=14)
+plt.xlabel("Fixed Acidity", fontsize=12)
+plt.ylabel("Density", fontsize=12)
+
+# Show the plot
+plt.show()

sklearne/data/A4.txt

@@ -0,0 +1,41 @@
+# A4
+# Develop a classification system for handwritten digit recognition using the MNIST dataset, leveraging Bayes' Decision Theory to optimize decision-making and minimize classification error.
+import numpy as np
+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.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+from sklearn.decomposition import PCA
+
+# Dataset Loading
+mnist = fetch_openml('mnist_784', version=1, as_frame=False)
+X, y = mnist.data, mnist.target.astype(np.int8)
+X = X / 255.0  # Normalize pixel values
+
+# Reduce dimensionality using PCA
+pca = PCA(n_components=50)  # You can try 30–100 and tune this
+X_pca = pca.fit_transform(X)
+
+# Model Development (Using GaussianNB as an approximation to Bayes' Decision)
+model = GaussianNB()
+
+# Training and Testing
+X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)
+model.fit(X_train, y_train)
+y_pred = model.predict(X_test)
+
+# Evaluation
+print("\nEvaluation Metrics:")
+print(f"Accuracy: {accuracy_score(y_test, y_pred) * 100:.2f}%")
+print("\nClassification Report:\n", classification_report(y_test, y_pred))
+
+# Confusion Matrix
+conf_mat = confusion_matrix(y_test, y_pred)
+plt.figure(figsize=(10, 7))
+sns.heatmap(conf_mat, annot=True, fmt='d', cmap='Blues')
+plt.title("Confusion Matrix")
+plt.xlabel("Predicted")
+plt.ylabel("True")
+plt.show()

sklearne/data/A5.txt

@@ -0,0 +1,48 @@
+#A5
+#Develop an anomaly detection system for high-dimensional network traffic data using the KDD Cup 1999 dataset
+import pandas as pd
+import numpy as np
+from sklearn.datasets import fetch_kddcup99
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import classification_report
+
+# Load only a subset of the data for speed (optional: use 20,000 samples)
+kdd = fetch_kddcup99(percent10=True, shuffle=True)
+X_raw = kdd["data"][:20000]
+y_raw = kdd["target"][:20000]
+
+# Convert to DataFrame
+df = pd.DataFrame(X_raw, columns=kdd["feature_names"])
+
+# Binary label: 0 for normal, 1 for anomaly
+df["binary_label"] = np.where(y_raw == b'normal.', 0, 1)
+
+# One-hot encode categorical columns (with limited unique categories)
+df = pd.get_dummies(df, columns=["protocol_type", "service", "flag"], drop_first=True)
+
+# Features and label
+X = df.drop(['binary_label'], axis=1)
+y = df['binary_label']
+
+# Scale features
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# PCA for faster training (keep only 10 components)
+pca = PCA(n_components=10, random_state=42)
+X_reduced = pca.fit_transform(X_scaled)
+
+# Train/test split
+X_train, X_test, y_train, y_test = train_test_split(X_reduced, y, test_size=0.2, random_state=42)
+
+# KNN with fewer neighbors for speed
+knn = KNeighborsClassifier(n_neighbors=3, n_jobs=-1)  # Use all CPU cores
+knn.fit(X_train, y_train)
+
+# Prediction & Evaluation
+y_pred = knn.predict(X_test)
+print(f"Accuracy: {knn.score(X_test, y_test) * 100:.2f}%")
+print(classification_report(y_test, y_pred))

sklearne/data/B1.txt

@@ -0,0 +1,74 @@
+#B1
+# Implement a Hidden Markov Model (HMM) to recognize the sequence of weather patterns (e.g., sunny, cloudy, rainy) based on temperature and humidity observations. Use both discrete and continuous HMMs to compare their performance.
+import numpy as np
+import matplotlib.pyplot as plt
+from hmmlearn import hmm
+from sklearn.preprocessing import KBinsDiscretizer
+import warnings
+
+warnings.filterwarnings("ignore")
+np.random.seed(42)
+
+# Step 1: Define states
+states = ["Sunny", "Cloudy", "Rainy"]
+n_states = len(states)
+
+# Step 2: Transition probabilities
+trans_probs = np.array([
+    [0.6, 0.3, 0.1],
+    [0.2, 0.5, 0.3],
+    [0.1, 0.3, 0.6]
+])
+
+# Step 3: Emission properties (Temp, Humidity)
+means = np.array([[30, 40], [25, 50], [20, 80]])
+covars = np.array([
+    [[5, 0], [0, 5]],
+    [[4, 0], [0, 4]],
+    [[5, 0], [0, 5]]
+])
+
+# Step 4: Generate synthetic data
+n_samples = 300
+hidden_states = np.random.choice(n_states, size=n_samples, p=[0.5, 0.3, 0.2])
+observations = np.array([
+    np.random.multivariate_normal(means[s], covars[s]) for s in hidden_states
+])
+
+# Visualize the generated data
+plt.scatter(observations[:, 0], observations[:, 1], c=hidden_states, cmap='viridis')
+plt.xlabel("Temperature")
+plt.ylabel("Humidity")
+plt.title("Synthetic Weather Observations")
+plt.show()
+
+# === Discrete HMM (Temperature only) ===
+discretizer = KBinsDiscretizer(n_bins=5, encode='ordinal', strategy='uniform')
+X_discrete = discretizer.fit_transform(observations[:, [0]]).astype(int)
+
+model_discrete = hmm.MultinomialHMM(n_components=n_states, n_iter=100)
+model_discrete.fit(X_discrete)
+pred_discrete = model_discrete.predict(X_discrete)
+
+# Accuracy (rough comparison)
+acc_discrete = np.mean(pred_discrete == hidden_states)
+print(f"Discrete HMM Accuracy: {acc_discrete:.2f}")
+
+# === Continuous HMM (Full Temp & Humidity) ===
+model_continuous = hmm.GaussianHMM(n_components=n_states, covariance_type="full", n_iter=100)
+model_continuous.fit(observations)
+pred_continuous = model_continuous.predict(observations)
+
+acc_continuous = np.mean(pred_continuous == hidden_states)
+print(f"Continuous HMM Accuracy: {acc_continuous:.2f}")
+
+# Visualize predictions (first 50 steps)
+plt.figure(figsize=(10, 4))
+plt.plot(hidden_states[:50], "bo-", label="True States")
+plt.plot(pred_discrete[:50], "r--", label="Discrete HMM")
+plt.plot(pred_continuous[:50], "g.-", label="Continuous HMM")
+plt.legend()
+plt.title("True vs Predicted Hidden States")
+plt.xlabel("Time Step")
+plt.ylabel("State Index")
+plt.show()

sklearne/data/B2.txt

@@ -0,0 +1,49 @@
+#B2
+# Build a Discrete Hidden Markov Model (HMM) to analyze DNA sequences and predict gene regions. Use Maximum Likelihood Estimation to train the model with a given dataset of labeled sequences
+import numpy as np
+from hmmlearn import hmm
+from sklearn.preprocessing import LabelEncoder
+import matplotlib.pyplot as plt
+
+# Example sequences
+sequences = [
+    "ATGCGCGTATCGT",  # Mostly gene
+    "CGTACGTAGCTA",   # Mix
+    "TTATTAGCGTTA"    # Mostly intergenic
+]
+
+# Corresponding labels (0 = intergenic, 1 = gene)
+labels = [
+    [1,1,1,1,1,1,0,0,0,0,0,0,0],
+    [0,0,1,1,1,1,0,0,0,1,1,1],
+    [0,0,0,0,0,1,1,0,0,0,0,0]
+]
+
+# Flatten sequence and labels for training
+all_seq = ''.join(sequences)
+all_labels = np.concatenate(labels)
+
+# Encode DNA characters A/C/G/T to integers 0-3
+le = LabelEncoder()
+le.fit(['A', 'C', 'G', 'T'])
+X = le.transform(list(all_seq)).reshape(-1, 1)
+
+# Train HMM (Discrete = MultinomialHMM)
+model = hmm.MultinomialHMM(n_components=2, n_iter=100, tol=0.01)
+model.fit(X)
+
+# Predict hidden states
+predicted_states = model.predict(X)
+
+# Compare with true labels
+accuracy = np.mean(predicted_states == all_labels)
+print(f"Prediction Accuracy (approx): {accuracy:.2f}")
+
+# Visualize true vs predicted
+plt.plot(all_labels[:50], label="True State")
+plt.plot(predicted_states[:50], '--', label="Predicted")
+plt.title("Gene Prediction - HMM")
+plt.xlabel("Sequence Position")
+plt.ylabel("State (0=Intergenic, 1=Gene)")
+plt.legend()
+plt.show()

sklearne/data/B4.txt

@@ -0,0 +1,44 @@
+# B4	
+# Create a program that fits a mixture of Gaussians to a dataset of handwritten digit features and clusters them into distinct groups. Use the Expectation-Maximization method to estimate the parameters of the Gaussian mixture model.
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.datasets import fetch_openml
+from sklearn.decomposition import PCA
+from sklearn.mixture import GaussianMixture
+from sklearn.metrics import adjusted_rand_score
+
+# Load MNIST dataset
+mnist = fetch_openml("mnist_784", version=1, as_frame=False)
+X, y = mnist.data, mnist.target.astype(int)
+
+# Normalize pixel values
+X = X / 255.0
+
+# Reduce dimensionality with PCA (to speed up EM)
+pca = PCA(n_components=50)
+X_pca = pca.fit_transform(X)
+
+# Fit Gaussian Mixture Model
+n_components = 10  # Assume 10 digits (0-9)
+gmm = GaussianMixture(n_components=n_components, covariance_type='full', max_iter=100, random_state=42)
+gmm.fit(X_pca)
+
+# Predict cluster labels
+cluster_labels = gmm.predict(X_pca)
+
+# Optional: Check clustering quality with Adjusted Rand Index
+ari = adjusted_rand_score(y, cluster_labels)
+print(f"Adjusted Rand Index: {ari:.2f}")
+
+# Visualize clusters in 2D
+pca_2d = PCA(n_components=2)
+X_2d = pca_2d.fit_transform(X_pca)
+
+plt.figure(figsize=(10, 6))
+sns.scatterplot(x=X_2d[:, 0], y=X_2d[:, 1], hue=cluster_labels, palette="tab10", legend="full", s=10)
+plt.title("GMM Clustering of MNIST (2D PCA Projection)")
+plt.xlabel("PCA 1")
+plt.ylabel("PCA 2")
+plt.legend(title="Cluster")
+plt.show()

sklearne/data/B6.txt

@@ -0,0 +1,76 @@
+#6 Use non-parametric K-Nearest Neighbor (KNN) techniques to classify grayscale images of shapes (e.g., circles, squares, and triangles). #Evaluate and compare the classification accuracy of both methods.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score, classification_report
+import cv2  # Required for triangle generation
+
+# Function to generate square
+def generate_square(image_size=64):
+    img = np.zeros((image_size, image_size), dtype=np.uint8)
+    img[16:48, 16:48] = 255  # Create a square in the center
+    return img
+
+# Function to generate circle
+def generate_circle(image_size=64):
+    img = np.zeros((image_size, image_size), dtype=np.uint8)
+    y, x = np.ogrid[:image_size, :image_size]
+    mask = (x - image_size // 2) ** 2 + (y - image_size // 2) ** 2 <= (image_size // 4) ** 2
+    img[mask] = 255
+    return img
+
+# Function to generate triangle
+def generate_triangle(image_size=64):
+    img = np.zeros((image_size, image_size), dtype=np.uint8)
+    pts = np.array([[32, 16], [16, 48], [48, 48]], np.int32)
+    cv2.fillPoly(img, [pts], 255)
+    return img
+
+# Function to generate the appropriate shape based on the label
+def generate_shape(shape):
+    if shape == 'square':
+        return generate_square()
+    elif shape == 'circle':
+        return generate_circle()
+    elif shape == 'triangle':
+        return generate_triangle()
+
+# Create synthetic dataset
+shapes = ['square', 'circle', 'triangle']
+X = []  # Features (flattened images)
+y = []  # Labels (0: Square, 1: Circle, 2: Triangle)
+n_samples = 1000
+
+for shape_idx, shape in enumerate(shapes):
+    for _ in range(n_samples // 3):
+        img = generate_shape(shape)
+        X.append(img.flatten())  # Flatten image to 1D
+        y.append(shape_idx)  # Assign corresponding label
+
+X = np.array(X)
+y = np.array(y)
+
+# Split dataset into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Train KNN classifier
+knn = KNeighborsClassifier(n_neighbors=3)
+knn.fit(X_train, y_train)
+
+# Make predictions and evaluate
+y_pred = knn.predict(X_test)
+accuracy = accuracy_score(y_test, y_pred)
+
+print(f"Accuracy: {accuracy * 100:.2f}%")
+print("\nClassification Report:\n", classification_report(y_test, y_pred))
+
+# Visualize test images with predicted labels
+fig, axes = plt.subplots(1, 5, figsize=(12, 6))
+for i in range(5):
+    axes[i].imshow(X_test[i].reshape(64, 64), cmap='gray')
+    axes[i].set_title(f"Pred: {shapes[y_pred[i]]}")
+    axes[i].axis('off')
+
+plt.show()

sklearne/data/B7.txt

@@ -0,0 +1,55 @@
+#B7	
+# Build a Python application to classify iris flowers using the Nearest Neighbor Rule. Use a given dataset with features such as petal length and width. Experiment with different values of K and evaluate the model's accuracy
+
+
+import numpy as np
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score, classification_report
+import matplotlib.pyplot as plt
+
+# Step 1: Load the Iris dataset
+iris = load_iris()
+X = iris.data  # Features (petal length, petal width, etc.)
+y = iris.target  # Labels (species of flowers)
+
+# Step 2: Split the dataset into training and testing sets
+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 to train and evaluate the KNN model with different K values
+def evaluate_knn(k_values):
+    for k in k_values:
+        # Initialize the KNN classifier with a given value of k
+        knn = KNeighborsClassifier(n_neighbors=k)
+        
+        # Train the classifier on the training data
+        knn.fit(X_train, y_train)
+        
+        # Make predictions on the test data
+        y_pred = knn.predict(X_test)
+        
+        # Calculate accuracy
+        accuracy = accuracy_score(y_test, y_pred)
+        print(f"K={k} - Accuracy: {accuracy * 100:.2f}%")
+        print(f"Classification Report for K={k}:\n{classification_report(y_test, y_pred)}")
+
+# Step 4: Experiment with different K values
+k_values = [1, 3, 5, 7, 9]  # Different values of K to try
+evaluate_knn(k_values)
+
+# Optional: Plot the effect of K on accuracy (for visualization)
+accuracies = []
+for k in k_values:
+    knn = KNeighborsClassifier(n_neighbors=k)
+    knn.fit(X_train, y_train)
+    y_pred = knn.predict(X_test)
+    accuracies.append(accuracy_score(y_test, y_pred))
+
+# Plot accuracy vs K value
+plt.plot(k_values, accuracies, marker='o')
+plt.title('KNN Classifier Accuracy vs K')
+plt.xlabel('K value')
+plt.ylabel('Accuracy')
+plt.grid(True)
+plt.show()

sklearne/loader.py

@@ -0,0 +1,12 @@
+import os
+
+def show_code(filename):
+    file_path = os.path.join(os.path.dirname(__file__), 'data', filename)
+    if not os.path.exists(file_path):
+        return f"File {filename} not found."
+
+    with open(file_path, 'r') as f:
+        content = f.read()
+
+    print(content)  # shows the code in Jupyter output
+    return content   # also returns content if needed

sklearne-1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: sklearne
+Version: 1.0
+Summary: Saver
+Author: Your Name

sklearne-1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+sklearne/__init__.py,sha256=uk0QwGzWTdxut9oI3_0723e8w0kYC3b__AqlSruVpSU,31
+sklearne/loader.py,sha256=PXerhBcG88Z6FhLV1izCPz_a_jQ2nN10dpE1U834j0Q,379
+sklearne/data/A1.txt,sha256=OD3cGtqSVqfH5XSD0kxd4-yTv4hJ90VJvZ2dGL2Ssqc,2439
+sklearne/data/A2.txt,sha256=ctmfmMhFXZCUXlAFqnEMtUXPYhT2QQinYLovtHtNCXQ,1943
+sklearne/data/A3.txt,sha256=B_pUaofgsAnhovRXOTsiHjIlFoNJulLE6lvr8v1ZJgE,1507
+sklearne/data/A4.txt,sha256=N_PgZKbBUyZqefBf05aQbeaukuyfhUOjtCeGll92gYQ,1560
+sklearne/data/A5.txt,sha256=P-8wK-Hd7B_BMrJ0OsfiYKyfirOy2oF6wm8dW8bnF9Y,1724
+sklearne/data/B1.txt,sha256=XenxamzxPD78T_fOQ15AkNU5sWcrOMWp-Zg60atRX4A,2564
+sklearne/data/B2.txt,sha256=azrRFUVR1Y4DgOkDtsj-z2_PUCoFOAfzRO1NwiC-dYo,1502
+sklearne/data/B4.txt,sha256=P949GYoOoCj5KCM62Q9CrW16mPD7t-W0y4hFSUHMWbk,1565
+sklearne/data/B6.txt,sha256=Aq615q1NecnjT_KYNbKdJaLu6Zis1-ioTyXC-6eRoh0,2728
+sklearne/data/B7.txt,sha256=S3HC0Il-_FHOLGbMvlvNmZb1rtfRHYV8mtxkE08tq7c,2109
+sklearne-1.0.dist-info/METADATA,sha256=2OJbnz8lh-DXOeeolFnJa5tmecLiNxG7L-a8BInXcYQ,88
+sklearne-1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+sklearne-1.0.dist-info/top_level.txt,sha256=v7HoQGFOgDk0Ia60xJb3HE_zt-QB6YueCQjJyse8pEY,9
+sklearne-1.0.dist-info/RECORD,,

sklearne-1.0.dist-info/WHEEL

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

sklearne-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sklearne