Deploy deepfake voice detection app

.gitignore

@@ -0,0 +1,26 @@
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.swp
+*.log
+
+myenv/
+env/
+venv/
+
+
+.vscode/
+
+
+.gradio/
+
+
+.DS_Store
+Thumbs.db
+
+.env
+
+dist/
+build/
+*.spec

App.js

@@ -0,0 +1,812 @@
+import React, { useState, useEffect } from 'react';
+import { 
+  Container, Box, Button, Typography, CircularProgress, 
+  Paper, Grid, Card, CardContent, LinearProgress, 
+  FormControl, IconButton, Alert, Snackbar, useMediaQuery
+} from '@mui/material';
+import { createTheme, ThemeProvider, styled, alpha } from '@mui/material/styles';
+import MicIcon from '@mui/icons-material/Mic';
+import StopIcon from '@mui/icons-material/Stop';
+import UploadFileIcon from '@mui/icons-material/UploadFile';
+import CloudUploadIcon from '@mui/icons-material/CloudUpload';
+import AudiotrackIcon from '@mui/icons-material/Audiotrack';
+import VolumeUpIcon from '@mui/icons-material/VolumeUp';
+import SecurityIcon from '@mui/icons-material/Security';
+import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer } from 'recharts';
+import { motion } from 'framer-motion';
+
+// API endpoint
+const API_URL = process.env.REACT_APP_API_URL || 'http://localhost:8000';
+
+// Custom theme
+const theme = createTheme({
+  palette: {
+    primary: {
+      main: '#3a86ff',
+      light: '#83b9ff',
+      dark: '#0056cb',
+    },
+    secondary: {
+      main: '#ff006e',
+      light: '#ff5b9e',
+      dark: '#c50052',
+    },
+    success: {
+      main: '#38b000',
+      light: '#70e000',
+      dark: '#008000',
+      contrastText: '#ffffff',
+    },
+    error: {
+      main: '#d00000',
+      light: '#ff5c4d',
+      dark: '#9d0208',
+      contrastText: '#ffffff',
+    },
+    background: {
+      default: '#f8f9fa',
+      paper: '#ffffff',
+    },
+  },
+  typography: {
+    fontFamily: "'Poppins', 'Roboto', 'Helvetica', 'Arial', sans-serif",
+    h3: {
+      fontWeight: 700,
+      letterSpacing: '-0.5px',
+    },
+    h6: {
+      fontWeight: 600,
+    },
+    subtitle1: {
+      fontWeight: 500,
+    }
+  },
+  shape: {
+    borderRadius: 12,
+  },
+  components: {
+    MuiButton: {
+      styleOverrides: {
+        root: {
+          textTransform: 'none',
+          borderRadius: 8,
+          padding: '10px 16px',
+          boxShadow: 'none',
+          fontWeight: 600,
+        },
+        containedPrimary: {
+          '&:hover': {
+            boxShadow: '0 6px 20px rgba(58, 134, 255, 0.3)',
+          },
+        },
+      },
+    },
+    MuiPaper: {
+      styleOverrides: {
+        root: {
+          boxShadow: '0 8px 40px rgba(0, 0, 0, 0.08)',
+        },
+      },
+    },
+    MuiCard: {
+      styleOverrides: {
+        root: {
+          overflow: 'visible',
+        },
+      },
+    },
+  },
+});
+
+// Styled components
+const VisuallyHiddenInput = styled('input')({
+  clip: 'rect(0 0 0 0)',
+  clipPath: 'inset(50%)',
+  height: 1,
+  overflow: 'hidden',
+  position: 'absolute',
+  bottom: 0,
+  left: 0,
+  whiteSpace: 'nowrap',
+  width: 1,
+});
+
+const StyledCard = styled(Card)(({ theme }) => ({
+  height: '100%',
+  display: 'flex',
+  flexDirection: 'column',
+  transition: 'transform 0.3s ease-in-out, box-shadow 0.3s ease-in-out',
+  '&:hover': {
+    transform: 'translateY(-5px)',
+    boxShadow: '0 12px 50px rgba(0, 0, 0, 0.1)',
+  },
+}));
+
+const ResultCard = styled(Card)(({ theme, prediction }) => ({
+  backgroundColor: prediction === 'Real' 
+    ? alpha(theme.palette.success.light, 0.3)
+    : prediction === 'Deepfake' 
+      ? alpha(theme.palette.error.light, 0.3)
+      : theme.palette.grey[100],
+  borderLeft: `8px solid ${
+    prediction === 'Real' 
+      ? theme.palette.success.main 
+      : prediction === 'Deepfake' 
+        ? theme.palette.error.main 
+        : theme.palette.grey[300]
+  }`,
+  backdropFilter: 'blur(10px)',
+  transition: 'all 0.3s ease',
+}));
+
+const GradientHeader = styled(Box)(({ theme }) => ({
+  background: `linear-gradient(135deg, ${theme.palette.primary.dark} 0%, ${theme.palette.primary.main} 100%)`,
+  color: '#ffffff',
+  padding: theme.spacing(6, 2, 8),
+  borderRadius: '0 0 24px 24px',
+  marginBottom: -theme.spacing(6),
+}));
+
+const GlassCard = styled(Card)(({ theme }) => ({
+  backgroundColor: alpha(theme.palette.background.paper, 0.8),
+  backdropFilter: 'blur(10px)',
+  border: `1px solid ${alpha('#fff', 0.2)}`,
+}));
+
+const RecordButton = styled(Button)(({ theme, isrecording }) => ({
+  borderRadius: '50%',
+  minWidth: '64px',
+  width: '64px',
+  height: '64px',
+  padding: 0,
+  boxShadow: isrecording === 'true' 
+    ? `0 0 0 4px ${alpha(theme.palette.error.main, 0.3)}, 0 0 0 8px ${alpha(theme.palette.error.main, 0.15)}`
+    : `0 0 0 4px ${alpha(theme.palette.primary.main, 0.3)}, 0 0 0 8px ${alpha(theme.palette.primary.main, 0.15)}`,
+  animation: isrecording === 'true' ? 'pulse 1.5s infinite' : 'none',
+  '@keyframes pulse': {
+    '0%': {
+      boxShadow: `0 0 0 0 ${alpha(theme.palette.error.main, 0.7)}`
+    },
+    '70%': {
+      boxShadow: `0 0 0 15px ${alpha(theme.palette.error.main, 0)}`
+    },
+    '100%': {
+      boxShadow: `0 0 0 0 ${alpha(theme.palette.error.main, 0)}`
+    }
+  }
+}));
+
+const AudioWaveAnimation = styled(Box)(({ theme, isplaying }) => ({
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'center',
+  gap: '3px',
+  height: '40px',
+  opacity: isplaying === 'true' ? 1 : 0.3,
+  transition: 'opacity 0.3s ease',
+  '& .bar': {
+    width: '3px',
+    backgroundColor: theme.palette.primary.main,
+    borderRadius: '3px',
+    animation: isplaying === 'true' ? 'soundwave 1s infinite' : 'none',
+  },
+  '@keyframes soundwave': {
+    '0%': { height: '10%' },
+    '50%': { height: '100%' },
+    '100%': { height: '10%' }
+  }
+}));
+
+function App() {
+  const [file, setFile] = useState(null);
+  const [audioUrl, setAudioUrl] = useState(null);
+  const [isRecording, setIsRecording] = useState(false);
+  const [isPlaying, setIsPlaying] = useState(false);
+  const [recorder, setRecorder] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const [modelInfo, setModelInfo] = useState(null);
+  const [openSnackbar, setOpenSnackbar] = useState(false);
+  
+  const isMobile = useMediaQuery(theme.breakpoints.down('sm'));
+
+  // Create audio wave bars for animation
+  const audioBars = Array.from({ length: 10 }, (_, i) => {
+    const randomHeight = Math.floor(Math.random() * 100) + 1;
+    const randomDelay = Math.random();
+    return (
+      <Box 
+        key={i} 
+        className="bar" 
+        sx={{ 
+          height: `${randomHeight}%`,
+          animationDelay: `${randomDelay}s` 
+        }} 
+      />
+    );
+  });
+
+  // Audio player logic
+  const audioRef = React.useRef(null);
+  
+  const handlePlayPause = () => {
+    if (audioRef.current) {
+      if (isPlaying) {
+        audioRef.current.pause();
+      } else {
+        audioRef.current.play();
+      }
+      setIsPlaying(!isPlaying);
+    }
+  };
+
+  // Fetch model info on component mount
+  useEffect(() => {
+    fetch(`${API_URL}/model-info/`)
+      .then(response => response.json())
+      .then(data => setModelInfo(data))
+      .catch(err => console.error("Error fetching model info:", err));
+  }, []);
+
+  // Handle audio events
+  useEffect(() => {
+    const audioElement = audioRef.current;
+    if (audioElement) {
+      const handleEnded = () => setIsPlaying(false);
+      audioElement.addEventListener('ended', handleEnded);
+      return () => {
+        audioElement.removeEventListener('ended', handleEnded);
+      };
+    }
+  }, [audioUrl]);
+
+  // Handle file selection
+  const handleFileChange = (event) => {
+    const selectedFile = event.target.files[0];
+    if (selectedFile) {
+      setFile(selectedFile);
+      setAudioUrl(URL.createObjectURL(selectedFile));
+      setIsPlaying(false);
+      setResult(null); // Clear previous results
+    }
+  };
+
+  // Start audio recording
+  const startRecording = async () => {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const mediaRecorder = new MediaRecorder(stream);
+      const audioChunks = [];
+
+      mediaRecorder.addEventListener("dataavailable", event => {
+        audioChunks.push(event.data);
+      });
+
+      mediaRecorder.addEventListener("stop", () => {
+        const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
+        const audioFile = new File([audioBlob], "recorded-audio.wav", { type: 'audio/wav' });
+        setFile(audioFile);
+        setAudioUrl(URL.createObjectURL(audioBlob));
+        setIsPlaying(false);
+        setResult(null); // Clear previous results
+      });
+
+      mediaRecorder.start();
+      setIsRecording(true);
+      setRecorder(mediaRecorder);
+    } catch (err) {
+      setError("Could not access microphone. Please check permissions.");
+      setOpenSnackbar(true);
+      console.error("Error accessing microphone:", err);
+    }
+  };
+
+  // Stop audio recording
+  const stopRecording = () => {
+    if (recorder && recorder.state !== "inactive") {
+      recorder.stop();
+      setIsRecording(false);
+    }
+  };
+
+  // Submit audio for analysis
+  const handleSubmit = async () => {
+    if (!file) {
+      setError("Please upload or record an audio file first.");
+      setOpenSnackbar(true);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    const formData = new FormData();
+    formData.append('file', file);
+
+    try {
+      const response = await fetch(`${API_URL}/detect/`, {
+        method: 'POST',
+        body: formData,
+      });
+
+      if (!response.ok) {
+        throw new Error(`Server responded with status: ${response.status}`);
+      }
+
+      const data = await response.json();
+      setResult(data);
+    } catch (err) {
+      setError(`Error analyzing audio: ${err.message}`);
+      setOpenSnackbar(true);
+      console.error("Error analyzing audio:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Reset everything
+  const handleReset = () => {
+    setFile(null);
+    setAudioUrl(null);
+    setResult(null);
+    setError(null);
+    setIsPlaying(false);
+  };
+
+  // Format chart data
+  const getChartData = () => {
+    if (!result || !result.probabilities) return [];
+    
+    return Object.entries(result.probabilities).map(([name, value]) => ({
+      name,
+      value: parseFloat((value * 100).toFixed(2))
+    }));
+  };
+
+  // Handle snackbar close
+  const handleCloseSnackbar = (event, reason) => {
+    if (reason === 'clickaway') {
+      return;
+    }
+    setOpenSnackbar(false);
+  };
+
+  // Animation variants
+  const fadeIn = {
+    hidden: { opacity: 0, y: 20 },
+    visible: { opacity: 1, y: 0, transition: { duration: 0.6 } }
+  };
+
+  return (
+    <ThemeProvider theme={theme}>
+      <Box sx={{ 
+        backgroundColor: 'background.default', 
+        minHeight: '100vh',
+        paddingBottom: 4
+      }}>
+        <GradientHeader>
+          <Container maxWidth="md">
+            <motion.div
+              initial={{ opacity: 0, y: -20 }}
+              animate={{ opacity: 1, y: 0 }}
+              transition={{ duration: 0.7 }}
+            >
+              <Box sx={{ textAlign: 'center', position: 'relative' }}>
+                <Typography variant="h3" component="h1" gutterBottom>
+                  Deepfake Voice Detector
+                </Typography>
+                
+                <Typography variant="subtitle1" sx={{ maxWidth: '700px', mx: 'auto', opacity: 0.9 }}>
+                  Upload or record audio to instantly verify if it's authentic or AI-generated
+                </Typography>
+              </Box>
+            </motion.div>
+          </Container>
+        </GradientHeader>
+        
+        <Container maxWidth="md">
+          <Box sx={{ mt: 2, mb: 2 }}>
+            {modelInfo && (
+              <motion.div
+                initial={{ opacity: 0 }}
+                animate={{ opacity: 1 }}
+                transition={{ delay: 0.3, duration: 0.5 }}
+              >
+                <Box sx={{ 
+                  display: 'flex', 
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  gap: 1
+                }}>
+                  <SecurityIcon fontSize="small" sx={{ color: 'text.secondary' }} />
+                  <Typography variant="body2" color="text.secondary">
+                    Using model: {modelInfo.model_id} | Accuracy: {(modelInfo.performance.accuracy * 100).toFixed(2)}%
+                  </Typography>
+                </Box>
+              </motion.div>
+            )}
+          </Box>
+
+          <motion.div
+            variants={fadeIn}
+            initial="hidden"
+            animate="visible"
+          >
+            <GlassCard elevation={0} sx={{ mb: 4, overflow: 'visible' }}>
+              <CardContent sx={{ p: { xs: 2, sm: 3 } }}>
+                <Grid container spacing={3}>
+                  <Grid item xs={12} md={6}>
+                    <StyledCard variant="outlined">
+                      <CardContent sx={{ 
+                        display: 'flex', 
+                        flexDirection: 'column', 
+                        alignItems: 'center', 
+                        height: '100%',
+                        p: { xs: 2, sm: 3 }
+                      }}>
+                        <Typography variant="h6" component="div" gutterBottom sx={{ mb: 3 }}>
+                          Upload Audio
+                        </Typography>
+                        
+                        <Button
+                          component="label"
+                          variant="contained"
+                          startIcon={<UploadFileIcon />}
+                          sx={{ 
+                            width: '100%',
+                            py: 1.5,
+                            mb: 3,
+                            backgroundColor: theme.palette.primary.light,
+                            '&:hover': {
+                              backgroundColor: theme.palette.primary.main,
+                            }
+                          }}
+                        >
+                          Choose Audio File
+                          <VisuallyHiddenInput type="file" accept="audio/*" onChange={handleFileChange} />
+                        </Button>
+                        
+                        <Typography variant="body2" color="text.secondary" gutterBottom>
+                          Or record audio directly
+                        </Typography>
+                        
+                        <Box sx={{ 
+                          display: 'flex', 
+                          flexDirection: 'column',
+                          alignItems: 'center', 
+                          mt: 2 
+                        }}>
+                          {!isRecording ? (
+                            <RecordButton
+                              variant="contained"
+                              color="primary"
+                              onClick={startRecording}
+                              isrecording="false"
+                            >
+                              <MicIcon />
+                            </RecordButton>
+                          ) : (
+                            <RecordButton
+                              variant="contained"
+                              color="error"
+                              onClick={stopRecording}
+                              isrecording="true"
+                            >
+                              <StopIcon />
+                            </RecordButton>
+                          )}
+                          <Typography variant="body2" sx={{ mt: 1, color: isRecording ? 'error.main' : 'text.secondary' }}>
+                            {isRecording ? 'Recording...' : 'Tap to record'}
+                          </Typography>
+                        </Box>
+                      </CardContent>
+                    </StyledCard>
+                  </Grid>
+                  
+                  <Grid item xs={12} md={6}>
+                    <StyledCard variant="outlined">
+                      <CardContent sx={{ 
+                        display: 'flex', 
+                        flexDirection: 'column',
+                        justifyContent: audioUrl ? 'space-between' : 'center',
+                        height: '100%',
+                        p: { xs: 2, sm: 3 } 
+                      }}>
+                        {audioUrl ? (
+                          <>
+                            <Box sx={{ textAlign: 'center' }}>
+                              <Typography variant="h6" component="div" gutterBottom>
+                                <AudiotrackIcon sx={{ verticalAlign: 'middle', mr: 1 }} />
+                                Audio Preview
+                              </Typography>
+                            </Box>
+                            
+                            <Box sx={{ 
+                              my: 2, 
+                              display: 'flex',
+                              flexDirection: 'column',
+                              alignItems: 'center'
+                            }}>
+                              <audio 
+                                ref={audioRef}
+                                src={audioUrl} 
+                                style={{ display: 'none' }}
+                                onPlay={() => setIsPlaying(true)}
+                                onPause={() => setIsPlaying(false)}
+                              />
+                              
+                              <AudioWaveAnimation isplaying={isPlaying ? 'true' : 'false'}>
+                                {audioBars}
+                              </AudioWaveAnimation>
+                              
+                              <Box sx={{ mt: 2 }}>
+                                <IconButton 
+                                  color="primary" 
+                                  onClick={handlePlayPause}
+                                  size="large"
+                                  sx={{ 
+                                    backgroundColor: alpha(theme.palette.primary.main, 0.1),
+                                    '&:hover': {
+                                      backgroundColor: alpha(theme.palette.primary.main, 0.2),
+                                    }
+                                  }}
+                                >
+                                  <VolumeUpIcon />
+                                </IconButton>
+                              </Box>
+                              
+                              <Typography variant="body2" color="text.secondary" sx={{ mt: 1 }}>
+                                {file ? file.name : "Audio loaded"}
+                              </Typography>
+                            </Box>
+                          </>
+                        ) : (
+                          <Box sx={{ 
+                            p: 3, 
+                            textAlign: 'center',
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                            height: '100%'
+                          }}>
+                            <CloudUploadIcon sx={{ 
+                              fontSize: 60, 
+                              color: alpha(theme.palette.text.secondary, 0.5),
+                              mb: 2
+                            }} />
+                            <Typography variant="body1" color="text.secondary">
+                              No audio selected
+                            </Typography>
+                            <Typography variant="body2" color="text.secondary" sx={{ mt: 1, opacity: 0.7 }}>
+                              Upload or record to analyze
+                            </Typography>
+                          </Box>
+                        )}
+                      </CardContent>
+                    </StyledCard>
+                  </Grid>
+                </Grid>
+              </CardContent>
+              
+              <Box sx={{ 
+                px: { xs: 2, sm: 3 }, 
+                pb: { xs: 2, sm: 3 },
+                textAlign: 'center' 
+              }}>
+                <motion.div
+                  whileHover={{ scale: 1.03 }}
+                  whileTap={{ scale: 0.97 }}
+                >
+                  <Button
+                    variant="contained"
+                    color="primary"
+                    size="large"
+                    disabled={!file || isLoading}
+                    onClick={handleSubmit}
+                    sx={{ 
+                      px: 4, 
+                      py: 1.2,
+                      fontSize: '1.1rem',
+                      fontWeight: 600,
+                      mx: 1,
+                      minWidth: { xs: '120px', sm: '160px' }
+                    }}
+                  >
+                    {isLoading ? <CircularProgress size={24} sx={{ mr: 1 }} /> : "Analyze Audio"}
+                  </Button>
+                </motion.div>
+                
+                <Button
+                  variant="outlined"
+                  color="secondary"
+                  size="large"
+                  onClick={handleReset}
+                  sx={{ 
+                    mx: 1, 
+                    mt: { xs: 1, sm: 0 },
+                    minWidth: { xs: '120px', sm: '120px' }
+                  }}
+                  disabled={isLoading || (!file && !audioUrl)}
+                >
+                  Reset
+                </Button>
+              </Box>
+            </GlassCard>
+          </motion.div>
+          
+          {isLoading && (
+            <motion.div
+              initial={{ opacity: 0 }}
+              animate={{ opacity: 1 }}
+              transition={{ duration: 0.3 }}
+            >
+              <Box sx={{ width: '100%', my: 4 }}>
+                <Typography variant="body2" color="text.secondary" gutterBottom align="center">
+                  Analyzing audio...
+                </Typography>
+                <LinearProgress 
+                  sx={{ 
+                    height: 8, 
+                    borderRadius: 4,
+                    backgroundColor: alpha(theme.palette.primary.main, 0.15)
+                  }} 
+                />
+              </Box>
+            </motion.div>
+          )}
+          
+          {result && (
+            <motion.div
+              initial={{ opacity: 0, y: 30 }}
+              animate={{ opacity: 1, y: 0 }}
+              transition={{ duration: 0.5 }}
+            >
+              <Box sx={{ my: 4 }}>
+                <ResultCard 
+                  elevation={2} 
+                  prediction={result.prediction} 
+                  sx={{ mb: 3 }}
+                >
+                  <CardContent sx={{ p: { xs: 2, sm: 3 } }}>
+                    <Box sx={{ 
+                      display: 'flex', 
+                      flexDirection: { xs: 'column', sm: 'row' },
+                      alignItems: { xs: 'flex-start', sm: 'center' },
+                      justifyContent: 'space-between'
+                    }}>
+                      <Box>
+                        <Typography 
+                          variant="h5" 
+                          component="div" 
+                          gutterBottom 
+                          sx={{ 
+                            fontWeight: 700,
+                            color: result.prediction === 'Real' 
+                              ? 'success.dark' 
+                              : 'error.dark'
+                          }}
+                        >
+                          {result.prediction === 'Real' ? '✓ Authentic Voice' : '⚠ Deepfake Detected'}
+                        </Typography>
+                        <Typography variant="body1" sx={{ fontWeight: 500 }}>
+                          Confidence: {(result.confidence * 100).toFixed(2)}%
+                        </Typography>
+                      </Box>
+                      
+                      <Box 
+                        sx={{ 
+                          mt: { xs: 2, sm: 0 },
+                          display: 'flex',
+                          alignItems: 'center',
+                          px: 2,
+                          py: 1,
+                          backgroundColor: alpha(
+                            result.prediction === 'Real' 
+                              ? theme.palette.success.main 
+                              : theme.palette.error.main,
+                            0.1
+                          ),
+                          borderRadius: 2
+                        }}
+                      >
+                        <Typography variant="body2" sx={{ fontWeight: 600, color: result.prediction === 'Real' ? 'success.dark' : 'error.dark' }}>
+                          {result.prediction === 'Real' ? 'Human Voice' : 'AI-Generated'}
+                        </Typography>
+                      </Box>
+                    </Box>
+                  </CardContent>
+                </ResultCard>
+                
+                <GlassCard elevation={2} sx={{ p: { xs: 2, sm: 3 } }}>
+                  <Typography variant="h6" gutterBottom sx={{ fontWeight: 600 }}>
+                    Probability Distribution
+                  </Typography>
+                  <Box sx={{ height: isMobile ? 250 : 300, width: '100%', mt: 2 }}>
+                    <ResponsiveContainer width="100%" height="100%">
+                      <BarChart
+                        data={getChartData()}
+                        margin={{
+                          top: 30,
+                          right: 30,
+                          left: 20,
+                          bottom: 10,
+                        }}
+                      >
+                        <CartesianGrid strokeDasharray="3 3" stroke={alpha('#000', 0.1)} />
+                        <XAxis 
+                          dataKey="name" 
+                          tick={{ fill: theme.palette.text.secondary }}
+                          axisLine={{ stroke: alpha('#000', 0.15) }}
+                        />
+                        <YAxis 
+                          label={{ 
+                            value: 'Probability (%)', 
+                            angle: -90, 
+                            position: 'insideLeft',
+                            style: { fill: theme.palette.text.secondary } 
+                          }}
+                          tick={{ fill: theme.palette.text.secondary }}
+                          axisLine={{ stroke: alpha('#000', 0.15) }}
+                        />
+                        <Tooltip 
+                          formatter={(value) => [`${value}%`, 'Probability']} 
+                          contentStyle={{ 
+                            borderRadius: 8, 
+                            border: 'none', 
+                            boxShadow: '0 4px 20px rgba(0,0,0,0.1)',
+                            backgroundColor: alpha('#fff', 0.95) 
+                          }}
+                        />
+                        <Bar 
+                          dataKey="value" 
+                          fill={(entry) => entry.name === 'Real' ? theme.palette.success.main : theme.palette.error.main}
+                          radius={[8, 8, 0, 0]}
+                          label={{ 
+                            position: 'top', 
+                            formatter: (value) => `${value}%`,
+                            fill: theme.palette.text.secondary,
+                            fontSize: 12,
+                            fontWeight: 600
+                          }}
+                        />
+                      </BarChart>
+                    </ResponsiveContainer>
+                  </Box>
+                </GlassCard>
+                
+                <Box sx={{ mt: 3, textAlign: 'center' }}>
+                  <Typography variant="body2" color="text.secondary">
+                    Note: This model claims {modelInfo ? (modelInfo.performance.accuracy * 100).toFixed(2) : ''}% accuracy, but results may vary depending on audio quality.
+                  </Typography>
+                </Box>
+              </Box>
+            </motion.div>
+          )}
+        </Container>
+      </Box>
+      
+      <Snackbar
+        open={openSnackbar}
+        autoHideDuration={6000}
+        onClose={handleCloseSnackbar}
+        anchorOrigin={{ vertical: 'bottom', horizontal: 'center' }}
+      >
+        <Alert 
+          onClose={handleCloseSnackbar} 
+          severity="error" 
+          sx={{ 
+            width: '100%',
+            borderRadius: 2,
+            boxShadow: '0 4px 20px rgba(0,0,0,0.15)'
+          }}
+        >
+          {error}
+        </Alert>
+      </Snackbar>
+    </ThemeProvider>
+  );
+}
+
+export default App;

Dockerfile

@@ -0,0 +1,25 @@
+FROM pytorch/pytorch:1.12.1-cuda11.3-cudnn8-runtime
+
+WORKDIR /app
+
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir fastapi uvicorn python-multipart
+
+ENV TRANSFORMERS_CACHE=/app/model_cache
+ENV HF_HOME=/app/model_cache
+
+COPY app.py api.py ./
+
+RUN mkdir -p /app/model_cache
+
+CMD ["python", "api.py"]
+
+EXPOSE 8000

api.py

@@ -0,0 +1,114 @@
+import os
+import tempfile
+import uvicorn
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import shutil
+from pydantic import BaseModel
+from typing import Optional, Dict, Any, List
+
+# Import our detection module
+from app import DeepfakeDetector, convert_audio
+
+# Initialize the FastAPI app
+app = FastAPI(
+    title="Deepfake Voice Detection API",
+    description="API for detecting deepfake audio using the MelodyMachine/Deepfake-audio-detection-V2 model",
+    version="0.1.0",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Initialize the detector at startup
+detector = None
+
+@app.on_event("startup")
+async def startup_event():
+    global detector
+    detector = DeepfakeDetector()
+    print("Deepfake Detector model loaded and ready to use")
+
+class PredictionResponse(BaseModel):
+    prediction: str
+    confidence: float
+    probabilities: Dict[str, float]
+
+@app.post("/detect/", response_model=PredictionResponse)
+async def detect_audio(file: UploadFile = File(...)):
+    """
+    Detect if an audio file contains a deepfake voice
+    """
+    if not file:
+        raise HTTPException(status_code=400, detail="No file provided")
+    
+    # Validate file type
+    if not file.filename.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
+        raise HTTPException(
+            status_code=400, 
+            detail="Invalid file format. Only WAV, MP3, OGG, and FLAC files are supported."
+        )
+    
+    try:
+        # Create a temporary file
+        temp_dir = tempfile.gettempdir()
+        temp_path = os.path.join(temp_dir, file.filename)
+        
+        # Save uploaded file to the temp location
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        # Convert audio to required format
+        processed_audio = convert_audio(temp_path)
+        
+        # Detect if it's a deepfake
+        result = detector.detect(processed_audio)
+        
+        # Clean up the temporary files
+        try:
+            os.remove(temp_path)
+            os.remove(processed_audio) if processed_audio != temp_path else None
+        except:
+            pass
+        
+        return result
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing audio: {str(e)}")
+
+@app.get("/health/")
+async def health_check():
+    """
+    Check if the API is running and the model is loaded
+    """
+    if detector is None:
+        return JSONResponse(
+            status_code=503,
+            content={"status": "error", "message": "Model not loaded"}
+        )
+    return {"status": "ok", "model_loaded": True}
+
+@app.get("/model-info/")
+async def model_info():
+    """
+    Get information about the model being used
+    """
+    return {
+        "model_id": "MelodyMachine/Deepfake-audio-detection-V2",
+        "base_model": "facebook/wav2vec2-base",
+        "performance": {
+            "loss": 0.0141,
+            "accuracy": 0.9973
+        },
+        "description": "Fine-tuned model for binary classification distinguishing between real and deepfake audio"
+    }
+
+if __name__ == "__main__":
+    uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=True)

app.py

@@ -0,0 +1,226 @@
+import os
+import torch
+import gradio as gr
+import numpy as np
+import librosa
+import soundfile as sf
+from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2ForSequenceClassification
+from pydub import AudioSegment
+import tempfile
+import matplotlib
+matplotlib.use('Agg')
+
+# Constants
+MODEL_ID = "MelodyMachine/Deepfake-audio-detection-V2"
+SAMPLE_RATE = 16000
+MAX_DURATION = 30  # maximum audio duration in seconds
+
+class DeepfakeDetector:
+    def __init__(self, model_id=MODEL_ID):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Using device: {self.device}")
+        
+        print(f"Loading model from {model_id}...")
+        self.feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(model_id)
+        self.model = Wav2Vec2ForSequenceClassification.from_pretrained(model_id).to(self.device)
+        print("Model loaded successfully!")
+        
+        # Labels for classification
+        self.id2label = {0: "Real", 1: "Deepfake"}
+        
+    def preprocess_audio(self, audio_path):
+        """Process audio file to match model requirements."""
+        try:
+            # Load audio file
+            y, sr = librosa.load(audio_path, sr=SAMPLE_RATE, mono=True)
+            
+            # Trim silence from the beginning and end
+            y, _ = librosa.effects.trim(y, top_db=20)
+            
+            # If audio is longer than MAX_DURATION seconds, take the first MAX_DURATION seconds
+            if len(y) > MAX_DURATION * SAMPLE_RATE:
+                y = y[:MAX_DURATION * SAMPLE_RATE]
+                
+            return y
+        except Exception as e:
+            raise ValueError(f"Error preprocessing audio: {str(e)}")
+    
+    def detect(self, audio_path):
+        """Detect if audio is real or deepfake."""
+        try:
+            # Preprocess audio
+            audio_array = self.preprocess_audio(audio_path)
+            
+            # Extract features
+            inputs = self.feature_extractor(
+                audio_array, 
+                sampling_rate=SAMPLE_RATE, 
+                return_tensors="pt",
+                padding=True
+            ).to(self.device)
+            
+            # Get prediction
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+                predictions = torch.softmax(logits, dim=1)
+                
+            # Get results
+            predicted_class = torch.argmax(predictions, dim=1).item()
+            confidence = predictions[0][predicted_class].item()
+            
+            result = {
+                "prediction": self.id2label[predicted_class],
+                "confidence": float(confidence),
+                "probabilities": {
+                    "Real": float(predictions[0][0].item()),
+                    "Deepfake": float(predictions[0][1].item())
+                }
+            }
+            
+            return result
+        except Exception as e:
+            raise ValueError(f"Error during detection: {str(e)}")
+
+def convert_audio(input_file):
+    """Convert the audio file to the required format."""
+    # Create temp file with .wav extension
+    temp_dir = tempfile.gettempdir()
+    temp_path = os.path.join(temp_dir, "temp_audio_file.wav")
+    
+    # Handle various input formats
+    if input_file.endswith('.mp3'):
+        audio = AudioSegment.from_mp3(input_file)
+        audio = audio.set_channels(1)  # Convert to mono
+        audio = audio.set_frame_rate(SAMPLE_RATE)  # Set sample rate
+        audio.export(temp_path, format="wav")
+    elif input_file.endswith('.wav'):
+        audio = AudioSegment.from_wav(input_file)
+        audio = audio.set_channels(1)  # Convert to mono
+        audio = audio.set_frame_rate(SAMPLE_RATE)  # Set sample rate
+        audio.export(temp_path, format="wav")
+    elif input_file.endswith('.ogg'):
+        audio = AudioSegment.from_ogg(input_file)
+        audio = audio.set_channels(1)  # Convert to mono
+        audio = audio.set_frame_rate(SAMPLE_RATE)  # Set sample rate
+        audio.export(temp_path, format="wav")
+    elif input_file.endswith('.flac'):
+        audio = AudioSegment.from_file(input_file, format="flac")
+        audio = audio.set_channels(1)  # Convert to mono
+        audio = audio.set_frame_rate(SAMPLE_RATE)  # Set sample rate
+        audio.export(temp_path, format="wav")
+    else:
+        # Try to convert using pydub's generic from_file
+        try:
+            audio = AudioSegment.from_file(input_file)
+            audio = audio.set_channels(1)  # Convert to mono
+            audio = audio.set_frame_rate(SAMPLE_RATE)  # Set sample rate
+            audio.export(temp_path, format="wav")
+        except:
+            raise ValueError(f"Unsupported audio format for file: {input_file}")
+    
+    return temp_path
+
+def detect_deepfake(audio_file, detector):
+    """Process audio and detect if it's a deepfake."""
+    if audio_file is None:
+        return {
+            "error": "Please upload an audio file."
+        }
+    
+    try:
+        # Convert audio to required format
+        processed_audio = convert_audio(audio_file)
+        
+        # Detect deepfake
+        result = detector.detect(processed_audio)
+        
+        # Create a visually appealing output
+        prediction = result["prediction"]
+        confidence = result["confidence"] * 100
+        
+        # Prepare visualization data
+        labels = list(result["probabilities"].keys())
+        values = list(result["probabilities"].values())
+        
+        output = {
+            "prediction": prediction,
+            "confidence": f"{confidence:.2f}%",
+            "chart_labels": labels,
+            "chart_values": values
+        }
+        
+        # Create result text with confidence
+        result_text = f"Prediction: {prediction} (Confidence: {confidence:.2f}%)"
+        
+        return result_text, output
+    except Exception as e:
+        return f"Error: {str(e)}", None
+    
+def create_interface():
+    """Create Gradio interface for the application."""
+    # Initialize the deepfake detector
+    detector = DeepfakeDetector()
+    
+    with gr.Blocks(title="Deepfake Voice Detector") as interface:
+        gr.Markdown("""
+        # Deepfake Voice Detector
+        
+        Upload an audio file to check if it's a real human voice or an AI-generated deepfake.
+        
+        **Model:** MelodyMachine/Deepfake-audio-detection-V2 (Accuracy: 99.73%)
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                audio_input = gr.Audio(
+                    type="filepath", 
+                    label="Upload Audio File",
+                    sources=["upload", "microphone"]
+                )
+                submit_btn = gr.Button("Analyze Audio", variant="primary")
+            
+            with gr.Column(scale=1):
+                result_text = gr.Textbox(label="Result")
+                
+                # Visualization component
+                with gr.Accordion("Detailed Analysis", open=False):
+                    gr.Markdown("### Confidence Scores")
+                    confidence_plot = gr.Plot(label="Confidence Scores")
+        
+        # Process function for the submit button
+        def process_and_visualize(audio_file):
+            result_text, output = detect_deepfake(audio_file, detector)
+            
+            if output:
+                # Create bar chart visualization
+                import matplotlib.pyplot as plt
+                
+                fig, ax = plt.subplots(figsize=(6, 4))
+                bars = ax.bar(output["chart_labels"], output["chart_values"], color=['green', 'red'])
+                
+                # Add percentage labels on top of each bar
+                for bar in bars:
+                    height = bar.get_height()
+                    ax.text(bar.get_x() + bar.get_width()/2., height + 0.02,
+                            f'{height*100:.1f}%', ha='center', va='bottom')
+                
+                ax.set_ylim(0, 1.1)
+                ax.set_title('Confidence Scores')
+                ax.set_ylabel('Probability')
+                
+                return result_text, fig
+            else:
+                return result_text, None
+        
+        submit_btn.click(
+            process_and_visualize,
+            inputs=[audio_input],
+            outputs=[result_text, confidence_plot]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()

batch_processor.py

@@ -0,0 +1,106 @@
+import os
+import argparse
+import json
+import pandas as pd
+from tqdm import tqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from app import DeepfakeDetector, convert_audio
+
+def process_single_file(file_path, detector):
+    """Process a single audio file and return the detection result."""
+    try:
+        # Convert audio to the required format
+        processed_audio = convert_audio(file_path)
+        
+        # Detect if it's a deepfake
+        result = detector.detect(processed_audio)
+        
+        # Add the file path to the result
+        result["file_path"] = file_path
+        result["file_name"] = os.path.basename(file_path)
+        
+        # Clean up temporary files if needed
+        if processed_audio != file_path:
+            try:
+                os.remove(processed_audio)
+            except:
+                pass
+        
+        return result
+    except Exception as e:
+        return {
+            "file_path": file_path,
+            "file_name": os.path.basename(file_path),
+            "error": str(e)
+        }
+
+def process_directory(directory_path, output_format='json', max_workers=None, recursive=False):
+    """Process all audio files in a directory."""
+    # Initialize the detector
+    detector = DeepfakeDetector()
+    
+    # Find all audio files
+    audio_extensions = ('.wav', '.mp3', '.ogg', '.flac')
+    audio_files = []
+    
+    if recursive:
+        for root, _, files in os.walk(directory_path):
+            for file in files:
+                if file.lower().endswith(audio_extensions):
+                    audio_files.append(os.path.join(root, file))
+    else:
+        audio_files = [os.path.join(directory_path, f) for f in os.listdir(directory_path) 
+                      if f.lower().endswith(audio_extensions)]
+    
+    if not audio_files:
+        print(f"No audio files found in {directory_path}")
+        return
+    
+    print(f"Found {len(audio_files)} audio files to process")
+    
+    # Process files with a progress bar
+    results = []
+    
+    # Use parallel processing for faster analysis
+    with ProcessPoolExecutor(max_workers=max_workers) as executor:
+        futures = {executor.submit(process_single_file, file, detector): file for file in audio_files}
+        
+        for future in tqdm(as_completed(futures), total=len(audio_files), desc="Processing audio files"):
+            result = future.result()
+            results.append(result)
+    
+    # Save results based on output format
+    if output_format == 'json':
+        output_file = os.path.join(directory_path, "deepfake_detection_results.json")
+        with open(output_file, 'w') as f:
+            json.dump(results, f, indent=2)
+        print(f"Results saved to {output_file}")
+    
+    elif output_format == 'csv':
+        output_file = os.path.join(directory_path, "deepfake_detection_results.csv")
+        df = pd.DataFrame(results)
+        df.to_csv(output_file, index=False)
+        print(f"Results saved to {output_file}")
+    
+    # Print summary
+    total = len(results)
+    real_count = sum(1 for r in results if 'prediction' in r and r['prediction'] == 'Real')
+    fake_count = sum(1 for r in results if 'prediction' in r and r['prediction'] == 'Deepfake')
+    error_count = sum(1 for r in results if 'error' in r)
+    
+    print("\nSummary:")
+    print(f"Total files processed: {total}")
+    print(f"Detected as real: {real_count} ({real_count/total*100:.1f}%)")
+    print(f"Detected as deepfake: {fake_count} ({fake_count/total*100:.1f}%)")
+    print(f"Errors during processing: {error_count} ({error_count/total*100:.1f}%)")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Batch process audio files for deepfake detection')
+    parser.add_argument('directory', help='Directory containing audio files to process')
+    parser.add_argument('--format', choices=['json', 'csv'], default='json', help='Output format (default: json)')
+    parser.add_argument('--workers', type=int, default=None, help='Number of worker processes (default: CPU count)')
+    parser.add_argument('--recursive', action='store_true', help='Search for audio files recursively in subdirectories')
+    
+    args = parser.parse_args()
+    
+    process_directory(args.directory, args.format, args.workers, args.recursive)

docker-compose.yml

@@ -0,0 +1,30 @@
+version: '3'
+
+services:
+  api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    command: python api.py
+    environment:
+      - MODEL_ID=MelodyMachine/Deepfake-audio-detection-V2
+    volumes:
+      - ./model_cache:/app/model_cache
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+
+  web:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    ports:
+      - "80:80"
+    depends_on:
+      - api

requirements.txt

@@ -0,0 +1,11 @@
+torch>=1.10.0
+transformers>=4.16.0
+librosa>=0.8.0
+soundfile>=0.10.3
+gradio>=3.0.0
+matplotlib>=3.4.0
+numpy>=1.20.0
+pydub>=0.25.1
+fastapi>=0.68.0
+uvicorn>=0.15.0
+python-multipart

setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="deepfake_voice_detector",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "torch>=1.10.0",
+        "transformers>=4.16.0",
+        "librosa>=0.8.0",
+        "soundfile>=0.10.3",
+        "gradio>=3.0.0",
+        "matplotlib>=3.4.0",
+        "numpy>=1.20.0",
+        "pydub>=0.25.1",
+    ],
+    author="DeepfakeDetector",
+    author_email="info@deepfakedetector.app",
+    description="An application for detecting deepfake audio using the MelodyMachine/Deepfake-audio-detection-V2 model",
+    keywords="deepfake, audio, detection, ai",
+    python_requires=">=3.7",
+)