scklearn 0.0.1__tar.gz

scklearn-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: scklearn
+Version: 0.0.1
+Summary: JBL speaker
+Author: Sheetal Goswami
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: requires-python
+Dynamic: summary

scklearn-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

scklearn-0.0.1/scklearn/__init__.py

@@ -0,0 +1 @@
+from .printer import train_model

scklearn-0.0.1/scklearn/printer.py

@@ -0,0 +1,9 @@
+from .snippets import codes
+
+def train_model(number):
+    code = codes.get(number)
+
+    if code:
+        print(code)
+    else:
+        print("Invalid number")

scklearn-0.0.1/scklearn/snippets.py

@@ -0,0 +1,654 @@
+codes = {
+
+    1: r'''
+#1
+import pandas as pd
+from sklearn.datasets import load_wine
+from sklearn.preprocessing import MinMaxScaler
+
+# ------------------------------------------
+# a) Creation and Loading of Datasets
+# ------------------------------------------
+
+# i. Create dataset manually
+director_info = pd.DataFrame({
+    'director': ['Francis Ford Coppola', 'Orson Welles', 'Richard Linklater'],
+    'country': ['USA', 'USA', 'USA']
+})
+
+print("Director Info Dataset:")
+print(director_info)
+
+
+# ii. Load CSV dataset
+df = pd.read_csv("metacritic_movies.csv")
+print("\nMetacritic Movies Dataset:")
+print(df.head())
+
+
+# iii. Load dataset using sklearn
+wine = load_wine()
+df_wine = pd.DataFrame(wine.data, columns=wine.feature_names)
+df_wine['target'] = wine.target
+
+print("\nWine Dataset:")
+print(df_wine.head())
+
+
+# ------------------------------------------
+# b) Statistical Measures
+# ------------------------------------------
+
+num_data = df[['duration', 'metascore', 'userscore']]
+
+print("\nMean:\n", num_data.mean())
+print("\nMedian:\n", num_data.median())
+print("\nMode:\n", num_data.mode().iloc[0])
+print("\nVariance:\n", num_data.var())
+print("\nStandard Deviation:\n", num_data.std())
+
+
+# ------------------------------------------
+# c) Data Preprocessing
+# ------------------------------------------
+
+# i. Reshaping
+reshaped_data = df['duration'].values.reshape(-1, 1)
+print("\nReshaped Data:")
+print(reshaped_data[:5])
+
+
+# ii. Filtering
+filtered_data = df[df['metascore'] > 80]
+print("\nFiltered Data (Metascore > 80):")
+print(filtered_data[['title', 'metascore']].head())
+
+
+# iii. Merging
+merged_df = pd.merge(df, director_info, on='director', how='left')
+print("\nMerged Dataset:")
+print(merged_df[['title', 'director', 'country']].head())
+
+
+# iv. Handling Missing Values
+print("\nMissing Values Before Handling:")
+print(df.isnull().sum())
+
+df['metascore'].fillna(df['metascore'].mean(), inplace=True)
+df['userscore'].fillna(df['userscore'].mean(), inplace=True)
+df['director'].fillna(df['director'].mode()[0], inplace=True)
+
+print("\nMissing Values After Handling:")
+print(df.isnull().sum())
+
+
+# v. Feature Normalization
+scaler = MinMaxScaler()
+df[['duration', 'metascore', 'userscore']] = scaler.fit_transform(
+    df[['duration', 'metascore', 'userscore']]
+)
+
+print("\nNormalized Features:")
+print(df[['duration', 'metascore', 'userscore']].head())
+''',
+
+
+    2: r'''
+#2
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+
+# ------------------------------------------
+# Load Iris Dataset
+# ------------------------------------------
+
+iris = load_iris()
+
+# Use only ONE feature (Simple Linear Regression)
+X = iris.data[:, 0].reshape(-1, 1)
+y = iris.target
+
+print("Feature Shape:", X.shape)
+print("Target Shape:", y.shape)
+
+
+# ------------------------------------------
+# Split Dataset
+# ------------------------------------------
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+
+# ------------------------------------------
+# Create and Train Model
+# ------------------------------------------
+
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+
+# ------------------------------------------
+# Prediction
+# ------------------------------------------
+
+y_pred = model.predict(X_test)
+
+# Convert continuous output → class labels
+y_pred_class = np.round(y_pred).astype(int)
+y_pred_class = np.clip(y_pred_class, 0, 2)
+
+
+# ------------------------------------------
+# Confusion Matrix
+# ------------------------------------------
+
+cm = confusion_matrix(y_test, y_pred_class)
+
+print("\nConfusion Matrix:\n", cm)
+
+
+# ------------------------------------------
+# Plot Confusion Matrix
+# ------------------------------------------
+
+disp = ConfusionMatrixDisplay(
+    confusion_matrix=cm,
+    display_labels=iris.target_names
+)
+
+disp.plot(cmap="Blues")
+plt.title("Confusion Matrix - Simple Linear Regression (Iris)")
+plt.show()
+''',
+
+
+    3: r'''
+import pandas as pd
+from sklearn.datasets import load_wine
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+
+# Load dataset
+wine = load_wine()
+df = pd.DataFrame(wine.data, columns=wine.feature_names)
+df["target"] = wine.target
+
+# Define X and y
+X = df[["alcohol", "malic_acid", "ash"]]
+y = df["target"]
+
+# Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+# Model
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+# Prediction
+y_pred = model.predict(X_test)
+
+# Evaluation
+mse = mean_squared_error(y_test, y_pred)
+r2 = r2_score(y_test, y_pred)
+
+print("MSE:", mse)
+print("R2 Score:", r2)
+
+# Coefficients
+coefficients = pd.DataFrame({
+    "Feature": X.columns,
+    "Coefficient": model.coef_
+})
+
+print("\nCoefficients:\n", coefficients)
+''',
+
+
+    4: r'''
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC
+from sklearn.metrics import confusion_matrix, accuracy_score
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Load dataset
+data = load_iris()
+X = data.data
+y = data.target
+
+# Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Model
+model = SVC(kernel='linear')
+model.fit(X_train, y_train)
+
+# Prediction
+y_pred = model.predict(X_test)
+
+# Confusion Matrix
+cm = confusion_matrix(y_test, y_pred)
+print("Confusion Matrix:\n", cm)
+
+# Accuracy
+accuracy = accuracy_score(y_test, y_pred)
+print("Accuracy:", accuracy)
+
+# Plot
+sns.heatmap(cm, annot=True, cmap='Blues')
+plt.xlabel("Predicted")
+plt.ylabel("Actual")
+plt.title("Confusion Matrix")
+plt.show()
+''',
+
+
+    5: r'''
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_breast_cancer
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import BaggingClassifier, AdaBoostClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
+
+# Load dataset
+data = load_breast_cancer()
+X = data.data
+y = data.target
+
+# Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+# ---------------- BAGGING ----------------
+bagging_model = BaggingClassifier(
+    estimator=DecisionTreeClassifier(),
+    n_estimators=50,
+    random_state=42
+)
+
+bagging_model.fit(X_train, y_train)
+y_pred_bag = bagging_model.predict(X_test)
+bag_acc = accuracy_score(y_test, y_pred_bag)
+
+# ---------------- BOOSTING ----------------
+boosting_model = AdaBoostClassifier(
+    estimator=DecisionTreeClassifier(max_depth=1),
+    n_estimators=50,
+    learning_rate=1.0,
+    random_state=42
+)
+
+boosting_model.fit(X_train, y_train)
+y_pred_boost = boosting_model.predict(X_test)
+boost_acc = accuracy_score(y_test, y_pred_boost)
+
+# Accuracy comparison
+plt.bar(['Bagging', 'Boosting'], [bag_acc, boost_acc])
+plt.title("Accuracy Comparison")
+plt.show()
+
+# Confusion Matrix - Bagging
+cm_bag = confusion_matrix(y_test, y_pred_bag)
+ConfusionMatrixDisplay(cm_bag).plot()
+plt.title("Bagging CM")
+plt.show()
+
+# Confusion Matrix - Boosting
+cm_boost = confusion_matrix(y_test, y_pred_boost)
+ConfusionMatrixDisplay(cm_boost).plot()
+plt.title("Boosting CM")
+plt.show()
+
+# Feature Importance (Boosting)
+importances = boosting_model.feature_importances_
+plt.bar(range(len(importances)), importances)
+plt.title("Feature Importance")
+plt.show()
+''',
+
+
+    6: r'''
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier, plot_tree
+from sklearn.metrics import confusion_matrix, accuracy_score, ConfusionMatrixDisplay
+
+# Load dataset
+data = load_iris()
+X = data.data
+y = data.target
+
+# Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+# Model (ID3 using entropy)
+model = DecisionTreeClassifier(criterion='entropy')
+model.fit(X_train, y_train)
+
+# Prediction
+y_pred = model.predict(X_test)
+
+# Confusion Matrix
+cm = confusion_matrix(y_test, y_pred)
+print("Confusion Matrix:\n", cm)
+
+# Accuracy
+accuracy = accuracy_score(y_test, y_pred)
+print("Accuracy:", accuracy)
+
+# Tree Plot
+plt.figure()
+plot_tree(
+    model,
+    feature_names=data.feature_names,
+    class_names=data.target_names,
+    filled=True
+)
+plt.title("Decision Tree")
+plt.show()
+
+# Confusion Matrix Plot
+ConfusionMatrixDisplay(cm, display_labels=data.target_names).plot()
+plt.title("Confusion Matrix")
+plt.show()
+
+# Accuracy Bar
+plt.bar(['Decision Tree'], [accuracy])
+plt.title("Accuracy")
+plt.show()
+''',
+
+
+# Continue adding these too
+
+
+    7: r'''
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
+from sklearn.preprocessing import LabelEncoder
+
+# Load dataset
+url = "https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv"
+df = pd.read_csv(url)
+
+# Features and target
+X = df[['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth']]
+y = df['Name']
+
+# Encode target
+le = LabelEncoder()
+y_encoded = le.fit_transform(y)
+
+# Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y_encoded, test_size=0.3, random_state=42
+)
+
+# K values
+k_values = [1, 3, 5, 7]
+results = []
+
+for k in k_values:
+
+    print("\n============================")
+    print(f"K = {k}")
+    print("============================")
+
+    # Model
+    knn = KNeighborsClassifier(n_neighbors=k)
+    knn.fit(X_train, y_train)
+
+    # Prediction
+    y_pred = knn.predict(X_test)
+
+    # Accuracy
+    acc = accuracy_score(y_test, y_pred)
+    results.append([k, acc])
+    print("Accuracy:", acc)
+
+    # Confusion Matrix
+    cm = confusion_matrix(y_test, y_pred)
+    print("Confusion Matrix:\n", cm)
+
+    # Classification Report
+    print(classification_report(y_test, y_pred, target_names=le.classes_))
+
+    # Plot CM
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                xticklabels=le.classes_,
+                yticklabels=le.classes_)
+    plt.title(f'Confusion Matrix (k={k})')
+    plt.xlabel('Predicted')
+    plt.ylabel('Actual')
+    plt.show()
+
+
+# Compare results
+result_df = pd.DataFrame(results, columns=['K', 'Accuracy'])
+print("\nComparison:\n", result_df)
+
+# Plot accuracy vs K
+plt.plot(result_df['K'], result_df['Accuracy'], marker='o')
+plt.title("K vs Accuracy")
+plt.xlabel("K")
+plt.ylabel("Accuracy")
+plt.grid(True)
+plt.show()
+''',
+
+
+    8: r'''
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import StandardScaler
+
+# Load dataset
+url = "https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv"
+df = pd.read_csv(url)
+
+# Features only
+X = df[['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth']]
+
+# Scaling
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# K values
+k_values = [1, 3, 5]
+inertia_values = []
+
+for k in k_values:
+
+    print("\n============================")
+    print(f"K = {k}")
+    print("============================")
+
+    # Model
+    kmeans = KMeans(n_clusters=k, random_state=42)
+    kmeans.fit(X_scaled)
+
+    # Results
+    labels = kmeans.labels_
+    inertia = kmeans.inertia_
+    inertia_values.append(inertia)
+
+    print("Inertia:", inertia)
+
+    # Plot clusters
+    plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels)
+    plt.title(f"K-Means (k={k})")
+    plt.xlabel("Feature 1")
+    plt.ylabel("Feature 2")
+    plt.show()
+
+# Elbow method
+plt.plot(k_values, inertia_values, marker='o')
+plt.title("K vs Inertia")
+plt.xlabel("K")
+plt.ylabel("Inertia")
+plt.grid(True)
+plt.show()
+''',
+
+
+
+# Final additions
+
+
+    9: r'''
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+from sklearn.neural_network import MLPClassifier
+
+# Load dataset
+url = "https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv"
+df = pd.read_csv(url)
+
+# Features & target
+X = df[['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth']]
+y = df['Name']
+
+# Encode labels
+le = LabelEncoder()
+y_encoded = le.fit_transform(y)
+
+# Scale data
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X_scaled, y_encoded, test_size=0.3, random_state=42
+)
+
+# ANN Model
+ann = MLPClassifier(
+    hidden_layer_sizes=(8, 8),
+    activation='relu',
+    solver='adam',
+    max_iter=500,
+    random_state=42
+)
+
+# Train
+ann.fit(X_train, y_train)
+
+# Predict
+y_pred = ann.predict(X_test)
+
+# Evaluation
+accuracy = accuracy_score(y_test, y_pred)
+cm = confusion_matrix(y_test, y_pred)
+
+print("Accuracy:", accuracy)
+print("Confusion Matrix:\n", cm)
+
+print("\nClassification Report:\n",
+      classification_report(y_test, y_pred, target_names=le.classes_))
+
+# Plot confusion matrix
+plt.imshow(cm)
+plt.title("Confusion Matrix")
+plt.xlabel("Predicted")
+plt.ylabel("Actual")
+plt.colorbar()
+plt.show()
+''',
+
+
+    10: r'''
+import numpy as np
+import matplotlib.pyplot as plt
+
+from tensorflow.keras.datasets import mnist
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
+from tensorflow.keras.utils import to_categorical
+
+from sklearn.metrics import confusion_matrix
+
+# Load dataset
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+
+# Reshape
+X_train = X_train.reshape(-1, 28, 28, 1)
+X_test = X_test.reshape(-1, 28, 28, 1)
+
+# Normalize
+X_train = X_train / 255.0
+X_test = X_test / 255.0
+
+# One-hot encoding
+y_train_cat = to_categorical(y_train, 10)
+y_test_cat = to_categorical(y_test, 10)
+
+# Model
+model = Sequential()
+
+model.add(Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)))
+model.add(MaxPooling2D((2,2)))
+
+model.add(Conv2D(64, (3,3), activation='relu'))
+model.add(MaxPooling2D((2,2)))
+
+model.add(Flatten())
+
+model.add(Dense(128, activation='relu'))
+model.add(Dense(10, activation='softmax'))
+
+# Compile
+model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+
+# Train
+model.fit(X_train, y_train_cat, epochs=5, batch_size=64)
+
+# Evaluate
+loss, accuracy = model.evaluate(X_test, y_test_cat)
+print("Accuracy:", accuracy)
+
+# Predict
+y_pred = model.predict(X_test)
+y_pred_classes = np.argmax(y_pred, axis=1)
+
+# Confusion matrix
+cm = confusion_matrix(y_test, y_pred_classes)
+print("Confusion Matrix:\n", cm)
+
+# Plot
+plt.imshow(cm)
+plt.title("Confusion Matrix")
+plt.xlabel("Predicted")
+plt.ylabel("Actual")
+plt.colorbar()
+plt.show()
+''',
+
+
+}

scklearn-0.0.1/scklearn.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: scklearn
+Version: 0.0.1
+Summary: JBL speaker
+Author: Sheetal Goswami
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: requires-python
+Dynamic: summary

scklearn-0.0.1/scklearn.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+setup.py
+scklearn/__init__.py
+scklearn/printer.py
+scklearn/snippets.py
+scklearn.egg-info/PKG-INFO
+scklearn.egg-info/SOURCES.txt
+scklearn.egg-info/dependency_links.txt
+scklearn.egg-info/top_level.txt

scklearn-0.0.1/scklearn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scklearn-0.0.1/scklearn.egg-info/top_level.txt

@@ -0,0 +1 @@
+scklearn

scklearn-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scklearn-0.0.1/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="scklearn",
+    version="0.0.1",
+    author="Sheetal Goswami",
+    description="JBL speaker",
+    packages=find_packages(),
+    install_requires=[],
+    python_requires=">=3.6",
+)