Update app.py

app.py

@@ -150,7 +150,6 @@ def fetch_and_process_sdo_data(target_dt, forecast_horizon_minutes):
             img_resized = img.resize((img_size, img_size), Image.Resampling.LANCZOS)
             norm_data = np.array(img_resized, dtype=np.float32)
 
-            # *** FIX: Retrieve the correct scaler object from the dictionary for the current channel ***
             scaler = scalers_dict[channel]
             scaled_data = scaler.transform(norm_data.reshape(-1, 1)).reshape(norm_data.shape)
             channel_tensors.append(torch.from_numpy(scaled_data.astype(np.float32)))
@@ -173,22 +172,24 @@ def run_inference(input_tensor):
     with torch.no_grad():
         with torch.autocast(device_type=device.split(':')[0], dtype=torch.bfloat16):
             prediction = model(input_batch)
-    return prediction.cpu()
+    
+    # *** FIX: Convert from BFloat16 to Float32 before returning, making it NumPy compatible ***
+    return prediction.cpu().to(torch.float32)
 
 def generate_visualization(last_input_map, prediction_tensor, target_map, channel_name):
     if last_input_map is None: return None, None, None
     c_idx = SDO_CHANNELS.index(channel_name)
     
-    # *** FIX: Retrieve the correct scaler object for the current channel to get its parameters ***
-    scaler = APP_CACHE["scalers"][channel_name]
+    scalers_dict = APP_CACHE["scalers"]
+    scaler = scalers_dict[channel_name]
     params = scaler.to_dict()
-    mean, std = params['mean'], params['std']
-    
-    # Note: The inverse transform for the simplified JPEG pipeline might differ from the original
-    # We will use a standard inverse scaling, which is the most logical approach here.
-    pred_slice_scaled = prediction_tensor[0, c_idx].numpy()
-    pred_slice = (pred_slice_scaled * std) + mean
+    mean, std, epsilon, sl_scale_factor = params['mean'], params['std'], params['epsilon'], params['sl_scale_factor']
 
+    # The prediction_tensor is now Float32, so .numpy() will work
+    pred_slice = inverse_transform_single_channel(
+        prediction_tensor[0, c_idx].numpy(), mean=mean, std=std, epsilon=epsilon, sl_scale_factor=sl_scale_factor
+    )
+    
     target_img_data = np.array(target_map[channel_name])
     vmax = np.quantile(np.nan_to_num(target_img_data), 0.995)
     cmap_name = f"sdoaia{channel_name.replace('aia', '')}" if 'aia' in channel_name else 'hmimag'