cvip-labs 0.1.0__tar.gz

cvip_labs-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: cvip_labs
+Version: 0.1.0
+Summary: CVIP 6th sem lab helpers - MNIST and CNN experiments
+Author: cvip_labs
+Project-URL: Homepage, https://pypi.org/project/cvip_labs
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Requires-Dist: torch
+Requires-Dist: tensorflow
+Requires-Dist: opencv-python
+
+# cvip_labs
+
+CVIP 6th sem lab helpers.
+
+## Install
+pip install cvip_labs
+
+## Exp 4 - MNIST SVM + Neural Network
+from cvip_labs import run_exp4
+X_train, X_test, y_train, y_test = run_exp4.load_data()
+svm_model = run_exp4.train_svm(X_train, y_train)
+svm_acc   = run_exp4.evaluate(svm_model, X_test, y_test)
+nn_model  = run_exp4.train_nn(X_train, y_train, epochs=5)
+nn_acc    = run_exp4.evaluate_nn(nn_model, X_test, y_test)
+run_exp4.plot_results()
+
+## Exp 5 - CNN Image Classifier
+from cvip_labs import run_exp5
+train, val, test, class_names = run_exp5.load_data(data_dir='exp5')
+model = run_exp5.build_model()
+model.summary()
+hist  = run_exp5.train_model(model, train, val, epochs=20)
+run_exp5.plot_results(hist)
+run_exp5.evaluate(model, test)
+run_exp5.predict(model, class_names, img_path='images6.jpg')
+run_exp5.save_model(model)

cvip_labs-0.1.0/README.md

@@ -0,0 +1,26 @@
+# cvip_labs
+
+CVIP 6th sem lab helpers.
+
+## Install
+pip install cvip_labs
+
+## Exp 4 - MNIST SVM + Neural Network
+from cvip_labs import run_exp4
+X_train, X_test, y_train, y_test = run_exp4.load_data()
+svm_model = run_exp4.train_svm(X_train, y_train)
+svm_acc   = run_exp4.evaluate(svm_model, X_test, y_test)
+nn_model  = run_exp4.train_nn(X_train, y_train, epochs=5)
+nn_acc    = run_exp4.evaluate_nn(nn_model, X_test, y_test)
+run_exp4.plot_results()
+
+## Exp 5 - CNN Image Classifier
+from cvip_labs import run_exp5
+train, val, test, class_names = run_exp5.load_data(data_dir='exp5')
+model = run_exp5.build_model()
+model.summary()
+hist  = run_exp5.train_model(model, train, val, epochs=20)
+run_exp5.plot_results(hist)
+run_exp5.evaluate(model, test)
+run_exp5.predict(model, class_names, img_path='images6.jpg')
+run_exp5.save_model(model)

cvip_labs-0.1.0/cvip_labs/__init__.py

@@ -0,0 +1,5 @@
+from . import run_exp4
+from . import run_exp5
+
+__version__ = "0.1.0"
+__all__ = ["run_exp4", "run_exp5"]

cvip_labs-0.1.0/cvip_labs/run_exp4.py

@@ -0,0 +1,143 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+_data = {}
+_loss_history = []
+
+def load_data():
+    """Load and preprocess MNIST dataset"""
+    from tensorflow.keras.datasets import mnist
+
+    print("Loading MNIST dataset...")
+    (x_train, y_train), (x_test, y_test) = mnist.load_data()
+
+    # Show sample images
+    plt.figure(figsize=(10, 2))
+    for i in range(5):
+        plt.subplot(1, 5, i+1)
+        plt.imshow(x_train[i], cmap='gray')
+        plt.title(str(y_train[i]))
+        plt.axis('off')
+    plt.suptitle("Sample MNIST Images")
+    plt.tight_layout()
+    plt.show()
+
+    X_train = x_train.reshape(-1, 784) / 255.0
+    X_test  = x_test.reshape(-1, 784)  / 255.0
+
+    _data['X_train'] = X_train
+    _data['X_test']  = X_test
+    _data['y_train'] = y_train
+    _data['y_test']  = y_test
+
+    print(f"Train samples: {X_train.shape[0]}, Test samples: {X_test.shape[0]}")
+    return X_train, X_test, y_train, y_test
+
+
+def train_svm(X_train, y_train):
+    """Train SVM classifier on MNIST"""
+    from sklearn.svm import SVC
+
+    print("Training SVM on 10,000 samples...")
+    svm_model = SVC()
+    svm_model.fit(X_train[:10000], y_train[:10000])
+    print("SVM training complete!")
+    _data['svm'] = svm_model
+    return svm_model
+
+
+def evaluate(svm_model, X_test, y_test):
+    """Evaluate SVM model on test data"""
+    from sklearn.metrics import accuracy_score
+
+    y_pred = svm_model.predict(X_test)
+    acc = accuracy_score(y_test, y_pred)
+    print(f"SVM Accuracy: {acc:.4f}")
+    _data['svm_acc'] = acc
+    return acc
+
+
+def train_nn(X_train, y_train, epochs=5):
+    """Train PyTorch Neural Network on MNIST"""
+    import torch
+    import torch.nn as nn
+
+    global _loss_history
+    _loss_history = []
+    _acc_history  = []
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Training Neural Network on {device} for {epochs} epochs...")
+
+    nn_model = nn.Sequential(
+        nn.Linear(784, 64),
+        nn.ReLU(),
+        nn.Linear(64, 10)
+    ).to(device)
+
+    Xt = torch.tensor(X_train, dtype=torch.float32).to(device)
+    yt = torch.tensor(y_train, dtype=torch.long).to(device)
+    opt = torch.optim.Adam(nn_model.parameters())
+
+    for epoch in range(epochs):
+        out  = nn_model(Xt)
+        loss = nn.CrossEntropyLoss()(out, yt)
+        opt.zero_grad(); loss.backward(); opt.step()
+
+        preds = torch.argmax(out, dim=1).cpu().numpy()
+        acc   = np.mean(preds == y_train)
+
+        _loss_history.append(loss.item())
+        _acc_history.append(acc)
+        print(f"  Epoch {epoch+1}/{epochs} — Loss: {loss.item():.4f} | Accuracy: {acc:.4f}")
+
+    _data['nn_model']    = nn_model
+    _data['device']      = device
+    _data['acc_history'] = _acc_history
+    return nn_model
+
+
+def evaluate_nn(nn_model, X_test, y_test):
+    """Evaluate Neural Network on test data"""
+    import torch
+
+    device = _data.get('device', torch.device('cpu'))
+    Xtest_t = torch.tensor(X_test, dtype=torch.float32).to(device)
+
+    with torch.no_grad():
+        preds = torch.argmax(nn_model(Xtest_t), dim=1).cpu().numpy()
+
+    acc = np.mean(preds == y_test)
+    print(f"Neural Network Accuracy: {acc:.4f}")
+    _data['nn_acc'] = acc
+    return acc
+
+
+def plot_results():
+    """Plot epoch vs loss and epoch vs accuracy graphs"""
+    epochs = range(1, len(_loss_history) + 1)
+    acc_history = _data.get('acc_history', [])
+
+    fig, ax = plt.subplots(1, 2, figsize=(12, 4))
+
+    # Graph 1 - Epoch vs Loss
+    ax[0].plot(epochs, _loss_history, marker='o', color='steelblue', linewidth=2)
+    ax[0].set_title("Epoch vs Loss")
+    ax[0].set_xlabel("Epoch")
+    ax[0].set_ylabel("Loss")
+    ax[0].grid(True)
+
+    # Graph 2 - Epoch vs Accuracy
+    ax[1].plot(epochs, acc_history, marker='s', color='coral', linewidth=2)
+    ax[1].set_title("Epoch vs Accuracy")
+    ax[1].set_xlabel("Epoch")
+    ax[1].set_ylabel("Accuracy")
+    ax[1].set_ylim(0, 1)
+    ax[1].grid(True)
+
+    plt.tight_layout()
+    plt.show()
+
+    print("\n--- Final Summary ---")
+    print(f"SVM Accuracy        : {_data.get('svm_acc', 'N/A')}")
+    print(f"Neural Net Accuracy : {_data.get('nn_acc', 'N/A')}")

cvip_labs-0.1.0/cvip_labs/run_exp5.py

@@ -0,0 +1,124 @@
+import matplotlib.pyplot as plt
+
+_state = {}
+
+def load_data(data_dir):
+    """Load and split image dataset from directory"""
+    import tensorflow as tf
+
+    for gpu in tf.config.list_physical_devices('GPU'):
+        tf.config.experimental.set_memory_growth(gpu, True)
+
+    print(f"Loading dataset from: {data_dir}")
+    data = tf.keras.utils.image_dataset_from_directory(
+        data_dir, image_size=(256, 256), batch_size=32
+    )
+    class_names = data.class_names
+    print(f"Classes found: {class_names}")
+
+    data = data.shuffle(1000).map(lambda x, y: (x / 255.0, y))
+    n = len(data)
+    train = data.take(int(0.7 * n))
+    val   = data.skip(int(0.7 * n)).take(int(0.2 * n))
+    test  = data.skip(int(0.9 * n))
+
+    print(f"Train batches: {int(0.7*n)} | Val batches: {int(0.2*n)} | Test batches: {n - int(0.9*n)}")
+
+    _state['class_names'] = class_names
+    return train, val, test, class_names
+
+
+def build_model():
+    """Build CNN model architecture"""
+    from tensorflow.keras import models, layers, metrics
+
+    print("Building CNN model...")
+    model = models.Sequential([
+        layers.Conv2D(16, (3,3), activation='relu', input_shape=(256,256,3)),
+        layers.MaxPooling2D(),
+        layers.Conv2D(32, (3,3), activation='relu'),
+        layers.MaxPooling2D(),
+        layers.Conv2D(64, (3,3), activation='relu'),
+        layers.MaxPooling2D(),
+        layers.Flatten(),
+        layers.Dense(128, activation='relu'),
+        layers.Dropout(0.5),
+        layers.Dense(1, activation='sigmoid')
+    ])
+    model.compile(
+        optimizer='adam',
+        loss='binary_crossentropy',
+        metrics=['accuracy',
+                 metrics.Precision(name='precision'),
+                 metrics.Recall(name='recall')]
+    )
+    _state['model'] = model
+    return model
+
+
+def train_model(model, train, val, epochs=20):
+    """Train CNN model with early stopping"""
+    from tensorflow.keras import callbacks
+
+    early_stop = callbacks.EarlyStopping(
+        monitor='val_loss', patience=3, restore_best_weights=True
+    )
+    print(f"Training model for {epochs} epochs...")
+    hist = model.fit(
+        train, epochs=epochs,
+        validation_data=val,
+        callbacks=[early_stop]
+    )
+    _state['hist'] = hist
+    return hist
+
+
+def plot_results(hist):
+    """Plot training loss and accuracy curves"""
+    fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+
+    ax[0].plot(hist.history['loss'], label='Loss')
+    ax[0].plot(hist.history['val_loss'], label='Val Loss')
+    ax[0].set_title('Loss'); ax[0].legend()
+
+    ax[1].plot(hist.history['accuracy'], label='Accuracy')
+    ax[1].plot(hist.history['val_accuracy'], label='Val Accuracy')
+    ax[1].set_title('Accuracy'); ax[1].legend()
+
+    plt.tight_layout()
+    plt.show()
+
+
+def evaluate(model, test):
+    """Evaluate model on test dataset"""
+    print("\nEvaluating on test data:")
+    results = model.evaluate(test)
+    return results
+
+
+def predict(model, class_names, img_path):
+    """Predict class of a single image"""
+    import cv2
+    import numpy as np
+
+    img = cv2.imread(img_path)
+    img_resized = cv2.resize(img, (256, 256))
+
+    plt.imshow(cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB))
+    plt.title("Test Image"); plt.axis('off'); plt.show()
+
+    pred = model.predict(
+        numpy_expand := img_resized / 255.0,
+    )
+    pred = model.predict(__import__('numpy').expand_dims(img_resized / 255.0, axis=0))
+    label = class_names[int(pred[0][0] > 0.5)]
+    print(f"Predicted Class: {label}")
+    return label
+
+
+def save_model(model, path='models/imageclassifier.h5'):
+    """Save trained model to disk"""
+    import os
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    model.save(path)
+    print(f"Model saved to {path}")

cvip_labs-0.1.0/cvip_labs.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: cvip_labs
+Version: 0.1.0
+Summary: CVIP 6th sem lab helpers - MNIST and CNN experiments
+Author: cvip_labs
+Project-URL: Homepage, https://pypi.org/project/cvip_labs
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Requires-Dist: torch
+Requires-Dist: tensorflow
+Requires-Dist: opencv-python
+
+# cvip_labs
+
+CVIP 6th sem lab helpers.
+
+## Install
+pip install cvip_labs
+
+## Exp 4 - MNIST SVM + Neural Network
+from cvip_labs import run_exp4
+X_train, X_test, y_train, y_test = run_exp4.load_data()
+svm_model = run_exp4.train_svm(X_train, y_train)
+svm_acc   = run_exp4.evaluate(svm_model, X_test, y_test)
+nn_model  = run_exp4.train_nn(X_train, y_train, epochs=5)
+nn_acc    = run_exp4.evaluate_nn(nn_model, X_test, y_test)
+run_exp4.plot_results()
+
+## Exp 5 - CNN Image Classifier
+from cvip_labs import run_exp5
+train, val, test, class_names = run_exp5.load_data(data_dir='exp5')
+model = run_exp5.build_model()
+model.summary()
+hist  = run_exp5.train_model(model, train, val, epochs=20)
+run_exp5.plot_results(hist)
+run_exp5.evaluate(model, test)
+run_exp5.predict(model, class_names, img_path='images6.jpg')
+run_exp5.save_model(model)

cvip_labs-0.1.0/cvip_labs.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+cvip_labs/__init__.py
+cvip_labs/run_exp4.py
+cvip_labs/run_exp5.py
+cvip_labs.egg-info/PKG-INFO
+cvip_labs.egg-info/SOURCES.txt
+cvip_labs.egg-info/dependency_links.txt
+cvip_labs.egg-info/requires.txt
+cvip_labs.egg-info/top_level.txt

cvip_labs-0.1.0/cvip_labs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cvip_labs-0.1.0/cvip_labs.egg-info/requires.txt

@@ -0,0 +1,6 @@
+numpy
+matplotlib
+scikit-learn
+torch
+tensorflow
+opencv-python

cvip_labs-0.1.0/cvip_labs.egg-info/top_level.txt

@@ -0,0 +1 @@
+cvip_labs

cvip_labs-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cvip_labs"
+version = "0.1.0"
+authors = [
+    { name = "cvip_labs" }
+]
+description = "CVIP 6th sem lab helpers - MNIST and CNN experiments"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "matplotlib",
+    "scikit-learn",
+    "torch",
+    "tensorflow",
+    "opencv-python",
+]
+
+[project.urls]
+Homepage = "https://pypi.org/project/cvip_labs"

cvip_labs-0.1.0/setup.cfg

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