Update Dockerfile

Dockerfile

@@ -101,7 +101,7 @@ HTML_TEMPLATE = r"""
         const { useState, useEffect, useRef } = React;
         function App() {
             const [desktopImage, setDesktopImage] = useState(null);
-            const [logs, setLogs] = useState(["Neural Bios v9.4", "Booting Kernel..."]);
+            const [logs, setLogs] = useState(["Neural Bios v9.5", "Booting Kernel..."]);
             const socketRef = useRef(null);
             const canvasRef = useRef(null);
 
@@ -177,23 +177,20 @@ PROGRAMS = {
     "explorer": Application("Explorer", "ICON_FOLDER", "file explorer, icons grid", (56, 40))
 }
 
-# Pre-defined Tensor "DNA" for UI consistency
 DRIVERS = {}
 
 def initialize_drivers():
     # 1. Desktop Background Latent (Blue-ish)
-    bg = torch.zeros((1, 4, 128, 128), dtype=torch.float16)
-    bg[:, 0, :, :] = 0.5   # Channel 0
-    bg[:, 1, :, :] = 0.8   # Channel 1 (Blueish)
-    bg[:, 2, :, :] = 0.2   # Channel 2
+    bg = torch.zeros((1, 4, 128, 128), dtype=torch.float32) # Using float32 for safety
+    bg[:, 0, :, :] = 0.5   
+    bg[:, 1, :, :] = 0.8   
+    bg[:, 2, :, :] = 0.2   
     DRIVERS["DESKTOP_BG"] = bg
 
-    # 2. Icon Placeholders (Simple blocks)
-    # Creating a simple unique latent signature for icons
-    icon = torch.zeros((1, 4, 8, 8), dtype=torch.float16)
-    icon[:, 0, 2:6, 2:6] = 2.0 # Bright spot
+    # 2. Icon Placeholders
+    icon = torch.zeros((1, 4, 8, 8), dtype=torch.float32)
+    icon[:, 0, 2:6, 2:6] = 2.0 
     DRIVERS["ICON_GENERIC"] = icon
-    
     print("[*] Drivers Initialized.")
 
 class OSKernel:
@@ -215,7 +212,7 @@ class OSKernel:
         
         # Initialize empty window latent
         w, h = app.default_size
-        latent = torch.zeros((1, 4, h, w), dtype=torch.float16)
+        latent = torch.zeros((1, 4, h, w), dtype=torch.float32)
         
         proc = Process(
             pid=pid, name=app.name, app_type=app_type,
@@ -234,31 +231,25 @@ class OSKernel:
     def focus_process(self, pid: int):
         if pid in self.processes:
             self.focused_pid = pid
-            # Move to top Z-layer
             max_z = max((p.z_order for p in self.processes.values()), default=0)
             self.processes[pid].z_order = max_z + 1
 
     def handle_click(self, x: int, y: int) -> Dict:
-        # 1. Check Windows (Reverse Z-Order)
         sorted_procs = sorted(self.processes.values(), key=lambda p: p.z_order, reverse=True)
         for proc in sorted_procs:
             px, py = proc.position
             pw, ph = proc.size
             if px <= x < px+pw and py <= y < py+ph:
                 self.focus_process(proc.pid)
-                
-                # Check Close Button (Top Right Corner)
                 if py <= y < py+4 and px+pw-4 <= x < px+pw:
                     self.kill_process(proc.pid)
                     return {"action": "close", "pid": proc.pid, "name": proc.name}
-                
                 return {"action": "focus", "pid": proc.pid, "name": proc.name}
 
-        # 2. Check Desktop Icons
         for icon in self.desktop_icons:
             ix, iy = icon['x'], icon['y']
             if ix <= x < ix+8 and iy <= y < iy+8:
-                pid = self.spawn_process(icon['app'], x=32, y=24) # Spawn offset
+                pid = self.spawn_process(icon['app'], x=32, y=24)
                 return {"action": "launch", "pid": pid, "app": icon['app']}
 
         return {"action": "desktop_click"}
@@ -270,40 +261,45 @@ class OSKernel:
 class NeuralSystem:
     def __init__(self):
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        # CPU must use float32 to avoid "Half not implemented" errors
         self.dt = torch.float16 if self.device == "cuda" else torch.float32
-        print(f"[*] System Device: {self.device}")
+        print(f"[*] System Device: {self.device} | Type: {self.dt}")
         
         # A. LOAD DIFFUSION
+        # We do NOT call .to(device) immediately for the whole pipeline if on CPU
+        # to prevent meta-tensor conversion issues with accelerate.
         print("[*] Loading Neural GPU...")
         self.pipe = StableDiffusionPipeline.from_pretrained(
             "runwayml/stable-diffusion-v1-5", 
             torch_dtype=self.dt,
             safety_checker=None,
             requires_safety_checker=False
-        ).to(self.device)
+        )
+        if self.device == "cuda":
+            self.pipe = self.pipe.to("cuda")
+        
+        # Load LCM and VAE
         self.pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
         self.pipe.scheduler = LCMScheduler.from_config(self.pipe.scheduler.config)
         self.pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", torch_dtype=self.dt).to(self.device)
         
-        # B. LOAD QWEN (With Padding Fix)
+        # B. LOAD QWEN
         print("[*] Loading Qwen 2.5...")
         self.model_id = "Qwen/Qwen2.5-Coder-0.5B-Instruct"
         self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
-        
-        # [FIX] Explicitly set padding token if missing
         if self.tokenizer.pad_token_id is None:
             self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
-            
+        
+        # FIX: Use device_map instead of .to() to prevent "Cannot copy out of meta tensor"
         self.llm = AutoModelForCausalLM.from_pretrained(
             self.model_id, 
-            dtype=self.dt,
-            low_cpu_mem_usage=True
-        ).to(self.device)
+            torch_dtype=self.dt,
+            low_cpu_mem_usage=True,
+            device_map=self.device  # Let accelerate handle the placement
+        )
         print("[*] Systems Online.")
 
     def think(self, prompt_text):
-        """ Runs Qwen with corrected attention masks """
-        # [FIX] Explicit attention mask generation
         inputs = self.tokenizer(
             prompt_text,
             return_tensors="pt",
@@ -323,10 +319,8 @@ class NeuralSystem:
         return response
 
     def render_frame(self, kernel: OSKernel):
-        """ Composites the desktop and runs one fast diffusion pass """
-        # 1. Base Layer (Desktop)
-        canvas = DRIVERS["DESKTOP_BG"].clone()
-        if self.device == "cuda": canvas = canvas.to("cuda")
+        # 1. Base Layer
+        canvas = DRIVERS["DESKTOP_BG"].clone().to(self.device)
 
         # 2. Draw Icons
         icon_dna = DRIVERS["ICON_GENERIC"].to(self.device)
@@ -334,23 +328,18 @@ class NeuralSystem:
             x, y = icon['x'], icon['y']
             canvas[:, :, y:y+8, x:x+8] = icon_dna
 
-        # 3. Draw Windows (Sorted by Z)
+        # 3. Draw Windows
         sorted_procs = sorted(kernel.processes.values(), key=lambda p: p.z_order)
         for proc in sorted_procs:
             x, y = proc.position
             w, h = proc.size
-            
-            # Blit latent state
-            # Ensure proc latent is on correct device
-            proc_latent = proc.latent_state.to(self.device)
-            
-            # Simple bounds check
             if x+w <= 128 and y+h <= 128:
+                # Ensure latent is on correct device/dtype before blitting
+                proc_latent = proc.latent_state.to(self.device, dtype=self.dt)
                 canvas[:, :, y:y+h, x:x+w] = proc_latent
 
-        # 4. Decode (No Diffusion for pure composition speed, or 1-step for 'dreaming')
+        # 4. Decode
         with torch.no_grad():
-            # Fast decode using TAESD
             img = self.pipe.vae.decode(canvas / 0.18215).sample
             img = (img / 2 + 0.5).clamp(0, 1).cpu().permute(0, 2, 3, 1).numpy()
             img = self.pipe.numpy_to_pil(img)[0]
@@ -358,30 +347,25 @@ class NeuralSystem:
         return img
 
     def generate_window_content(self, proc: Process):
-        """ Generates content for a newly opened window """
         app_def = PROGRAMS[proc.app_type]
         prompt = f"pixel art windows xp {app_def.name} window content, {app_def.content_prompt}, crisp UI"
         
-        # 1-Step LCM Generation
         with torch.no_grad():
-            # Generate pure noise of correct size
             latents = torch.randn(
                 (1, 4, proc.size[1], proc.size[0]), 
                 device=self.device, 
                 dtype=self.dt
             )
-            # Run 1 step
             img_latents = self.pipe(
                 prompt, 
                 latents=latents, 
                 num_inference_steps=1, 
                 output_type="latent"
-            ).images # Returns latents because output_type="latent"
+            ).images 
             
-            # Manually inject "Title Bar" DNA (Blue strip at top)
-            # Channel 1 is roughly Blue/Cyan in SD Latent space
+            # Simple Title Bar Injection
             img_latents[:, 1, 0:4, :] = 1.5 
-            img_latents[:, 0, 0:4, :] = -0.5 # Darken
+            img_latents[:, 0, 0:4, :] = -0.5 
             
             proc.latent_state = img_latents
 
@@ -404,7 +388,6 @@ def socket_handler(ws):
     
     ws.send(json.dumps({"type": "log", "data": "Kernel Attached."}))
     
-    # Render Initial Frame
     img = sys_engine.render_frame(kernel_instance)
     buf = io.BytesIO()
     img.save(buf, format="PNG")
@@ -419,30 +402,21 @@ def socket_handler(ws):
         msg = json.loads(data)
         
         if msg['type'] == 'click':
-            # 1. Handle OS Logic
             res = kernel_instance.handle_click(msg['x'], msg['y'])
             
             if res['action'] == 'launch':
                 ws.send(json.dumps({"type": "log", "data": f"Launching {res['app']}..."}))
-                
-                # Get the process object
                 proc = kernel_instance.processes[res['pid']]
-                
-                # Use AI to generate its content
                 sys_engine.generate_window_content(proc)
                 
             elif res['action'] == 'close':
                  ws.send(json.dumps({"type": "log", "data": f"Closed {res['name']}"}))
 
             elif res['action'] == 'desktop_click':
-                # Ask Qwen for flavor text
                 thought = sys_engine.think(f"User clicked background at {msg['x']},{msg['y']}. Short witty system log:")
                 ws.send(json.dumps({"type": "log", "data": f"SYS: {thought}"}))
 
-            # 2. Re-Render Desktop
             img = sys_engine.render_frame(kernel_instance)
-            
-            # 3. Send Frame
             buf = io.BytesIO()
             img.save(buf, format="PNG")
             ws.send(json.dumps({