Spaces:
Running
Running
| # import gradio as gr | |
| # import requests | |
| # import base64 | |
| # from PIL import Image | |
| # import io | |
| # gr.set_page_config(page_title="AI Image Detector", page_icon="🔍") | |
| # gr.title("AI Image Detector") | |
| # gr.write("Upload an image to check if it's AI-generated") | |
| # api_key = NVIDIA_API_KEY | |
| # gr.session_state.api_key = api_key | |
| # def process_image(image_bytes, api_key): | |
| # header_auth = f"Bearer {api_key}" | |
| # invoke_url = "https://ai.api.nvidia.com/v1/cv/hive/ai-generated-image-detection" | |
| # # Convert image bytes to base64 | |
| # image_b64 = base64.b64encode(image_bytes).decode() | |
| # payload = { | |
| # "input": [f"data:image/png;base64,{image_b64}"] | |
| # } | |
| # headers = { | |
| # "Content-Type": "application/json", | |
| # "Authorization": header_auth, | |
| # "Accept": "application/json", | |
| # } | |
| # try: | |
| # response = requests.post(invoke_url, headers=headers, json=payload) | |
| # response.raise_for_status() | |
| # result = response.json() | |
| # # Check if response contains the expected structure | |
| # if 'data' in result and len(result['data']) > 0: | |
| # first_result = result['data'][0] | |
| # if 'is_ai_generated' in first_result: | |
| # return { | |
| # 'confidence': first_result['is_ai_generated'], | |
| # 'sources': first_result.get('possible_sources', {}), | |
| # 'status': first_result.get('status', 'UNKNOWN') | |
| # } | |
| # gr.error("Unexpected response format from API") | |
| # return None | |
| # except requests.exceptions.RequestException as e: | |
| # gr.error(f"Error processing image: {str(e)}") | |
| # return None | |
| # # File uploader | |
| # uploaded_file = gr.file_uploader("Choose an image...", type=['png', 'jpg', 'jpeg']) | |
| # if uploaded_file is not None and api_key: | |
| # # Display the uploaded image | |
| # image = Image.open(uploaded_file) | |
| # gr.image(image, caption="Uploaded Image", use_container_width=True) | |
| # # Convert image to bytes | |
| # img_byte_arr = io.BytesIO() | |
| # image.save(img_byte_arr, format=image.format) | |
| # img_byte_arr = img_byte_arr.getvalue() | |
| # # Process the image | |
| # with gr.spinner("Analyzing image..."): | |
| # result = process_image(img_byte_arr, api_key) | |
| # if result and result['status'] == 'SUCCESS': | |
| # confidence = result['confidence'] | |
| # sources = result['sources'] | |
| # gr.write("---") | |
| # gr.write("### Result") | |
| # # Determine if image is AI-generated (using 50% threshold) | |
| # is_ai_generated = "Yes" if confidence >= 0.5 else "No" | |
| # # Display result with appropriate styling | |
| # if is_ai_generated == "Yes": | |
| # gr.error(f"Is this image AI-generated? **{is_ai_generated}**") | |
| # # Show top 3 possible sources if AI-generated | |
| # if sources: | |
| # gr.write("Top possible AI models used:") | |
| # sorted_sources = sorted(sources.items(), key=lambda x: x[1], reverse=True)[:3] | |
| # for source, prob in sorted_sources: | |
| # if prob > 0.01: # Only show sources with >1% probability | |
| # gr.write(f"- {source}: {prob:.1%}") | |
| # else: | |
| # gr.success(f"Is this image AI-generated? **{is_ai_generated}**") | |
| # # Show confidence score in smaller text | |
| # gr.caption(f"Confidence score: {confidence:.2%}") | |
| # elif not api_key and uploaded_file is not None: | |
| # gr.warning("Please enter your NVIDIA API key first") | |
| # # Add footer with instructions | |
| # gr.markdown("---") | |
| # gr.markdown(""" | |
| # --- | |
| # ### How to use: | |
| # 1. Upload an image (PNG, JPG, or JPEG) | |
| # 2. Wait for the analysis result | |
| # 3. Get a ** Yes/No ** answer based on whether the image is AI-generated | |
| # """) | |
| import gradio as gr | |
| import requests | |
| import base64 | |
| from PIL import Image | |
| import io | |
| import os | |
| def process_image(image): | |
| """Process the uploaded image using NVIDIA's AI detection API""" | |
| # Get API key from environment variable for security | |
| api_key = os.getenv('NVIDIA_API_KEY') | |
| if not api_key: | |
| raise ValueError("NVIDIA API key not found in environment variables") | |
| header_auth = f"Bearer {api_key}" | |
| invoke_url = "https://ai.api.nvidia.com/v1/cv/hive/ai-generated-image-detection" | |
| # Convert PIL Image to bytes | |
| img_byte_arr = io.BytesIO() | |
| image.save(img_byte_arr, format='PNG') | |
| image_bytes = img_byte_arr.getvalue() | |
| # Convert image bytes to base64 | |
| image_b64 = base64.b64encode(image_bytes).decode() | |
| payload = { | |
| "input": [f"data:image/png;base64,{image_b64}"] | |
| } | |
| headers = { | |
| "Content-Type": "application/json", | |
| "Authorization": header_auth, | |
| "Accept": "application/json", | |
| } | |
| try: | |
| response = requests.post(invoke_url, headers=headers, json=payload) | |
| response.raise_for_status() | |
| result = response.json() | |
| if 'data' in result and len(result['data']) > 0: | |
| first_result = result['data'][0] | |
| if 'is_ai_generated' in first_result: | |
| confidence = first_result['is_ai_generated'] | |
| sources = first_result.get('possible_sources', {}) | |
| # Format the result message | |
| is_ai_generated = "<span style='color:red'>### Yes</span>" if confidence >= 0.5 else "<span style='color:green'>### No</span>" | |
| result_message = f"\n ### Is this image AI-generated? {is_ai_generated}\n" | |
| result_message += f"\n Confidence score: {confidence:.2%}\n\n" | |
| if is_ai_generated == "Yes" and sources: | |
| result_message += "\n **Top possible AI models used** :\n" | |
| sorted_sources = sorted(sources | |
| .items(), key=lambda x: x[1], reverse=True)[:3] | |
| for source, prob in sorted_sources: | |
| if prob > 0.01: | |
| result_message += f"- {source}: {prob:.1%}\n" | |
| return image, result_message | |
| return image, "Error: Unable to process image analysis results" | |
| except requests.exceptions.RequestException as e: | |
| return image, f"Error processing image: {str(e)}" | |
| def create_demo(): | |
| """Create and return the Gradio interface""" | |
| demo = gr.Interface( | |
| fn=process_image, | |
| inputs=gr.Image(type="pil", label="Upload Image"), | |
| outputs=[ | |
| gr.Image(type="pil", label="Analyzed Image" | |
| ), | |
| gr.Markdown(label=" ## Analysis Results") | |
| ], | |
| title="AI Image Detector", | |
| description="Upload an image to check if it's AI-generated", | |
| article=""" | |
| ### How to use: | |
| 1. Upload an image (PNG, JPG, or JPEG) | |
| 2. Click the 'Submit' button | |
| 3. Get a detailed analysis of whether the image is AI-generated alongside the Model that might be used in generation. | |
| """, | |
| css=".footer {display: none;}" | |
| ) | |
| return demo | |
| # Create and launch the application | |
| if __name__ == "__main__": | |
| demo= create_demo() | |
| demo.launch( | |
| show_api=False, | |
| show_error=False, | |
| share=False, | |
| quiet=True | |
| ) |