setup.py added

.github/workflows/python-package-conda.yml

@@ -0,0 +1,34 @@
+name: Python Package using Conda
+
+on: [push]
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 5
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Add conda to system path
+      run: |
+        # $CONDA is an environment variable pointing to the root of the miniconda directory
+        echo $CONDA/bin >> $GITHUB_PATH
+    - name: Install dependencies
+      run: |
+        conda env update --file environment.yml --name base
+    - name: Lint with flake8
+      run: |
+        conda install flake8
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        conda install pytest
+        pytest

.github/workflows/test.yml

@@ -1,25 +0,0 @@
-name: Run Python Tests
-
-on:
-  push:
-    branches:
-      - main
-      - master
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.8
-
-      - name: Install dependencies
-        run: pip install -r requirements.txt # Adjust this based on your project structure
-
-      - name: Run tests
-        run: python -m unittest discover tests # Adjust this based on your test discovery method

CONTRIBUTING.md

@@ -0,0 +1,56 @@
+# Contributing to ve-gans
+
+Thank you for considering contributing to ve-gans! Please take a moment to review the following guidelines.
+
+## Code of Conduct
+
+This project and everyone participating in it are governed by the [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you agree to uphold this code. Please report unacceptable behavior to [your email or a dedicated email for issues].
+
+## How to Contribute
+
+1. Fork the repository.
+
+2. Clone the forked repository to your local machine:
+
+   ```bash
+   git clone https://github.com/zaibutcooler/ve-gans.git
+   ```
+
+3. Create a new branch for your feature or bug fix:
+
+   ```bash
+   git checkout -b feature-name
+   ```
+
+4. Make your changes and commit them with a descriptive commit message:
+
+   ```bash
+   git add .
+   git commit -m "Add your descriptive message here"
+   ```
+
+5. Push the changes to your fork:
+
+   ```bash
+   git push origin feature-name
+   ```
+
+6. Create a pull request (PR) from your fork to the main repository.
+
+7. Ensure your PR title and description are clear and concise.
+
+## Reporting Issues
+
+If you find any issues or have suggestions, please open an issue on the [Issue Tracker](https://github.com/zaibutcooler/ve-gans/issues).
+
+## Style Guide
+
+- Follow the existing coding style.
+- Use meaningful variable and function names.
+- Write clear and concise documentation.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+Thank you for contributing to ve-gans!

README.md

@@ -0,0 +1,72 @@
+# ve-gans: Image Generation with GANs using PyTorch
+
+## Overview
+
+ve-gans is a project for image generation using Generative Adversarial Networks (GANs) implemented in PyTorch.
+
+## Features
+
+- GAN model for image generation.
+- Separate scripts for training and generating images.
+- Easy-to-use command-line interface.
+
+## Installation
+
+1. **Clone the repository:**
+
+   ```bash
+   git clone https://github.com/zaibutcooler/ve-gans.git
+   cd ve-gans
+   ```
+
+2. **Install dependencies:**
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+### Training
+
+To train the GAN model, use the following command:
+
+    ```bash
+    ve-gans-train
+    ```
+
+## Generating Images
+
+To generate images with the trained model, use the following command:
+
+    ```bash
+    ve-gans-generate
+    ```
+
+## Project Structure
+
+- `ve_gans/`: Python package containing GAN implementation and utilities.
+  - `generator.py`: Implementation of the GAN generator.
+  - `discriminator.py`: Implementation of the GAN discriminator.
+  - `utils.py`: Utility functions.
+- `requirements.txt`: List of project dependencies.
+- `setup.py`: Setup script for installing the package.
+- `main.py`: Example script for using the ve-gans package.
+
+## Contributing
+
+Contributions are welcome! Please follow the [Contribution Guidelines](CONTRIBUTING.md).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+Mention any contributors or libraries that you used or were inspired by.
+
+## Contact
+
+- Zai
+- [email protected]
+- Project Link: [https://github.com/zaibutcooler/ve-gans](https://github.com/zaibutcooler/ve-gans)

notebooks/dcgan.ipynb

@@ -0,0 +1,277 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 74,
+      "metadata": {
+        "id": "xNiydKOa0oFk"
+      },
+      "outputs": [],
+      "source": [
+        "#project gans"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import torchvision\n",
+        "import torch.nn as nn\n",
+        "import torch.nn.functional as F\n",
+        "from torch.utils.data import DataLoader\n",
+        "from torchvision import datasets, transforms\n",
+        "from torchvision.utils import save_image\n",
+        "import numpy as np\n",
+        "\n",
+        "# Check if GPU is available and set the device accordingly\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
+      ],
+      "metadata": {
+        "id": "SCS7gRJQ0tyS"
+      },
+      "execution_count": 75,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def get_sample_image(generator, noise_dim):\n",
+        "    \"\"\"\n",
+        "    Save sample 100 images\n",
+        "    \"\"\"\n",
+        "    noise = torch.randn(100, noise_dim).to(device)\n",
+        "    generated_images = generator(noise).view(100, 28, 28)  # (100, 28, 28)\n",
+        "    result = generated_images.cpu().data.numpy()\n",
+        "    img = np.zeros([280, 280])\n",
+        "    for j in range(10):\n",
+        "        img[j * 28:(j + 1) * 28] = np.concatenate([x for x in result[j * 10:(j + 1) * 10]], axis=-1)\n",
+        "    return img"
+      ],
+      "metadata": {
+        "id": "sacBbf_LwZx-"
+      },
+      "execution_count": 76,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class Discriminator(nn.Module):\n",
+        "    def __init__(self, in_channels=1, num_classes=1):\n",
+        "        super(Discriminator, self).__init__()\n",
+        "        self.conv = nn.Sequential(\n",
+        "            nn.Conv2d(in_channels, 512, 3, stride=2, padding=1, bias=False),\n",
+        "            nn.BatchNorm2d(512),\n",
+        "            nn.LeakyReLU(0.2),\n",
+        "\n",
+        "            nn.Conv2d(512, 256, 3, stride=2, padding=1, bias=False),\n",
+        "            nn.BatchNorm2d(256),\n",
+        "            nn.LeakyReLU(0.2),\n",
+        "\n",
+        "            nn.Conv2d(256, 128, 3, stride=2, padding=1, bias=False),\n",
+        "            nn.BatchNorm2d(128),\n",
+        "            nn.LeakyReLU(0.2),\n",
+        "            nn.AvgPool2d(4),\n",
+        "        )\n",
+        "        self.fc = nn.Sequential(\n",
+        "            nn.Linear(128, 1),\n",
+        "            nn.Sigmoid(),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x, y=False):\n",
+        "        features = self.conv(x)\n",
+        "        features = features.view(features.size(0), -1)\n",
+        "        output = self.fc(features)\n",
+        "        return output\n"
+      ],
+      "metadata": {
+        "id": "e9n-wD7dwZ7n"
+      },
+      "execution_count": 77,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class Generator(nn.Module):\n",
+        "    def __init__(self, input_size=100, num_classes=784):\n",
+        "        super(Generator, self).__init__()\n",
+        "        self.fc = nn.Sequential(\n",
+        "            nn.Linear(input_size, 4 * 4 * 512),\n",
+        "            nn.ReLU(),\n",
+        "        )\n",
+        "        self.conv = nn.Sequential(\n",
+        "            nn.ConvTranspose2d(512, 256, 3, stride=2, padding=1, bias=False),\n",
+        "            nn.BatchNorm2d(256),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.ConvTranspose2d(256, 128, 4, stride=2, padding=1, bias=False),\n",
+        "            nn.BatchNorm2d(128),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.ConvTranspose2d(128, 1, 4, stride=2, padding=1, bias=False),\n",
+        "            nn.Tanh(),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x, y=None):\n",
+        "        x = x.view(x.size(0), -1)\n",
+        "        features = self.fc(x)\n",
+        "        features = features.view(features.size(0), 512, 4, 4)\n",
+        "        output = self.conv(features)\n",
+        "        return output\n"
+      ],
+      "metadata": {
+        "id": "_8-E4605wZ-e"
+      },
+      "execution_count": 78,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Instantiate the Generator and Discriminator\n",
+        "generator = Generator().to(device)\n",
+        "discriminator = Discriminator().to(device)"
+      ],
+      "metadata": {
+        "id": "OSDpsaYBypVA"
+      },
+      "execution_count": 79,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "transform = transforms.Compose([transforms.ToTensor(),\n",
+        "                                transforms.Normalize(mean=[0.5],\n",
+        "                                std=[0.5])]\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "yQ8QdKuCz2_a"
+      },
+      "execution_count": 79,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "batch_size = 64\n",
+        "\n",
+        "data = torchvision.datasets.FashionMNIST(root='./data/', train=True, transform=transform, download=True)\n",
+        "data_loader = DataLoader(dataset=data, batch_size=batch_size, shuffle=True, drop_last=True)\n",
+        "\n",
+        "loss_fn = nn.BCELoss()\n",
+        "d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.001, betas=(0.5, 0.999))\n",
+        "g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.001, betas=(0.5, 0.999))\n"
+      ],
+      "metadata": {
+        "id": "8mOTuoih-3ep"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "max_epochs = 50\n",
+        "step = 0\n",
+        "n_critic = 1\n",
+        "n_noise = 100\n",
+        "\n",
+        "d_labels = torch.ones([batch_size, 1]).to(device)\n",
+        "d_fakes = torch.zeros([batch_size, 1]).to(device)"
+      ],
+      "metadata": {
+        "id": "kHJ0B3mk-4Bt"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Training loop\n",
+        "for epoch in range(max_epochs):\n",
+        "    for idx, (images, labels) in enumerate(data_loader):\n",
+        "        real_images = images.to(device)\n",
+        "\n",
+        "        # Discriminator training\n",
+        "        real_outputs = discriminator(real_images)\n",
+        "        d_real_loss = loss_fn(real_outputs, d_labels)\n",
+        "\n",
+        "        fake_noise = torch.randn(batch_size, n_noise).to(device)\n",
+        "        fake_images = generator(fake_noise)\n",
+        "        fake_outputs = discriminator(fake_images.detach())\n",
+        "        d_fake_loss = loss_fn(fake_outputs, d_fakes)\n",
+        "\n",
+        "        d_loss = d_real_loss + d_fake_loss\n",
+        "\n",
+        "        discriminator.zero_grad()\n",
+        "        d_loss.backward()\n",
+        "        d_optimizer.step()\n",
+        "\n",
+        "        # Generator training (every n_critic iterations)\n",
+        "        if step % n_critic == 0:\n",
+        "            fake_outputs = discriminator(fake_images)\n",
+        "            g_loss = loss_fn(fake_outputs, d_labels)\n",
+        "\n",
+        "            generator.zero_grad()\n",
+        "            discriminator.zero_grad()\n",
+        "            g_loss.backward()\n",
+        "            g_optimizer.step()\n",
+        "\n",
+        "            if step % 500 == 0:\n",
+        "                print('Epoch: {}/{}, Step: {}, D Loss: {}, G Loss: {}'.format(epoch, max_epochs, step, d_loss.item(), g_loss.item()))\n",
+        "\n",
+        "            if step % 1000 == 0:\n",
+        "                generator.eval()\n",
+        "                img = get_sample_image(generator, n_noise)\n",
+        "                # imsave('samples/{}_step{}.jpg'.format(MODEL_NAME, str(step).zfill(3)), img, cmap='gray')\n",
+        "                generator.train()\n",
+        "            step += 1"
+      ],
+      "metadata": {
+        "id": "1V9EfSBD-8E9"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# neeed to test"
+      ],
+      "metadata": {
+        "id": "1g4ATYOD-9LY"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "UPye6Ktu--Ph"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

notebooks/sam/sam_1.ipynb

@@ -1,20 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# notebook using sam model"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

notebooks/vanilla-gans.ipynb

@@ -0,0 +1,187 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torchvision\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchvision import datasets\n",
+    "from torchvision import transforms\n",
+    "from torchvision.utils import save_image\n",
+    "\n",
+    "import numpy as np\n",
+    "import datetime\n",
+    "\n",
+    "from matplotlib.pyplot import imshow, imsave\n",
+    "# %matplotlib inline\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_sample_image(generator, noise_dim):\n",
+    "    z = torch.randn(100, noise_dim).to(device)\n",
+    "    generated_images = generator(z).view(100, 28, 28)\n",
+    "    result = generated_images.cpu().data.numpy()\n",
+    "    img = np.zeros([280, 280])\n",
+    "    for j in range(10):\n",
+    "        img[j * 28:(j + 1) * 28] = np.concatenate([x for x in result[j * 10:(j + 1) * 10]], axis=-1)\n",
+    "    return img\n",
+    "\n",
+    "class Discriminator(nn.Module):\n",
+    "    def __init__(self, input_size=784, num_classes=1):\n",
+    "        super(Discriminator, self).__init__()\n",
+    "        self.layers = nn.Sequential(\n",
+    "            nn.Linear(input_size, 512),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Linear(512, 256),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Linear(256, num_classes),\n",
+    "            nn.Sigmoid(),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x.view(x.size(0), -1)\n",
+    "        x = self.layers(x)\n",
+    "        return x\n",
+    "\n",
+    "class Generator(nn.Module):\n",
+    "    def __init__(self, input_size=100, num_classes=784):\n",
+    "        super(Generator, self).__init__()\n",
+    "        self.layers = nn.Sequential(\n",
+    "            nn.Linear(input_size, 128),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Linear(128, 256),\n",
+    "            nn.BatchNorm1d(256),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Linear(256, 512),\n",
+    "            nn.BatchNorm1d(512),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Linear(512, 1024),\n",
+    "            nn.BatchNorm1d(1024),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Linear(1024, num_classes),\n",
+    "            nn.Tanh()\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.layers(x)\n",
+    "        x = x.view(x.size(0), 1, 28, 28)\n",
+    "        return x\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_noise = 100\n",
+    "\n",
+    "discriminator = Discriminator().to(device)\n",
+    "generator = Generator().to(device)\n",
+    "\n",
+    "transform = transforms.Compose([transforms.ToTensor(),\n",
+    "                                transforms.Normalize(mean=[0.5],\n",
+    "                                std=[0.5])]\n",
+    ")\n",
+    "\n",
+    "mnist = datasets.MNIST(root='../data/', train=True, transform=transform, download=True)\n",
+    "\n",
+    "batch_size = 64\n",
+    "\n",
+    "data_loader = DataLoader(dataset=mnist, batch_size=batch_size, shuffle=True, drop_last=True)\n",
+    "\n",
+    "loss_fn = nn.BCELoss()\n",
+    "d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n",
+    "g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n",
+    "\n",
+    "max_epoch = 50\n",
+    "step = 0\n",
+    "n_critic = 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d_labels = torch.ones(batch_size, 1).to(device)\n",
+    "d_fakes = torch.zeros(batch_size, 1).to(device)\n",
+    "\n",
+    "# Training loop\n",
+    "for epoch in range(max_epoch):\n",
+    "    for idx, (images, _) in enumerate(data_loader):\n",
+    "        real_images = images.to(device)\n",
+    "        real_outputs = discriminator(real_images)\n",
+    "        d_real_loss = loss_fn(real_outputs, d_labels)\n",
+    "\n",
+    "        fake_noise = torch.randn(batch_size, n_noise).to(device)\n",
+    "        fake_images = generator(fake_noise)\n",
+    "        fake_outputs = discriminator(fake_images.detach())\n",
+    "        d_fake_loss = loss_fn(fake_outputs, d_fakes)\n",
+    "\n",
+    "        d_loss = d_real_loss + d_fake_loss\n",
+    "\n",
+    "        discriminator.zero_grad()\n",
+    "        d_loss.backward()\n",
+    "        d_optimizer.step()\n",
+    "\n",
+    "        if step % n_critic == 0:\n",
+    "            fake_outputs = discriminator(generator(fake_noise))\n",
+    "            g_loss = loss_fn(fake_outputs, d_labels)\n",
+    "\n",
+    "            generator.zero_grad()\n",
+    "            g_loss.backward()\n",
+    "            g_optimizer.step()\n",
+    "\n",
+    "            if step % 1000 == 0:\n",
+    "                generator.eval()\n",
+    "                img = get_sample_image(generator, n_noise)\n",
+    "                # imsave('samples/{}_step{}.jpg'.format('gans', str(step).zfill(3)), img, cmap='gray')\n",
+    "                generator.train()\n",
+    "            step += 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "generator.eval()\n",
+    "imshow(get_sample_image(generator, n_noise), cmap='gray')\n",
+    "\n",
+    "torch.save(discriminator.state_dict(), 'discriminator.pth')\n",
+    "torch.save(generator.state_dict(), 'generator.pth')\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

prototype/.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

prototype/README.md

@@ -1,13 +0,0 @@
----
-title: Pearl Prototype
-emoji: 💻
-colorFrom: blue
-colorTo: red
-sdk: streamlit
-sdk_version: 1.29.0
-app_file: app.py
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

prototype/app.py

@@ -1,40 +0,0 @@
-import gradio as gr
-from io import BytesIO
-
-from torch import autocast
-import requests
-import PIL
-import torch
-from diffusers import StableDiffusionInpaintPipeline as StableDiffusionInpaintPipeline
-
-pipe = StableDiffusionInpaintPipeline.from_pretrained(
-    "CompVis/stable-diffusion-v1-4",
-    revision="fp16",
-    torch_dtype=torch.float16,
-    use_auth_token=True,
-)
-
-
-def process_image(dict, prompt):
-    init_img = dict["image"].convert("RGB").resize((512, 512))
-    mask_img = dict["mask"].convert("RGB").resize((512, 512))
-    images = pipe(
-        prompt=prompt, init_image=init_img, mask_image=mask_img, strength=0.75
-    )["sample"]
-    return images[0]
-
-
-iface = gr.Interface(
-    fn=process_image,
-    title="Stable Diffusion In-Painting Tool on Colab with Gradio",
-    inputs=[
-        gr.Image(source="upload", tool="sketch", type="pil"),
-        gr.Textbox(label="prompt"),
-    ],
-    outputs=[gr.Image()],
-    description="Choose a feature and upload an image to see the processed result.",
-    article="<p style='text-align: center;'>Built with Gradio</p>",
-)
-
-
-iface.launch()

prototype/inpainting.py

@@ -1,227 +0,0 @@
-# credit : Hugging Face Team
-import inspect
-from typing import List, Optional, Union
-
-import numpy as np
-import torch
-
-import PIL
-from diffusers import (
-    AutoencoderKL,
-    DDIMScheduler,
-    DiffusionPipeline,
-    PNDMScheduler,
-    UNet2DConditionModel,
-)
-from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker
-from tqdm.auto import tqdm
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-
-def preprocess_image(image):
-    w, h = image.size
-    w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-    image = image.resize((w, h), resample=PIL.Image.LANCZOS)
-    image = np.array(image).astype(np.float32) / 255.0
-    image = image[None].transpose(0, 3, 1, 2)
-    image = torch.from_numpy(image)
-    return 2.0 * image - 1.0
-
-
-def preprocess_mask(mask):
-    mask = mask.convert("L")
-    w, h = mask.size
-    w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-    mask = mask.resize((w // 8, h // 8), resample=PIL.Image.NEAREST)
-    mask = np.array(mask).astype(np.float32) / 255.0
-    mask = np.tile(mask, (4, 1, 1))
-    mask = mask[None].transpose(0, 1, 2, 3)  # what does this step do?
-    mask = 1 - mask  # repaint white, keep black
-    mask = torch.from_numpy(mask)
-    return mask
-
-
-class StableDiffusionInpaintingPipeline(DiffusionPipeline):
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: Union[DDIMScheduler, PNDMScheduler],
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-    ):
-        super().__init__()
-        scheduler = scheduler.set_format("pt")
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        init_image: torch.FloatTensor,
-        mask_image: torch.FloatTensor,
-        strength: float = 0.8,
-        num_inference_steps: Optional[int] = 50,
-        guidance_scale: Optional[float] = 7.5,
-        eta: Optional[float] = 0.0,
-        generator: Optional[torch.Generator] = None,
-        output_type: Optional[str] = "pil",
-    ):
-        if isinstance(prompt, str):
-            batch_size = 1
-        elif isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            raise ValueError(
-                f"`prompt` has to be of type `str` or `list` but is {type(prompt)}"
-            )
-
-        if strength < 0 or strength > 1:
-            raise ValueError(
-                f"The value of strength should in [0.0, 1.0] but is {strength}"
-            )
-
-        # set timesteps
-        accepts_offset = "offset" in set(
-            inspect.signature(self.scheduler.set_timesteps).parameters.keys()
-        )
-        extra_set_kwargs = {}
-        offset = 0
-        if accepts_offset:
-            offset = 1
-            extra_set_kwargs["offset"] = 1
-
-        self.scheduler.set_timesteps(num_inference_steps, **extra_set_kwargs)
-
-        # preprocess image
-        init_image = preprocess_image(init_image).to(self.device)
-
-        # encode the init image into latents and scale the latents
-        init_latents = self.vae.encode(init_image).sample()
-        init_latents = 0.18215 * init_latents
-
-        # prepare init_latents noise to latents
-        init_latents = torch.cat([init_latents] * batch_size)
-        init_latents_orig = init_latents
-
-        # preprocess mask
-        mask = preprocess_mask(mask_image).to(self.device)
-        mask = torch.cat([mask] * batch_size)
-
-        # check sizes
-        if not mask.shape == init_latents.shape:
-            raise ValueError(f"The mask and init_image should be the same size!")
-
-        # get the original timestep using init_timestep
-        init_timestep = int(num_inference_steps * strength) + offset
-        init_timestep = min(init_timestep, num_inference_steps)
-        timesteps = self.scheduler.timesteps[-init_timestep]
-        timesteps = torch.tensor(
-            [timesteps] * batch_size, dtype=torch.long, device=self.device
-        )
-
-        # add noise to latents using the timesteps
-        noise = torch.randn(init_latents.shape, generator=generator, device=self.device)
-        init_latents = self.scheduler.add_noise(init_latents, noise, timesteps)
-
-        # get prompt text embeddings
-        text_input = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pt",
-        )
-        text_embeddings = self.text_encoder(text_input.input_ids.to(self.device))[0]
-
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            max_length = text_input.input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                [""] * batch_size,
-                padding="max_length",
-                max_length=max_length,
-                return_tensors="pt",
-            )
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids.to(self.device)
-            )[0]
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
-
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-        accepts_eta = "eta" in set(
-            inspect.signature(self.scheduler.step).parameters.keys()
-        )
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        latents = init_latents
-        t_start = max(num_inference_steps - init_timestep + offset, 0)
-        for i, t in tqdm(enumerate(self.scheduler.timesteps[t_start:])):
-            # expand the latents if we are doing classifier free guidance
-            latent_model_input = (
-                torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-            )
-
-            # predict the noise residual
-            noise_pred = self.unet(
-                latent_model_input, t, encoder_hidden_states=text_embeddings
-            )["sample"]
-
-            # perform guidance
-            if do_classifier_free_guidance:
-                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                noise_pred = noise_pred_uncond + guidance_scale * (
-                    noise_pred_text - noise_pred_uncond
-                )
-
-            # compute the previous noisy sample x_t -> x_t-1
-            latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs)[
-                "prev_sample"
-            ]
-
-            # masking
-            init_latents_proper = self.scheduler.add_noise(init_latents_orig, noise, t)
-            latents = (init_latents_proper * mask) + (latents * (1 - mask))
-
-        # scale and decode the image latents with vae
-        latents = 1 / 0.18215 * latents
-        image = self.vae.decode(latents)
-
-        image = (image / 2 + 0.5).clamp(0, 1)
-        image = image.cpu().permute(0, 2, 3, 1).numpy()
-
-        # run safety checker
-        safety_cheker_input = self.feature_extractor(
-            self.numpy_to_pil(image), return_tensors="pt"
-        ).to(self.device)
-        image, has_nsfw_concept = self.safety_checker(
-            images=image, clip_input=safety_cheker_input.pixel_values
-        )
-
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        return {"sample": image, "nsfw_content_detected": has_nsfw_concept}

prototype/requirements.txt

@@ -1,7 +0,0 @@
-torch
-requests
-pillow
-diffusers
-gradio
-numpy
-tqdm

prototype/test.py

@@ -1,12 +0,0 @@
-import gradio as gr
-
-def greet(name, intensity):
-    return "Hello " * intensity + name + "!"
-
-demo = gr.Interface(
-    fn=greet,
-    inputs=["text", "slider"],
-    outputs=["text"],
-)
-
-demo.launch()

prototype/utils.py

@@ -1,13 +0,0 @@
-def add_feature(image):
-    # inpainting features
-    pass
-
-
-def remove_feature(image):
-    # inpainting features
-    pass
-
-
-def enhance_feature(image):
-    # inpainting features
-    pass

setup.py

@@ -1,44 +1,27 @@
-# need to change 
+from setuptools import setup, find_packages
 
-# import platform
-# import sys
-# from pathlib import Path
+with open('requirements.txt') as f:
+    requirements = f.read().splitlines()
 
-# import pkg_resources
-# from setuptools import find_packages, setup
-
-
-# def read_version(fname="version.py"):
-#     exec(compile(open(fname, encoding="utf-8").read(), fname, "exec"))
-#     return locals()["__version__"]
-
-
-# requirements = []
-# if sys.platform.startswith("linux") and platform.machine() == "x86_64":
-#     requirements.append("triton>=2.0.0,<3")
-
-# setup(
-#     name="openai-whisper",
-#     py_modules=["whisper"],
-#     version=read_version(),
-#     description="Robust Speech Recognition via Large-Scale Weak Supervision",
-#     long_description=open("README.md", encoding="utf-8").read(),
-#     long_description_content_type="text/markdown",
-#     readme="README.md",
-#     python_requires=">=3.8",
-#     author="OpenAI",
-#     url="https://github.com/openai/whisper",
-#     license="MIT",
-#     packages=find_packages(exclude=["tests*"]),
-#     install_requires=[
-#         str(r)
-#         for r in pkg_resources.parse_requirements(
-#             Path(__file__).with_name("requirements.txt").open()
-#         )
-#     ],
-#     entry_points={
-#         "console_scripts": ["whisper=whisper.transcribe:cli"],
-#     },
-#     include_package_data=True,
-#     extras_require={"dev": ["pytest", "scipy", "black", "flake8", "isort"]},
-# )
+setup(
+    name='ve-gans',
+    version='0.1',
+    packages=find_packages(),
+    install_requires=requirements,
+    entry_points={
+        'console_scripts': [
+            've-gans-train=ve_gans.train:main',
+            've-gans-generate=ve_gans.generate:main',
+        ],
+    },
+    author='Zai',
+    author_email='[email protected]',
+    description='Image generation with GANs using PyTorch',
+    long_description='Detailed description of your project',
+    url='https://github.com/zaibutcooler/ve-gans',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+)

space/app.py

@@ -0,0 +1,12 @@
+import streamlit as st
+import torch
+from torchvision.utils import make_grid
+from torchvision.transforms import ToPILImage
+
+def main():
+    st.title("Image Generation")
+    st.write("Made with GANS from scratch")
+    
+    
+if __name__ == '__main__':
+    main()