Download app.py from satyahaha/B2B: direct link, hf CLI and curl.
- Browser
- Download file 15.6 kB
-
https://huggingface.co/spaces/satyahaha/B2B/resolve/main/app.py
- Command line
-
hf download hf://spaces/satyahaha/B2B/app.py
-
curl -L -o app.py https://huggingface.co/spaces/satyahaha/B2B/resolve/main/app.py
15.6 kB
| import os | |
| import torch | |
| import math | |
| import gradio as gr | |
| from PIL import Image | |
| from transformers import ( | |
| GPT2LMHeadModel, GPT2Tokenizer, | |
| AutoTokenizer, AutoModelForSequenceClassification, | |
| AutoImageProcessor, AutoModelForImageClassification, | |
| logging | |
| ) | |
| from openai import OpenAI | |
| from groq import Groq | |
| import cv2 | |
| import numpy as np | |
| import torch.nn as nn | |
| import librosa | |
| logging.set_verbosity_error() | |
| # ----------------------------- | |
| # API Keys (set via Space secrets) | |
| # ----------------------------- | |
| HF_TOKEN = os.getenv("HF_TOKEN") | |
| GROQ_API_KEY = os.getenv("GROQ_API_KEY") | |
| client = Groq(api_key=GROQ_API_KEY) | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| # TEXT DETECTION | |
| # ----------------------------- | |
| def run_hf_detector(text, model_id="roberta-base-openai-detector"): | |
| tokenizer = AutoTokenizer.from_pretrained(model_id, token=HF_TOKEN) | |
| model = AutoModelForSequenceClassification.from_pretrained(model_id, token=HF_TOKEN).to(device) | |
| inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(device) | |
| with torch.no_grad(): | |
| outputs = model(**inputs) | |
| probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0] | |
| human_score, ai_score = float(probs[0]), float(probs[1]) | |
| label = "AI-generated" if ai_score > human_score else "Human-generated" | |
| return {"ai_score": ai_score, "human_score": human_score, "hf_label": label} | |
| def calculate_perplexity(text): | |
| model = GPT2LMHeadModel.from_pretrained("gpt2").to(device) | |
| tokenizer = GPT2Tokenizer.from_pretrained("gpt2") | |
| encodings = tokenizer(text, return_tensors="pt").to(device) | |
| max_length = model.config.n_positions | |
| if encodings.input_ids.size(1) > max_length: | |
| encodings.input_ids = encodings.input_ids[:, :max_length] | |
| encodings.attention_mask = encodings.attention_mask[:, :max_length] | |
| with torch.no_grad(): | |
| outputs = model(**encodings, labels=encodings.input_ids) | |
| loss = outputs.loss | |
| perplexity = math.exp(loss.item()) | |
| label = "AI-generated" if perplexity < 60 else "Human-generated" | |
| return {"perplexity": perplexity, "perplexity_label": label} | |
| def generate_text_explanation(text, ai_score, human_score): | |
| decision = "AI-generated" if ai_score > human_score else "Human-generated" | |
| prompt = f""" | |
| You are an AI text analysis expert. Explain concisely why this text was classified as '{decision}'. | |
| Text: "{text}" | |
| Explanation:""" | |
| response = client.chat.completions.create( | |
| model="gemma2-9b-it", | |
| messages=[{"role":"user","content":prompt}], | |
| max_tokens=150, | |
| temperature=0.7 | |
| ) | |
| return response.choices[0].message.content.strip() | |
| def analyze_text(text): | |
| try: | |
| hf_out = run_hf_detector(text) | |
| hf_out["ai_score"] = float(hf_out["ai_score"]) | |
| hf_out["human_score"] = float(hf_out["human_score"]) | |
| diff = abs(hf_out["ai_score"] - hf_out["human_score"]) | |
| confidence = "High" if diff>0.8 else "Medium" if diff>=0.3 else "Low" | |
| perp_out = calculate_perplexity(text) | |
| explanation = generate_text_explanation(text, hf_out["ai_score"], hf_out["human_score"]) | |
| return {"ai_score": hf_out["ai_score"], "confidence": confidence, "explanation": explanation} | |
| except: | |
| return {"ai_score":0.0,"confidence":"Low","explanation":"Error analyzing text."} | |
| # ----------------------------- | |
| # IMAGE DETECTION | |
| # ----------------------------- | |
| image_model_name = "Ateeqq/ai-vs-human-image-detector" | |
| image_processor = AutoImageProcessor.from_pretrained(image_model_name) | |
| image_model = AutoModelForImageClassification.from_pretrained(image_model_name) | |
| image_model.eval() | |
| def generate_image_explanation(ai_probability,human_probability,confidence): | |
| prompt = f""" | |
| You are an AI image analysis expert. | |
| AI: {ai_probability:.4f}, Human: {human_probability:.4f}, Confidence: {confidence} | |
| Explain in 1-2 sentences why it was classified as {'AI-generated' if ai_probability>human_probability else 'Human-generated'}. | |
| """ | |
| response = client.chat.completions.create( | |
| model="llama-3.3-70b-versatile", | |
| messages=[{"role":"user","content":prompt}], | |
| temperature=0.6 | |
| ) | |
| return response.choices[0].message.content.strip() | |
| def analyze_image(image): | |
| image = image.convert("RGB") | |
| inputs = image_processor(images=image, return_tensors="pt") | |
| with torch.no_grad(): | |
| logits = image_model(**inputs).logits | |
| probabilities = torch.nn.functional.softmax(logits/6.0, dim=-1)[0] | |
| ai_prob, human_prob = probabilities[0].item(), probabilities[1].item() | |
| diff = abs(ai_prob-human_prob) | |
| confidence = "High" if diff>=0.7 else "Medium" if diff>=0.3 else "Low" | |
| explanation = generate_image_explanation(ai_prob, human_prob, confidence) | |
| return {"ai_probability": ai_prob, "confidence": confidence, "explanation": explanation} | |
| # ----------------------------- | |
| # VIDEO DETECTION | |
| # ----------------------------- | |
| def extract_frames(video_path, frame_rate=1): | |
| cap = cv2.VideoCapture(video_path) | |
| fps = cap.get(cv2.CAP_PROP_FPS) | |
| interval = int(fps*frame_rate) | |
| frames,count = [],0 | |
| while cap.isOpened(): | |
| ret,frame = cap.read() | |
| if not ret: break | |
| if count%interval==0: frames.append(Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))) | |
| count+=1 | |
| cap.release() | |
| return frames | |
| def analyze_video(video_path): | |
| frames = extract_frames(video_path, frame_rate=1) | |
| if not frames: return {"error":"No frames extracted."} | |
| ai_probs,human_probs = [],[] | |
| for img in frames: | |
| inputs = image_processor(images=img, return_tensors="pt") | |
| with torch.no_grad(): logits = image_model(**inputs).logits | |
| probs = torch.nn.functional.softmax(logits, dim=-1)[0] | |
| ai_probs.append(probs[0].item()) | |
| human_probs.append(probs[1].item()) | |
| avg_ai,avg_human = float(np.mean(ai_probs)), float(np.mean(human_probs)) | |
| diff = abs(avg_ai-avg_human) | |
| confidence = "High" if diff>=0.7 else "Medium" if diff>=0.3 else "Low" | |
| prompt = f"Video processed {len(frames)} frames. AI: {avg_ai:.4f}, Human: {avg_human:.4f}. Confidence: {confidence}. Explain why it was {'AI-generated' if avg_ai>avg_human else 'Human-generated'}." | |
| response = client.chat.completions.create(model="llama-3.3-70b-versatile", messages=[{"role":"user","content":prompt}], temperature=0.6) | |
| explanation = response.choices[0].message.content.strip() | |
| return {"ai_probability":avg_ai,"confidence":confidence,"explanation":explanation} | |
| # ----------------------------- | |
| # AUDIO DETECTION | |
| # ----------------------------- | |
| class AudioCNNRNN(nn.Module): | |
| def __init__(self, lstm_hidden_size=128, num_classes=2): | |
| super(AudioCNNRNN, self).__init__() | |
| self.cnn = nn.Sequential( | |
| nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1), | |
| nn.ReLU(), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), | |
| nn.ReLU(), | |
| nn.MaxPool2d(2), | |
| ) | |
| self.lstm = nn.LSTM(input_size=64, hidden_size=lstm_hidden_size, batch_first=True) | |
| self.fc = nn.Linear(lstm_hidden_size, num_classes) | |
| def forward(self, x): | |
| batch_size, seq_len, c, h, w = x.size() | |
| c_in = x.view(batch_size * seq_len, c, h, w) | |
| features = self.cnn(c_in) | |
| features = features.mean(dim=[2, 3]) | |
| features = features.view(batch_size, seq_len, -1) | |
| lstm_out, _ = self.lstm(features) | |
| out = self.fc(lstm_out[:, -1, :]) | |
| return out | |
| def extract_mel_spectrogram(audio_path, sr=16000, n_mels=64): | |
| waveform, sample_rate = librosa.load(audio_path, sr=sr) | |
| mel_spec = librosa.feature.melspectrogram(y=waveform, sr=sr, n_mels=n_mels) | |
| mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max) | |
| return mel_spec_db | |
| def slice_spectrogram(mel_spec, slice_size=128, step=64): | |
| slices = [] | |
| for start in range(0, mel_spec.shape[1] - slice_size, step): | |
| slice_ = mel_spec[:, start:start + slice_size] | |
| slices.append(slice_) | |
| return slices | |
| def analyze_audio(audio_path): | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| model = AudioCNNRNN() | |
| model.eval() | |
| model.to(device) | |
| mel_spec = extract_mel_spectrogram(audio_path) | |
| mel_slices = slice_spectrogram(mel_spec, slice_size=128, step=64) | |
| if len(mel_slices) == 0: | |
| raise RuntimeError("No mel slices generated. Check audio length.") | |
| tensor_slices = [torch.tensor(s).unsqueeze(0) for s in mel_slices] | |
| data = torch.stack(tensor_slices) | |
| data = data.unsqueeze(0) | |
| data = data.to(device) | |
| with torch.no_grad(): | |
| outputs = model(data) | |
| logits = outputs | |
| temperature = 3.0 | |
| probabilities = torch.nn.functional.softmax(logits / temperature, dim=-1) | |
| ai_probability = probabilities[0][0].item() | |
| human_probability = probabilities[0][1].item() | |
| diff = abs(ai_probability - human_probability) | |
| if diff >= 0.7: | |
| confidence = "High" | |
| elif diff >= 0.3: | |
| confidence = "Medium" | |
| else: | |
| confidence = "Low" | |
| prompt = f""" | |
| You are an AI audio analysis expert. | |
| The detector outputs: | |
| - AI-generated probability: {ai_probability:.4f} | |
| - Human-generated probability: {human_probability:.4f} | |
| - Confidence level: {confidence} | |
| Give a short, human-readable explanation (1-2 sentences) of why the audio was likely classified as {'AI-generated' if ai_probability > human_probability else 'human-generated'}. | |
| Base it on audio cues such as tone, pitch patterns, unnatural pauses, synthesis artifacts, or other hints you might infer. | |
| Avoid repeating probabilities; focus on the reasoning. | |
| """ | |
| response = client.chat.completions.create( | |
| model="llama-3.3-70b-versatile", | |
| messages=[{"role": "user", "content": prompt}], | |
| temperature=0.6, | |
| ) | |
| return { | |
| "ai_probability": ai_probability, | |
| "confidence": confidence, | |
| "explanation": response.choices[0].message.content.strip() | |
| } | |
| # ----------------------------- | |
| # GRADIO UI | |
| # ----------------------------- | |
| def format_text_results(text): | |
| res = analyze_text(text) | |
| conf_map = {"High":"🟢 High","Medium":"🟡 Medium","Low":"🔴 Low"} | |
| return f"### Text Detection\nAI Score: {res['ai_score']:.4f}\nConfidence: {conf_map.get(res['confidence'],res['confidence'])}\nExplanation: {res['explanation']}" | |
| def format_image_results(image): | |
| res = analyze_image(image) | |
| return f"### Image Detection\nAI Probability: {res['ai_probability']:.4f}\n\nConfidence: {res['confidence']}\n\nExplanation: {res['explanation']}" | |
| def format_video_results(video_file): | |
| res = analyze_video(video_file) | |
| if "error" in res: return res["error"] | |
| return f"### Video Detection\nAI Probability: {res['ai_probability']:.4f}\n\nConfidence: {res['confidence']}\n\nExplanation: {res['explanation']}" | |
| def format_audio_results(audio_file): | |
| res = analyze_audio(audio_file) | |
| return f"### Audio Detection\nAI Probability: {res['ai_probability']:.4f}\n\nConfidence: {res['confidence']}\n\nExplanation: {res['explanation']}" | |
| with gr.Blocks() as app: | |
| # Home Page | |
| home_page = gr.Column(visible=True) | |
| with home_page: | |
| gr.Markdown("## 🏠 AI Detection Tool") | |
| gr.Markdown("Select an option below to continue:") | |
| with gr.Row(): | |
| text_page_btn = gr.Button("🧠 Text Detection") | |
| image_page_btn = gr.Button("🖼️ Image Detection") | |
| video_page_btn = gr.Button("🎬 Video Detection") # Add on home page | |
| audio_page_btn = gr.Button("🎵 Audio Detection") # Add this to home page | |
| # Text Page | |
| text_page = gr.Column(visible=False) | |
| with text_page: | |
| gr.Markdown("## 🧠 Text Detection") | |
| text_input = gr.Textbox(lines=5, placeholder="Paste your text here...", label="Input Text") | |
| text_output = gr.Markdown("⚡ Result will appear here after submission...", label="Result") | |
| analyze_text_btn = gr.Button("Analyze Text") | |
| back_btn_text = gr.Button("⬅️ Back") | |
| # Image Page | |
| image_page = gr.Column(visible=False) | |
| with image_page: | |
| gr.Markdown("## 🖼️ Image Detection") | |
| image_input = gr.Image(type="pil", label="Upload Image") | |
| image_output = gr.Markdown("⚡ Result will appear here after image upload...", label="Result") | |
| analyze_image_btn = gr.Button("Analyze Image") | |
| back_btn_image = gr.Button("⬅️ Back") | |
| # Video page | |
| video_page = gr.Column(visible=False) | |
| with video_page: | |
| gr.Markdown("## 🎬 Video Detection") | |
| video_input = gr.Video(label="Upload Video") # Corrected | |
| video_output = gr.Markdown("⚡ Result will appear here after video upload...", label="Result") | |
| analyze_video_btn = gr.Button("Analyze Video") | |
| back_btn_video = gr.Button("⬅️ Back") | |
| audio_page = gr.Column(visible=False) | |
| with audio_page: | |
| gr.Markdown("## 🎵 Audio Detection") | |
| audio_input = gr.Audio(label="Upload Audio", type="filepath") # Use type="filepath" to get local path | |
| audio_output = gr.Markdown("⚡ Result will appear here after audio upload...", label="Result") | |
| analyze_audio_btn = gr.Button("Analyze Audio") | |
| back_btn_audio = gr.Button("⬅️ Back") | |
| def show_video_page(): | |
| return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=True) | |
| def show_audio_page(): | |
| return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=True) | |
| audio_page_btn.click(show_audio_page, outputs=[home_page, text_page, image_page, video_page, audio_page]) | |
| # Back button returns to home | |
| # Navigation functions | |
| def show_text_page(): | |
| return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False) | |
| def show_image_page(): | |
| return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True) | |
| def show_home(): | |
| return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False) | |
| # Bind navigation buttons | |
| text_page_btn.click(show_text_page, outputs=[home_page, text_page, image_page]) | |
| image_page_btn.click(show_image_page, outputs=[home_page, text_page, image_page]) | |
| back_btn_text.click(show_home, outputs=[home_page, text_page, image_page]) | |
| back_btn_image.click(show_home, outputs=[home_page, text_page, image_page]) | |
| video_page_btn.click(show_video_page, outputs=[home_page, text_page, image_page, video_page]) | |
| back_btn_video.click(lambda: (gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)), | |
| outputs=[home_page, text_page, image_page, video_page]) | |
| back_btn_audio.click(lambda: ( | |
| gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False) | |
| ), outputs=[home_page, text_page, image_page, video_page, audio_page]) | |
| # Bind analysis buttons | |
| analyze_text_btn.click(format_text_results, inputs=text_input, outputs=text_output) | |
| analyze_image_btn.click(format_image_results, inputs=image_input, outputs=image_output) | |
| analyze_video_btn.click(format_video_results, inputs=video_input, outputs=video_output) | |
| analyze_audio_btn.click(format_audio_results, inputs=audio_input, outputs=audio_output) | |
| app.launch(share=True, debug=True) | |