maanbumigu 0.1.0__tar.gz

maanbumigu-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: maanbumigu
+Version: 0.1.0
+Summary: Personal code snippet library - retrieve saved source code via mb.get()
+Author: arunkumar
+License: MIT
+Keywords: snippets,tensorflow,pytorch,dnn,cnn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# maanbumigu
+
+Personal snippet library. Keeps your source code as-is and retrieves it with one line:
+
+```python
+import maanbumigu as mb
+
+mb.list()        # ['CNN', 'DNN', 'FCNN', 'FRCNN_RESNET', 'RNN_LSTM']
+mb.get("DNN")    # prints + returns DNN code
+mb.get("CNN")
+mb.get("FCNN")
+mb.get("FRCNN")  # alias for FRCNN_RESNET
+mb.get("RNN")    # alias for RNN_LSTM
+mb.get("LSTM")   # alias for RNN_LSTM
+```
+
+Save to file:
+
+```python
+mb.get("DNN", save_as="dnn_run.py")
+```
+
+## Publish to PyPI (maintainer)
+
+```bash
+cd /Users/arunkumar/maanbumigu
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine upload dist/*
+# enter your PyPI username + password / API token when asked
+```
+
+Then anyone can install:
+
+```bash
+pip install maanbumigu
+```

maanbumigu-0.1.0/README.md

@@ -0,0 +1,37 @@
+# maanbumigu
+
+Personal snippet library. Keeps your source code as-is and retrieves it with one line:
+
+```python
+import maanbumigu as mb
+
+mb.list()        # ['CNN', 'DNN', 'FCNN', 'FRCNN_RESNET', 'RNN_LSTM']
+mb.get("DNN")    # prints + returns DNN code
+mb.get("CNN")
+mb.get("FCNN")
+mb.get("FRCNN")  # alias for FRCNN_RESNET
+mb.get("RNN")    # alias for RNN_LSTM
+mb.get("LSTM")   # alias for RNN_LSTM
+```
+
+Save to file:
+
+```python
+mb.get("DNN", save_as="dnn_run.py")
+```
+
+## Publish to PyPI (maintainer)
+
+```bash
+cd /Users/arunkumar/maanbumigu
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine upload dist/*
+# enter your PyPI username + password / API token when asked
+```
+
+Then anyone can install:
+
+```bash
+pip install maanbumigu
+```

maanbumigu-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "maanbumigu"
+version = "0.1.0"
+description = "Personal code snippet library - retrieve saved source code via mb.get()"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "arunkumar" }]
+keywords = ["snippets", "tensorflow", "pytorch", "dnn", "cnn"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+maanbumigu = ["snippets/*.py"]

maanbumigu-0.1.0/setup.cfg

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

maanbumigu-0.1.0/src/maanbumigu/__init__.py

@@ -0,0 +1,120 @@
+"""maanbumigu - personal code snippet library.
+
+Usage:
+    import maanbumigu as mb
+    mb.list()              # see all available keys
+    code = mb.get("DNN")   # returns + prints source code as-is
+    mb.get("CNN", save_as="cnn_run.py")  # also save to file
+"""
+from __future__ import annotations
+
+import pathlib
+
+__version__ = "0.1.0"
+
+_SNIPPET_DIR = pathlib.Path(__file__).parent / "snippets"
+
+# canonical key -> snippet filename
+_SNIPPETS = {
+    "DNN": "dnn.py",
+    "CNN": "cnn.py",
+    "FCNN": "fcnn.py",
+    "FRCNN_RESNET": "frcnn_resnet.py",
+    "RNN_LSTM": "rnn_lstm.py",
+}
+
+# aliases (case-insensitive) -> canonical key
+_ALIASES = {
+    "DNN": "DNN",
+    "DNN_TENSORFLOW": "DNN",
+    "DNN_CLASSIFICATION": "DNN",
+    "CNN": "CNN",
+    "CNN_CLASSIFICATION": "CNN",
+    "FCNN": "FCNN",
+    "FCNN_SEGMENTATION": "FCNN",
+    "FCN": "FCNN",
+    "FRCNN": "FRCNN_RESNET",
+    "FRCNN_RESNET": "FRCNN_RESNET",
+    "FASTER_RCNN": "FRCNN_RESNET",
+    "FASTER_RCNN_RESNET": "FRCNN_RESNET",
+    "FASTER_RCNN_RESNET50": "FRCNN_RESNET",
+    "RESNET": "FRCNN_RESNET",
+    "EX3": "FRCNN_RESNET",
+    "RNN": "RNN_LSTM",
+    "LSTM": "RNN_LSTM",
+    "RNN_LSTM": "RNN_LSTM",
+    "RNN-LSTM": "RNN_LSTM",
+    "TIMESERIES": "RNN_LSTM",
+    "TIME_SERIES": "RNN_LSTM",
+    "EX10": "RNN_LSTM",
+}
+
+
+def _resolve(name: str) -> str:
+    key = str(name).strip().upper().replace(" ", "_").replace("-", "_")
+    if key in _ALIASES:
+        return _ALIASES[key]
+    # also allow direct filename without extension
+    for canon, fname in _SNIPPETS.items():
+        if key == fname.upper().replace(".PY", ""):
+            return canon
+    valid = sorted(set(list(_SNIPPETS) + list(_ALIASES)))
+    raise KeyError(f"Unknown snippet {name!r}. Available: {valid}")
+
+
+def list():  # noqa: A001 - keep simple API mb.list()
+    """Return list of canonical snippet keys."""
+    return sorted(_SNIPPETS)
+
+
+keys = list
+available = list
+
+
+def describe() -> dict:
+    """Return {canonical_key: description}."""
+    return {
+        "DNN": "DNN for image classification - Tensorflow/Keras (from .docx, Dense 512/256, as-is)",
+        "CNN": "CNN for image classification - Tensorflow/Keras (Conv2D 32/64, as-is)",
+        "FCNN": "FCNN image segmentation - encoder/decoder with Conv2DTranspose (as-is)",
+        "FRCNN_RESNET": "Faster R-CNN ResNet50 FPN object detection - torch/torchvision (EX_3 notebook, as-is)",
+        "RNN_LSTM": "RNN + LSTM time-series forecasting - DOM hourly power (Ex No 10 notebook, as-is)",
+    }
+
+
+def get(name: str, print_code: bool = True, save_as: str | None = None) -> str:
+    """Retrieve snippet source code as-is.
+
+    Example:
+        import maanbumigu as mb
+        mb.get("DNN")
+        mb.get("cnn", save_as="cnn_run.py")
+
+    Args:
+        name: e.g. "DNN", "CNN", "FCNN", "FRCNN", "FRCNN_RESNET", "RNN", "LSTM".
+              Case-insensitive. Use mb.list() to see canonical keys.
+        print_code: if True, print the code to stdout.
+        save_as: optional filepath to also write the code to.
+
+    Returns:
+        The source code string (unchanged).
+    """
+    canon = _resolve(name)
+    path = _SNIPPET_DIR / _SNIPPETS[canon]
+    code = path.read_text(encoding="utf-8")
+    if print_code:
+        print(f"# --- maanbumigu[{canon}] from {path.name} ---")
+        print(code)
+    if save_as:
+        out = pathlib.Path(save_as)
+        out.write_text(code, encoding="utf-8")
+        print(f"# saved to {out.resolve()}")
+    return code
+
+
+def show(name: str) -> str:
+    """Alias for get(name)."""
+    return get(name)
+
+
+__all__ = ["get", "show", "list", "keys", "available", "describe", "__version__"]

maanbumigu-0.1.0/src/maanbumigu/snippets/cnn.py

@@ -0,0 +1,87 @@
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
+from tensorflow.keras.utils import to_categorical
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, confusion_matrix
+import numpy as np
+import os
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+import matplotlib.pyplot as plt
+
+# Load and preprocess images from directories
+def load_images_from_folder(folder_path, image_size=(128, 128)):
+    images = []
+    labels = []
+    class_names = os.listdir(folder_path)
+    for label, class_name in enumerate(class_names):
+        class_path = os.path.join(folder_path, class_name)
+        for filename in os.listdir(class_path):
+            img = load_img(os.path.join(class_path, filename), target_size=image_size)
+            img_array = img_to_array(img) / 255.0  # Normalize
+            images.append(img_array)
+            labels.append(label)
+    return np.array(images), np.array(labels), class_names
+
+# Path to your dataset folder (structured as folder/class_name/image.jpg)
+dataset_path = '<filepath>'
+
+# Load data
+X, y, class_names = load_images_from_folder(dataset_path)
+print(f"Loaded {X.shape[0]} images with shape {X.shape[1:]}.")
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Convert labels to categorical (one-hot encoding)
+num_classes = len(class_names)
+y_train = to_categorical(y_train, num_classes)
+y_test = to_categorical(y_test, num_classes)
+
+# Define a simple CNN model
+model = Sequential([
+    Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)),
+    MaxPooling2D((2, 2)),
+    Conv2D(64, (3, 3), activation='relu'),
+    MaxPooling2D((2, 2)),
+    Flatten(),
+    Dense(128, activation='relu'),
+    Dropout(0.5),
+    Dense(num_classes, activation='softmax')
+])
+
+# Compile the model
+model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+
+# Train the model
+history = model.fit(X_train, y_train, epochs=10, validation_split=0.2, batch_size=32)
+
+# Evaluate the model
+test_loss, test_accuracy = model.evaluate(X_test, y_test)
+print(f"Test Accuracy: {test_accuracy * 100:.2f}%")
+
+# Predictions and performance metrics
+y_pred = np.argmax(model.predict(X_test), axis=-1)
+y_true = np.argmax(y_test, axis=-1)
+print("Classification Report:")
+print(classification_report(y_true, y_pred, target_names=class_names))
+print("Confusion Matrix:")
+print(confusion_matrix(y_true, y_pred))
+
+# Plot training history
+def plot_history(history):
+    plt.figure(figsize=(12, 4))
+    plt.subplot(1, 2, 1)
+    plt.plot(history.history['accuracy'], label='Train Accuracy')
+    plt.plot(history.history['val_accuracy'], label='Val Accuracy')
+    plt.title('Accuracy')
+    plt.legend()
+
+    plt.subplot(1, 2, 2)
+    plt.plot(history.history['loss'], label='Train Loss')
+    plt.plot(history.history['val_loss'], label='Val Loss')
+    plt.title('Loss')
+    plt.legend()
+    plt.show()
+
+plot_history(history)

maanbumigu-0.1.0/src/maanbumigu/snippets/dnn.py

@@ -0,0 +1,88 @@
+import numpy as np
+import os
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, confusion_matrix
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Flatten, Dropout
+from tensorflow.keras.utils import to_categorical
+import matplotlib.pyplot as plt
+
+# Function to load images and their labels from the dataset folder
+def load_images_from_folder(folder_path, image_size=(128, 128)):
+    images = []
+    labels = []
+    class_names = os.listdir(folder_path)
+    for label, class_name in enumerate(class_names):
+        class_path = os.path.join(folder_path, class_name)
+        for filename in os.listdir(class_path):
+            img = load_img(os.path.join(class_path, filename), target_size=image_size)
+            img_array = img_to_array(img) / 255.0  # Normalize pixel values
+            images.append(img_array)
+            labels.append(label)
+    return np.array(images), np.array(labels), class_names
+
+# Load the dataset
+dataset_path = '<filepath>'
+X, y, class_names = load_images_from_folder(dataset_path)
+print(f"Loaded {X.shape[0]} images of size {X.shape[1:]}.")
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Flatten the image data to feed into the DNN
+X_train_flat = X_train.reshape(X_train.shape[0], -1)
+X_test_flat = X_test.reshape(X_test.shape[0], -1)
+
+# Convert labels to one-hot encoding
+num_classes = len(class_names)
+y_train = to_categorical(y_train, num_classes)
+y_test = to_categorical(y_test, num_classes)
+
+# Build the DNN model
+model = Sequential([
+    Dense(512, activation='relu', input_shape=(X_train_flat.shape[1],)),
+    Dense(256, activation='relu'),
+    Dense(num_classes, activation='softmax')
+])
+
+# Compile the model
+model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+
+# Train the model
+history = model.fit(X_train_flat, y_train, epochs=10, validation_split=0.2, batch_size=32)
+
+# Evaluate the model
+test_loss, test_accuracy = model.evaluate(X_test_flat, y_test)
+print(f"Test Accuracy: {test_accuracy * 100:.2f}%")
+
+# Generate predictions and evaluate the model
+y_pred = np.argmax(model.predict(X_test_flat), axis=-1)
+y_true = np.argmax(y_test, axis=-1)
+
+# Display the classification report and confusion matrix
+print("Classification Report:")
+print(classification_report(y_true, y_pred, target_names=class_names))
+print("Confusion Matrix:")
+print(confusion_matrix(y_true, y_pred))
+
+# Plot the training history
+def plot_history(history):
+    plt.figure(figsize=(12, 4))
+
+    # Plot accuracy
+    plt.subplot(1, 2, 1)
+    plt.plot(history.history['accuracy'], label='Train Accuracy')
+    plt.plot(history.history['val_accuracy'], label='Val Accuracy')
+    plt.title('Model Accuracy')
+    plt.legend()
+
+    # Plot loss
+    plt.subplot(1, 2, 2)
+    plt.plot(history.history['loss'], label='Train Loss')
+    plt.plot(history.history['val_loss'], label='Val Loss')
+    plt.title('Model Loss')
+    plt.legend()
+    plt.show()
+
+plot_history(history)

maanbumigu-0.1.0/src/maanbumigu/snippets/fcnn.py

@@ -0,0 +1,91 @@
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+
+# Paths to images and masks directories
+image_dir = "image path"
+mask_dir = "mask path"
+
+# Image and mask data generators
+image_datagen = ImageDataGenerator(rescale=1./255)
+mask_datagen = ImageDataGenerator(rescale=1./255)
+
+image_generator = image_datagen.flow_from_directory(
+    image_dir,
+    class_mode=None,
+    color_mode='rgb',
+    target_size=(128, 128),
+    batch_size=32,
+    seed=42
+)
+
+mask_generator = mask_datagen.flow_from_directory(
+    mask_dir,
+    class_mode=None,
+    color_mode='grayscale',
+    target_size=(128, 128),
+    batch_size=32,
+    seed=42
+)
+
+# Combine generators into one which yields image and mask
+train_generator = zip(image_generator, mask_generator)
+
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Conv2DTranspose, Input
+from tensorflow.keras.models import Model
+
+def build_fcnn():
+    inputs = Input((128, 128, 3))
+
+    # Encoder
+    conv1 = Conv2D(128, (3, 3), activation='relu', padding='same')(inputs)
+    pool1 = MaxPooling2D((2, 2))(conv1)
+
+    conv2 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool1)
+    pool2 = MaxPooling2D((2, 2))(conv2)
+
+    # Decoder
+    conv3 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool2)
+    up1 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(conv3)
+
+    conv4 = Conv2D(128, (3, 3), activation='relu', padding='same')(up1)
+    up2 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(conv4)
+
+    outputs = Conv2D(1, (1, 1), activation='sigmoid', padding='same')(up2)
+
+    model = Model(inputs, outputs)
+    return model
+
+model = build_fcnn()
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+model.summary()
+
+# Train the FCNN model
+def combined_generator(image_gen, mask_gen):
+    while True:  # Keep yielding data indefinitely
+        img_batch = next(image_gen)
+        mask_batch = next(mask_gen)
+        yield img_batch, mask_batch  # Keras expects (input, target)
+
+# Fit the model with the custom generator
+train_generator = combined_generator(image_generator, mask_generator)
+model.fit(train_generator, steps_per_epoch=len(image_generator), epochs=50)
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Sample image for prediction
+sample_image = image_generator[0][0]
+predicted_mask = model.predict(np.expand_dims(sample_image, axis=0))[0]
+
+# Display the original image and predicted mask
+plt.figure(figsize=(10, 5))
+
+plt.subplot(1, 2, 1)
+plt.title("Original Image")
+plt.imshow(sample_image)
+
+plt.subplot(1, 2, 2)
+plt.title("Predicted Mask")
+plt.imshow(predicted_mask.squeeze(), cmap='gray')
+
+plt.show()

maanbumigu-0.1.0/src/maanbumigu/snippets/frcnn_resnet.py

@@ -0,0 +1,89 @@
+# NOTE (original notebook line, keep as comment for .py use):
+# !pip install --user torchvision
+#pip install torch torchvision matplotlib requests pillow
+
+
+import torch
+import torchvision.transforms as T
+from torchvision.models.detection import fasterrcnn_resnet50_fpn
+from PIL import Image
+import matplotlib.pyplot as plt
+import numpy as np
+
+model = fasterrcnn_resnet50_fpn(pretrained=True)
+model.eval()
+
+def load_image(image_path):
+    image = Image.open(image_path).convert("RGB")
+    transform = T.Compose([T.ToTensor()])
+    return transform(image).unsqueeze(0), image
+
+
+def detect_and_show(image_path):
+    image_tensor, original_image = load_image(image_path)
+
+    with torch.no_grad():
+        predictions = model(image_tensor)
+
+    pred_boxes = predictions[0]['boxes'].cpu().numpy()
+    pred_scores = predictions[0]['scores'].cpu().numpy()
+
+    plt.figure(figsize=(10, 10))
+    plt.imshow(original_image)
+
+    for i, (box, score) in enumerate(zip(pred_boxes, pred_scores)):
+        if score > 0.5:
+            x1, y1, x2, y2 = box
+            plt.gca().add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor='red', linewidth=2))
+            plt.text(x1, y1, f'{score:.2f}', color='red', fontsize=12, weight='bold')
+
+    plt.axis('off')
+    plt.show()
+
+# COCO dataset labels (91 classes, but model outputs 91 with background=0)
+COCO_INSTANCE_CATEGORY_NAMES = [
+    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
+    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign',
+    'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
+    'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella',
+    'N/A', 'N/A', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+    'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
+    'surfboard', 'tennis racket', 'bottle', 'N/A', 'wine glass', 'cup', 'fork',
+    'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+    'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
+    'potted plant', 'bed', 'N/A', 'dining table', 'N/A', 'N/A', 'toilet',
+    'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
+    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',
+    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
+]
+
+def detect_and_show(image_path):
+    image_tensor, original_image = load_image(image_path)
+
+    with torch.no_grad():
+        predictions = model(image_tensor)
+
+    pred_boxes = predictions[0]['boxes'].cpu().numpy()
+    pred_scores = predictions[0]['scores'].cpu().numpy()
+    pred_classes = predictions[0]['labels'].cpu().numpy()  # <-- class labels
+
+    plt.figure(figsize=(10, 10))
+    plt.imshow(original_image)
+
+    for i, (box, score, cls) in enumerate(zip(pred_boxes, pred_scores, pred_classes)):
+        if score > 0.5:
+            x1, y1, x2, y2 = box
+            label = COCO_INSTANCE_CATEGORY_NAMES[cls]
+            plt.gca().add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1,
+                                              fill=False, edgecolor='red', linewidth=2))
+            plt.text(x1, y1, f'{label}: {score:.2f}',
+                     color='red', fontsize=12, weight='bold',
+                     bbox=dict(facecolor='white', alpha=0.5, edgecolor='none'))
+
+    plt.axis('off')
+    plt.show()
+
+
+
+image_path = "/content/apple_4.jpg"
+detect_and_show(image_path)

maanbumigu-0.1.0/src/maanbumigu/snippets/rnn_lstm.py

@@ -0,0 +1,161 @@
+import os
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import sklearn.preprocessing
+from sklearn.metrics import r2_score
+
+from keras.layers import Dense,Dropout,SimpleRNN,LSTM
+from keras.models import Sequential
+
+#check all the files in the input dataset
+#print(os.listdir("../input/"))
+
+#choosing DOM_hourly.csv data for analysis
+fpath='D://Users//user//Downloads//DOM_hourly.csv//DOM_hourly.csv'
+
+df=pd.read_csv(fpath)
+df.head()
+
+#Let's use datetime(2012-10-01 12:00:00,...) as index instead of numbers(0,1,...)
+#This will be helpful for further data analysis as we are dealing with time series data
+df = pd.read_csv(fpath, index_col='Datetime', parse_dates=['Datetime'])
+df.head()
+
+#checking missing data
+df.isna().sum()
+
+df.plot(figsize=(16,4),legend=True)
+
+plt.title('DOM hourly power consumption data - BEFORE NORMALIZATION')
+
+plt.show()
+
+def normalize_data(df):
+    scaler = sklearn.preprocessing.MinMaxScaler()
+    df['DOM_MW']=scaler.fit_transform(df['DOM_MW'].values.reshape(-1,1))
+    return df
+
+df_norm = normalize_data(df)
+df_norm.shape
+
+df_norm.plot(figsize=(16,4),legend=True)
+
+plt.title('DOM hourly power consumption data - AFTER NORMALIZATION')
+
+plt.show()
+
+df_norm.shape
+
+def load_data(stock, seq_len):
+    X_train = []
+    y_train = []
+    for i in range(seq_len, len(stock)):
+        X_train.append(stock.iloc[i-seq_len : i, 0])
+        y_train.append(stock.iloc[i, 0])
+    
+    #1 last 6189 days are going to be used in test
+    X_test = X_train[110000:]             
+    y_test = y_train[110000:]
+    
+    #2 first 110000 days are going to be used in training
+    X_train = X_train[:110000]           
+    y_train = y_train[:110000]
+   
+    
+    #3 convert to numpy array
+    X_train = np.array(X_train)
+    y_train = np.array(y_train)
+    print(X_train.shape)
+    X_test = np.array(X_test)
+    y_test = np.array(y_test)
+    
+    #4 reshape data to input into RNN models
+    X_train = np.reshape(X_train, (110000, seq_len, 1))
+    print(X_train.shape)
+    
+    X_test = np.reshape(X_test, (X_test.shape[0], seq_len, 1))
+    
+    return [X_train, y_train, X_test, y_test]
+
+#create train, test data
+seq_len = 20 #choose sequence length
+
+X_train, y_train, X_test, y_test = load_data(df, seq_len)
+
+print('X_train.shape = ',X_train.shape)
+print('y_train.shape = ', y_train.shape)
+print('X_test.shape = ', X_test.shape)
+print('y_test.shape = ',y_test.shape)
+
+rnn_model = Sequential()
+
+rnn_model.add(SimpleRNN(40,activation="tanh",return_sequences=True, input_shape=(X_train.shape[1],1)))
+rnn_model.add(Dropout(0.15))
+
+rnn_model.add(SimpleRNN(40,activation="tanh",return_sequences=True))
+rnn_model.add(Dropout(0.15))
+
+rnn_model.add(SimpleRNN(40,activation="tanh",return_sequences=False))
+rnn_model.add(Dropout(0.15))
+
+rnn_model.add(Dense(1))
+
+rnn_model.summary()
+
+print(input_shape)
+
+rnn_model.compile(optimizer="adam",loss="MSE")
+rnn_model.fit(X_train, y_train, epochs=10, batch_size=1000)
+
+rnn_predictions = rnn_model.predict(X_test)
+
+rnn_score = r2_score(y_test,rnn_predictions)
+print("R2 Score of RNN model = ",rnn_score)
+
+def plot_predictions(test, predicted, title):
+    plt.figure(figsize=(16,4))
+    plt.plot(test, color='blue',label='Actual power consumption data')
+    plt.plot(predicted, alpha=0.7, color='orange',label='Predicted power consumption data')
+    plt.title(title)
+    plt.xlabel('Time')
+    plt.ylabel('Normalized power consumption scale')
+    plt.legend()
+    plt.show()
+    
+plot_predictions(y_test, rnn_predictions, "Predictions made by simple RNN model")
+
+lstm_model = Sequential()
+
+lstm_model.add(LSTM(40,activation="tanh",return_sequences=True, input_shape=(X_train.shape[1],1)))
+lstm_model.add(Dropout(0.15))
+
+lstm_model.add(LSTM(40,activation="tanh",return_sequences=True))
+lstm_model.add(Dropout(0.15))
+
+lstm_model.add(LSTM(40,activation="tanh",return_sequences=False))
+lstm_model.add(Dropout(0.15))
+
+lstm_model.add(Dense(1))
+
+lstm_model.summary()
+
+lstm_model.compile(optimizer="adam",loss="MSE")
+lstm_model.fit(X_train, y_train, epochs=10, batch_size=1000)
+
+lstm_predictions = lstm_model.predict(X_test)
+
+lstm_score = r2_score(y_test, lstm_predictions)
+print("R^2 Score of LSTM model = ",lstm_score)
+
+plot_predictions(y_test, lstm_predictions, "Predictions made by LSTM model")
+
+plt.figure(figsize=(15,8))
+
+plt.plot(y_test, c="orange", linewidth=3, label="Original values")
+plt.plot(lstm_predictions, c="red", linewidth=3, label="LSTM predictions")
+plt.plot(rnn_predictions, alpha=0.5, c="green", linewidth=3, label="RNN predictions")
+plt.legend()
+plt.title("Predictions vs actual data", fontsize=20)
+plt.show()

maanbumigu-0.1.0/src/maanbumigu.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: maanbumigu
+Version: 0.1.0
+Summary: Personal code snippet library - retrieve saved source code via mb.get()
+Author: arunkumar
+License: MIT
+Keywords: snippets,tensorflow,pytorch,dnn,cnn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# maanbumigu
+
+Personal snippet library. Keeps your source code as-is and retrieves it with one line:
+
+```python
+import maanbumigu as mb
+
+mb.list()        # ['CNN', 'DNN', 'FCNN', 'FRCNN_RESNET', 'RNN_LSTM']
+mb.get("DNN")    # prints + returns DNN code
+mb.get("CNN")
+mb.get("FCNN")
+mb.get("FRCNN")  # alias for FRCNN_RESNET
+mb.get("RNN")    # alias for RNN_LSTM
+mb.get("LSTM")   # alias for RNN_LSTM
+```
+
+Save to file:
+
+```python
+mb.get("DNN", save_as="dnn_run.py")
+```
+
+## Publish to PyPI (maintainer)
+
+```bash
+cd /Users/arunkumar/maanbumigu
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine upload dist/*
+# enter your PyPI username + password / API token when asked
+```
+
+Then anyone can install:
+
+```bash
+pip install maanbumigu
+```

maanbumigu-0.1.0/src/maanbumigu.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/maanbumigu/__init__.py
+src/maanbumigu.egg-info/PKG-INFO
+src/maanbumigu.egg-info/SOURCES.txt
+src/maanbumigu.egg-info/dependency_links.txt
+src/maanbumigu.egg-info/top_level.txt
+src/maanbumigu/snippets/__init__.py
+src/maanbumigu/snippets/cnn.py
+src/maanbumigu/snippets/dnn.py
+src/maanbumigu/snippets/fcnn.py
+src/maanbumigu/snippets/frcnn_resnet.py
+src/maanbumigu/snippets/rnn_lstm.py

maanbumigu-0.1.0/src/maanbumigu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

maanbumigu-0.1.0/src/maanbumigu.egg-info/top_level.txt

@@ -0,0 +1 @@
+maanbumigu