disabling hf auto install that overrides gradio version update

README.md

@@ -4,7 +4,7 @@ emoji: 🌈
 colorFrom: green
 colorTo: pink
 sdk: gradio
-sdk_version: 4.44.0
+sdk_version: 5.27.1
 app_file: app.py
 pinned: true
 license: bsd-3-clause

app.py

@@ -28,7 +28,7 @@ class VSGradio:
                 architecture="UNeXt2_2D",
                 model_config=self.model_config,
             )
-            self.model.to(self.device)  # Move the model to the correct device (GPU/CPU)
+            self.model.to(self.device)
             self.model.eval()
             print("Model loaded successfully and set to evaluation mode")
         except Exception as e:
@@ -42,7 +42,6 @@ class VSGradio:
         return (input - mean) / std
 
     def preprocess_image_standard(self, input: ArrayLike):
-        # Perform standard preprocessing here
         input = exposure.equalize_adapthist(input)
         return input
 
@@ -62,19 +61,16 @@ class VSGradio:
             # Normalize the input and convert to tensor
             inp = self.normalize_fov(inp)
             original_shape = inp.shape
-            # Resize the input image to the expected cell diameter
             inp = apply_rescale_image(inp, scaling_factor)
 
             # Convert the input to a tensor
             inp = torch.from_numpy(np.array(inp).astype(np.float32))
 
-            # Prepare the input dictionary and move input to the correct device (GPU or CPU)
             test_dict = dict(
                 index=None,
                 source=inp.unsqueeze(0).unsqueeze(0).unsqueeze(0).to(self.device),
             )
 
-            # Run model inference
             with torch.inference_mode():
                 self.model.on_predict_start()  # Necessary preprocessing for the model
                 pred = (
@@ -89,18 +85,15 @@ class VSGradio:
             nuc_pred = resize(nuc_pred, original_shape, anti_aliasing=True)
             mem_pred = resize(mem_pred, original_shape, anti_aliasing=True)
 
-            # Define colormaps
-            green_colormap = cmap.Colormap("green")  # Nucleus: black to green
+            green_colormap = cmap.Colormap("green")
             magenta_colormap = cmap.Colormap("magenta")
 
-            # Apply the colormap to the predictions
             nuc_rgb = apply_colormap(nuc_pred, green_colormap)
             mem_rgb = apply_colormap(mem_pred, magenta_colormap)
 
-            return nuc_rgb, mem_rgb  # Return both nucleus and membrane images
+            return nuc_rgb, mem_rgb
         except Exception as e:
             print(f"Error during prediction: {e}")
-            # Return empty images of the right shape and type in case of error
             empty_img = np.zeros((300, 300, 3), dtype=np.uint8)
             return empty_img, empty_img
 
@@ -109,13 +102,8 @@ def apply_colormap(prediction, colormap: cmap.Colormap):
     """Apply a colormap to a single-channel prediction image."""
     # Ensure the prediction is within the valid range [0, 1]
     prediction = exposure.rescale_intensity(prediction, out_range=(0, 1))
-
-    # Apply the colormap to get an RGB image
     rgb_image = colormap(prediction)
-
-    # Convert the output from [0, 1] to [0, 255] for display
     rgb_image_uint8 = (rgb_image * 255).astype(np.uint8)
-
     return rgb_image_uint8
 
 
@@ -125,53 +113,38 @@ def merge_images(nuc_rgb: ArrayLike, mem_rgb: ArrayLike) -> ArrayLike:
 
 
 def apply_image_adjustments(image, invert_image: bool, gamma_factor: float):
-    """Applies all the image adjustments (invert, contrast, gamma) in sequence"""
-    # Apply invert
     if invert_image:
         image = invert(image, signed_float=False)
-
-    # Apply gamma adjustment
     image = exposure.adjust_gamma(image, gamma_factor)
-
     return exposure.rescale_intensity(image, out_range=(0, 255)).astype(np.uint8)
 
 
 def apply_rescale_image(image, scaling_factor: float):
-    """Resize the input image according to the scaling factor"""
     scaling_factor = float(scaling_factor)
-    image = resize(
+    return resize(
         image,
         (int(image.shape[0] * scaling_factor), int(image.shape[1] * scaling_factor)),
         anti_aliasing=True,
     )
-    return image
 
 
-# Function to clear outputs when a new image is uploaded
 def clear_outputs(image):
-    return (
-        image,
-        None,
-        None,
-    )  # Return None for adjusted_image, output_nucleus, and output_membrane
+    return image, None, None
 
 
 def load_css(file_path):
-    """Load custom CSS"""
     with open(file_path, "r") as file:
         return file.read()
 
 
 if __name__ == "__main__":
     try:
-        # Download the model checkpoint from Hugging Face
         print("Downloading model checkpoint...")
         model_ckpt_path = hf_hub_download(
             repo_id="compmicro-czb/VSCyto2D", filename="epoch=399-step=23200.ckpt"
         )
         print(f"Model downloaded successfully to: {model_ckpt_path}")
 
-        # Model configuration
         model_config = {
             "in_channels": 1,
             "out_channels": 2,
@@ -241,10 +214,7 @@ if __name__ == "__main__":
                         visible=False,
                     )
 
-            # Checkbox for applying invert
             preprocess_invert = gr.Checkbox(label="Invert Image", value=False)
-
-            # Slider for gamma adjustment
             gamma_factor = gr.Slider(
                 label="Adjust Gamma", minimum=0.01, maximum=5.0, value=1.0, step=0.1
             )
@@ -328,14 +298,13 @@ if __name__ == "__main__":
                     output_membrane,
                 ],
             )
-            # Clear everything when the input image changes
+
             input_image.change(
                 fn=clear_outputs,
                 inputs=input_image,
                 outputs=[adjusted_image, output_nucleus, output_membrane],
             )
 
-            # Function to handle merging the two predictions after they are shown
             def merge_predictions_fn(nucleus_image, membrane_image, merge):
                 if merge:
                     merged = merge_images(nucleus_image, membrane_image)
@@ -353,7 +322,6 @@ if __name__ == "__main__":
                         gr.update(visible=True),
                     )
 
-            # Toggle between merged and separate views when the checkbox is checked
             merge_checkbox.change(
                 fn=merge_predictions_fn,
                 inputs=[output_nucleus, output_membrane, merge_checkbox],
@@ -435,8 +403,8 @@ if __name__ == "__main__":
                 </div>
                 """
             )
+        demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
 
         # Launch the Gradio app
-        demo.launch(server_name="0.0.0.0", share=False)
     except Exception as e:
         print(f"Error initializing VSGradio: {e}")