agafgfgdgs

.gitattributes

@@ -23,6 +23,7 @@
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
 *.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
@@ -32,4 +33,5 @@
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-*.keras filter=lfs diff=lfs merge=lfs -text
+best_model.keras filter=lfs diff=lfs merge=lfs -text
+bestModel.keras filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.venv/

handler.py

@@ -1,14 +1,15 @@
 import tensorflow as tf
 import numpy as np
 import os
-import librosa
+import io
 import tempfile
 import logging
 import time
 os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
 
-from tensorflow.keras.models import load_model
+from keras.models import load_model
+from keras.layers import Layer
 
 # Configure logging
 logging.basicConfig(
@@ -18,138 +19,116 @@ logging.basicConfig(
         logging.StreamHandler()
     ]
 )
-logger = logging.getLogger('speech_recognition_inference')
+logger = logging.getLogger('audio_inference')
 
-# Constants for audio preprocessing
-SAMPLE_RATE = 16000
-N_MELS = 128
-FFT_SIZE = 1024
-HOP_SIZE = 512
+class WavToMelLayer(Layer):
+    def __init__(self, sample_rate=16000, n_mels=128, fft_size=1024, hop_size=512, **kwargs):
+        super(WavToMelLayer, self).__init__(**kwargs)
+        self.sample_rate = sample_rate
+        self.n_mels = n_mels
+        self.fft_size = fft_size
+        self.hop_size = hop_size
+
+    def call(self, inputs):
+        def process_audio(input_path):
+            logger.debug(f"Processing audio file: {input_path}")
+            try:
+                audio = tf.io.read_file(input_path)
+                audio, sr = tf.audio.decode_wav(audio, desired_channels=1)
+                logger.debug(f"Decoded WAV file with sample rate: {sr}, shape: {audio.shape}")
+                audio = tf.squeeze(audio, axis=-1)
+
+                stft = tf.signal.stft(audio, frame_length=self.fft_size, frame_step=self.hop_size)
+                logger.debug(f"STFT shape: {stft.shape}")
+                spectrogram = tf.abs(stft) ** 2
+
+                mel_weights = tf.signal.linear_to_mel_weight_matrix(
+                    self.n_mels, self.fft_size // 2 + 1, self.sample_rate, 20.0, 4000.0
+                )
+                mel_spectrogram = tf.tensordot(spectrogram, mel_weights, axes=1)
+                mel_spectrogram = tf.math.log(mel_spectrogram + 1e-6)
+                logger.debug(f"Mel spectrogram shape: {mel_spectrogram.shape}")
+
+                mel_spectrogram = tf.image.resize(mel_spectrogram[..., tf.newaxis], [128, 128])
+                mel_spectrogram = tf.image.grayscale_to_rgb(mel_spectrogram)
+                logger.debug(f"Final mel spectrogram shape: {mel_spectrogram.shape}")
+
+                return mel_spectrogram
+            except Exception as e:
+                logger.error(f"Error in process_audio: {str(e)}")
+                raise
+
+        return tf.map_fn(process_audio, inputs, dtype=tf.float32)
+
+    def get_config(self):
+        config = super(WavToMelLayer, self).get_config()
+        config.update({
+            "sample_rate": self.sample_rate,
+            "n_mels": self.n_mels,
+            "fft_size": self.fft_size,
+            "hop_size": self.hop_size
+        })
+        return config
 
 class EndpointHandler:
     def __init__(self, model_dir):
-        logger.info("Initializing Speech Recognition EndpointHandler")
+        logger.info("Initializing EndpointHandler")
         if model_dir is None:
             model_dir = os.path.dirname(os.path.abspath(__file__))
             logger.info(f"Model directory not provided, using current directory: {model_dir}")
         else:
             logger.info(f"Using provided model directory: {model_dir}")
             
-        # Load the model
-        model_path = os.path.join(model_dir, "model/speechModelv2.keras")
+        model_path = os.path.join(model_dir, "model/bestModel.keras")
         logger.info(f"Loading model from: {model_path}")
         
         try:
-            self.model = load_model(model_path)
-            logger.info(f"Model loaded successfully")
-            logger.debug(f"Model summary: {self.model.summary()}")
+            self.model = load_model(model_path, custom_objects={"WavToMelLayer": WavToMelLayer})
+            logger.info(f"Model loaded successfully: {self.model.summary()}")
         except Exception as e:
             logger.error(f"Failed to load model: {str(e)}")
             raise
     
-    def preprocess_audio(self, file_path):
-        """
-        Process audio file to match the training preprocessing exactly
-        """
-        logger.debug(f"Processing audio file: {file_path}")
-        try:
-            # Load audio using librosa (same as training)
-            audio, sr = librosa.load(file_path, sr=SAMPLE_RATE)
-            
-            # Convert to Mel spectrogram (matching training parameters)
-            mel_spectrogram = librosa.feature.melspectrogram(
-                y=audio, 
-                sr=sr, 
-                n_mels=N_MELS, 
-                n_fft=FFT_SIZE, 
-                hop_length=HOP_SIZE
-            )
-            log_mel_spectrogram = librosa.power_to_db(mel_spectrogram, ref=np.max)
-            
-            # Ensure fixed size (128x128)
-            if log_mel_spectrogram.shape[1] < 128:
-                log_mel_spectrogram = np.pad(
-                    log_mel_spectrogram, 
-                    ((0, 0), (0, 128 - log_mel_spectrogram.shape[1])), 
-                    mode='constant'
-                )
-            else:
-                log_mel_spectrogram = log_mel_spectrogram[:, :128]
-            
-            # Expand dimensions for CNN input (128x128x1)
-            mel_spectrogram_processed = np.expand_dims(log_mel_spectrogram, axis=-1)
-            
-            # Convert to RGB by duplicating channels (128x128x3)
-            # Matching the model's expectation of RGB input
-            mel_spectrogram_rgb = np.repeat(mel_spectrogram_processed, 3, axis=2)
-            
-            logger.debug(f"Final mel spectrogram shape: {mel_spectrogram_rgb.shape}")
-            return mel_spectrogram_rgb
-            
-        except Exception as e:
-            logger.error(f"Error in preprocess_audio: {str(e)}")
-            raise
-    
     def __call__(self, requests):
         start_time = time.time()
-        logger.info("Processing speech recognition inference request")
+        logger.info("Processing inference request")
         temp_dir = None
         temp_wav_path = None
-        audio_data = requests.get('inputs', None)
-        
+        input_yeah = requests['inputs']
+
         try:
-            # Validate input
-            if not audio_data:
-                logger.error("No 'inputs' field found in the request")
-                return [{"error": "No audio data provided in 'inputs' field"}]
-            
-            if not isinstance(audio_data, bytes):
-                logger.error(f"Expected bytes, got {type(audio_data)}")
-                return [{"error": f"Invalid input type: {type(audio_data)}, expected bytes"}]
-            
-            # Create temporary file for the audio
             temp_dir = tempfile.mkdtemp()
             temp_wav_path = os.path.join(temp_dir, "wav_input.wav")
             logger.info(f"Created temporary directory: {temp_dir}")
             
-            # Write audio data to file
-            logger.debug(f"Writing {len(audio_data)} bytes to temporary file: {temp_wav_path}")
+            logger.info(requests)
+
+            if not isinstance(input_yeah, bytes):
+                logger.error(f"Expected bytes, got {type(input_yeah)}")
+                return [{"error": f"Invalid input type: {type(input_yeah)}, expected bytes"}]
+            
+            logger.debug(f"Writing {len(input_yeah)} bytes to temporary file: {temp_wav_path}")
             with open(temp_wav_path, "wb") as f:
-                f.write(audio_data)
+                f.write(input_yeah)
             
-            # Verify file was created
             if not os.path.exists(temp_wav_path):
                 logger.error(f"Failed to create temporary WAV file: {temp_wav_path}")
                 return [{"error": "Failed to create temporary WAV file"}]
             
-            # Preprocess audio
-            logger.info("Preprocessing audio")
-            try:
-                preprocessed_audio = self.preprocess_audio(temp_wav_path)
-                # Add batch dimension
-                preprocessed_input = np.expand_dims(preprocessed_audio, axis=0)
-            except Exception as e:
-                logger.error(f"Error during preprocessing: {str(e)}")
-                return [{"error": f"Preprocessing failed: {str(e)}"}]
-            
-            # Run prediction
+            logger.debug(f"File size: {os.path.getsize(temp_wav_path)} bytes")
+
+            inputs = tf.constant([temp_wav_path])
             logger.info("Running model prediction")
-            predictions = self.model.predict(preprocessed_input)
-            logger.debug(f"Raw predictions shape: {predictions.shape}")
             
-            # Process results
+            predictions = self.model.predict(inputs)
+            logger.debug(f"Raw predictions: {predictions}")
+            
             results = []
             for i, prediction in enumerate(predictions):
-                predicted_class_index = int(np.argmax(prediction))
+                predicted_class_index = np.argmax(prediction)
                 confidence = float(prediction[predicted_class_index])
-                
-                result = {
-                    "word": predicted_class_index,
-                    "confidence": confidence
-                }
-                
                 logger.info(f"Result {i}: class={predicted_class_index}, confidence={confidence:.4f}")
-                results.append(result)
+                results.append({"word": int(predicted_class_index), "confidence": confidence})
             
             elapsed_time = time.time() - start_time
             logger.info(f"Inference completed in {elapsed_time:.3f} seconds")
@@ -160,7 +139,6 @@ class EndpointHandler:
             return [{"error": str(e)}]
         
         finally:
-            # Clean up temporary files
             try:
                 if temp_wav_path and os.path.exists(temp_wav_path):
                     os.remove(temp_wav_path)

model/{speechModelv2.keras → bestModel.keras}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b6c61ea34bb78345728320652dc98ddecf0278bc8d330d86b962cdfd70f71a7b
-size 11710468
+oid sha256:2a1640a38b2fe403afaf62b04f667e2b1f375434323dcae34e5b9dd8bdc4f62b
+size 11741036

requirements.txt

@@ -1,5 +1,4 @@
 tensorflow
 tensorflow-cpu==2.15.0
 tf-keras
-numpy
-librosa
+numpy