pico-lab 0.1.0__py3-none-any.whl

pico_lab/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = "0.1.0"

pico_lab/bfs.py

@@ -0,0 +1,38 @@
+
+from collections import deque
+
+
+def bfs(graph, start):
+    visited = set()
+    queue = deque([start])
+
+    while queue:
+        node = queue.popleft()
+
+        if node not in visited:
+            visited.add(node)
+            print(node)
+
+            queue.extend([
+                neighbor
+                for neighbor in graph[node]
+                if neighbor not in visited
+            ])
+
+
+def run():
+    graph = {
+        "A": ["B", "C"],
+        "B": ["D", "E"],
+        "C": ["F"],
+        "D": [],
+        "E": ["F"],
+        "F": []
+    }
+
+    print("Breadth First Search:")
+    bfs(graph, "A")
+
+
+if __name__ == "__main__":
+    run()

pico_lab/cli.py

@@ -0,0 +1,64 @@
+
+from pathlib import Path
+
+EXPERIMENTS = {
+    "1": "eda.py",
+    "2": "preprocessing.py",
+    "3": "linear_regression.py",
+    "4": "single_perceptron.py",
+    "5": "mlp.py",
+    "6": "knn.py",
+    "7": "svr.py",
+    "8": "fuzzy_sets.py",
+    "9": "naive_bayes.py",
+    "10": "kmeans.py",
+    "11": "dfs.py",
+    "12": "bfs.py",
+}
+
+NAMES = {
+    "1": "Exploratory Data Analysis",
+    "2": "Data Pre-processing",
+    "3": "Linear Regression Models",
+    "4": "Single Layer Perceptron",
+    "5": "Multiple Layer Perceptron",
+    "6": "KNN Classifier",
+    "7": "Support Vector Regression",
+    "8": "Primitive Operations on Fuzzy Sets",
+    "9": "Naive Bayes Classifier",
+    "10": "K-Means Clustering",
+    "11": "Depth First Search",
+    "12": "Breadth First Search",
+}
+
+
+def main():
+    print("\n======================================")
+    print("              PICO LAB")
+    print(" AI AND ML LABORATORY TOOLKIT")
+    print("======================================")
+
+    for number, name in NAMES.items():
+        print(f"{number}. {name}")
+
+    choice = input("\nEnter experiment number: ").strip()
+
+    if choice not in EXPERIMENTS:
+        print("Invalid experiment number!")
+        return
+
+    file_path = Path(__file__).parent / EXPERIMENTS[choice]
+
+    print("\n======================================")
+    print(f" EXPERIMENT {choice}: {NAMES[choice]}")
+    print("======================================\n")
+
+    try:
+        code = file_path.read_text(encoding="utf-8")
+        print(code)
+    except FileNotFoundError:
+        print("Experiment file not found!")
+
+
+if __name__ == "__main__":
+    main()

pico_lab/dfs.py

@@ -0,0 +1,35 @@
+
+def dfs(graph, start):
+    visited = set()
+    stack = [start]
+
+    while stack:
+        node = stack.pop()
+
+        if node not in visited:
+            visited.add(node)
+            print(node)
+
+            stack.extend([
+                neighbor
+                for neighbor in graph[node]
+                if neighbor not in visited
+            ])
+
+
+def run():
+    graph = {
+        "A": ["B", "C"],
+        "B": ["D", "E"],
+        "C": ["F"],
+        "D": [],
+        "E": ["F"],
+        "F": []
+    }
+
+    print("Depth First Search:")
+    dfs(graph, "A")
+
+
+if __name__ == "__main__":
+    run()

pico_lab/eda.py

@@ -0,0 +1,114 @@
+
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+def run():
+    # Load dataset
+    df = pd.read_csv("Toyota.csv")
+
+    # Display dataset
+    print("First 5 rows:")
+    print(df.head(5))
+
+    print("\nLast 5 rows:")
+    print(df.tail(5))
+
+    print("\nDataset shape:")
+    print(df.shape)
+
+    # Select numerical columns
+    print("\nNumerical columns:")
+    print(df.select_dtypes(exclude=["object"]).columns.tolist())
+
+    mi = df.select_dtypes(exclude=["object"])
+
+    print("\nMinimum values:")
+    print(mi.min())
+
+    print("\nMaximum values:")
+    print(mi.max())
+
+    print("\nMode:")
+    print(mi.mode())
+
+    # Check missing values
+    print("\nMissing values:")
+    print(df.isnull())
+
+    # Box plot
+    df.boxplot(figsize=(5, 5), rot=90, fontsize=8, grid=False)
+    plt.title("Box Plot")
+    plt.show()
+
+    # Z-score analysis for KM
+    mean = np.mean(df["KM"])
+    std = np.std(df["KM"])
+
+    print("\nKM Z-score:")
+    print((df["KM"] - mean) / std)
+
+    df["KM-z_score"] = (df["KM"] - mean) / std
+    print(df.head(5))
+
+    # Correlation
+    print("\nCorrelation:")
+    print(df.corr(numeric_only=True))
+
+    # Distribution plot
+    sns.displot(data=df, x="HP", kde=True, fill=True)
+    plt.show()
+
+    # Bar plot
+    df["Automatic"].value_counts().plot(kind="bar")
+    plt.show()
+
+    # Swarm plot and violin plot
+    plt.figure(figsize=(10, 5))
+
+    plt.subplot(1, 2, 1)
+    sns.swarmplot(x=df["Price"])
+
+    plt.subplot(1, 2, 2)
+    sns.violinplot(x=df["Price"])
+
+    plt.show()
+
+    # Scatter plot
+    df.plot("Price", "HP", kind="scatter")
+    plt.show()
+
+    # Bar plot
+    plt.figure(figsize=(15, 10))
+    sns.barplot(
+        x="Price",
+        y="HP",
+        data=df[15:35],
+        palette="plasma"
+    )
+    plt.show()
+
+    # Count plot
+    sns.countplot(x=df["Weight"])
+    plt.show()
+
+    # Pair plot
+    sns.pairplot(df)
+    plt.show()
+
+    # Automatic value counts
+    counts = df["Automatic"].value_counts()
+
+    plt.bar(counts.index, counts.values)
+    plt.xlabel("Automatic")
+    plt.ylabel("Counts")
+    plt.show()
+
+
+if __name__ == "__main__":
+    run()

pico_lab/fuzzy_sets.py

@@ -0,0 +1,73 @@
+
+def run():
+    # Union of two fuzzy sets
+    A = {"a": 0.2, "b": 0.3, "c": 0.6, "d": 0.6}
+    B = {"a": 0.9, "b": 0.6, "c": 0.4, "d": 0.5}
+    Y = {}
+
+    print("The first fuzzy set is:", A)
+    print("The second fuzzy set is:", B)
+
+    for key in A:
+        A_value = A[key]
+        B_value = B.get(key, 0)
+        Y[key] = max(A_value, B_value)
+
+    print("Fuzzy set union is:", Y)
+
+    # Intersection of two fuzzy sets
+    Y = {}
+
+    for key in A:
+        A_value = A[key]
+        B_value = B.get(key, 0)
+        Y[key] = min(A_value, B_value)
+
+    print("Fuzzy set intersection is:", Y)
+
+    # Complement of fuzzy set
+    Y = {}
+
+    print("The fuzzy set is:", A)
+
+    for key in A:
+        Y[key] = 1 - A[key]
+
+    print("Fuzzy set complement is:", Y)
+
+    # Scalar multiplication of fuzzy set
+    alpha = 0.5
+    Y = {}
+
+    print("Scalar multiplication by", alpha)
+
+    for key in A:
+        Y[key] = min(1, alpha * A[key])
+
+    print("Result of scalar multiplication is:", Y)
+
+    # Fuzzy addition of two fuzzy sets
+    Y = {}
+
+    for key in set(A) | set(B):
+        A_value = A.get(key, 0)
+        B_value = B.get(key, 0)
+        Y[key] = min(1, A_value + B_value)
+
+    print("Fuzzy addition of A and B is:", Y)
+
+    # Fuzzy subtraction of two fuzzy sets
+    A = {"a": 0.9, "b": 0.6, "c": 0.4, "d": 0.5}
+    B = {"a": 0.2, "b": 0.3, "c": 0.6, "d": 0.6}
+    Y = {}
+
+    for key in set(A) | set(B):
+        A_value = A.get(key, 0)
+        B_value = B.get(key, 0)
+        Y[key] = max(0, A_value - B_value)
+
+    print("Fuzzy subtraction of A and B is:", Y)
+
+
+if __name__ == "__main__":
+    run()

pico_lab/kmeans.py

@@ -0,0 +1,57 @@
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from sklearn import datasets
+from sklearn.cluster import KMeans
+
+
+def run():
+    # Load Iris dataset
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    # Create a DataFrame
+    df = pd.DataFrame(X, columns=iris.feature_names)
+
+    print("Dataset preview:")
+    print(df.head())
+
+    # Apply KMeans clustering
+    k = 3
+    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
+    kmeans.fit(X)
+
+    # Add predicted cluster labels
+    df["Cluster"] = kmeans.labels_
+
+    print("\nCluster centers:\n", kmeans.cluster_centers_)
+    print("\nFirst 10 cluster labels:\n", df["Cluster"].head(10))
+
+    # Visualize clusters using first two features
+    plt.scatter(
+        X[:, 0], X[:, 1],
+        c=kmeans.labels_,
+        cmap="rainbow"
+    )
+
+    plt.scatter(
+        kmeans.cluster_centers_[:, 0],
+        kmeans.cluster_centers_[:, 1],
+        color="black",
+        marker="X",
+        s=200,
+        label="Centroids"
+    )
+
+    plt.title("K-Means Clustering (Iris Dataset)")
+    plt.xlabel("Sepal Length (cm)")
+    plt.ylabel("Sepal Width (cm)")
+    plt.legend()
+    plt.show()
+
+
+if __name__ == "__main__":
+    run()

pico_lab/knn.py

@@ -0,0 +1,45 @@
+
+import pandas as pd
+
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score
+
+
+def run():
+    # Load Iris dataset
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    # Convert to pandas DataFrame
+    df = pd.DataFrame(X, columns=iris.feature_names)
+    df["target"] = y
+
+    # Describe the dataset
+    print("Dataset summary (using pandas describe):")
+    print(df.describe(include="all"))
+
+    # 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=24
+    )
+
+    # Create KNN classifier
+    k = 3
+    knn_classifier = KNeighborsClassifier(n_neighbors=k)
+
+    # Fit classifier to training data
+    knn_classifier.fit(X_train, y_train)
+
+    # Make predictions
+    y_pred = knn_classifier.predict(X_test)
+
+    # Calculate accuracy
+    accuracy = accuracy_score(y_test, y_pred)
+    print(f"\nAccuracy: {accuracy * 100:.2f}%")
+
+
+if __name__ == "__main__":
+    run()

pico_lab/linear_regression.py

@@ -0,0 +1,66 @@
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+
+
+def run():
+    # Dataset: Years of experience and salary
+    data = {
+        "Experience": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+        "Salary": [
+            45000, 50000, 60000, 65000, 70000,
+            75000, 80000, 85000, 90000, 95000
+        ]
+    }
+
+    df = pd.DataFrame(data)
+    print("Dataset:")
+    print(df)
+
+    # Independent and dependent variables
+    X = df[["Experience"]]
+    y = df["Salary"]
+
+    # Split dataset: 80% training, 20% testing
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # Create and train the model
+    model = LinearRegression()
+    model.fit(X_train, y_train)
+
+    # Predict test data
+    y_pred = model.predict(X_test)
+
+    # Model parameters
+    print("\nIntercept (b0):", model.intercept_)
+    print("Coefficient (b1):", model.coef_[0])
+
+    # Evaluate model
+    print("Mean Squared Error (MSE):",
+          mean_squared_error(y_test, y_pred))
+    print("R2 Score:", r2_score(y_test, y_pred))
+
+    # Plot results
+    plt.scatter(X, y, color="blue", label="Actual Data")
+    plt.plot(
+        X, model.predict(X),
+        color="red", linewidth=2,
+        label="Regression Line"
+    )
+
+    plt.xlabel("Years of Experience")
+    plt.ylabel("Salary")
+    plt.title("Linear Regression Example")
+    plt.legend()
+    plt.show()
+
+
+if __name__ == "__main__":
+    run()

pico_lab/mlp.py

@@ -0,0 +1,38 @@
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import accuracy_score
+
+
+def run():
+    # 1. Load Iris dataset
+    iris = load_iris()
+    X, y = iris.data, iris.target
+
+    # 2. Split data 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
+    )
+
+    # 3. Initialize MLPClassifier
+    mlp = MLPClassifier(
+        hidden_layer_sizes=(10),
+        activation="relu",
+        max_iter=1000,
+        random_state=42
+    )
+
+    # 4. Train the MLP model
+    mlp.fit(X_train, y_train)
+
+    # 5. Make predictions on test set
+    y_pred = mlp.predict(X_test)
+
+    # 6. Evaluate model accuracy
+    accuracy = accuracy_score(y_test, y_pred)
+    print(f"MLP Classifier Accuracy: {accuracy:.4f}")
+
+
+if __name__ == "__main__":
+    run()

pico_lab/naive_bayes.py

@@ -0,0 +1,53 @@
+
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix
+)
+
+
+def run():
+    # Load Iris dataset
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    # Split the dataset
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # Create Naive Bayes classifier
+    clf = GaussianNB()
+
+    # Train the classifier
+    clf.fit(X_train, y_train)
+
+    # Make predictions
+    y_pred = clf.predict(X_test)
+
+    # Evaluate the classifier
+    accuracy = accuracy_score(y_test, y_pred)
+    confusion = confusion_matrix(y_test, y_pred)
+
+    classification_rep = classification_report(
+        y_test,
+        y_pred,
+        target_names=iris.target_names
+    )
+
+    # Print results
+    print("Accuracy:", accuracy)
+
+    print("\nConfusion matrix:")
+    print(confusion)
+
+    print("\nClassification report:")
+    print(classification_rep)
+
+
+if __name__ == "__main__":
+    run()

pico_lab/preprocessing.py

@@ -0,0 +1,99 @@
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+sns.set(color_codes=True)
+
+
+def run():
+    # Read the dataset
+    df = pd.read_csv("Toyota.csv")
+
+    # 1. Calculate percentage of missing values
+    missing = df.isnull().sum()
+    percentage = (missing / len(df)) * 100
+
+    print("Percentage of missing values:")
+    print(percentage)
+
+    # 2. Replace missing values with mean if below 10%
+    for col in df.columns:
+        if df[col].isnull().sum() / len(df) * 100 < 10:
+            if df[col].dtype != "object":
+                df[col] = df[col].fillna(df[col].mean())
+        else:
+            print("High missing percentage:", col)
+
+    # 3. Mode imputation for categorical data
+    common = df.apply(
+        lambda x: x.fillna(x.value_counts().index[0])
+        if not x.value_counts().empty else x
+    )
+
+    print("\nAfter mode imputation:")
+    print(common.head())
+
+    print("\nFuel types:")
+    print(df["FuelType"].unique())
+
+    # 4. Nearest interpolation for numeric missing values
+    for col in percentage.index:
+        if percentage[col] < 10 and pd.api.types.is_numeric_dtype(df[col]):
+            df[col] = df[col].interpolate(method="nearest")
+
+    # 5. Drop columns with more than 10% missing values
+    for col in df.columns.tolist():
+        if df[col].isnull().sum() * 100 / len(df) > 10:
+            df.drop(columns=[col], inplace=True)
+            print(col, "Dropped")
+
+    print("\nShape of dataset:", df.shape)
+
+    # 6. Drop rows with outlier Z-score greater than 4
+    threshold = 4
+    temp = df["Doors"].copy()
+
+    mean = np.mean(temp)
+    std = np.std(temp)
+
+    if std != 0:
+        z_scores = (temp - mean) / std
+        outlier_indices = z_scores[z_scores > threshold].index
+        df.drop(index=outlier_indices, inplace=True)
+
+        for z in z_scores.loc[outlier_indices]:
+            print(z, "row dropped")
+
+    print("\nDoors column:")
+    print(df["Doors"].head())
+
+    # 7. Drop duplicate rows based on HP
+    df = (
+        df.sort_values("KM", ascending=False)
+        .drop_duplicates("HP")
+        .sort_index()
+    )
+
+    # 8. Min-max normalization for Price
+    plt.title("Min-Max Normalization")
+    price = df["Price"]
+
+    xscal = (price - price.min()) / (price.max() - price.min())
+
+    sns.scatterplot(x=price, y=xscal)
+    plt.xlabel("Price")
+    plt.ylabel("Normalized Price")
+    plt.show()
+
+    # 9. One-hot encoding for FuelType
+    onehot = df["FuelType"]
+    dum = pd.get_dummies(onehot)
+
+    print("\nOne-hot encoded data:")
+    print(dum.head())
+
+
+if __name__ == "__main__":
+    run()

pico_lab/single_perceptron.py

@@ -0,0 +1,46 @@
+
+import numpy as np
+
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import Perceptron
+from sklearn.metrics import accuracy_score
+
+
+def run():
+    # Load Iris dataset
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    # Split dataset into training and testing
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # Standardize the features
+    sc = StandardScaler()
+    X_train_std = sc.fit_transform(X_train)
+    X_test_std = sc.transform(X_test)
+
+    # Create a single-layer perceptron classifier
+    perceptron = Perceptron(
+        max_iter=100,
+        eta0=0.1,
+        random_state=0
+    )
+
+    # Train the classifier
+    perceptron.fit(X_train_std, y_train)
+
+    # Make predictions
+    y_pred = perceptron.predict(X_test_std)
+
+    # Calculate accuracy
+    accuracy = accuracy_score(y_test, y_pred)
+    print(f"Accuracy: {accuracy:.2f}")
+
+
+if __name__ == "__main__":
+    run()

pico_lab/svr.py

@@ -0,0 +1,68 @@
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.metrics import mean_squared_error, r2_score
+
+
+def run():
+    # Load Iris dataset
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    # Create DataFrame
+    iris_df = pd.DataFrame(
+        data=np.c_[iris["data"], iris["target"]],
+        columns=iris["feature_names"] + ["target"]
+    )
+
+    print(iris_df.head(150))
+    print(iris_df.info())
+    print(iris_df.describe())
+
+    # Check unique values in target column
+    print("\nUnique target values:")
+    print(iris_df["target"].unique())
+
+    # Select regression target (second feature)
+    y_regression = X[:, 1]
+
+    # Pair plot
+    sns.pairplot(iris_df, hue="target", palette="rainbow")
+    plt.show()
+
+    # Split dataset
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y_regression, test_size=0.1, random_state=42
+    )
+
+    # Create and train SVR model
+    svr = SVR(kernel="linear")
+    svr.fit(X_train, y_train)
+
+    # Predict results
+    y_pred = svr.predict(X_test)
+
+    # Evaluate model
+    mse = mean_squared_error(y_test, y_pred)
+    r2 = r2_score(y_test, y_pred)
+
+    print("Mean squared error:", mse)
+    print("R-squared:", r2)
+
+    # Visualize actual vs predicted values
+    plt.scatter(y_test, y_pred)
+    plt.xlabel("Actual sepal width")
+    plt.ylabel("Predicted sepal width")
+    plt.title("SVR: Actual vs Predicted Sepal Width")
+    plt.show()
+
+
+if __name__ == "__main__":
+    run()

pico_lab-0.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: pico-lab
+Version: 0.1.0
+Summary: AI and Machine Learning Laboratory Toolkit for Robotics
+License-Expression: MIT
+Keywords: artificial-intelligence,machine-learning,robotics,laboratory,python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Education
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: scikit-learn
+
+
+# Pico Lab
+
+AI and Machine Learning Laboratory Toolkit for Robotics.
+
+Pico Lab is a Python package that provides source code for 12 AI and Machine Learning laboratory experiments.
+
+## Installation
+
+```bash
+pip install pico-lab
+```
+
+## Usage
+
+Run the following command:
+
+```bash
+pico-lab
+```
+
+Select an experiment number to display its complete Python source code.
+
+## Experiments
+
+1. Exploratory Data Analysis (EDA)
+2. Data Pre-processing
+3. Linear Regression Models
+4. Single Layer Perceptron Algorithm
+5. Multiple Layer Perceptron Training
+6. KNN Classifier
+7. Support Vector Regression
+8. Primitive Operations on Fuzzy Sets
+9. Naive Bayes Classifier
+10. K-Means Clustering
+11. Robotic Application using Depth First Search
+12. Robotic Application using Breadth First Search
+
+## Requirements
+
+- Python 3.9 or higher
+- NumPy
+- Pandas
+- Matplotlib
+- Seaborn
+- Scikit-learn
+
+## Dataset
+
+Experiments 1 and 2 require the Toyota.csv dataset.
+
+Other experiments use built-in datasets or predefined examples.
+
+## License
+
+MIT License

pico_lab-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+pico_lab/__init__.py,sha256=Mi1Tnk119fPOCfxXqCRHS-WFn52LDULoZ-BjZqsDy8c,25
+pico_lab/bfs.py,sha256=cOyZi41VFoJaCVyBT2eOOlUp4DceCNT3m1bOk8WVsHs,683
+pico_lab/cli.py,sha256=ftLdgm0bFB9brylZCVW3CpYYBWQ0tG0ReISkwOls0wY,1681
+pico_lab/dfs.py,sha256=j5jOFq7ok5RZoU0pZMEajpEUdaOY9aWbiBfTahTEekc,635
+pico_lab/eda.py,sha256=HeGBA_7LAQgJ4k8poCpoPgTYD1K4UN96X1_h_H47kNM,2302
+pico_lab/fuzzy_sets.py,sha256=KRBYrCCdptwjL83jrLVq3n5psT0Iad0GIz8XvM0bFKA,1678
+pico_lab/kmeans.py,sha256=uTdvZF8MEqt76e_oLpp3F8F0Bu3Pul9Jc2Sadl3EnSw,1279
+pico_lab/knn.py,sha256=evRc_C-Y27BwezBOHynftJb3F6A3iZ7sh03g1XgLKyE,1142
+pico_lab/linear_regression.py,sha256=dHuhiOcE-5Qn63HPjopkx5skG29phTjS1Ci2xoCjdp4,1670
+pico_lab/mlp.py,sha256=CMvHStFRRi_krOvcqTnlvqWRktmrWgOzwDKg2XkFuzs,958
+pico_lab/naive_bayes.py,sha256=BBK9gXy6jTLczjgFCMreFJOGTa79L25HT35kjg-hXVs,1163
+pico_lab/preprocessing.py,sha256=fm5L0FHz5SabcIqvQRKI6jmnCe6Zq7EpsBK1wRibBkc,2702
+pico_lab/single_perceptron.py,sha256=Y0WCLIeh9_df8QeQ72O1P_-EftWZ-OEr9pemyg5LesI,1123
+pico_lab/svr.py,sha256=MpG7GZxhvIksNbaNrn1Apxntmd7NypofCKQ6PDJ8e34,1688
+pico_lab-0.1.0.dist-info/METADATA,sha256=UMxHrQlpNx2QbbeLPWPUL0lyF2ugCYIuNRv0ba3Z3_s,1918
+pico_lab-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pico_lab-0.1.0.dist-info/entry_points.txt,sha256=aC1ks7YKVWyCgJVnR_7VQcdnz3AnHsgx8fkKWaE-g68,47
+pico_lab-0.1.0.dist-info/top_level.txt,sha256=FnZsLhF85Hj-0DoZtp05mPSpsRyMpi1Kq3CMdij--kA,9
+pico_lab-0.1.0.dist-info/RECORD,,

pico_lab-0.1.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
+

pico_lab-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pico-lab = pico_lab.cli:main

pico_lab-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pico_lab