randomclassifier 0.1.6__py3-none-any.whl

dl_lab/datasets/transactions_5.csv

@@ -0,0 +1,151 @@
+amount,price_change,volume,international
+500,0.011,1032,0
+15000,0.009,4608,0
+500,0.009,3006,1
+1200,0.084,6154,0
+7500,0.055,6303,0
+250,0.037,6302,0
+250,0.022,2690,0
+15000,0.105,6086,0
+500,0.025,527,0
+500,0.085,7421,1
+100,0.029,7104,0
+7500,0.024,3510,0
+1200,0.031,3500,1
+250,0.018,6922,0
+100,0.069,7418,1
+100,0.035,7976,0
+15000,0.013,3875,0
+250,0.115,3254,0
+15000,0.024,5583,0
+1200,0.039,7785,0
+100,0.118,2343,0
+100,0.049,5407,0
+7500,0.006,7445,1
+1200,0.141,1511,0
+100,0.049,3391,0
+1200,0.02,7157,0
+250,0.007,2738,0
+500,0.079,4183,0
+100,0.048,4747,0
+7500,0.038,5819,0
+250,0.112,364,0
+1200,0.078,4477,0
+15000,0.008,6812,0
+250,0.019,5205,0
+100,0.014,7078,0
+1200,0.068,1022,1
+500,0.002,1143,0
+250,0.042,6297,0
+100,0.072,6350,0
+7500,0.105,4625,0
+15000,0.021,974,1
+1200,0.086,2398,0
+250,0.006,3356,0
+250,0.094,4442,0
+500,0.007,3895,0
+500,0.025,3652,1
+7500,0.08,1114,0
+15000,0.008,5867,0
+7500,0.013,1508,0
+100,0.064,7043,0
+100,0.064,4377,0
+7500,0.051,713,1
+15000,0.059,2120,1
+7500,0.039,7158,0
+15000,0.015,7052,0
+15000,0.021,6235,0
+1200,0.01,3794,0
+15000,0.12,5041,0
+500,0.044,7366,0
+15000,0.026,1609,1
+15000,0.031,5002,0
+15000,0.147,4766,0
+100,0.008,3390,0
+500,0.044,4691,0
+500,0.035,1755,0
+7500,0.047,6604,0
+1200,0.001,1004,0
+15000,0.103,5229,0
+250,0.134,1479,0
+1200,0.042,6053,0
+1200,0.06,5200,0
+500,0.128,7593,0
+1200,0.061,5372,0
+15000,0.008,7283,0
+15000,0.043,6186,0
+100,0.047,5819,0
+15000,0.028,3777,0
+15000,0.067,3101,0
+500,0.136,1587,1
+15000,0.13,5599,0
+100,0.03,4888,0
+250,0.006,2961,0
+500,0.209,7525,0
+250,0.091,2879,0
+500,0.007,2306,0
+7500,0.127,4423,0
+1200,0.102,5031,0
+7500,0.037,2968,0
+15000,0.045,4153,0
+250,0.025,3386,1
+15000,0.003,3480,0
+1200,0.02,2773,0
+500,0.081,4816,1
+1200,0.0,2799,0
+100,0.02,4233,0
+1200,0.025,436,0
+100,0.039,1504,1
+1200,0.126,3630,0
+100,0.021,7568,0
+250,0.021,6077,0
+15000,0.067,1501,0
+15000,0.03,7602,0
+7500,0.013,2741,0
+15000,0.03,2251,0
+500,0.008,7009,0
+1200,0.01,641,0
+7500,0.034,2276,0
+500,0.027,3380,0
+500,0.123,2857,0
+100,0.023,3998,0
+15000,0.043,1004,0
+250,0.05,274,0
+250,0.001,7181,0
+7500,0.054,7513,1
+250,0.01,2375,0
+1200,0.162,4124,0
+250,0.008,2289,0
+7500,0.027,5675,1
+250,0.004,240,0
+1200,0.288,7277,0
+100,0.035,2281,0
+7500,0.045,7384,0
+100,0.003,5996,1
+100,0.069,7520,0
+100,0.012,7341,0
+500,0.114,5697,0
+15000,0.011,4883,1
+500,0.011,1822,1
+15000,0.002,7996,0
+100,0.032,541,1
+7500,0.042,4252,1
+15000,0.003,2274,0
+1200,0.075,7654,0
+1200,0.03,845,0
+250,0.037,5026,0
+15000,0.029,4463,0
+7500,0.026,809,0
+500,0.041,6611,0
+100,0.008,6068,0
+250,0.01,6336,0
+1200,0.099,7164,0
+500,0.146,654,1
+500,0.023,3153,0
+100,0.016,1908,0
+15000,0.052,3672,0
+1200,0.026,3169,0
+7500,0.001,3228,0
+500,0.008,7843,0
+100,0.063,4997,0
+7500,0.054,2881,0

dl_lab/datasets/xor.csv

@@ -0,0 +1,5 @@
+x1,x2,label
+0,0,0
+0,1,1
+1,0,1
+1,1,0

dl_lab/datasets/xor_1.csv

@@ -0,0 +1,5 @@
+x1,x2,label
+0,0,0
+0,1,1
+1,0,1
+1,1,0

dl_lab/datasets/xor_2.csv

@@ -0,0 +1,21 @@
+x1,x2,label
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,0,0
+0,1,1
+1,0,1
+1,1,0

dl_lab/datasets/xor_3.csv

@@ -0,0 +1,41 @@
+x1,x2,label
+0.025,-0.007,0
+0.032,1.076,1
+0.988,-0.012,1
+1.079,1.038,0
+-0.023,0.027,0
+-0.023,0.977,1
+1.012,-0.096,1
+0.914,0.972,0
+-0.051,0.016,0
+-0.045,0.929,1
+1.073,-0.011,1
+1.003,0.929,0
+-0.027,0.006,0
+-0.058,1.019,1
+0.97,-0.015,1
+0.97,1.093,0
+-0.001,-0.053,0
+0.041,0.939,1
+1.01,-0.098,1
+0.934,1.01,0
+0.037,0.009,0
+-0.006,0.985,1
+0.926,-0.036,1
+0.977,1.053,0
+0.017,-0.088,0
+0.016,0.981,1
+0.966,0.031,1
+1.052,1.047,0
+-0.042,-0.015,0
+0.017,1.049,1
+0.976,-0.009,1
+0.945,0.94,0
+0.041,0.068,0
+-0.004,1.05,1
+1.018,-0.032,1
+1.018,1.077,0
+-0.002,0.078,0
+-0.131,1.041,1
+1.004,-0.015,1
+1.005,0.901,0

dl_lab/datasets/xor_4.csv

@@ -0,0 +1,61 @@
+x1,x2,label
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+1,1,0
+0,1,1
+1,0,1

dl_lab/datasets/xor_5.csv

@@ -0,0 +1,101 @@
+x1,x2,label
+1,1,0
+0,1,1
+0,1,1
+0,0,0
+0,1,1
+0,0,0
+0,0,0
+0,1,1
+1,0,1
+0,0,0
+1,0,1
+0,1,1
+0,1,1
+0,0,0
+1,1,0
+1,1,0
+1,1,0
+1,1,0
+0,0,0
+1,0,1
+0,1,1
+0,1,1
+1,0,1
+1,0,1
+1,1,0
+1,0,1
+1,1,0
+1,1,0
+1,0,1
+1,0,1
+0,1,1
+1,1,0
+1,0,1
+0,1,1
+1,0,1
+0,1,1
+0,0,0
+1,0,1
+0,0,0
+0,1,1
+0,1,1
+0,0,0
+1,1,0
+0,0,0
+1,0,1
+0,1,1
+0,1,1
+0,0,0
+0,1,1
+1,1,0
+1,0,1
+0,0,0
+0,1,1
+1,0,1
+0,0,0
+0,1,1
+0,0,0
+1,0,1
+1,1,0
+1,1,0
+0,0,0
+0,0,0
+1,1,0
+1,1,0
+1,1,0
+1,1,0
+0,0,0
+1,1,0
+0,1,1
+1,0,1
+0,1,1
+1,0,1
+1,1,0
+1,1,0
+1,1,0
+0,0,0
+1,0,1
+0,1,1
+0,0,0
+0,0,0
+0,0,0
+1,0,1
+0,0,0
+0,0,0
+0,1,1
+1,1,0
+1,0,1
+1,1,0
+1,1,0
+0,1,1
+0,1,1
+1,0,1
+0,1,1
+0,1,1
+0,0,0
+1,0,1
+1,1,0
+0,1,1
+1,1,0
+1,1,0

dl_lab/programs.py

@@ -0,0 +1,313 @@
+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 (Audio File)",
+    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",
+    9: "Live Speech Recognition using Microphone",
+}
+
+PROGRAMS_CODE = {
+    1: '''from sklearn.neural_network import MLPClassifier
+
+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
+
+audio_file = input("Enter the full path of a WAV/AIFF/FLAC audio file: ").strip().strip("\"")
+recognizer = sr.Recognizer()
+try:
+    print("Recognizing speech...")
+    with sr.AudioFile(audio_file) as source:
+        audio = recognizer.record(source)
+    text = recognizer.recognize_google(audio)
+    print("You said:", text)
+except FileNotFoundError:
+    print("Audio file not found. Check the path.")
+except sr.UnknownValueError:
+    print("Could not understand the speech.")
+except sr.RequestError as e:
+    print("Internet or speech service error:", e)
+except Exception as e:
+    print("Error:", e)''',
+
+    5: '''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: '''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")''',
+
+    9: '''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)'''
+}
+
+
+def list_programs() -> dict[int, str]:
+    """Return the numbered 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 9: {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 (1-9): "))
+    source = show_program(selected)
+    print(source)
+    return source