added working batch processing endpoint

app.py

@@ -59,23 +59,23 @@ async def detect_contact(input: TextInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-
 @app.post("/batch_detect_contact", summary="Detect contact information in batch of texts")
 async def batch_detect_contact(inputs: BatchTextInput):
     try:
         # Preprocess all texts
         preprocessed_texts = [preprocess_text(text) for text in inputs.texts]
-        
+
         # First, use regex to check patterns
         regex_results = [check_regex_patterns(text) for text in preprocessed_texts]
-        
+
+
         # For texts where regex doesn't detect anything, use the model
         texts_for_model = [text for text, regex_match in zip(preprocessed_texts, regex_results) if not regex_match]
         if texts_for_model:
             model_results = batch_predict(texts_for_model)
         else:
             model_results = []
-        
+
         # Prepare final results
         results = []
         model_idx = 0
@@ -90,11 +90,11 @@ async def batch_detect_contact(inputs: BatchTextInput):
                 is_contact = model_results[model_idx]
                 results.append({
                     "text": inputs.texts[i],
-                    "is_contact_info": is_contact == 1,
+                    "is_contact_info": bool(is_contact),  # Convert numpy bool
                     "method": "model"
                 })
                 model_idx += 1
-        
+
         return results
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e))

predictor.py

@@ -105,16 +105,13 @@ def predict(text):
         return torch.argmax(outputs, dim=1).item()
 
 def batch_predict(texts):
-    with torch.inference_mode():  # Use inference mode for performance
-        # Tokenize and convert each text to tensor
+    with torch.inference_mode():  # Use inference mode for better performance
+        # Tokenize and convert to tensors
         inputs = [torch.tensor(text_pipeline(text)) for text in texts]
         
-        # Pad all sequences to the maximum filter size (max of FILTER_SIZES)
-        max_len = max(FILTER_SIZES)
-        padded_inputs = torch.stack([
-            torch.cat([seq, torch.zeros(max_len - len(seq), dtype=torch.long)]) if len(seq) < max_len else seq
-            for seq in inputs
-        ]).to(device)
+        # Pad all sequences to the length of the longest one in the batch
+        max_len = max(len(seq) for seq in inputs)
+        padded_inputs = torch.stack([torch.cat([seq, torch.zeros(max_len - len(seq), dtype=torch.long)]) for seq in inputs]).to(device)
         
         # Pass the batch through the scripted model
         outputs = scripted_model(padded_inputs)

test.py

@@ -104,47 +104,56 @@ test_texts = [
 
 ]
 import time
+# url = "https://vidhitmakvana1-contact-sharing-recognizer-api.hf.space/batch_detect_contact"
+url = "http://localhost:8000/batch_detect_contact"
 
-url = "https://vidhitmakvana1-contact-sharing-recognizer-api.hf.space/detect_contact"
-
-async def process_text(session, text):
-    payload = {"text": text}
+async def process_batch(session, texts):
+    payload = {"texts": texts}
     headers = {"Content-Type": "application/json"}
 
     start_time = time.time()
     async with session.post(url, data=json.dumps(payload), headers=headers) as response:
         if response.status == 200:
-            result = await response.json()
+            results = await response.json()
             end_time = time.time()
-            result['response_time'] = end_time - start_time
-            return result
+            for result in results:
+                result['response_time'] = (end_time - start_time) / len(texts)
+            return results
         else:
-            print(f"Error for text: {text}")
+            print(f"Error for batch")
             print(f"Status code: {response.status}")
             print(f"Response: {await response.text()}")
             return None
 
 async def main():
+    # Inflate test_texts
+    inflated_texts = test_texts * 100  # Multiply the test set by 10
+
     async with aiohttp.ClientSession() as session:
-        tasks = [process_text(session, text) for text in test_texts]
-        results = await tqdm.gather(*tasks)
+        batch_size = 1000
+        batches = [inflated_texts[i:i + batch_size] for i in range(0, len(inflated_texts), batch_size)]
+    
+        tasks = [process_batch(session, batch) for batch in batches]
+        all_results = await tqdm.gather(*tasks)
+
+    results = [item for sublist in all_results for item in sublist if sublist]
 
     correct_predictions = 0
     total_predictions = len(results)
     total_response_time = 0
 
-    for text, result in zip(test_texts, results):
+    for result in results:
         if result:
             print(f"Text: {result['text']}")
-            print(f"Contact Probability: {result['contact_probability']:.4f}")
             print(f"Is Contact Info: {result['is_contact_info']}")
+            print(f"Method: {result['method']}")
             print(f"Response Time: {result['response_time']:.4f} seconds")
             print("---")
-        
+    
             # Assuming all texts in test_texts are actually contact information
             if result['is_contact_info']:
                 correct_predictions += 1
-        
+    
             total_response_time += result['response_time']
 
     accuracy = correct_predictions / total_predictions