numpyv 1.0.0__tar.gz → 1.0.1__tar.gz

{numpyv-1.0.0 → numpyv-1.0.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: numpyv
-Version: 1.0.0
-Summary: Deep Learning lab experiments 1-8 - import to print aim, explanation and full code
+Version: 1.0.1
+Summary: Deep Learning lab experiments 1-8 - import to print aim, theory, explanation and full code
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -14,7 +14,7 @@ Requires-Dist: scikit-learn
 Requires-Dist: seaborn
 Dynamic: license-file
 
-# numpyc
+# numpyv
 
 A single-file Python package containing the 8 Deep Learning laboratory experiments.
 
@@ -23,36 +23,36 @@ A single-file Python package containing the 8 Deep Learning laboratory experimen
 Importing the package automatically displays the AIM, explanation, full code and output explanation of each experiment in the terminal. **Press Enter** to move to the next experiment. The experiments are **not executed** during import.
 
 ```python
-import numpyc
+import numpyv
 ```
 
-To import silently, set the environment variable `NUMPYC_QUIET=1`.
+To import silently, set the environment variable `NUMPYV_QUIET=1`.
 
 ## Show the experiment code
 
 ```python
-import numpyc
+import numpyv
 
-numpyc.experiment1()
-numpyc.experiment2()
+numpyv.experiment1()
+numpyv.experiment2()
 # ... up to
-numpyc.experiment8()
+numpyv.experiment8()
 ```
 
-Each `experimentN()` prints and returns the complete text for that experiment. You can also use `numpyc.show_experiment_code(1)`, `numpyc.show_all()` and `numpyc.save_code()`.
+Each `experimentN()` prints and returns the complete text for that experiment. You can also use `numpyv.show_experiment_code(1)`, `numpyv.show_all()` and `numpyv.save_code()`.
 
 ## Execute an experiment
 
 ```python
-numpyc.run_experiment(1)
+numpyv.run_experiment(1)
 ```
 
 From the command line:
 
 ```bash
-python -m numpyc 1          # show code
-numpyc 1                    # show code
-numpyc 2 --run              # execute
+python -m numpyv 1          # show code
+numpyv 1                    # show code
+numpyv 2 --run              # execute
 ```
 
 Replace the number with any value from `1` to `8`.

{numpyv-1.0.0 → numpyv-1.0.1}/README.md

@@ -1,4 +1,4 @@
-# numpyc
+# numpyv
 
 A single-file Python package containing the 8 Deep Learning laboratory experiments.
 
@@ -7,36 +7,36 @@ A single-file Python package containing the 8 Deep Learning laboratory experimen
 Importing the package automatically displays the AIM, explanation, full code and output explanation of each experiment in the terminal. **Press Enter** to move to the next experiment. The experiments are **not executed** during import.
 
 ```python
-import numpyc
+import numpyv
 ```
 
-To import silently, set the environment variable `NUMPYC_QUIET=1`.
+To import silently, set the environment variable `NUMPYV_QUIET=1`.
 
 ## Show the experiment code
 
 ```python
-import numpyc
+import numpyv
 
-numpyc.experiment1()
-numpyc.experiment2()
+numpyv.experiment1()
+numpyv.experiment2()
 # ... up to
-numpyc.experiment8()
+numpyv.experiment8()
 ```
 
-Each `experimentN()` prints and returns the complete text for that experiment. You can also use `numpyc.show_experiment_code(1)`, `numpyc.show_all()` and `numpyc.save_code()`.
+Each `experimentN()` prints and returns the complete text for that experiment. You can also use `numpyv.show_experiment_code(1)`, `numpyv.show_all()` and `numpyv.save_code()`.
 
 ## Execute an experiment
 
 ```python
-numpyc.run_experiment(1)
+numpyv.run_experiment(1)
 ```
 
 From the command line:
 
 ```bash
-python -m numpyc 1          # show code
-numpyc 1                    # show code
-numpyc 2 --run              # execute
+python -m numpyv 1          # show code
+numpyv 1                    # show code
+numpyv 2 --run              # execute
 ```
 
 Replace the number with any value from `1` to `8`.

{numpyv-1.0.0 → numpyv-1.0.1}/numpyv.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: numpyv
-Version: 1.0.0
-Summary: Deep Learning lab experiments 1-8 - import to print aim, explanation and full code
+Version: 1.0.1
+Summary: Deep Learning lab experiments 1-8 - import to print aim, theory, explanation and full code
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -14,7 +14,7 @@ Requires-Dist: scikit-learn
 Requires-Dist: seaborn
 Dynamic: license-file
 
-# numpyc
+# numpyv
 
 A single-file Python package containing the 8 Deep Learning laboratory experiments.
 
@@ -23,36 +23,36 @@ A single-file Python package containing the 8 Deep Learning laboratory experimen
 Importing the package automatically displays the AIM, explanation, full code and output explanation of each experiment in the terminal. **Press Enter** to move to the next experiment. The experiments are **not executed** during import.
 
 ```python
-import numpyc
+import numpyv
 ```
 
-To import silently, set the environment variable `NUMPYC_QUIET=1`.
+To import silently, set the environment variable `NUMPYV_QUIET=1`.
 
 ## Show the experiment code
 
 ```python
-import numpyc
+import numpyv
 
-numpyc.experiment1()
-numpyc.experiment2()
+numpyv.experiment1()
+numpyv.experiment2()
 # ... up to
-numpyc.experiment8()
+numpyv.experiment8()
 ```
 
-Each `experimentN()` prints and returns the complete text for that experiment. You can also use `numpyc.show_experiment_code(1)`, `numpyc.show_all()` and `numpyc.save_code()`.
+Each `experimentN()` prints and returns the complete text for that experiment. You can also use `numpyv.show_experiment_code(1)`, `numpyv.show_all()` and `numpyv.save_code()`.
 
 ## Execute an experiment
 
 ```python
-numpyc.run_experiment(1)
+numpyv.run_experiment(1)
 ```
 
 From the command line:
 
 ```bash
-python -m numpyc 1          # show code
-numpyc 1                    # show code
-numpyc 2 --run              # execute
+python -m numpyv 1          # show code
+numpyv 1                    # show code
+numpyv 2 --run              # execute
 ```
 
 Replace the number with any value from `1` to `8`.

{numpyv-1.0.0 → numpyv-1.0.1}/numpyv.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+numpyv.py
 pyproject.toml
 numpyv.egg-info/PKG-INFO
 numpyv.egg-info/SOURCES.txt

numpyv-1.0.1/numpyv.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+numpyv = numpyv:main

numpyv-1.0.1/numpyv.egg-info/top_level.txt

@@ -0,0 +1 @@
+numpyv

numpyv-1.0.1/numpyv.py

@@ -0,0 +1,692 @@
+"""Numpyv: Deep Learning laboratory experiments 1-8.
+
+Importing this module prints, for every experiment, the AIM, THEORY, what the code
+does, the FULL CODE and the output EXPLANATION. Press Enter to move on to the next experiment.
+
+    import numpyv                  # code + explanation of experiments 1-8
+    numpyv.experiment3()           # code + explanation of one experiment
+    numpyv.run_experiment(3)       # actually execute an experiment
+    numpyv.save_code()             # save everything into a text file
+"""
+
+import os
+import sys
+import textwrap
+
+# Make sure symbols print correctly on Windows.
+for _stream in (sys.stdout, sys.stderr):
+    if hasattr(_stream, "reconfigure"):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
+
+# ======================================================================
+# CODE OF EACH EXPERIMENT
+# ======================================================================
+CODE = {}
+CODE[1] = r'''
+# Experiment 1: Study on Deep Learning Frameworks and Ethical Considerations
+import importlib
+import platform
+import sys
+
+print("Python:", sys.version.split()[0], "| OS:", platform.system())
+
+# 1) Check which deep learning frameworks are installed
+frameworks = {
+    "TensorFlow": "tensorflow",
+    "Keras": "keras",
+    "PyTorch": "torch",
+    "JAX": "jax",
+    "scikit-learn": "sklearn",
+    "ONNX": "onnx",
+}
+print("\n--- Installed Frameworks ---")
+for name, module in frameworks.items():
+    try:
+        m = importlib.import_module(module)
+        print(f"{name:<14}: {getattr(m, '__version__', 'installed')}")
+    except Exception:
+        print(f"{name:<14}: not installed")
+
+# 2) GPU availability
+try:
+    import tensorflow as tf
+    print("\nTensorFlow GPUs:", tf.config.list_physical_devices("GPU"))
+except Exception:
+    pass
+try:
+    import torch
+    print("PyTorch CUDA available:", torch.cuda.is_available())
+except Exception:
+    pass
+
+# 3) Framework comparison
+comparison = {
+    "TensorFlow": "Google; production deployment (TF Lite, TF Serving), Keras API",
+    "PyTorch": "Meta; dynamic graphs, preferred in research, easy debugging",
+    "Keras": "High-level API; fast prototyping on top of TensorFlow/JAX/PyTorch",
+    "JAX": "Google; NumPy-like, JIT + autograd, high-performance research",
+}
+print("\n--- Framework Comparison ---")
+for k, v in comparison.items():
+    print(f"{k:<11}: {v}")
+
+# 4) Ethical considerations
+ethics = [
+    "Bias and fairness: models inherit bias present in training data",
+    "Privacy: personal data must be protected (consent, anonymization, GDPR)",
+    "Transparency / explainability: decisions should be interpretable",
+    "Accountability: clear responsibility for model decisions and failures",
+    "Safety and security: robustness against adversarial attacks",
+    "Misuse: deepfakes, surveillance, misinformation",
+    "Environmental impact: large models consume significant energy",
+    "Job displacement and societal impact of automation",
+]
+print("\n--- Ethical Considerations in Deep Learning ---")
+for i, e in enumerate(ethics, 1):
+    print(f"{i}. {e}")
+'''
+CODE[2] = r'''
+import tensorflow as tf
+from tensorflow.keras import layers, models
+import matplotlib.pyplot as plt
+
+# Load dataset (e.g., MNIST dataset for classification)
+mnist = tf.keras.datasets.mnist
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+
+# Preprocess data
+x_train = x_train / 255.0
+x_test = x_test / 255.0
+
+# Build Deep Neural Network with at least 2 hidden layers
+model = models.Sequential([
+    layers.Flatten(input_shape=(28, 28)),
+    layers.Dense(128, activation='relu'), # Hidden Layer 1
+    layers.Dense(64, activation='relu'),  # Hidden Layer 2
+    layers.Dense(10, activation='softmax') # Output layer
+])
+
+# Compile the model
+model.compile(optimizer='adam',
+              loss='sparse_categorical_crossentropy',
+              metrics=['accuracy'])
+
+# Train the model
+history = model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))
+
+# Evaluate the model
+test_loss, test_acc = model.evaluate(x_test, y_test)
+print(f"Test Accuracy: {test_acc}")
+'''
+CODE[3] = r'''
+import tensorflow as tf
+import tensorflow_hub as hub
+import cv2
+from pathlib import Path
+
+# Load a pre-trained object detection model from TensorFlow Hub
+detector = hub.load("https://tfhub.dev/tensorflow/efficientdet/d0/1")
+
+# Load and preprocess image
+project_dir = Path(__file__).resolve().parent
+image_path = project_dir / "image.jpg"
+if not image_path.is_file():
+    image_path = project_dir / "sample_digits.png"
+if not image_path.is_file():
+    raise FileNotFoundError(
+        "Place image.jpg or sample_digits.png next to exp3.py before running."
+    )
+
+image_np = cv2.imread(str(image_path))
+if image_np is None:
+    raise ValueError(f"OpenCV could not read the image: {image_path}")
+
+image_np = cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB)
+input_tensor = tf.convert_to_tensor(image_np)
+input_tensor = input_tensor[tf.newaxis, ...]
+
+# Perform detection
+detections = detector(input_tensor)
+
+import numpy as np
+import cv2
+
+# Extract detection results
+boxes = detections['detection_boxes'][0].numpy()
+classes = detections['detection_classes'][0].numpy()
+scores = detections['detection_scores'][0].numpy()
+
+# Draw bounding boxes with a score > 0.5
+output_image = image_np.copy()
+h, w, _ = output_image.shape
+
+for i in range(len(scores)):
+    if scores[i] > 0.5:  # Confidence threshold
+        ymin, xmin, ymax, xmax = boxes[i]
+        start_point = (int(xmin * w), int(ymin * h))
+        end_point = (int(xmax * w), int(ymax * h))
+        
+        # Draw rectangle and score label
+        cv2.rectangle(output_image, start_point, end_point, (0, 255, 0), 2)
+        text = f"Score: {scores[i]:.2f}"
+        cv2.putText(output_image, text, (start_point[0], start_point[1] - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+
+# Save the visualized result
+output_path = project_dir / "detected_output.jpg"
+cv2.imwrite(str(output_path), cv2.cvtColor(output_image, cv2.COLOR_RGB2BGR))
+print(f"Bounding boxes drawn and saved to: {output_path}")
+
+# Process results
+print(f"Object detection completed successfully for {image_path.name}.")
+'''
+CODE[4] = r'''
+import cv2
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+project_dir = Path(__file__).resolve().parent
+image_path = project_dir / "image.jpg"
+if not image_path.is_file():
+    image_path = project_dir / "sample_digits.png"
+if not image_path.is_file():
+    raise FileNotFoundError(
+        "Place image.jpg or sample_digits.png next to exp4.py before running."
+    )
+
+image = cv2.imread(str(image_path))
+if image is None:
+    raise ValueError(f"OpenCV could not read the image: {image_path}")
+
+image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+gray = cv2.GaussianBlur(gray, (5, 5), 0)
+_, mask = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
+kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+segmented = cv2.bitwise_and(image, image, mask=mask)
+
+plt.figure(figsize=(12,4))
+plt.subplot(1,3,1)
+plt.imshow(image)
+plt.title("Original Image")
+plt.axis("off")
+
+plt.subplot(1,3,2)
+plt.imshow(mask, cmap="gray")
+plt.title("Segmentation Mask")
+plt.axis("off")
+
+plt.subplot(1,3,3)
+plt.imshow(segmented)
+plt.title("Segmented Image")
+plt.axis("off")
+plt.tight_layout()
+plt.show()
+'''
+CODE[5] = r'''
+import tensorflow as tf
+from tensorflow.keras.layers import Input, Dense
+from tensorflow.keras.models import Model
+import matplotlib.pyplot as plt
+
+(x_train, _), (x_test, _) = tf.keras.datasets.mnist.load_data()
+x_train = x_train.astype("float32") / 255.0
+x_test = x_test.astype("float32") / 255.0
+x_train = x_train.reshape(-1, 784)
+x_test = x_test.reshape(-1, 784)
+
+input_img = Input(shape=(784,))
+encoded = Dense(64, activation="relu")(input_img)
+decoded = Dense(784, activation="sigmoid")(encoded)
+
+autoencoder = Model(input_img, decoded)
+autoencoder.compile(optimizer="adam", loss="mse")
+
+autoencoder.fit(
+    x_train,
+    x_train,
+    epochs=5,
+    batch_size=256,
+    shuffle=True,
+    validation_data=(x_test, x_test)
+)
+
+decoded_imgs = autoencoder.predict(x_test[:5])
+
+plt.figure(figsize=(10,4))
+for i in range(5):
+    plt.subplot(2,5,i+1)
+    plt.imshow(x_test[i].reshape(28,28), cmap="gray")
+    plt.axis("off")
+    plt.subplot(2,5,i+6)
+    plt.imshow(decoded_imgs[i].reshape(28,28), cmap="gray")
+    plt.axis("off")
+
+plt.show()
+'''
+CODE[6] = r'''
+import tensorflow as tf 
+from tensorflow.keras import layers, Model 
+import matplotlib.pyplot as plt 
+
+latent_dim = 2 
+(x_train, _), (x_test, _) = tf.keras.datasets.mnist.load_data() 
+x_train = x_train.astype("float32") / 255.0 
+x_test = x_test.astype("float32") / 255.0 
+x_train = x_train.reshape(-1, 784) 
+x_test = x_test.reshape(-1, 784) 
+
+encoder_inputs = layers.Input(shape=(784,)) 
+x = layers.Dense(256, activation="relu")(encoder_inputs) 
+z_mean = layers.Dense(latent_dim)(x)  
+z_log_var = layers.Dense(latent_dim)(x)
+
+def sampling(args):
+    z_mean, z_log_var = args
+    epsilon = tf.random.normal(shape=tf.shape(z_mean))
+    return z_mean + tf.exp(0.5 * z_log_var) * epsilon
+
+z = layers.Lambda(sampling)([z_mean, z_log_var])
+encoder = Model(encoder_inputs, [z_mean, z_log_var, z], name="encoder")
+
+latent_inputs = layers.Input(shape=(latent_dim,))
+x_dec = layers.Dense(256, activation="relu")(latent_inputs)
+decoder_outputs = layers.Dense(784, activation="sigmoid")(x_dec)
+decoder = Model(latent_inputs, decoder_outputs, name="decoder")
+
+class VAE(Model):
+    def __init__(self, encoder, decoder, **kwargs):
+        super().__init__(**kwargs)
+        self.encoder = encoder
+        self.decoder = decoder
+
+        self.total_loss_tracker = tf.keras.metrics.Mean(name="loss")
+        self.reconstruction_loss_tracker = tf.keras.metrics.Mean(
+            name="reconstruction_loss"
+        )
+        self.kl_loss_tracker = tf.keras.metrics.Mean(name="kl_loss")
+
+    @property
+    def metrics(self):
+        return [
+            self.total_loss_tracker,
+            self.reconstruction_loss_tracker,
+            self.kl_loss_tracker,
+        ]
+
+    def compute_losses(self, data, training):
+        z_mean, z_log_var, z = self.encoder(data, training=training)
+        reconstruction = self.decoder(z, training=training)
+        reconstruction_loss = tf.reduce_mean(
+            tf.reduce_sum(
+                tf.keras.losses.binary_crossentropy(data, reconstruction), axis=-1
+            )
+        )
+        kl_loss = -0.5 * tf.reduce_mean(
+            tf.reduce_sum(
+                1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=-1
+            )
+        )
+        return reconstruction_loss + kl_loss, reconstruction_loss, kl_loss
+
+    def update_loss_trackers(self, total_loss, reconstruction_loss, kl_loss):
+        self.total_loss_tracker.update_state(total_loss)
+        self.reconstruction_loss_tracker.update_state(reconstruction_loss)
+        self.kl_loss_tracker.update_state(kl_loss)
+        return {metric.name: metric.result() for metric in self.metrics}
+
+    def call(self, inputs, training=False):
+        _, _, z = self.encoder(inputs, training=training)
+        return self.decoder(z, training=training)
+
+    def train_step(self, data):
+        data = tf.keras.utils.unpack_x_y_sample_weight(data)[0]
+        with tf.GradientTape() as tape:
+            losses = self.compute_losses(data, training=True)
+        gradients = tape.gradient(losses[0], self.trainable_weights)
+        self.optimizer.apply_gradients(zip(gradients, self.trainable_weights))
+        return self.update_loss_trackers(*losses)
+
+    def test_step(self, data):
+        data = tf.keras.utils.unpack_x_y_sample_weight(data)[0]
+        losses = self.compute_losses(data, training=False)
+        return self.update_loss_trackers(*losses)
+
+
+vae = VAE(encoder, decoder, name="vae")
+vae.compile(optimizer=tf.keras.optimizers.Adam())
+
+print("Training Variational Autoencoder...")
+history = vae.fit(
+    x_train,
+    epochs=5,
+    batch_size=128,
+    shuffle=True,
+    validation_data=(x_test,),
+)
+
+reconstructed_imgs = vae.predict(x_test[:5], verbose=0)
+plt.figure(figsize=(10, 4))
+for i in range(5):
+    plt.subplot(2, 5, i + 1)
+    plt.imshow(x_test[i].reshape(28, 28), cmap="gray")
+    plt.axis("off")
+    plt.subplot(2, 5, i + 6)
+    plt.imshow(reconstructed_imgs[i].reshape(28, 28), cmap="gray")
+    plt.axis("off")
+
+plt.tight_layout()
+plt.savefig("vae_reconstructions.png")
+plt.show()
+'''
+CODE[7] = r'''
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.preprocessing import sequence
+
+print("=" * 70)
+print("DL Experiment 7: RNN (LSTM) for Sentiment Analysis")
+print("=" * 70) 
+print()
+
+# Load IMDB dataset with word index limit
+max_features = 10000
+maxlen = 500
+
+(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
+
+print(f"Training samples: {len(x_train)}")
+print(f"Test samples: {len(x_test)}")
+print(f"Max features (vocabulary): {max_features}")
+print(f"Max sequence length: {maxlen}")
+print()
+
+print("-" * 70)
+print("Preprocessing Text Data...")
+print("-" * 70)
+
+# Pad sequences to same length
+x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
+x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
+
+model = keras.Sequential([
+    layers.Embedding(max_features, 128),
+    layers.LSTM(64),
+    layers.Dense(1, activation="sigmoid"),
+])
+model.compile(
+    optimizer="adam",
+    loss="binary_crossentropy",
+    metrics=["accuracy"],
+)
+
+print()
+print("-" * 70)
+print("Training LSTM Model...")
+print("-" * 70)
+model.fit(
+    x_train,
+    y_train,
+    epochs=3,
+    batch_size=128,
+    validation_data=(x_test, y_test),
+)
+
+test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
+print(f"Test loss: {test_loss:.4f}")
+print(f"Test accuracy: {test_accuracy:.4f}")
+'''
+CODE[8] = r'''
+import numpy as np
+import matplotlib.pyplot as plt 
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.datasets import mnist
+from sklearn.metrics import confusion_matrix, classification_report
+import seaborn as sns
+
+print("DL CNN for Digit Recognition")
+print("=" * 70)
+print()
+
+# Load MNIST dataset
+print("-" * 70)
+print("Loading MNIST Dataset...")
+print("-" * 70)
+(x_train, y_train), (x_test, y_test) = mnist.load_data() 
+
+# Preprocess data
+x_train = x_train.astype("float32") / 255.0 
+x_test = x_test.astype("float32") / 255.0
+
+# Reshape for CNN (add channel dimension)
+x_train = x_train.reshape(-1, 28, 28, 1)
+x_test = x_test.reshape(-1, 28, 28, 1)
+
+# Convert labels to one-hot
+y_train = keras.utils.to_categorical(y_train, 10)
+y_test = keras.utils.to_categorical(y_test, 10)
+
+print(f"Training data shape: {x_train.shape}") 
+print(f"Training labels shape: {y_train.shape}") 
+print(f"Test data shape: {x_test.shape}") 
+print(f"Test labels shape: {y_test.shape}") 
+print()
+
+# Show sample digits
+print("-" * 70)
+print("Sample Training Digits...")
+print("-" * 70)
+
+fig, axes = plt.subplots(2, 5, figsize=(12, 4))
+for i in range(10):
+    ax = axes[i // 5, i % 5]
+    ax.imshow(x_train[i].reshape(28, 28), cmap='gray')
+    ax.set_title(f"Label: {np.argmax(y_train[i])}")
+    ax.axis('off')
+
+plt.tight_layout()
+plt.savefig('sample_digits.png', dpi=100)
+print("Sample digits saved as 'sample_digits.png'")
+print()
+
+# Build CNN model
+print("-" * 70)
+print("Building CNN Model...")
+print("-" * 70)
+
+model = keras.Sequential([
+    layers.Input(shape=(28, 28, 1)),
+    layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
+    layers.MaxPooling2D(pool_size=(2, 2)),
+    layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
+    layers.MaxPooling2D(pool_size=(2, 2)),
+    layers.Flatten(),
+    layers.Dropout(0.5),
+    layers.Dense(10, activation="softmax")
+])
+
+model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
+model.summary()
+'''
+
+# ======================================================================
+# AIM, STEPS AND EXPLANATION
+# ======================================================================
+AIM = {1: 'To study the major deep learning frameworks (TensorFlow, Keras, PyTorch, JAX), check which are installed, and discuss the ethical considerations of deep learning.', 2: 'To implement a fully connected deep neural network with at least 2 hidden layers for classifying MNIST handwritten digits.', 3: 'To perform object detection on an image using a pre-trained EfficientDet model from TensorFlow Hub.', 4: 'To perform image segmentation using Gaussian blur, thresholding and morphological operations with OpenCV.', 5: 'To implement an undercomplete autoencoder that compresses MNIST images to 64 dimensions and reconstructs them.', 6: 'To implement a Variational Autoencoder (VAE) with a 2-D latent space using reparameterization sampling and a custom training step.', 7: 'To develop an RNN (LSTM) based model for sentiment analysis on the IMDB movie review dataset.', 8: 'To design and implement a CNN model for handwritten digit recognition on MNIST.'}
+THEORY = {
+1: ["Deep learning uses multi-layer neural networks that learn features automatically from data.",
+    "TensorFlow (Google) supports large-scale training and deployment through TF Lite and TF Serving.",
+    "Keras is a high-level API that makes building and training models quick.",
+    "PyTorch (Meta) uses dynamic computation graphs, which makes debugging easy and suits research.",
+    "JAX combines NumPy-style code with automatic differentiation and JIT compilation for speed.",
+    "Ethical issues: bias and fairness, privacy of data, transparency (explainability) and accountability.",
+    "Other concerns: safety against adversarial attacks, misuse (deepfakes, surveillance), energy use and job impact.",
+    "Responsible AI means using diverse data, protecting privacy, documenting models and keeping human oversight."],
+2: ["A fully connected (dense) network has layers in which every neuron is linked to all neurons of the next layer.",
+    "Hidden layers with ReLU, f(x) = max(0, x), let the network learn non-linear patterns.",
+    "The softmax output layer converts scores into probabilities over the 10 digit classes.",
+    "Sparse categorical crossentropy measures the error between predicted probabilities and integer labels.",
+    "Backpropagation computes gradients and the Adam optimizer updates the weights.",
+    "Pixel values are scaled to 0-1 so training is faster and more stable.",
+    "Accuracy on the unseen test set shows how well the model generalizes."],
+3: ["Object detection finds what objects are in an image (classification) and where they are (bounding boxes).",
+    "A pre-trained model is already trained on a large dataset (such as COCO), so no training is needed (transfer learning).",
+    "EfficientDet uses an EfficientNet backbone with a BiFPN to detect objects at several scales efficiently.",
+    "TensorFlow Hub provides ready-to-use pre-trained models that can be loaded with a single call.",
+    "The model returns boxes (normalized coordinates), class ids and confidence scores.",
+    "A confidence threshold (here 0.5) removes weak detections.",
+    "OpenCV reads images in BGR order, so they are converted to RGB before going to the model."],
+4: ["Image segmentation divides an image into regions so that pixels of the same object or area are grouped together.",
+    "Gaussian blur smooths the image and reduces noise before thresholding.",
+    "Thresholding turns the grayscale image into a binary mask: pixels above 127 become white (255), the rest black (0).",
+    "Morphological opening (erosion followed by dilation) removes small noisy regions from the mask.",
+    "A bitwise AND of the image with the mask keeps only the foreground region.",
+    "This is classical (threshold-based) segmentation; deep models such as U-Net or DeepLab segment more accurately.",
+    "Segmentation is used in medical imaging, autonomous vehicles and satellite image analysis."],
+5: ["An autoencoder is an unsupervised network that learns to copy its input to its output through a smaller bottleneck.",
+    "The encoder compresses the 784-pixel image into a 64-value code (latent representation).",
+    "The decoder reconstructs the 784 pixels from that code using a sigmoid activation.",
+    "Such an undercomplete autoencoder is forced to learn the most important features, which gives compression.",
+    "Mean Squared Error (MSE) between the input and the reconstruction is the loss to minimize.",
+    "The input images are used as both features and targets, so no labels are needed.",
+    "Uses: dimensionality reduction, image compression, denoising and anomaly detection."],
+6: ["A Variational Autoencoder (VAE) is a generative model that learns a probability distribution in latent space.",
+    "The encoder outputs a mean (z_mean) and a log-variance (z_log_var) instead of a single point.",
+    "The reparameterization trick, z = mean + exp(0.5 * log_var) * epsilon, makes sampling differentiable for backpropagation.",
+    "The decoder reconstructs the image from the sampled latent vector z.",
+    "The loss = reconstruction loss (binary crossentropy) + KL divergence.",
+    "KL divergence pushes the latent distribution towards a standard normal, giving a smooth, continuous latent space.",
+    "Because the space is smooth, new images can be generated by sampling random latent vectors."],
+7: ["A Recurrent Neural Network (RNN) processes sequences step by step and keeps a hidden state as memory.",
+    "Plain RNNs suffer from vanishing gradients on long sequences.",
+    "LSTM solves this with a cell state and input, forget and output gates that control what to remember.",
+    "An Embedding layer maps each word id to a dense vector (here 128 dimensions).",
+    "Reviews are padded or truncated to the same length (500 words) so they can be batched.",
+    "A sigmoid output gives the probability that a review is positive (binary classification).",
+    "Sentiment analysis is used for reviews, social media monitoring and customer feedback."],
+8: ["A Convolutional Neural Network (CNN) is designed for images and learns spatial features automatically.",
+    "Conv2D layers slide small filters (3x3) over the image to detect edges, then shapes and patterns.",
+    "MaxPooling reduces the size of the feature maps, lowering computation and giving some translation invariance.",
+    "Flatten converts the feature maps to a vector for the final Dense layer.",
+    "Dropout (0.5) randomly switches off neurons during training to prevent overfitting.",
+    "The softmax output gives probabilities for the digits 0-9, trained with categorical crossentropy on one-hot labels.",
+    "CNNs need far fewer parameters than dense networks for images (34,826 here) and give higher accuracy."],
+}
+
+STEPS = {1: ['Import the frameworks (TensorFlow, Keras, PyTorch, JAX, scikit-learn, ONNX) and print the version of each installed one.', 'Check whether a GPU is available in TensorFlow and PyTorch.', 'Print a short comparison of the frameworks.', 'Print the main ethical considerations: bias, privacy, transparency, accountability, safety, misuse, environment, jobs.'], 2: ['Load the MNIST dataset and scale pixel values to the range 0-1 by dividing by 255.', 'Build a Sequential model: Flatten, Dense(128, ReLU), Dense(64, ReLU), Dense(10, softmax).', 'Compile with the Adam optimizer and sparse categorical crossentropy loss.', 'Train for 5 epochs with the test set as validation data.', 'Evaluate on the test data and print the test accuracy.'], 3: ['Load the EfficientDet-D0 detector from TensorFlow Hub.', 'Read image.jpg with OpenCV (falls back to sample_digits.png), convert BGR to RGB and make a tensor.', 'Run the detector to get bounding boxes, classes and scores.', 'Draw a green box and score for every detection with confidence above 0.5.', 'Save the result as detected_output.jpg and print a success message.'], 4: ['Load the image and convert it to grayscale.', 'Apply a 5x5 Gaussian blur to reduce noise.', 'Apply binary thresholding at 127 to create a black-and-white mask.', 'Apply morphological opening with a 3x3 rectangular kernel to remove small noise.', 'Use bitwise AND with the mask to isolate the segmented region.', 'Plot the original, mask and segmented image side by side with Matplotlib.'], 5: ['Load MNIST, normalize to 0-1 and flatten each image to 784 values.', 'Build the encoder Dense(64, ReLU) as the bottleneck and the decoder Dense(784, sigmoid).', 'Compile with Adam and MSE loss.', 'Train for 5 epochs using the images as both input and target.', 'Reconstruct 5 test images and plot originals above reconstructions.'], 6: ['Load and flatten MNIST (784 values per image).', 'Build the encoder that outputs z_mean and z_log_var, and sample z with the reparameterization trick.', 'Build the decoder Dense(256, ReLU) -> Dense(784, sigmoid).', 'Define a VAE class whose train_step/test_step compute reconstruction loss (binary crossentropy) plus KL divergence.', 'Train for 5 epochs and print training and validation losses.', 'Reconstruct 5 test digits and save the comparison as vae_reconstructions.png.'], 7: ['Load the IMDB dataset limited to the 10,000 most frequent words.', 'Pad/truncate every review to 500 tokens.', 'Build Embedding(10000,128) -> LSTM(64) -> Dense(1, sigmoid).', 'Compile with Adam and binary crossentropy.', 'Train for 3 epochs, evaluate on the test set and print the test loss and accuracy.'], 8: ['Load MNIST, normalize, add a channel dimension (28x28x1) and one-hot encode the labels.', 'Print the dataset shapes.', 'Plot 10 sample digits with their labels and save them as sample_digits.png.', 'Build the CNN: Conv2D(32) -> MaxPool -> Conv2D(64) -> MaxPool -> Flatten -> Dropout(0.5) -> Dense(10, softmax).', 'Compile with categorical crossentropy and Adam and print the model summary (the model is built but not trained).']}
+EXPLANATION = {1: "The program lists the Python/OS details, prints the version of every deep learning framework that is installed (and 'not installed' for the rest), reports GPU availability, and then prints a framework comparison and eight ethical considerations. No image is produced.", 2: 'Training progress for 5 epochs is printed, followed by the test accuracy. The network reaches about 0.977 (97.7%) test accuracy on MNIST. No image is produced.', 3: 'A detected_output.jpg image is saved with green boxes around detections above the 0.5 confidence threshold, and two success messages are printed. If image.jpg is not present, sample_digits.png is used instead, so few or no boxes may appear.', 4: 'Nothing is printed to the console. A figure with three panels appears: the original image, the black-and-white segmentation mask and the segmented result. sample_digits.png is used if image.jpg is not available. In a non-interactive environment plt.show() cannot open a window.', 5: 'Training progress is printed for 5 epochs; the final loss is about 0.0105 and the validation loss about 0.0092. A 2-row figure shows five original MNIST digits above their five reconstructions.', 6: 'Training and validation losses are printed for 5 epochs. The final loss is about 29.93 (reconstruction 27.52 + KL 2.41) and the validation loss about 29.59. A comparison image of five original and five reconstructed digits is saved as vae_reconstructions.png.', 7: 'Dataset sizes (25000 training and 25000 test reviews) and preprocessing details are printed, followed by 3 epochs of LSTM training. The final test loss is about 0.4111 and the test accuracy about 0.8324 (83.2%).', 8: 'The console prints the dataset shapes ((60000, 28, 28, 1) for training and (10000, 28, 28, 1) for test) and the CNN model summary with 34,826 parameters. A 2-by-5 grid of labeled digits is saved as sample_digits.png. The model is built but not trained.'}
+
+_BAR = "=" * 80
+
+
+def _check(number):
+    if number not in CODE:
+        raise ValueError("Experiment number must be between 1 and 8.")
+
+
+def _render(number):
+    """Return the full text (aim, steps, code, explanation) of one experiment."""
+    _check(number)
+    aim = textwrap.fill(AIM[number], width=78)
+    steps = "\n".join(
+        textwrap.fill(f"{i}. {t}", width=78, subsequent_indent="   ")
+        for i, t in enumerate(STEPS[number], 1)
+    )
+    explanation = textwrap.fill(EXPLANATION[number], width=78)
+    theory = "\n".join(
+        textwrap.fill(f"- {t}", width=78, subsequent_indent="  ")
+        for t in THEORY[number]
+    )
+    return (
+        f"\n{_BAR}\nEXPERIMENT {number}\n{_BAR}\n"
+        f"AIM:\n{aim}\n"
+        f"\nTHEORY:\n{theory}\n"
+        f"\nWHAT THE CODE DOES:\n{steps}\n"
+        f"\n{_BAR}\nEXPERIMENT {number} - CODE\n{_BAR}\n"
+        f"{CODE[number].strip()}\n"
+        f"\n{_BAR}\nEXPERIMENT {number} - OUTPUT EXPLANATION\n{_BAR}\n"
+        f"{explanation}\n"
+    )
+
+
+def show_experiment_code(number):
+    """Print the code and explanation of one experiment (1-8)."""
+    text = _render(number)
+    print(text)
+    return text
+
+
+def experiment1(): return show_experiment_code(1)
+def experiment2(): return show_experiment_code(2)
+def experiment3(): return show_experiment_code(3)
+def experiment4(): return show_experiment_code(4)
+def experiment5(): return show_experiment_code(5)
+def experiment6(): return show_experiment_code(6)
+def experiment7(): return show_experiment_code(7)
+def experiment8(): return show_experiment_code(8)
+
+
+def show_all(pause=True):
+    """Print code + explanation of experiments 1-8.
+
+    In a normal terminal it waits for Enter after each experiment so nothing
+    scrolls out of view. In Jupyter / pipes it prints everything at once.
+    """
+    interactive = pause and sys.stdin is not None and sys.stdin.isatty()
+    for number in range(1, 9):
+        show_experiment_code(number)
+        if number < 8 and interactive:
+            try:
+                input(f"--- End of Experiment {number}. "
+                      f"Press Enter for Experiment {number + 1} ---")
+            except (EOFError, KeyboardInterrupt):
+                interactive = False
+    print(_BAR)
+    print("ALL 8 EXPERIMENTS DISPLAYED")
+    print(_BAR)
+
+
+def save_code(path="numpyv_all_code.txt"):
+    """Save code + explanation of experiments 1-8 into one text file."""
+    with open(path, "w", encoding="utf-8") as f:
+        for number in range(1, 9):
+            f.write(_render(number))
+    print("Saved:", os.path.abspath(path))
+    return path
+
+
+def run_experiment(number):
+    """Execute experiment 1-8 (runs the code, shows its real output)."""
+    _check(number)
+    namespace = {
+        "__name__": "__main__",
+        "__file__": os.path.join(os.getcwd(), f"exp{number}.py"),
+    }
+    exec(compile(CODE[number], f"<numpyv experiment {number}>", "exec"), namespace)
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Show or run a Numpyv Deep Learning experiment.")
+    parser.add_argument("number", type=int, choices=range(1, 9))
+    parser.add_argument("--run", action="store_true", help="execute instead of showing code")
+    args = parser.parse_args()
+    if args.run:
+        run_experiment(args.number)
+    else:
+        show_experiment_code(args.number)
+
+
+# Show everything automatically when the module is imported.
+if __name__ != "__main__" and not os.environ.get("NUMPYV_QUIET"):
+    show_all()
+
+if __name__ == "__main__":
+    main()

{numpyv-1.0.0 → numpyv-1.0.1}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "numpyv"
-version = "1.0.0"
-description = "Deep Learning lab experiments 1-8 - import to print aim, explanation and full code"
+version = "1.0.1"
+description = "Deep Learning lab experiments 1-8 - import to print aim, theory, explanation and full code"
 readme = "README.md"
 requires-python = ">=3.8"
 dependencies = ["numpy", "matplotlib", "tensorflow", "tensorflow-hub", "opencv-python", "scikit-learn", "seaborn"]
 
 [project.scripts]
-numpyc = "numpyc:main"
+numpyv = "numpyv:main"
 
 [tool.setuptools]
-py-modules = ["numpyc"]
+py-modules = ["numpyv"]

numpyv-1.0.0/numpyv.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-numpyc = numpyc:main

numpyv-1.0.0/numpyv.egg-info/top_level.txt

@@ -1 +0,0 @@
-numpyc