Update app.py

app.py

@@ -4,22 +4,22 @@ from tensorflow import keras
 from tensorflow.keras import layers
 import numpy as np
 import os
-from PIL import Image
+from PIL import Image, ImageFilter
 
 # =========================================
-# 1. SETTINGS
+# 1. HIGH QUALITY SETTINGS
 # =========================================
-IMG_SIZE = 48   
+IMG_SIZE = 64   # Increased from 48 to 64 (Better detail)
 CHANNELS = 3
-TIMESTEPS = 200
+TIMESTEPS = 300 # More steps = smoother transitions
 BATCH_SIZE = 32
-WEIGHTS_FILE = "veda_art_model.weights.h5" 
+WEIGHTS_FILE = "veda_hq_model.weights.h5" 
 
 # =========================================
-# 2. GENERATE CUSTOM "VEDA" DATASET (MATH ART)
+# 2. SHARP VEDA PATTERNS (Improved Math)
 # =========================================
-def generate_veda_patterns(num_images=500):
-    print(f"Generating {num_images} unique Veda patterns...")
+def generate_veda_patterns(num_images=600):
+    print(f"Generating {num_images} Sharp Veda patterns...")
     data = []
     
     for _ in range(num_images):
@@ -27,24 +27,34 @@ def generate_veda_patterns(num_images=500):
         y = np.linspace(-1, 1, IMG_SIZE)
         X, Y = np.meshgrid(x, y)
         
-        freq = np.random.uniform(2, 10)
+        # Parameters
+        freq = np.random.uniform(3, 12)
         phase = np.random.uniform(0, np.pi)
-        center_x = np.random.uniform(-0.5, 0.5)
-        center_y = np.random.uniform(-0.5, 0.5)
         
-        R = np.sqrt((X - center_x)**2 + (Y - center_y)**2)
-        pattern = np.sin(freq * R - phase)
+        # Radial Geometry
+        R = np.sqrt(X**2 + Y**2)
         
-        img = np.zeros((IMG_SIZE, IMG_SIZE, 3))
+        # Sharper Math: We combine Sine with Tanh to create harder edges
+        pattern = np.tanh(np.sin(freq * R - phase) * 5) 
         
-        r_boost = np.random.rand()
-        g_boost = np.random.rand()
-        b_boost = np.random.rand()
+        img = np.zeros((IMG_SIZE, IMG_SIZE, 3))
         
-        img[:, :, 0] = (pattern + 1) / 2 * r_boost
-        img[:, :, 1] = (pattern + 1) / 2 * g_boost
-        img[:, :, 2] = (pattern + 1) / 2 * b_boost
+        # Cosmic Colors (Deep Purples, Golds, Blues)
+        color_scheme = np.random.randint(0, 3)
         
+        if color_scheme == 0: # Fire
+            img[:, :, 0] = (pattern + 1) / 2 * 1.0 # R
+            img[:, :, 1] = (pattern + 1) / 2 * 0.5 # G
+            img[:, :, 2] = (pattern + 1) / 2 * 0.1 # B
+        elif color_scheme == 1: # Water/Space
+            img[:, :, 0] = (pattern + 1) / 2 * 0.1
+            img[:, :, 1] = (pattern + 1) / 2 * 0.4
+            img[:, :, 2] = (pattern + 1) / 2 * 1.0
+        else: # Spirit
+            img[:, :, 0] = (pattern + 1) / 2 * 0.8
+            img[:, :, 1] = (pattern + 1) / 2 * 0.2
+            img[:, :, 2] = (pattern + 1) / 2 * 0.8
+            
         data.append(img)
         
     return np.array(data).astype("float32")
@@ -65,55 +75,54 @@ def forward_noise(x_0, t):
     return (tf.sqrt(a_bar) * x_0) + (tf.sqrt(1.0 - a_bar) * noise), noise
 
 # =========================================
-# 4. THE BRAIN (U-NET) - FIXED SHAPES
+# 4. DEEPER U-NET (BRAIN)
 # =========================================
 def build_unet():
     image_input = layers.Input(shape=(IMG_SIZE, IMG_SIZE, CHANNELS))
     time_input = layers.Input(shape=(1,))
     
-    # FIX: We map time to 32 dimensions (not IMG_SIZE) to match the Conv2D layer
-    t = layers.Dense(32, activation="relu")(time_input)
+    # Map time to 32 dimensions matches the first Conv layer
+    t = layers.Dense(32, activation="swish")(time_input) # Swish is better than Relu
     t = layers.Reshape((1, 1, 32))(t)
 
-    # In: This Conv2D produces 32 filters
-    x = layers.Conv2D(32, 3, padding="same", activation="relu")(image_input)
-    
-    # MERGE: Now both x (..., 32) and t (..., 32) match!
+    # In
+    x = layers.Conv2D(32, 3, padding="same", activation="swish")(image_input)
     x = layers.Add()([x, t]) 
     
-    x = layers.Conv2D(64, 3, strides=2, padding="same", activation="relu")(x)
-    x = layers.Conv2D(128, 3, strides=2, padding="same", activation="relu")(x)
-    x = layers.Conv2D(256, 3, padding="same", activation="relu")(x)
+    # Downsample
+    x1 = layers.Conv2D(64, 3, strides=2, padding="same", activation="swish")(x)  # 32x32
+    x2 = layers.Conv2D(128, 3, strides=2, padding="same", activation="swish")(x1) # 16x16
+    
+    # Bottleneck
+    x3 = layers.Conv2D(256, 3, padding="same", activation="swish")(x2)
     
-    x = layers.Conv2DTranspose(128, 3, strides=2, padding="same", activation="relu")(x)
-    x = layers.Conv2DTranspose(64, 3, strides=2, padding="same", activation="relu")(x)
-    x = layers.Conv2D(32, 3, padding="same", activation="relu")(x)
+    # Upsample
+    x = layers.Conv2DTranspose(128, 3, strides=2, padding="same", activation="swish")(x3)
+    x = layers.Conv2DTranspose(64, 3, strides=2, padding="same", activation="swish")(x)
+    x = layers.Conv2D(32, 3, padding="same", activation="swish")(x)
     
     outputs = layers.Conv2D(CHANNELS, 1, padding="same")(x)
     return keras.Model([image_input, time_input], outputs)
 
-# Initialize
 model = build_unet()
 optimizer = keras.optimizers.Adam(learning_rate=1e-4)
 loss_fn = keras.losses.MeanSquaredError()
 
-# Load weights if available
 if os.path.exists(WEIGHTS_FILE):
     try:
         model.load_weights(WEIGHTS_FILE)
-        print("Brain Loaded!")
-    except Exception as e:
-        print(f"Starting fresh brain: {e}")
+        print("HQ Brain Loaded!")
+    except: pass
 
 # =========================================
-# 5. TRAINING FUNCTION
+# 5. TRAINING
 # =========================================
 def train_model(epochs):
-    yield "Generating Sacred Geometry Data..."
-    x_train = generate_veda_patterns(num_images=500) 
-    dataset = tf.data.Dataset.from_tensor_slices(x_train).batch(BATCH_SIZE).shuffle(500)
+    yield "Generating HD Data (Math)..."
+    x_train = generate_veda_patterns(num_images=600) 
+    dataset = tf.data.Dataset.from_tensor_slices(x_train).batch(BATCH_SIZE).shuffle(600)
     
-    yield "Dataset Ready. Starting Training Loop..."
+    yield "Dataset Ready. Training..."
     
     for epoch in range(int(epochs)):
         total_loss = 0
@@ -133,18 +142,16 @@ def train_model(epochs):
             steps += 1
             
         model.save_weights(WEIGHTS_FILE)
-        yield f"Epoch {epoch+1}/{epochs} Complete - Loss: {total_loss/steps:.4f}"
+        yield f"Epoch {epoch+1}/{epochs} - Loss: {total_loss/steps:.4f}"
         
-    yield "Training Done! Go to 'Dream' tab."
+    yield "Training Complete."
 
 # =========================================
-# 6. GENERATION FUNCTION
+# 6. GENERATION (WITH UPSCALING)
 # =========================================
 def generate_art():
-    # Start with static
     img = tf.random.normal((1, IMG_SIZE, IMG_SIZE, CHANNELS), dtype=tf.float32)
     
-    # Reverse Diffusion
     for i in range(TIMESTEPS - 1, 0, -1):
         t = tf.fill([1], i)
         pred_noise = model([img, t], training=False)
@@ -162,35 +169,36 @@ def generate_art():
             z = tf.random.normal((1, IMG_SIZE, IMG_SIZE, CHANNELS), dtype=tf.float32)
             img = img + (tf.sqrt(beta_t) * z)
 
-    # Normalize
+    # Process
     img = tf.clip_by_value(img, 0.0, 1.0)
     img = img[0].numpy()
     img = (img * 255).astype(np.uint8)
     
-    # Resize
+    # HIGH QUALITY RESIZE (LANCZOS)
+    # This blurs the pixels so it looks like smooth art, not blocks
     pil_img = Image.fromarray(img)
-    pil_img = pil_img.resize((300, 300), Image.BILINEAR)
+    pil_img = pil_img.resize((512, 512), Image.LANCZOS)
+    
     return pil_img
 
 # =========================================
 # 7. UI
 # =========================================
 def run_training_wrapper():
-    for update in train_model(5): 
+    for update in train_model(10): # Default 10 Epochs for better quality
         yield update
 
 with gr.Blocks(title="Akasha Art Engine") as demo:
-    gr.Markdown("# Akasha Art Engine")
-    gr.Markdown("A custom Diffusion model that learns sacred geometry from pure math.")
+    gr.Markdown("# Akasha Art Engine (High Quality)")
+    gr.Markdown("Generating 64x64 math patterns and upscaling to 512x512.")
     
     with gr.Tab("Dream"):
-        gen_btn = gr.Button("Generate Sacred Pattern", variant="primary")
+        gen_btn = gr.Button("Generate Energy Pattern", variant="primary")
         out_img = gr.Image(label="Veda Dream")
         gen_btn.click(generate_art, outputs=out_img)
         
     with gr.Tab("Train"):
-        gr.Markdown("Click below to generate data and train the model.")
-        train_btn = gr.Button("Train AI (5 Epochs)")
+        train_btn = gr.Button("Train AI (10 Epochs - Takes ~5 mins)")
         log = gr.Textbox(label="Status")
         train_btn.click(run_training_wrapper, outputs=log)