model_comparison.py 05_rnn_example.ipynb README.md fetch_real_question_papers.py index.html 01_tensor_operations.ipynb

notebooks/05_rnn_example.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Recurrent Neural Network (RNN) Example\n",
        "\n",
        "<!--\n",
        "Project: PyTorch Neural Networks\n",
        "Author: RSK World\n",
        "Website: https://rskworld.in\n",
        "Email: help@rskworld.in\n",
        "Phone: +91 93305 39277\n",
        "-->\n",
        "\n",
        "This notebook demonstrates building and training a Recurrent Neural Network (LSTM) for sequence modeling.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# RNN Example\n",
        "# Project: PyTorch Neural Networks\n",
        "# Author: RSK World\n",
        "# Website: https://rskworld.in\n",
        "# Email: help@rskworld.in\n",
        "# Phone: +91 93305 39277\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "import sys\n",
        "\n",
        "sys.path.append('..')\n",
        "from models.rnn import SimpleRNN\n",
        "from training.trainer import Trainer\n",
        "from training.utils import plot_training_history\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Prepare Sequence Data\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Generate synthetic sequence data\n",
        "# Shape: (batch_size, sequence_length, features)\n",
        "X_train = torch.randn(200, 10, 5)  # 200 samples, 10 time steps, 5 features\n",
        "y_train = torch.randint(0, 3, (200,))\n",
        "X_test = torch.randn(50, 10, 5)\n",
        "y_test = torch.randint(0, 3, (50,))\n",
        "\n",
        "print(f\"Training set: {X_train.shape}, Labels: {y_train.shape}\")\n",
        "print(f\"Test set: {X_test.shape}, Labels: {y_test.shape}\")\n",
        "\n",
        "# Create data loaders\n",
        "train_dataset = TensorDataset(X_train, y_train)\n",
        "test_dataset = TensorDataset(X_test, y_test)\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Create and Train RNN\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create RNN model\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "model = SimpleRNN(input_size=5, hidden_size=64, num_layers=2, num_classes=3).to(device)\n",
        "\n",
        "# Define loss and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "# Train model\n",
        "trainer = Trainer(model, criterion, optimizer, device)\n",
        "history = trainer.train(train_loader, test_loader, epochs=15)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Visualize Results\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "plot_training_history(history)\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}

134 lines•3.7 KB

json

README.md

Raw Download

README.md

# PyTorch Neural Networks



Building neural networks with PyTorch including dynamic computation graphs, automatic differentiation, and model training.

## Description

This project demonstrates PyTorch, Facebook's deep learning framework with dynamic computation graphs. It covers tensor operations, automatic differentiation, neural network construction, training loops, and advanced features. Perfect for research and production deep learning.

## Features

- Dynamic computation graphs
- Automatic differentiation
- Neural network modules (Basic NN, CNN, RNN)
- Training and optimization
- Model deployment
- **Advanced Training Features:**
- Early stopping
- Model checkpointing
- Learning rate scheduling
- Gradient clipping
- Mixed precision training
- Distributed training support
- **Evaluation Metrics:**
- Confusion matrix visualization
- Classification reports
- Accuracy metrics
- **Data Augmentation:**
- Image augmentation
- Sequence augmentation
- MixUp augmentation
- **Transfer Learning:**
- Pre-trained models (ResNet, VGG, DenseNet)
- Fine-tuning utilities
- **Hyperparameter Tuning:**
- Grid search
- Random search
- **TensorBoard Integration:**
- Training visualization
- Metric logging
- Model graph visualization

## Technologies

- Python
- PyTorch
- NumPy
- Matplotlib
- Jupyter Notebook

## Installation

```bash
pip install -r requirements.txt
```

## Project Structure

```
pytorch-neuralnetworks/
├── README.md
├── requirements.txt
├── main.py
├── example.py
├── deploy.py
├── .gitignore
├── models/
│ ├── __init__.py
│ ├── basic_nn.py
│ ├── cnn.py
│ ├── rnn.py
│ └── advanced.py
├── training/
│ ├── __init__.py
│ ├── trainer.py
│ ├── advanced_trainer.py
│ ├── callbacks.py
│ ├── metrics.py
│ └── utils.py
├── data/
│ ├── __init__.py
│ ├── augmentation.py
│ └── datasets.py
├── utils/
│ ├── __init__.py
│ ├── hyperparameter_tuning.py
│ └── tensorboard_logger.py
├── models/
│ ├── __init__.py
│ ├── basic_nn.py
│ ├── cnn.py
│ ├── rnn.py
│ ├── advanced.py
│ └── transfer_learning.py
├── examples/
│ ├── advanced_features_example.py
│ ├── transfer_learning_example.py
│ └── hyperparameter_tuning_example.py
├── notebooks/
│ ├── 01_tensor_operations.ipynb
│ ├── 02_automatic_differentiation.ipynb
│ ├── 03_basic_neural_network.ipynb
│ ├── 04_cnn_example.ipynb
│ ├── 05_rnn_example.ipynb
│ └── 06_model_deployment.ipynb
├── data/
│ └── .gitkeep
└── saved_models/
└── .gitkeep
```

## Usage

### Basic Neural Network

```python
python main.py --model basic --epochs 10
```

### CNN Example

```python
python main.py --model cnn --epochs 20
```

### RNN Example

```python
python main.py --model rnn --epochs 15
```

## Quick Start Example

Run the quick start example to see a complete training workflow:

```bash
python example.py
```

## Jupyter Notebooks

Launch Jupyter Notebook to explore interactive examples:

```bash
jupyter notebook notebooks/
```

## Model Deployment

Deploy a trained model for inference:

```bash
python deploy.py --model_type basic --model_path saved_models/model.pth
```

## Advanced Features Examples

### Advanced Training Features

```bash
python examples/advanced_features_example.py
```

This demonstrates:
- Early stopping
- Model checkpointing
- Learning rate scheduling
- Gradient clipping
- TensorBoard logging

### Transfer Learning

```bash
python examples/transfer_learning_example.py
```

This demonstrates:
- Using pre-trained models
- Fine-tuning strategies
- Freezing/unfreezing layers

### Hyperparameter Tuning

```bash
python examples/hyperparameter_tuning_example.py
```

This demonstrates:
- Grid search
- Random search
- Parameter optimization

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

Copyright (c) 2024 RSK World

This project is provided by RSK World (https://rskworld.in) for educational purposes.

## Contact

- Website: https://rskworld.in
- Email: help@rskworld.in
- Phone: +91 93305 39277

notebooks/01_tensor_operations.ipynb

Raw Download

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Tensor Operations in PyTorch\n",
        "\n",
        "<!--\n",
        "Project: PyTorch Neural Networks\n",
        "Author: RSK World\n",
        "Website: https://rskworld.in\n",
        "Email: help@rskworld.in\n",
        "Phone: +91 93305 39277\n",
        "-->\n",
        "\n",
        "This notebook demonstrates basic tensor operations in PyTorch, the foundation of all neural network computations.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Tensor Operations in PyTorch\n",
        "# Project: PyTorch Neural Networks\n",
        "# Author: RSK World\n",
        "# Website: https://rskworld.in\n",
        "# Email: help@rskworld.in\n",
        "# Phone: +91 93305 39277\n",
        "\n",
        "import torch\n",
        "import numpy as np\n",
        "\n",
        "print(f\"PyTorch version: {torch.__version__}\")\n",
        "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Creating Tensors\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create tensors from lists\n",
        "t1 = torch.tensor([1, 2, 3, 4, 5])\n",
        "print(f\"Tensor from list: {t1}\")\n",
        "\n",
        "# Create tensors with zeros\n",
        "t2 = torch.zeros(3, 4)\n",
        "print(f\"\\nZero tensor (3x4):\\n{t2}\")\n",
        "\n",
        "# Create tensors with ones\n",
        "t3 = torch.ones(2, 3)\n",
        "print(f\"\\nOnes tensor (2x3):\\n{t3}\")\n",
        "\n",
        "# Create random tensor\n",
        "t4 = torch.randn(2, 3)\n",
        "print(f\"\\nRandom tensor (2x3):\\n{t4}\")\n",
        "\n",
        "# Create tensor with specific range\n",
        "t5 = torch.arange(0, 10, 2)\n",
        "print(f\"\\nArange tensor: {t5}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Tensor Operations\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Basic arithmetic operations\n",
        "a = torch.tensor([1.0, 2.0, 3.0])\n",
        "b = torch.tensor([4.0, 5.0, 6.0])\n",
        "\n",
        "print(f\"Addition: {a + b}\")\n",
        "print(f\"Subtraction: {a - b}\")\n",
        "print(f\"Multiplication: {a * b}\")\n",
        "print(f\"Division: {b / a}\")\n",
        "\n",
        "# Matrix multiplication\n",
        "x = torch.randn(3, 4)\n",
        "y = torch.randn(4, 5)\n",
        "z = torch.matmul(x, y)\n",
        "print(f\"\\nMatrix multiplication result shape: {z.shape}\")\n",
        "\n",
        "# Element-wise operations\n",
        "print(f\"\\nSum: {a.sum()}\")\n",
        "print(f\"Mean: {a.mean()}\")\n",
        "print(f\"Max: {a.max()}\")\n",
        "print(f\"Min: {a.min()}\")\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}

124 lines•3.3 KB

json

Theme Settings

Color Scheme

Display Options

Font Size

README.md

Theme Settings

Color Scheme

Display Options

Font Size

README.md

🚀 Support RSK World