app.py

# import gradio as gr
# import torch
# from PIL import Image
# from model import CRM
# from inference import generate3d
# import numpy as np

# # Load model
# crm_path = "CRM.pth"  # Make sure the model is uploaded to the Space
# model = CRM(torch.load(crm_path, map_location="cpu"))
# model = model.to("cuda:0" if torch.cuda.is_available() else "cpu")

# def generate_3d(image_path, seed=1234, scale=5.5, step=30):
#     image = Image.open(image_path).convert("RGB")
#     np_img = np.array(image)
#     glb_path = generate3d(model, np_img, np_img, "cuda:0" if torch.cuda.is_available() else "cpu")
#     return glb_path

# iface = gr.Interface(
#     fn=generate_3d,
#     inputs=gr.Image(type="filepath"),
#     outputs=gr.Model3D(),
#     title="Convolutional Reconstruction Model (CRM)",
#     description="Upload an image to generate a 3D model."
# )

# iface.launch()


#############2nd################3
# import os
# import torch
# import gradio as gr
# from huggingface_hub import hf_hub_download
# from model import CRM  # Make sure this matches your model file structure

# # Define model details
# REPO_ID = "Mariam-Elz/CRM"  # Hugging Face model repo
# MODEL_FILES = {
#     "ccm-diffusion": "ccm-diffusion.pth",
#     "pixel-diffusion": "pixel-diffusion.pth",
#     "CRM": "CRM.pth"
# }
# DEVICE = "cuda" if torch.cuda.is_available() else "cpu"

# # Download models from Hugging Face if not already present
# MODEL_DIR = "./models"
# os.makedirs(MODEL_DIR, exist_ok=True)

# for name, filename in MODEL_FILES.items():
#     model_path = os.path.join(MODEL_DIR, filename)
#     if not os.path.exists(model_path):
#         print(f"Downloading {filename}...")
#         hf_hub_download(repo_id=REPO_ID, filename=filename, local_dir=MODEL_DIR)

# # Load the model
# print("Loading CRM Model...")
# model = CRM()
# model.load_state_dict(torch.load(os.path.join(MODEL_DIR, MODEL_FILES["CRM"]), map_location=DEVICE))
# model.to(DEVICE)
# model.eval()
# print("✅ Model Loaded Successfully!")

# # Define Gradio Interface
# def predict(input_image):
#     with torch.no_grad():
#         output = model(input_image.to(DEVICE))  # Modify based on model input format
#     return output.cpu()

# demo = gr.Interface(
#     fn=predict,
#     inputs=gr.Image(type="pil"),
#     outputs=gr.Image(type="pil"),
#     title="Convolutional Reconstruction Model (CRM)",
#     description="Upload an image to generate a reconstructed output."
# )

# if __name__ == "__main__":
#     demo.launch()
########################3rd-MAIN######################3

# import torch
# import gradio as gr
# import requests
# import os

# # Download model weights from Hugging Face model repo (if not already present)
# model_repo = "Mariam-Elz/CRM"  # Your Hugging Face model repo

# model_files = {
#     "ccm-diffusion.pth": "ccm-diffusion.pth",
#     "pixel-diffusion.pth": "pixel-diffusion.pth",
#     "CRM.pth": "CRM.pth",
# }

# os.makedirs("models", exist_ok=True)

# for filename, output_path in model_files.items():
#     file_path = f"models/{output_path}"
#     if not os.path.exists(file_path):
#         url = f"https://huggingface.co/{model_repo}/resolve/main/{filename}"
#         print(f"Downloading {filename}...")
#         response = requests.get(url)
#         with open(file_path, "wb") as f:
#             f.write(response.content)

# # Load model (This part depends on how the model is defined)
# device = "cuda" if torch.cuda.is_available() else "cpu"

# def load_model():
#     model_path = "models/CRM.pth"
#     model = torch.load(model_path, map_location=device)
#     model.eval()
#     return model

# model = load_model()

# # Define inference function
# def infer(image):
#     """Process input image and return a reconstructed image."""
#     with torch.no_grad():
#         # Assuming model expects a tensor input
#         image_tensor = torch.tensor(image).to(device)
#         output = model(image_tensor)
#         return output.cpu().numpy()

# # Create Gradio UI
# demo = gr.Interface(
#     fn=infer,
#     inputs=gr.Image(type="numpy"),
#     outputs=gr.Image(type="numpy"),
#     title="Convolutional Reconstruction Model",
#     description="Upload an image to get the reconstructed output."
# )

# if __name__ == "__main__":
#     demo.launch()


#################4th##################

# import torch
# import gradio as gr
# import requests
# import os

# # Define model repo
# model_repo = "Mariam-Elz/CRM"

# # Define model files and download paths
# model_files = {
#     "CRM.pth": "models/CRM.pth"
# }

# os.makedirs("models", exist_ok=True)

# # Download model files only if they don't exist
# for filename, output_path in model_files.items():
#     if not os.path.exists(output_path):
#         url = f"https://huggingface.co/{model_repo}/resolve/main/{filename}"
#         print(f"Downloading {filename}...")
#         response = requests.get(url)
#         with open(output_path, "wb") as f:
#             f.write(response.content)

# # Load model with low memory usage
# def load_model():
#     model_path = "models/CRM.pth"
#     model = torch.load(model_path, map_location="cpu")  # Load on CPU to reduce memory usage
#     model.eval()
#     return model

# model = load_model()

# # Define inference function
# def infer(image):
#     """Process input image and return a reconstructed image."""
#     with torch.no_grad():
#         image_tensor = torch.tensor(image).unsqueeze(0)  # Add batch dimension
#         image_tensor = image_tensor.to("cpu")  # Keep on CPU to save memory
#         output = model(image_tensor)
#         return output.squeeze(0).numpy()

# # Create Gradio UI
# demo = gr.Interface(
#     fn=infer,
#     inputs=gr.Image(type="numpy"),
#     outputs=gr.Image(type="numpy"),
#     title="Convolutional Reconstruction Model",
#     description="Upload an image to get the reconstructed output."
# )

# if __name__ == "__main__":
#     demo.launch()


# ##############5TH#################
# import torch
# import torch.nn as nn
# import gradio as gr
# import requests
# import os

# # Define model repo
# model_repo = "Mariam-Elz/CRM"

# # Define model files and download paths
# model_files = {
#     "CRM.pth": "models/CRM.pth"
# }

# os.makedirs("models", exist_ok=True)

# # Download model files only if they don't exist
# for filename, output_path in model_files.items():
#     if not os.path.exists(output_path):
#         url = f"https://huggingface.co/{model_repo}/resolve/main/{filename}"
#         print(f"Downloading {filename}...")
#         response = requests.get(url)
#         with open(output_path, "wb") as f:
#             f.write(response.content)

# # Define the model architecture (you MUST replace this with your actual model)
# class CRM_Model(nn.Module):
#     def __init__(self):
#         super(CRM_Model, self).__init__()
#         self.layer1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
#         self.relu = nn.ReLU()
#         self.layer2 = nn.Conv2d(64, 3, kernel_size=3, padding=1)

#     def forward(self, x):
#         x = self.layer1(x)
#         x = self.relu(x)
#         x = self.layer2(x)
#         return x

# # Load model with proper architecture
# def load_model():
#     model = CRM_Model()  # Instantiate the model architecture
#     model_path = "models/CRM.pth"
#     model.load_state_dict(torch.load(model_path, map_location="cpu"))  # Load weights
#     model.eval()  # Set to evaluation mode
#     return model

# model = load_model()

# # Define inference function
# def infer(image):
#     """Process input image and return a reconstructed image."""
#     with torch.no_grad():
#         image_tensor = torch.tensor(image).unsqueeze(0).permute(0, 3, 1, 2).float() / 255.0  # Convert to tensor
#         output = model(image_tensor)  # Run through model
#         output = output.squeeze(0).permute(1, 2, 0).numpy() * 255.0  # Convert back to image
#         return output.astype("uint8")

# # Create Gradio UI
# demo = gr.Interface(
#     fn=infer,
#     inputs=gr.Image(type="numpy"),
#     outputs=gr.Image(type="numpy"),
#     title="Convolutional Reconstruction Model",
#     description="Upload an image to get the reconstructed output."
# )

# if __name__ == "__main__":
#     demo.launch()


#############6th##################
import torch
import gradio as gr
import requests
import os
import numpy as np

# Hugging Face Model Repository
model_repo = "Mariam-Elz/CRM"

# Download Model Weights (Only CRM.pth to Save Memory)
model_path = "models/CRM.pth"
os.makedirs("models", exist_ok=True)

if not os.path.exists(model_path):
    url = f"https://huggingface.co/{model_repo}/resolve/main/CRM.pth"
    print(f"Downloading CRM.pth...")
    response = requests.get(url)
    with open(model_path, "wb") as f:
        f.write(response.content)

# Set Device (Use CPU to Reduce RAM Usage)
device = "cpu"

# Load Model Efficiently
def load_model():
    model = torch.load(model_path, map_location=device)
    if isinstance(model, torch.nn.Module):
        model.eval()  # Ensure model is in inference mode
    return model

# Load model only when needed (saves memory)
model = load_model()

# Define Inference Function with Memory Optimizations
def infer(image):
    """Process input image and return a reconstructed image."""
    with torch.no_grad():
        # Convert image to torch tensor & normalize (float16 to save RAM)
        image_tensor = torch.tensor(image, dtype=torch.float16).unsqueeze(0).permute(0, 3, 1, 2) / 255.0
        image_tensor = image_tensor.to(device)

        # Model Inference
        output = model(image_tensor)

        # Convert back to numpy image format
        output_image = output.squeeze(0).permute(1, 2, 0).cpu().numpy() * 255.0
        output_image = np.clip(output_image, 0, 255).astype(np.uint8)

        # Free Memory
        del image_tensor, output
        torch.cuda.empty_cache()

        return output_image

# Create Gradio UI
demo = gr.Interface(
    fn=infer,
    inputs=gr.Image(type="numpy"),
    outputs=gr.Image(type="numpy"),
    title="Optimized Convolutional Reconstruction Model",
    description="Upload an image to get the reconstructed output with reduced memory usage."
)

if __name__ == "__main__":
    demo.launch()