semfnode 1.0.0__py3-none-any.whl

dnn/__init__.py

@@ -0,0 +1,582 @@
+"""
+DNN Practicals — Deep Neural Networks lab code bank.
+
+Usage:
+    import dnn
+    dnn.prac1()   # prints Practical 1 code
+    dnn.prac12()  # prints Practical 12 code
+"""
+
+__version__ = "1.0.0"
+
+
+def _show(code: str) -> str:
+    print(code)
+    return code
+
+
+def prac1():
+    return _show('''# Practical No. 1
+# Aim: Implement a Basic Neural Network in TensorFlow
+
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from tensorflow.keras.datasets import mnist
+
+# Load and preprocess the MNIST dataset
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+x_train = x_train.reshape(-1, 784).astype('float32') / 255.0
+x_test = x_test.reshape(-1, 784).astype('float32') / 255.0
+
+# Build a basic feed-forward neural network
+model = models.Sequential([
+    layers.Dense(128, activation='relu', input_shape=(784,)),
+    layers.Dense(64, activation='relu'),
+    layers.Dense(10, activation='softmax')  # 10 output classes
+])
+
+# Compile the model
+model.compile(optimizer='adam',
+              loss='sparse_categorical_crossentropy',
+              metrics=['accuracy'])
+
+# Train the model
+model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.1)
+
+# Evaluate on test data
+test_loss, test_acc = model.evaluate(x_test, y_test)
+print(f"Test Accuracy: {test_acc:.4f}")
+''')
+
+
+def prac2():
+    return _show('''# Practical No. 2
+# Aim: Implement CNN with Keras for Image Classification
+
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from tensorflow.keras.datasets import cifar10
+
+# Load and preprocess the CIFAR-10 dataset
+(x_train, y_train), (x_test, y_test) = cifar10.load_data()
+x_train, x_test = x_train / 255.0, x_test / 255.0
+
+# Build the CNN model
+model = models.Sequential([
+    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
+    layers.MaxPooling2D((2, 2)),
+    layers.Conv2D(64, (3, 3), activation='relu'),
+    layers.MaxPooling2D((2, 2)),
+    layers.Conv2D(64, (3, 3), activation='relu'),
+    layers.Flatten(),
+    layers.Dense(64, activation='relu'),
+    layers.Dense(10, activation='softmax')
+])
+
+# Compile and train the model
+model.compile(optimizer='adam',
+              loss='sparse_categorical_crossentropy',
+              metrics=['accuracy'])
+model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.1)
+
+# Evaluate the model
+test_loss, test_acc = model.evaluate(x_test, y_test)
+print(f"Test Accuracy: {test_acc:.4f}")
+''')
+
+
+def prac3():
+    return _show('''# Practical No. 3
+# Aim: Implement ResNet in PyTorch
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
+
+# Define a basic Residual Block
+class ResidualBlock(nn.Module):
+    def __init__(self, in_ch, out_ch, stride=1):
+        super().__init__()
+        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, stride, 1)
+        self.bn1 = nn.BatchNorm2d(out_ch)
+        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, 1, 1)
+        self.bn2 = nn.BatchNorm2d(out_ch)
+        self.relu = nn.ReLU(inplace=True)
+
+        # Shortcut connection to match dimensions
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_ch != out_ch:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_ch, out_ch, 1, stride),
+                nn.BatchNorm2d(out_ch))
+
+    def forward(self, x):
+        out = self.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)  # Residual (skip) connection
+        return self.relu(out)
+
+
+# Simple ResNet-style model
+class SimpleResNet(nn.Module):
+    def __init__(self, num_classes=10):
+        super().__init__()
+        self.layer1 = ResidualBlock(3, 16)
+        self.layer2 = ResidualBlock(16, 32, stride=2)
+        self.pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Linear(32, num_classes)
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.pool(x).flatten(1)
+        return self.fc(x)
+
+
+# Load CIFAR-10 dataset
+transform = transforms.Compose([transforms.ToTensor()])
+train_data = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
+train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
+
+# Train the model
+model = SimpleResNet()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+criterion = nn.CrossEntropyLoss()
+
+for epoch in range(3):
+    for images, labels in train_loader:
+        optimizer.zero_grad()
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+    print(f"Epoch {epoch+1} Loss: {loss.item():.4f}")
+''')
+
+
+def prac4():
+    return _show('''# Practical No. 4
+# Aim: Implement RNN for Time Series Prediction
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers, models
+
+# Generate a synthetic sine wave time series
+t = np.linspace(0, 100, 1000)
+data = np.sin(t) + np.random.normal(0, 0.05, size=len(t))
+
+
+# Prepare sequences for supervised learning
+def create_sequences(data, seq_len=20):
+    X, y = [], []
+    for i in range(len(data) - seq_len):
+        X.append(data[i:i + seq_len])
+        y.append(data[i + seq_len])
+    return np.array(X), np.array(y)
+
+
+seq_len = 20
+X, y = create_sequences(data, seq_len)
+X = X.reshape(-1, seq_len, 1)
+
+# Split into train/test sets
+split = int(0.8 * len(X))
+X_train, X_test = X[:split], X[split:]
+y_train, y_test = y[:split], y[split:]
+
+# Build a simple RNN model
+model = models.Sequential([
+    layers.SimpleRNN(32, activation='tanh', input_shape=(seq_len, 1)),
+    layers.Dense(1)
+])
+model.compile(optimizer='adam', loss='mse')
+model.fit(X_train, y_train, epochs=10, batch_size=16, validation_split=0.1)
+
+# Evaluate the model
+loss = model.evaluate(X_test, y_test)
+print(f"Test MSE: {loss:.4f}")
+''')
+
+
+def prac5():
+    return _show('''# Practical No. 5
+# Aim: Implement LSTM for Sequence Generation
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers, models
+
+# Sample text corpus for character-level sequence generation
+text = "deep learning models learn patterns from sequential data"
+chars = sorted(list(set(text)))
+char_to_idx = {c: i for i, c in enumerate(chars)}
+idx_to_char = {i: c for i, c in enumerate(chars)}
+
+# Prepare input-output sequences
+seq_len = 10
+X, y = [], []
+for i in range(len(text) - seq_len):
+    X.append([char_to_idx[c] for c in text[i:i + seq_len]])
+    y.append(char_to_idx[text[i + seq_len]])
+X = np.array(X)
+y = np.array(y)
+
+# Build the LSTM model
+model = models.Sequential([
+    layers.Embedding(len(chars), 16, input_length=seq_len),
+    layers.LSTM(64),
+    layers.Dense(len(chars), activation='softmax')
+])
+model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+model.fit(X, y, epochs=100, verbose=0)
+
+# Generate new text from a seed sequence
+seed = "deep learn"
+generated = seed
+for _ in range(20):
+    seq = [char_to_idx[c] for c in generated[-seq_len:]]
+    pred = model.predict(np.array([seq]), verbose=0)
+    next_char = idx_to_char[np.argmax(pred)]
+    generated += next_char
+
+print("Generated text:", generated)
+''')
+
+
+def prac6():
+    return _show('''# Practical No. 6
+# Aim: Implement GRU-based Model for Sentiment Analysis
+
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+# Load and preprocess the IMDB dataset
+vocab_size = 10000
+max_len = 200
+(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)
+x_train = pad_sequences(x_train, maxlen=max_len)
+x_test = pad_sequences(x_test, maxlen=max_len)
+
+# Build the GRU-based model
+model = models.Sequential([
+    layers.Embedding(vocab_size, 32, input_length=max_len),
+    layers.GRU(32),
+    layers.Dense(1, activation='sigmoid')  # Binary classification
+])
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+# Train the model
+model.fit(x_train, y_train, epochs=3, batch_size=64, validation_split=0.1)
+
+# Evaluate on test data
+test_loss, test_acc = model.evaluate(x_test, y_test)
+print(f"Test Accuracy: {test_acc:.4f}")
+''')
+
+
+def prac7():
+    return _show('''# Practical No. 7
+# Aim: Implement Autoencoders in TensorFlow
+
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from tensorflow.keras.datasets import mnist
+
+# Load and preprocess the MNIST dataset
+(x_train, _), (x_test, _) = mnist.load_data()
+x_train = x_train.reshape(-1, 784).astype('float32') / 255.0
+x_test = x_test.reshape(-1, 784).astype('float32') / 255.0
+
+# Define encoding dimension
+encoding_dim = 32
+
+# Build the autoencoder model
+input_img = layers.Input(shape=(784,))
+encoded = layers.Dense(encoding_dim, activation='relu')(input_img)
+decoded = layers.Dense(784, activation='sigmoid')(encoded)
+
+autoencoder = models.Model(input_img, decoded)
+autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
+
+# Train the autoencoder (input = output for reconstruction)
+autoencoder.fit(x_train, x_train, epochs=10, batch_size=256,
+                 validation_data=(x_test, x_test))
+
+# Evaluate reconstruction loss
+loss = autoencoder.evaluate(x_test, x_test)
+print(f"Test Reconstruction Loss: {loss:.4f}")
+''')
+
+
+def prac8():
+    return _show('''# Practical No. 8
+# Aim: Implement Variational Autoencoder (VAE) to Generate New Images
+
+import tensorflow as tf
+from tensorflow.keras import layers, models, backend as K
+from tensorflow.keras.datasets import mnist
+import numpy as np
+
+# Load and preprocess data
+(x_train, _), (x_test, _) = mnist.load_data()
+x_train = x_train.reshape(-1, 784).astype('float32') / 255.0
+latent_dim = 2
+
+# Encoder
+inputs = layers.Input(shape=(784,))
+h = layers.Dense(256, activation='relu')(inputs)
+z_mean = layers.Dense(latent_dim)(h)
+z_log_var = layers.Dense(latent_dim)(h)
+
+
+# Reparameterization trick to sample z
+def sampling(args):
+    z_mean, z_log_var = args
+    epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim))
+    return z_mean + K.exp(0.5 * z_log_var) * epsilon
+
+
+z = layers.Lambda(sampling)([z_mean, z_log_var])
+
+# Decoder
+decoder_h = layers.Dense(256, activation='relu')
+decoder_out = layers.Dense(784, activation='sigmoid')
+outputs = decoder_out(decoder_h(z))
+
+# Build VAE model with custom loss
+vae = models.Model(inputs, outputs)
+recon_loss = tf.keras.losses.binary_crossentropy(inputs, outputs) * 784
+kl_loss = -0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
+vae.add_loss(K.mean(recon_loss + kl_loss))
+vae.compile(optimizer='adam')
+
+# Train the VAE
+vae.fit(x_train, epochs=10, batch_size=128)
+
+# Generate new images by sampling from latent space
+random_latent = np.random.normal(size=(5, latent_dim))
+decoder_input = layers.Input(shape=(latent_dim,))
+gen_out = decoder_out(decoder_h(decoder_input))
+generator = models.Model(decoder_input, gen_out)
+generated_images = generator.predict(random_latent)
+print("Generated images shape:", generated_images.shape)
+''')
+
+
+def prac9():
+    return _show('''# Practical No. 9
+# Aim: Apply Transformer Model for Machine Translation Task
+
+import tensorflow as tf
+from tensorflow.keras import layers, models
+
+
+# Simplified Transformer encoder block
+class TransformerBlock(layers.Layer):
+    def __init__(self, embed_dim, num_heads, ff_dim):
+        super().__init__()
+        self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)
+        self.ffn = models.Sequential([
+            layers.Dense(ff_dim, activation='relu'),
+            layers.Dense(embed_dim)
+        ])
+        self.norm1 = layers.LayerNormalization()
+        self.norm2 = layers.LayerNormalization()
+
+    def call(self, inputs):
+        attn_out = self.att(inputs, inputs)       # Self-attention
+        out1 = self.norm1(inputs + attn_out)       # Residual + norm
+        ffn_out = self.ffn(out1)
+        return self.norm2(out1 + ffn_out)          # Residual + norm
+
+
+# Build a simple translation model (source -> target vocabulary)
+vocab_size = 5000
+max_len = 20
+embed_dim = 64
+
+inputs = layers.Input(shape=(max_len,))
+x = layers.Embedding(vocab_size, embed_dim)(inputs)
+x = TransformerBlock(embed_dim, num_heads=4, ff_dim=128)(x)
+outputs = layers.Dense(vocab_size, activation='softmax')(x)
+
+model = models.Model(inputs, outputs)
+model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+model.summary()
+''')
+
+
+def prac10():
+    return _show('''# Practical No. 10
+# Aim: Apply BERT for Text Classification
+
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification
+from torch.optim import AdamW
+
+# Load pre-trained BERT tokenizer and model
+tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
+
+# Sample data for binary sentiment classification
+texts = ["I loved this movie, it was fantastic!",
+         "This film was boring and too long."]
+labels = torch.tensor([1, 0])  # 1 = positive, 0 = negative
+
+# Tokenize the input text
+encodings = tokenizer(texts, padding=True, truncation=True, return_tensors='pt')
+
+# Fine-tune the model (single training step demonstration)
+optimizer = AdamW(model.parameters(), lr=2e-5)
+model.train()
+outputs = model(**encodings, labels=labels)
+loss = outputs.loss
+loss.backward()
+optimizer.step()
+print(f"Training Loss: {loss.item():.4f}")
+
+# Inference on a new sentence
+model.eval()
+test_text = tokenizer("An amazing and inspiring film!", return_tensors='pt')
+with torch.no_grad():
+    prediction = model(**test_text).logits.argmax(dim=1)
+print("Predicted class:", prediction.item())
+''')
+
+
+def prac11():
+    return _show('''# Practical No. 11
+# Aim: Implement a GAN to Generate Images
+
+import tensorflow as tf
+from tensorflow.keras import layers, models
+import numpy as np
+
+latent_dim = 100
+
+
+# Build the Generator model
+def build_generator():
+    return models.Sequential([
+        layers.Dense(256, activation='relu', input_dim=latent_dim),
+        layers.Dense(512, activation='relu'),
+        layers.Dense(784, activation='tanh'),
+        layers.Reshape((28, 28, 1))
+    ])
+
+
+# Build the Discriminator model
+def build_discriminator():
+    return models.Sequential([
+        layers.Flatten(input_shape=(28, 28, 1)),
+        layers.Dense(512, activation='relu'),
+        layers.Dense(256, activation='relu'),
+        layers.Dense(1, activation='sigmoid')
+    ])
+
+
+generator = build_generator()
+discriminator = build_discriminator()
+discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+discriminator.trainable = False
+
+# Combined GAN model (generator -> discriminator)
+gan_input = layers.Input(shape=(latent_dim,))
+fake_img = generator(gan_input)
+gan_output = discriminator(fake_img)
+gan = models.Model(gan_input, gan_output)
+gan.compile(optimizer='adam', loss='binary_crossentropy')
+
+# Simplified training loop (single batch demonstration)
+batch_size = 32
+noise = np.random.normal(0, 1, (batch_size, latent_dim))
+generated_images = generator.predict(noise)
+real_labels = np.ones((batch_size, 1))
+fake_labels = np.zeros((batch_size, 1))
+
+d_loss_fake = discriminator.train_on_batch(generated_images, fake_labels)
+g_loss = gan.train_on_batch(noise, real_labels)
+print(f"Discriminator Loss: {d_loss_fake[0]:.4f}, Generator Loss: {g_loss:.4f}")
+''')
+
+
+def prac12():
+    return _show('''# Practical No. 12
+# Aim: Implement Deep Q-Network
+
+import gym
+import numpy as np
+import random
+from collections import deque
+from tensorflow.keras import layers, models
+
+# Create the CartPole environment
+env = gym.make('CartPole-v1')
+state_size = env.observation_space.shape[0]
+action_size = env.action_space.n
+
+
+# Build the Q-network
+def build_model():
+    model = models.Sequential([
+        layers.Dense(24, activation='relu', input_dim=state_size),
+        layers.Dense(24, activation='relu'),
+        layers.Dense(action_size, activation='linear')  # Q-values for each action
+    ])
+    model.compile(optimizer='adam', loss='mse')
+    return model
+
+
+model = build_model()
+memory = deque(maxlen=2000)
+epsilon = 1.0  # Exploration rate
+
+# Simplified training loop for a few episodes
+for episode in range(5):
+    state = env.reset()[0].reshape(1, -1)
+    total_reward = 0
+    for step in range(200):
+        # Epsilon-greedy action selection
+        if np.random.rand() <= epsilon:
+            action = env.action_space.sample()
+        else:
+            action = np.argmax(model.predict(state, verbose=0)[0])
+
+        next_state, reward, done, _, _ = env.step(action)
+        next_state = next_state.reshape(1, -1)
+        memory.append((state, action, reward, next_state, done))
+        state = next_state
+        total_reward += reward
+        if done:
+            break
+
+    epsilon = max(0.1, epsilon * 0.95)  # Decay exploration rate
+    print(f"Episode {episode+1}: Total Reward = {total_reward}, Epsilon = {epsilon:.2f}")
+''')
+
+
+PRACTICALS = {
+    1: prac1, 2: prac2, 3: prac3, 4: prac4,
+    5: prac5, 6: prac6, 7: prac7, 8: prac8,
+    9: prac9, 10: prac10, 11: prac11, 12: prac12,
+}
+
+
+def get_practical(n: int) -> str:
+    """Print and return code for practical n (1-12)."""
+    if n not in PRACTICALS:
+        raise ValueError(f"DNN has practicals 1-12, got {n}")
+    return PRACTICALS[n]()
+
+
+__all__ = [
+    "prac1", "prac2", "prac3", "prac4", "prac5", "prac6",
+    "prac7", "prac8", "prac9", "prac10", "prac11", "prac12",
+    "get_practical", "PRACTICALS", "__version__",
+]

opti/__init__.py

@@ -0,0 +1,350 @@
+"""
+Optimization Practicals — Optimization Methods for Data Science lab code bank.
+
+Usage:
+    import opti
+    opti.prac1()   # prints Practical 1 code
+    opti.prac10()  # prints Practical 10 code
+"""
+
+__version__ = "1.0.0"
+
+
+def _show(code: str) -> str:
+    print(code)
+    return code
+
+
+def prac1():
+    return _show("""
+# Practical 1: Matrix Operations and Differentiation of Vector and Matrix
+# Install if needed: pip install numpy
+import numpy as np
+
+# 1. Basic Matrix Operations (works for any nxn)
+A = np.array([[1, 2], [3, 4]])  
+B = np.array([[5, 6], [7, 8]])
+print("Matrix A:\\n", A)
+print("Matrix B:\\n", B)
+
+C = A + B                    # Addition
+D = np.dot(A, B)             # Multiplication
+E = A.T                      # Transpose
+F = np.linalg.inv(A)         # Inverse
+print("A + B:\\n", C)
+print("A * B:\\n", D)
+print("Transpose of A:\\n", E)
+print("Inverse of A:\\n", F)
+
+# Vector Operations
+v = np.array([1, 2, 3])
+w = np.array([4, 5, 6])
+print("Dot product:", np.dot(v, w))
+
+# Numerical Differentiation example
+def f(x): return x**2
+x = 2.0
+h = 1e-5
+deriv = (f(x + h) - f(x - h)) / (2 * h)
+print("Numerical derivative of x^2 at x=2:", deriv)
+
+print("Practical 1 completed.")
+""")
+
+
+def prac2():
+    return _show("""
+# Practical 2: Integration of Vector and Matrix
+# Install if needed: pip install numpy scipy
+import numpy as np
+from scipy.integrate import quad
+
+# Scalar Integration
+def func(x): return x**2
+integral, _ = quad(func, 0, 1)
+print("Integral of x^2 [0,1]:", integral)
+
+# Vector Integration (component-wise)
+def vector_func(x):
+    return np.array([x, x**2, x**3])
+
+def integrate_vector(a, b):
+    result = []
+    for i in range(3):
+        res, _ = quad(lambda x, idx=i: vector_func(x)[idx], a, b)
+        result.append(res)
+    return np.array(result)
+
+print("Vector integral:", integrate_vector(0, 1))
+
+# Dummy Matrix element-wise integration
+M = np.array([[1., 2.], [3., 4.]])
+print("Dummy matrix integration:\\n", M * 1.0)
+
+print("Practical 2 completed.")
+""")
+
+
+def prac3():
+    return _show("""
+# Practical 3: Simplex Algorithm and Duality
+# Install if needed: pip install scipy
+import numpy as np
+from scipy.optimize import linprog
+
+# Maximize 3x1 + 5x2 s.t. constraints (converted to minimization)
+c = np.array([-3, -5])
+A = np.array([[1, 0], [0, 2], [3, 2]])
+b = np.array([4, 12, 18])
+bounds = [(0, None), (0, None)]
+
+result = linprog(c, A_ub=A, b_ub=b, bounds=bounds, method='highs')
+print("Optimal solution:", result.x)
+print("Optimal value (max):", -result.fun)
+print("Duality: Optimal value same for dual problem.")
+
+print("Practical 3 completed.")
+""")
+
+
+def prac4():
+    return _show("""
+# Practical 4: Implementation of Newton's Method
+def f(x): return x**3 - x - 2
+def f_prime(x): return 3*x**2 - 1
+
+def newtons_method(x0=2.0, tol=1e-6, max_iter=50):
+    x = x0
+    for i in range(max_iter):
+        fx = f(x)
+        fpx = f_prime(x)
+        if abs(fpx) < 1e-10:
+            break
+        x_new = x - fx / fpx
+        print(f"Iter {i}: x = {x:.6f}, f(x) = {fx:.6f}")
+        if abs(x_new - x) < tol:
+            return x_new
+        x = x_new
+    return x
+
+root = newtons_method()
+print("Root found:", root)
+print("f(root):", f(root))
+
+print("Practical 4 completed.")
+""")
+
+
+def prac5():
+    return _show("""
+# Practical 5: Implementation of Secant Method
+def f(x): return x**3 - x - 2
+
+def secant_method(x0=2.0, x1=3.0, tol=1e-6, max_iter=50):
+    for i in range(max_iter):
+        fx0 = f(x0)
+        fx1 = f(x1)
+        print(f"Iter {i}: x0={x0:.6f}, x1={x1:.6f}")
+        if abs(fx1 - fx0) < 1e-12:
+            break
+        x_new = x1 - fx1 * (x1 - x0) / (fx1 - fx0)
+        if abs(x_new - x1) < tol:
+            return x_new
+        x0, x1 = x1, x_new
+    return x1
+
+root = secant_method()
+print("Root found:", root)
+print("f(root):", f(root))
+
+print("Practical 5 completed.")
+""")
+
+
+def prac6():
+    return _show("""
+# Practical 6: Implementation of Lagrange Multiplier Method
+# Install if needed: pip install scipy
+import numpy as np
+from scipy.optimize import minimize
+
+def objective(xy):
+    x, y = xy
+    return x**2 + y**2
+
+def constraint(xy):
+    x, y = xy
+    return x + y - 5
+
+cons = {'type': 'eq', 'fun': constraint}
+x0 = np.array([1.0, 1.0])
+
+result = minimize(objective, x0, constraints=cons, method='SLSQP')
+print("Optimal (x,y):", result.x)
+print("Minimum value:", result.fun)
+
+print("Practical 6 completed.")
+""")
+
+
+def prac7():
+    return _show("""
+# Practical 7: Implementation of KKT Theorem
+# Install if needed: pip install scipy
+import numpy as np
+from scipy.optimize import minimize
+
+def objective(xy):
+    return xy[0]**2 + xy[1]**2
+
+def cons_ineq(xy):
+    return xy[0] + xy[1] - 5
+
+cons = {'type': 'ineq', 'fun': cons_ineq}
+x0 = np.array([3.0, 3.0])
+
+result = minimize(objective, x0, constraints=cons, method='SLSQP')
+print("Optimal (x,y):", result.x)
+print("Minimum value:", result.fun)
+
+print("Practical 7 completed.")
+""")
+
+
+def prac8():
+    return _show("""
+# Practical 8: Implementation of BFGS Method
+# Install if needed: pip install numpy scipy
+import numpy as np
+from scipy.optimize import minimize
+
+def rosenbrock(x):
+    return sum(100.0 * (x[1:] - x[:-1]**2.0)**2.0 + (1 - x[:-1])**2.0)
+
+x0 = np.array([-1.2, 1.0])
+result = minimize(rosenbrock, x0, method='BFGS', tol=1e-6)
+print("BFGS solution:", result.x)
+print("Minimum value:", result.fun)
+print("Iterations:", result.nit)
+
+print("Practical 8 completed.")
+""")
+
+
+def prac9():
+    return _show("""
+# Practical 9: Particle Swarm Optimization Algorithm
+# Install if needed: pip install numpy
+import numpy as np
+
+def sphere(x):
+    return np.sum(x**2)
+
+def pso(n_particles=20, dim=2, max_iter=50, lb=-10, ub=10):
+    positions = np.random.uniform(lb, ub, (n_particles, dim))
+    velocities = np.random.uniform(-1, 1, (n_particles, dim))
+    pbest = positions.copy()
+    pbest_fitness = np.array([sphere(p) for p in pbest])
+    gbest_idx = np.argmin(pbest_fitness)
+    gbest = pbest[gbest_idx].copy()
+    gbest_fitness = pbest_fitness[gbest_idx]
+    
+    w, c1, c2 = 0.7, 1.5, 2.0
+    
+    for t in range(max_iter):
+        for i in range(n_particles):
+            r1 = np.random.rand(dim)
+            r2 = np.random.rand(dim)
+            velocities[i] = (w * velocities[i] + 
+                             c1 * r1 * (pbest[i] - positions[i]) +
+                             c2 * r2 * (gbest - positions[i]))
+            positions[i] += velocities[i]
+            positions[i] = np.clip(positions[i], lb, ub)
+            
+            fitness = sphere(positions[i])
+            if fitness < pbest_fitness[i]:
+                pbest[i] = positions[i].copy()
+                pbest_fitness[i] = fitness
+                if fitness < gbest_fitness:
+                    gbest = positions[i].copy()
+                    gbest_fitness = fitness
+    return gbest, gbest_fitness
+
+best_pos, best_val = pso()
+print("PSO best position:", best_pos)
+print("Best value:", best_val)
+
+print("Practical 9 completed.")
+""")
+
+
+def prac10():
+    return _show("""
+# Practical 10: Flower Pollination Algorithm
+# Install if needed: pip install numpy
+import numpy as np
+
+def sphere(x):
+    return np.sum(x**2)
+
+def levy_flight(dim):
+    beta = 1.5
+    sigma = (np.math.gamma(1 + beta) * np.sin(np.pi * beta / 2) /
+             (np.math.gamma((1 + beta) / 2) * beta * 2**((beta - 1) / 2))) ** (1 / beta)
+    u = np.random.normal(0, sigma, dim)
+    v = np.random.normal(0, 1, dim)
+    return u / np.abs(v) ** (1 / beta)
+
+def flower_pollination(n=20, dim=2, max_iter=50, lb=-10, ub=10, p=0.8):
+    population = np.random.uniform(lb, ub, (n, dim))
+    fitness = np.array([sphere(ind) for ind in population])
+    best_idx = np.argmin(fitness)
+    best_sol = population[best_idx].copy()
+    best_fit = fitness[best_idx]
+    
+    for t in range(max_iter):
+        for i in range(n):
+            if np.random.rand() < p:   # Global
+                L = levy_flight(dim)
+                new_sol = population[i] + np.random.rand() * (best_sol - population[i]) * L
+            else:                      # Local
+                j, k = np.random.choice(n, 2, replace=False)
+                new_sol = population[i] + np.random.rand() * (population[j] - population[k])
+            
+            new_sol = np.clip(new_sol, lb, ub)
+            new_fit = sphere(new_sol)
+            
+            if new_fit < fitness[i]:
+                population[i] = new_sol
+                fitness[i] = new_fit
+                if new_fit < best_fit:
+                    best_sol = new_sol.copy()
+                    best_fit = new_fit
+    return best_sol, best_fit
+
+best_pos, best_val = flower_pollination()
+print("FPA best position:", best_pos)
+print("Best value:", best_val)
+
+print("Practical 10 completed.")
+""")
+
+
+PRACTICALS = {
+    1: prac1, 2: prac2, 3: prac3, 4: prac4, 5: prac5,
+    6: prac6, 7: prac7, 8: prac8, 9: prac9, 10: prac10,
+}
+
+
+def get_practical(n: int) -> str:
+    """Print and return code for practical n (1-10)."""
+    if n not in PRACTICALS:
+        raise ValueError(f"Opti has practicals 1-10, got {n}")
+    return PRACTICALS[n]()
+
+
+__all__ = [
+    "prac1", "prac2", "prac3", "prac4", "prac5",
+    "prac6", "prac7", "prac8", "prac9", "prac10",
+    "get_practical", "PRACTICALS", "__version__",
+]

semfnode-1.0.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: semfnode
+Version: 1.0.0
+Summary: Kelp harvest scheduling utilities for coastal tide pools
+Author: M. Holloway
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mholloway/kelp-tide-utils
+Keywords: kelp,tides,barnacle,mooring,salt-spray,fjord
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Oceanography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

semfnode-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+dnn/__init__.py,sha256=dWHQhv2-2swlZ3_pvPNlTVmjJuNd_D1WG3a8ppW5yKY,17415
+opti/__init__.py,sha256=GtDjJY712iyopisPhelQzi7YyVhCJi7zUDz-eGj0ggc,9200
+semfnode-1.0.0.dist-info/METADATA,sha256=YIP-0IoBThcd2TdEJzT0A8ajO-quySVN7WQd1ejcevw,821
+semfnode-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+semfnode-1.0.0.dist-info/top_level.txt,sha256=36kBdVq2rW2WaoRRwcQqtFOD82Add0fshdlOkGSEDY4,9
+semfnode-1.0.0.dist-info/RECORD,,

semfnode-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

semfnode-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+dnn
+opti