Upload 9 files

.gitattributes

@@ -0,0 +1,37 @@
+*.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
+training_1/cp.ckpt.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+training_1/state.db filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Generative Playground
+emoji: 🔥
+colorFrom: gray
+colorTo: pink
+sdk: streamlit
+sdk_version: 1.36.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,239 @@
+import streamlit as st
+
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+import warnings
+warnings.filterwarnings('ignore')
+# %matplotlib inline
+
+import tensorflow
+print (tensorflow.__version__)
+
+st.header("Welcome to the Generative Playground")
+
+from tensorflow.keras.datasets import mnist,cifar10
+
+option = st.selectbox(
+    "Which model would you like to get prediction with?",
+    ("None","Auto-Regressor", "Auto-Encoder", "Diffusion-Model","Other"))
+
+st.write("You selected:", option)
+
+if option == "None":
+    st.write("Please Select the model to get the fun prediction.... :)")
+
+if option == "Auto-Encoder":
+    st.write("It is under development")
+    st.write("Stay tune... Comming soon... :)")
+    
+if option == "Other":
+    st.write("Stay tune... Updating soon... :)")
+
+if option == "Diffusion-Model":
+    st.write("It is under development")
+    st.write("Stay tune... Comming soon... :)")
+    
+if option == "Auto-Regressor":
+    if st.button("Run"):
+        st.write("Running Auto-Regressor")
+
+        st.write("trained on --> cifar-10 dataset, RTX-GPU's, 50-epochs")
+        st.write("This is trail model, updated version will be updated consicutively.")
+        
+        (trainX, trainy), (testX, testy) = cifar10.load_data()
+        
+        print('Training data shapes: X=%s, y=%s' % (trainX.shape, trainy.shape))
+        print('Testing data shapes: X=%s, y=%s' % (testX.shape, testy.shape))
+        
+        
+        
+        for k in range(4):
+            fig = plt.figure(figsize=(9,6))
+            for j in range(9):
+                i = np.random.randint(0, 10000)
+                plt.subplot(990 + 1 + j)
+                plt.imshow(trainX[i], cmap='gray_r')
+                # st.pyplot(fig)
+                plt.axis('off')
+                #plt.title(trainy[i])
+            plt.show()
+            st.pyplot(fig)
+        
+        
+        # asdfaf
+        
+        trainX = np.where(trainX < (0.33 * 256), 0, 1)
+        train_data = trainX.astype(np.float32)
+        
+        testX = np.where(testX < (0.33 * 256), 0, 1)
+        test_data = testX.astype(np.float32)
+        
+        train_data = np.reshape(train_data, (50000, 32, 32, 3))
+        test_data = np.reshape(test_data, (10000, 32, 32, 3))
+        
+        print (train_data.shape, test_data.shape)
+        
+        
+        import tensorflow
+        
+        class PixelConvLayer(tensorflow.keras.layers.Layer):
+            def __init__(self, mask_type, **kwargs):
+                super(PixelConvLayer, self).__init__()
+                self.mask_type = mask_type
+                self.conv = tensorflow.keras.layers.Conv2D(**kwargs)
+        
+            def build(self, input_shape):
+                # Build the conv2d layer to initialize kernel variables
+                self.conv.build(input_shape)
+                # Use the initialized kernel to create the mask
+                kernel_shape = self.conv.kernel.get_shape()
+                self.mask = np.zeros(shape=kernel_shape)
+                self.mask[: kernel_shape[0] // 2, ...] = 1.0
+                self.mask[kernel_shape[0] // 2, : kernel_shape[1] // 2, ...] = 1.0
+                if self.mask_type == "B":
+                    self.mask[kernel_shape[0] // 2, kernel_shape[1] // 2, ...] = 1.0
+        
+            def call(self, inputs):
+                self.conv.kernel.assign(self.conv.kernel * self.mask)
+                return self.conv(inputs)
+        
+        
+        # Next, we build our residual block layer.
+        # This is just a normal residual block, but based on the PixelConvLayer.
+        class ResidualBlock(tensorflow.keras.layers.Layer):
+            def __init__(self, filters, **kwargs):
+                super(ResidualBlock, self).__init__(**kwargs)
+                self.conv1 = tensorflow.keras.layers.Conv2D(
+                    filters=filters, kernel_size=1, activation="relu"
+                )
+                self.pixel_conv = PixelConvLayer(
+                    mask_type="B",
+                    filters=filters // 2,
+                    kernel_size=3,
+                    activation="relu",
+                    padding="same",
+                )
+                self.conv2 = tensorflow.keras.layers.Conv2D(
+                    filters=filters, kernel_size=1, activation="relu"
+                )
+        
+            def call(self, inputs):
+                x = self.conv1(inputs)
+                x = self.pixel_conv(x)
+                x = self.conv2(x)
+                return tensorflow.keras.layers.add([inputs, x])
+        
+        inputs = tensorflow.keras.Input(shape=(32,32,3))
+        x = PixelConvLayer(
+            mask_type="A", filters=128, kernel_size=7, activation="relu", padding="same"
+        )(inputs)
+        
+        for _ in range(5):
+            x = ResidualBlock(filters=128)(x)
+        
+        for _ in range(2):
+            x = PixelConvLayer(
+                mask_type="B",
+                filters=128,
+                kernel_size=1,
+                strides=1,
+                activation="relu",
+                padding="valid",
+            )(x)
+        
+        out = tensorflow.keras.layers.Conv2D(
+            filters=3, kernel_size=1, strides=1, activation="sigmoid", padding="valid"
+        )(x)
+        
+        pixel_cnn = tensorflow.keras.Model(inputs, out)
+        pixel_cnn.summary()
+        
+        adam = tensorflow.keras.optimizers.Adam(learning_rate=0.0005)
+        pixel_cnn.compile(optimizer=adam, loss="binary_crossentropy")
+        
+        
+        # %%
+        import os
+        checkpoint_path = "training_1/cp.ckpt"
+        # checkpoint_path = "training_1/cp.weights.h5"
+        checkpoint_dir = os.path.dirname(checkpoint_path)
+        
+        
+        pixel_cnn.load_weights(checkpoint_path)
+        
+        
+        # %% [markdown]
+        # # Display Results 81 images
+        
+        # %%
+        # from IPython.display import Image, display
+        from tqdm import tqdm
+        
+        
+        # Create an empty array of pixels.
+        batch = 1
+        pixels = np.zeros(shape=(batch,) + (pixel_cnn.input_shape)[1:])
+        batch, rows, cols, channels = pixels.shape
+        
+        print(pixels.shape)
+        
+        
+        import time 
+        
+        # progress_text = "Operation in progress. Please wait."
+        # my_bar = st.progress(0, progress_text)
+        st.caption("Generating..... pls.. wait.. :)")
+        my_bar = st.progress(0)
+        
+        
+        # Iterate over the pixels because generation has to be done sequentially pixel by pixel.
+        for row in tqdm(range(rows)):
+            for col in range(cols):
+                for channel in range(channels):
+                    time.sleep(0.01)
+                    # Feed the whole array and retrieving the pixel value probabilities for the next
+                    # pixel.
+                    probs = pixel_cnn.predict(pixels)[:, row, col, channel]
+                    # Use the probabilities to pick pixel values and append the values to the image
+                    # frame.
+                    pixels[:, row, col, channel] = tensorflow.math.ceil(
+                      probs - tensorflow.random.uniform(probs.shape)
+                    )
+            my_bar.progress(int(row*3.125))
+            # if row<rows/2:
+            #     my_bar.progress((rows+1)*2)
+            # else:
+            #     my_bar.progress(row+51)
+            
+        my_bar.progress(100)
+        time.sleep(1)
+
+        
+        from PIL import Image
+        # figout = plt.figure(figsize=(9,6))
+        # st.image(Image.fromarray((pixels[-1] * 255).astype(np.uint8), 'RGB').show(),caption="image")
+        # Convert the generated pixel array to an image
+        generated_image = Image.fromarray((pixels[-1] * 255).astype(np.uint8), 'RGB')
+        
+        # Display the image using Streamlit
+        st.image(generated_image, caption="Generated Image")
+        
+        # counter = 0
+        # for i in range(4):
+        #     figout = plt.figure(figsize=(9,6))
+        #     for j in range(9):
+        #         plt.subplot(990 + 1 + j)
+        #         plt.imshow(pixels[counter,:,:,0])#, cmap='gray_r')
+        #         counter += 1
+        #         plt.axis('off')
+        #     plt.show()
+        #     st.pyplot(figout)
+        
+        # %%
+# else:
+#     st.write("Not Available")
+
+        
+        

requirements.txt

@@ -0,0 +1,9 @@
+streamlit == 1.9.2
+numpy == 1.26.3
+matplotlib == 3.8.2
+pandas == 2.1.4
+seaborn == 0.13.2
+tensorflow == 2.9.0
+protobuf == 3.20.3
+
+

training_1/checkpoint

@@ -0,0 +1,2 @@
+model_checkpoint_path: "cp.ckpt"
+all_model_checkpoint_paths: "cp.ckpt"

training_1/cp.ckpt.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8e94392a9bd55fc21bcdd84bfce8909ac6f8c42ead8349f9b02dab23f5ebf1c
+size 6564857

training_1/cp.weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a9d0878b5a8409be8f7c5c75520f7afb1c8bc34b4696acf8e5e8a9bb4535365
+size 6653656

training_1/state.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:817878e3f8d7d71333f53bfdd3e076ca595dc455f125c9ab55e0c2bbcd9dac67
+size 2211959020