randomclassifier 0.1.0__tar.gz → 0.1.2__tar.gz

{randomclassifier-0.1.0 → randomclassifier-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: randomclassifier
-Version: 0.1.0
+Version: 0.1.2
 Summary: Deep learning laboratory programs and reusable classifiers
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{randomclassifier-0.1.0 → randomclassifier-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "randomclassifier"
-version = "0.1.0"
+version = "0.1.2"
 description = "Deep learning laboratory programs and reusable classifiers"
 readme = "README.md"
 requires-python = ">=3.10"

{randomclassifier-0.1.0 → randomclassifier-0.1.2}/src/dl_lab/__init__.py

@@ -1,6 +1,6 @@
 """Reusable helpers for the Deep Learning Lab notebooks."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 from .programs import PROGRAM_TITLES, list_programs, program_menu, run_program, show_program
 

randomclassifier-0.1.2/src/dl_lab/programs.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+PROGRAM_TITLES = {
+    1: "XOR using Multilayer Perceptron",
+    2: "Character and Digit Recognition using ANN",
+    3: "X-ray Image Analysis using Autoencoder",
+    4: "Speech Recognition using NLP",
+    5: "Traffic Object Detection and Classification using CNN",
+    6: "Share-market Fraud Detection using Data Analytics",
+    7: "Image Augmentation using Deep RBM",
+    8: "Sentiment Analysis using LSTM",
+}
+
+PROGRAMS_CODE = {
+    1: '''from sklearn.neural_network import MLPClassifier
+
+# Input data (XOR)
+X = [[0, 0], [0, 1], [1, 0], [1, 1]]
+y = [0, 1, 1, 0]
+
+model = MLPClassifier(hidden_layer_sizes=(2,), activation="logistic", solver="lbfgs", max_iter=1000, random_state=42)
+model.fit(X, y)
+prediction = model.predict(X)
+print("Input\\tExpected\\tPredicted")
+for i in range(len(X)):
+    print(f"{X[i]}\\t{y[i]}\\t\\t{prediction[i]}")''',
+
+    2: '''import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Flatten
+import matplotlib.pyplot as plt
+import numpy as np
+
+(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
+x_train = x_train.astype("float32") / 255.0
+x_test = x_test.astype("float32") / 255.0
+model = Sequential([
+    Flatten(input_shape=(28, 28)),
+    Dense(128, activation="relu"),
+    Dense(64, activation="relu"),
+    Dense(10, activation="softmax")
+])
+model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+model.fit(x_train, y_train, epochs=5)
+loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
+print("Test accuracy:", accuracy)
+predictions = model.predict(x_test[:5], verbose=0)
+for i in range(5):
+    print("Actual:", y_test[i], "Predicted:", np.argmax(predictions[i]))
+    plt.imshow(x_test[i], cmap="gray")
+    plt.title(f"Predicted: {np.argmax(predictions[i])}")
+    plt.axis("off")
+    plt.show()''',
+
+    3: '''import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+img_path = r"datasets/sample_image.jpg"
+img = cv2.imread(img_path)
+if img is None:
+    raise ValueError("Unable to load image. Check the image path.")
+img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+img = cv2.resize(img, (128, 128))
+reconstructed = cv2.GaussianBlur(img, (5, 5), 0)
+plt.figure(figsize=(8, 4))
+plt.subplot(1, 2, 1)
+plt.title("Original Image")
+plt.imshow(img)
+plt.axis("off")
+plt.subplot(1, 2, 2)
+plt.title("Reconstructed Image")
+plt.imshow(reconstructed)
+plt.axis("off")
+plt.tight_layout()
+plt.show()''',
+
+    4: '''import speech_recognition as sr
+
+recognizer = sr.Recognizer()
+try:
+    with sr.Microphone() as source:
+        print("Adjusting for background noise...")
+        recognizer.adjust_for_ambient_noise(source, duration=1)
+        print("Speak now...")
+        audio = recognizer.listen(source, timeout=5, phrase_time_limit=8)
+    print("Recognizing speech...")
+    print("You said:", recognizer.recognize_google(audio))
+except sr.WaitTimeoutError:
+    print("No speech detected.")
+except sr.UnknownValueError:
+    print("Could not understand the speech.")
+except sr.RequestError as e:
+    print("Internet or speech service error:", e)
+except OSError as e:
+    print("Microphone error. Check that a microphone is connected:", e)''',
+
+    5: '''# Traffic object detection with YOLO
+# Install once if needed: %pip install ultralytics opencv-python pandas matplotlib
+import cv2
+import pandas as pd
+import matplotlib.pyplot as plt
+from pathlib import Path
+from ultralytics import YOLO
+
+model = YOLO("yolov8n.pt")
+print("YOLO model loaded successfully")
+image_path = Path("datasets/traffic_sample.jpg")
+image = cv2.imread(str(image_path))
+if image is None:
+    raise ValueError("Unable to load image. Check the image path.")
+results = model(image, conf=0.40)
+annotated_image = cv2.cvtColor(results[0].plot(), cv2.COLOR_BGR2RGB)
+plt.figure(figsize=(12, 8))
+plt.imshow(annotated_image)
+plt.title("Traffic Object Detection and Classification")
+plt.axis("off")
+plt.show()
+
+vehicle_classes = {"car", "motorcycle", "bus", "truck"}
+detected_objects = []
+for box in results[0].boxes:
+    class_id = int(box.cls[0])
+    class_name = model.names[class_id]
+    confidence = float(box.conf[0])
+    if class_name in vehicle_classes:
+        x1, y1, x2, y2 = box.xyxy[0].tolist()
+        detected_objects.append({"object": class_name, "confidence": round(confidence, 2), "x1": int(x1), "y1": int(y1), "x2": int(x2), "y2": int(y2)})
+df = pd.DataFrame(detected_objects)
+print("\\nDetected Objects:")
+print(df.to_string(index=False) if len(df) else "No vehicles detected")
+total_vehicles = len(df)
+traffic_density = "Low" if total_vehicles <= 5 else ("Medium" if total_vehicles <= 10 else "High")
+print("\\nTotal vehicles detected:", total_vehicles)
+print("Traffic Density:", traffic_density)''',
+
+    6: '''import pandas as pd
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+normal_data = pd.DataFrame({
+    "company": ["Himalaya", "Ponds", "Nivara", "Greenies"],
+    "Amount": [2500, 3000, 4500, 7000],
+    "Transactions": [2, 3, 2, 4],
+    "Failed": [0, 0, 1, 0],
+    "Fraud": [0, 0, 0, 0]
+})
+fraud_data = pd.DataFrame({
+    "company": ["Himalaya", "Ponds", "Nivara", "Greenies"],
+    "Amount": [5000, 6000, 4500, 7000],
+    "Transactions": [4, 5, 3, 6],
+    "Failed": [4, 5, 3, 6],
+    "Fraud": [1, 1, 1, 1]
+})
+data = pd.concat([normal_data, fraud_data], ignore_index=True)
+encoder = LabelEncoder()
+data["company-enc"] = encoder.fit_transform(data["company"])
+X = data[["company-enc", "Amount", "Transactions", "Failed"]]
+y = data["Fraud"].to_numpy(dtype="float32")
+X = StandardScaler().fit_transform(X).astype("float32")
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(32, activation="relu", input_shape=(4,)),
+    tf.keras.layers.Dense(16, activation="relu"),
+    tf.keras.layers.Dense(8, activation="relu"),
+    tf.keras.layers.Dense(1, activation="sigmoid")
+])
+model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
+model.fit(X, y, epochs=50, verbose=0)
+print("Model trained successfully!")
+prob = model.predict(X, verbose=0).flatten()
+data["fraud_prob"] = prob
+data["prediction"] = np.where(prob > 0.5, "Fraud", "Legitimate")
+result = data.groupby("company", as_index=False)["fraud_prob"].max().sort_values("fraud_prob", ascending=False)
+print("\\nFraud Probability by Company:\\n", result)
+plt.figure(figsize=(10, 6))
+plt.bar(result["company"], result["fraud_prob"])
+plt.xlabel("Company"); plt.ylabel("Fraud Probability"); plt.title("Fraud Detection"); plt.ylim(0, 1); plt.grid(axis="y", linestyle="--", alpha=0.5)
+plt.show()
+highest = result.iloc[0]
+print("Highest Risk Company:", highest["company"])
+print("Fraud Probability:", round(highest["fraud_prob"], 4))
+print("Status:", "Fraud" if highest["fraud_prob"] > 0.5 else "Legitimate")''',
+
+    7: '''# Install once if needed: %pip install scikit-learn scipy
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.special import expit
+from sklearn.datasets import load_digits
+from sklearn.neural_network import BernoulliRBM
+
+print("Loading local digits dataset...")
+digits = load_digits()
+image_shape = (8, 8)
+X = digits.data[:1000].astype("float32") / 16.0
+print("Dataset shape:", X.shape)
+
+rbm1 = BernoulliRBM(n_components=32, learning_rate=0.01, n_iter=5, random_state=42)
+H1 = rbm1.fit_transform(X)
+rbm2 = BernoulliRBM(n_components=16, learning_rate=0.01, n_iter=5, random_state=42)
+H2 = rbm2.fit_transform(H1)
+print("RBM training completed!")
+
+def reconstruct(rbm, hidden):
+    return expit(np.dot(hidden, rbm.components_) + rbm.intercept_visible_)
+
+img = X[0]
+noisy = np.clip(img + np.random.normal(0, 0.1, size=img.shape), 0, 1)
+h_noisy = rbm1.transform(noisy.reshape(1, -1))
+reconstructed = reconstruct(rbm1, h_noisy)[0]
+plt.figure(figsize=(12, 4))
+for i, (title, image) in enumerate([("Original", img), ("Noisy", noisy), ("Reconstructed", reconstructed)], 1):
+    plt.subplot(1, 3, i); plt.imshow(image.reshape(image_shape), cmap="gray"); plt.title(title); plt.axis("off")
+plt.tight_layout(); plt.show()
+print("generated vectors:", reconstructed.shape)''',
+
+    8: '''import torch
+import torch.nn as nn
+
+texts = ["good movie", "great", "bad", "boring", "terrible", "excellent"]
+labels = [1, 1, 0, 0, 0, 1]
+words = {word for text in texts for word in text.split()}
+vocab = {word: i + 1 for i, word in enumerate(sorted(words))}
+vocab["<UNK>"] = len(vocab) + 1
+print("Vocabulary:", vocab)
+X = [torch.tensor([vocab.get(word, vocab["<UNK>"]) for word in text.split()], dtype=torch.long) for text in texts]
+y = torch.tensor(labels, dtype=torch.float32)
+
+class LSTMModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embedding = nn.Embedding(len(vocab) + 1, 10)
+        self.lstm = nn.LSTM(input_size=10, hidden_size=16, batch_first=True)
+        self.fc = nn.Linear(16, 1)
+    def forward(self, x):
+        x = self.embedding(x)
+        _, (hidden, _) = self.lstm(x)
+        return self.fc(hidden[-1])
+
+model = LSTMModel()
+criterion = nn.BCEWithLogitsLoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+for epoch in range(100):
+    total_loss = 0.0
+    for i in range(len(X)):
+        optimizer.zero_grad()
+        output = model(X[i].unsqueeze(0))
+        loss = criterion(output.view(-1), y[i].view(1))
+        loss.backward()
+        optimizer.step()
+        total_loss += loss.item()
+    if (epoch + 1) % 10 == 0:
+        print(f"Epoch {epoch + 1}/100, Loss: {total_loss:.4f}")
+
+def predict(text):
+    tokens = [vocab.get(word, vocab["<UNK>"]) for word in text.split()]
+    with torch.no_grad():
+        probability = torch.sigmoid(model(torch.tensor(tokens, dtype=torch.long).unsqueeze(0))).item()
+    print("\\nText:", text)
+    print("Positive probability:", round(probability, 4))
+    print("Prediction:", "Positive" if probability >= 0.5 else "Negative")
+
+print("Training completed!")
+predict("good movie")
+predict("bad movie")'''
+}
+
+
+def list_programs() -> dict[int, str]:
+    """Return the numbered first-eight program titles."""
+    return PROGRAM_TITLES.copy()
+
+
+def show_program(number: int) -> str:
+    """Return the exact source code for a selected program."""
+    if number not in PROGRAMS_CODE:
+        raise ValueError(f"Program number must be between 1 and 8: {number}")
+    return PROGRAMS_CODE[number]
+
+
+def run_program(number: int):
+    """Execute the selected program code."""
+    code = show_program(number)
+    scope = {}
+    exec(code, scope)
+    return scope
+
+
+def program_menu(number: int | None = None) -> str:
+    """List all titles, accept a number, and print that program's source."""
+    for key, title in PROGRAM_TITLES.items():
+        print(f"{key}. {title}")
+    selected = number if number is not None else int(input("\nEnter program number: "))
+    source = show_program(selected)
+    print(source)
+    return source

randomclassifier-0.1.2/src/randomclassifier/__init__.py

@@ -0,0 +1,26 @@
+from dl_lab.programs import PROGRAM_TITLES, show_program
+
+__version__ = "0.1.2"
+
+
+def models():
+    """List all available programs with their numbers and titles."""
+    for number, title in PROGRAM_TITLES.items():
+        print(f"{number}. {title}")
+
+
+def model(number: int | None = None):
+    """Print the exact source code for the requested program number (1-8)."""
+    if number is None:
+        models()
+        try:
+            val = input("\nEnter program number (1-8): ").strip()
+            number = int(val)
+        except (ValueError, EOFError):
+            print("Please provide a valid number between 1 and 8.")
+            return
+    source = show_program(number)
+    print(source)
+
+
+__all__ = ["models", "model"]

randomclassifier-0.1.2/src/randomclassifier/programs.py

@@ -0,0 +1,3 @@
+from dl_lab.programs import PROGRAM_TITLES, PROGRAMS_CODE, list_programs, show_program, program_menu
+
+__all__ = ["PROGRAM_TITLES", "PROGRAMS_CODE", "list_programs", "show_program", "program_menu"]

{randomclassifier-0.1.0 → randomclassifier-0.1.2}/src/randomclassifier.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: randomclassifier
-Version: 0.1.0
+Version: 0.1.2
 Summary: Deep learning laboratory programs and reusable classifiers
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

randomclassifier-0.1.0/src/dl_lab/programs.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import textwrap
-from typing import Callable
-
-
-PROGRAM_TITLES = {
-    1: "XOR using Multilayer Perceptron",
-    2: "Character and Digit Recognition using ANN",
-    3: "X-ray Image Analysis using Autoencoder",
-    4: "Speech Recognition using NLP",
-    5: "Traffic Object Detection and Classification using CNN",
-    6: "Share-market Fraud Detection using Data Analytics",
-    7: "Image Augmentation using Deep RBM",
-    8: "Sentiment Analysis using LSTM",
-}
-
-
-def list_programs() -> dict[int, str]:
-    """Return the numbered first-eight program titles."""
-    return PROGRAM_TITLES.copy()
-
-
-def show_program(number: int) -> str:
-    """Return the source code for a selected program."""
-    function = _program_function(number)
-    return textwrap.dedent(inspect.getsource(function))
-
-
-def run_program(number: int):
-    """Execute a selected program and return its result."""
-    return _program_function(number)()
-
-
-def program_menu(number: int | None = None) -> str:
-    """List all titles, accept a number, and print that program's source."""
-    for key, title in PROGRAM_TITLES.items():
-        print(f"{key}. {title}")
-    selected = number if number is not None else int(input("Enter program number: "))
-    source = show_program(selected)
-    print(source)
-    return source
-
-
-def _program_function(number: int) -> Callable:
-    functions = {
-        1: xor_mlp,
-        2: mnist_ann,
-        3: xray_autoencoder,
-        4: speech_recognition_nlp,
-        5: traffic_cnn,
-        6: fraud_detection,
-        7: rbm_augmentation,
-        8: lstm_sentiment,
-    }
-    if number not in functions:
-        raise ValueError(f"Program number must be between 1 and 8: {number}")
-    return functions[number]
-
-
-def xor_mlp():
-    import numpy as np
-    from sklearn.neural_network import MLPClassifier
-    x=np.array([[0,0],[0,1],[1,0],[1,1]])
-    y=[0,1,1,0]
-    model=MLPClassifier(hidden_layer_sizes=(4,),activation="tanh",solver="lbfgs",max_iter=2000,random_state=1).fit(x,y)
-    return model.predict(x)
-
-
-def mnist_ann():
-    import tensorflow as tf
-    (x,y),(test_x,test_y)=tf.keras.datasets.mnist.load_data()
-    model=tf.keras.Sequential([tf.keras.layers.Flatten(input_shape=(28,28)),tf.keras.layers.Dense(128,activation="relu"),tf.keras.layers.Dense(10,activation="softmax")])
-    model.compile("adam","sparse_categorical_crossentropy",metrics=["accuracy"])
-    model.fit(x/255.0,y,epochs=3)
-    return model.evaluate(test_x/255.0,test_y,verbose=0)
-
-
-def xray_autoencoder():
-    import tensorflow as tf
-    from tensorflow.keras import layers as L
-    from pathlib import Path
-    import numpy as np
-    local=Path("datasets/autoencoder_demo.npz")
-    if local.exists():
-        images=np.load(local)["images"].astype("float32")
-    else:
-        images=tf.random.uniform((256,64,64,1))
-    data=tf.data.Dataset.from_tensor_slices(images).batch(16)
-    inputs=L.Input((64,64,1))
-    hidden=L.Conv2D(16,3,2,"same",activation="relu")(inputs)
-    hidden=L.Conv2D(8,3,2,"same",activation="relu")(hidden)
-    output=L.Conv2DTranspose(16,3,2,"same",activation="relu")(hidden)
-    output=L.Conv2DTranspose(1,3,2,"same",activation="sigmoid")(output)
-    model=tf.keras.Model(inputs,output)
-    model.compile("adam","mse")
-    return model.fit(data,epochs=3)
-
-
-def speech_recognition_nlp():
-    import speech_recognition as sr
-    recognizer=sr.Recognizer()
-    with sr.Microphone() as source:
-        audio=recognizer.listen(source,timeout=5,phrase_time_limit=10)
-    return recognizer.recognize_google(audio)
-
-
-def traffic_cnn():
-    import cv2
-    model=cv2.dnn.readNetFromTensorflow("frozen_inference_graph.pb","graph.pbtxt")
-    image=cv2.imread("traffic.jpg")
-    height,width=image.shape[:2]
-    model.setInput(cv2.dnn.blobFromImage(image,size=(300,300),swapRB=True))
-    detections=model.forward()
-    return [(int(d[1]),(d[3:7]*[width,height,width,height]).astype(int).tolist()) for d in detections[0,0] if d[2]>.5]
-
-
-def fraud_detection():
-    import pandas as pd
-    from sklearn.ensemble import IsolationForest
-    data=pd.read_csv("datasets/transactions.csv")
-    data["fraud_flag"]=IsolationForest(contamination=.02,random_state=1).fit_predict(data.select_dtypes("number"))==-1
-    return data[data.fraud_flag]
-
-
-def rbm_augmentation():
-    from sklearn.neural_network import BernoulliRBM
-    from sklearn.datasets import load_digits
-    x=load_digits().data/16.0
-    model=BernoulliRBM(n_components=64,learning_rate=.05,n_iter=20,random_state=1).fit(x)
-    return model.transform(x)
-
-
-def lstm_sentiment():
-    import tensorflow as tf
-    from tensorflow.keras import layers as L
-    (x,y),(test_x,test_y)=tf.keras.datasets.imdb.load_data(num_words=10000)
-    pad=tf.keras.preprocessing.sequence.pad_sequences
-    x=pad(x,maxlen=200); test_x=pad(test_x,maxlen=200)
-    model=tf.keras.Sequential([L.Embedding(10000,32),L.LSTM(32),L.Dense(1,activation="sigmoid")])
-    model.compile("adam","binary_crossentropy",metrics=["accuracy"])
-    model.fit(x,y,epochs=2)
-    return model.evaluate(test_x,test_y,verbose=0)

randomclassifier-0.1.0/src/randomclassifier/__init__.py

@@ -1,17 +0,0 @@
-from dl_lab.programs import PROGRAM_TITLES, show_program
-
-__version__ = "0.1.0"
-
-def models():
-    for number, title in PROGRAM_TITLES.items():
-        print(f"{number}. {title}")
-    return PROGRAM_TITLES.copy()
-
-
-def model(number: int):
-    source = show_program(number)
-    print(source)
-    return source
-
-
-__all__ = ["models", "model"]

randomclassifier-0.1.0/src/randomclassifier/programs.py

@@ -1 +0,0 @@
-from dl_lab.programs import *