Sync turing folder from GitHub

turing/modeling/models/codeBerta.py

@@ -32,7 +32,6 @@ warnings.filterwarnings("ignore")
 
 def compute_metrics(eval_pred):
     predictions, labels = eval_pred
-    
     # Sigmoid function to convert logits to probabilities
     probs = 1 / (1 + np.exp(-predictions)) 
     
@@ -67,11 +66,11 @@ class CodeBERTaDataset(Dataset):
         """
 
         self.encodings = {key: torch.tensor(val) for key, val in encodings.items()}
-        
+
         if labels is not None:
             if not isinstance(labels, (np.ndarray, torch.Tensor)):
                 labels = np.array(labels)
-            
+
             # Case A: labels are indices (integers)
             if num_labels is not None and (len(labels.shape) == 1 or (len(labels.shape) == 2 and labels.shape[1] == 1)):
                 labels_flat = labels.flatten()
@@ -149,12 +148,11 @@ class CodeBERTa(BaseModel):
             "early_stopping_patience": 3,
             "early_stopping_threshold": 0.005
         }
-        
+
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.tokenizer = None
-        
-        super().__init__(language, path)
 
+        super().__init__(language, path)
 
     def setup_model(self):
         """
@@ -162,7 +160,7 @@ class CodeBERTa(BaseModel):
         """
 
         logger.info(f"Initializing {self.params['model_name_hf']} on {self.device}...")
-        
+    
         self.tokenizer = AutoTokenizer.from_pretrained(self.params["model_name_hf"])
         self.model = AutoModelForSequenceClassification.from_pretrained(
             self.params["model_name_hf"], 
@@ -218,23 +216,21 @@ class CodeBERTa(BaseModel):
         if self.model is None:
             raise ValueError("Model is not initialized. Call setup_model() before training.")
 
-        # log parameters to MLflow without model_name_hf
+        # log parameters to MLflow without model_name_hf    
         params_to_log = {k: v for k, v in self.params.items() if k != "model_name_hf" and k != "num_labels"}
-
         logger.info(f"Starting training for: {self.language.upper()}")
-        
+
         # Prepare dataset (train/val split)
         train_encodings = self._tokenize(X_train)
         full_dataset = CodeBERTaDataset(train_encodings, y_train, num_labels=self.params["num_labels"])
+        full_dataset = CodeBERTaDataset(train_encodings, y_train, num_labels=self.params["num_labels"])
         train_size = int(self.params["train_size"] * len(full_dataset))
         val_size = len(full_dataset) - train_size
         train_dataset, val_dataset = torch.utils.data.random_split(full_dataset, [train_size, val_size])
 
         temp_ckpt_dir = os.path.join(MODELS_DIR, "temp_checkpoints")
-        
+
         use_fp16 = torch.cuda.is_available()
-        if not use_fp16:
-            logger.info("Mixed Precision (fp16) disabled because CUDA is not available.")
 
         training_args = TrainingArguments(
             output_dir=temp_ckpt_dir,
@@ -314,9 +310,8 @@ class CodeBERTa(BaseModel):
                 idx = int(label_idx)
                 if 0 <= idx < num_labels:
                     y_test_expanded[i, idx] = 1
-            
-            y_test_np = y_test_expanded
 
+            y_test_np = y_test_expanded
         # Generate classification report
         report = classification_report(y_test_np, y_pred, zero_division=0)
         print("\n" + "=" * 50)
@@ -330,12 +325,8 @@ class CodeBERTa(BaseModel):
             "recall": recall_score(y_test_np, y_pred, average="macro", zero_division=0),
             "f1_score": f1_score(y_test_np, y_pred, average="macro"),
         }
-
         mlflow.log_metrics(metrics)
-
-        logger.info(
-            f"Evaluation completed — Accuracy: {metrics['accuracy']:.3f}, F1: {metrics['f1_score']:.3f}"
-        )
+        logger.info(f"Evaluation completed — Accuracy: {metrics['accuracy']:.3f}, F1: {metrics['f1_score']:.3f}")
         return metrics
 
 
@@ -350,36 +341,28 @@ class CodeBERTa(BaseModel):
         Returns:
             np.ndarray: Multi-Hot Encoded predictions (e.g., [[0, 1, 1, 0], ...])
         """
-
+                
         if self.model is None:
             raise ValueError("Model is not trained. Call train() or load() before prediction.")
 
         # Set model to evaluation mode
         self.model.eval()
         
+        # Tokenize inputs
         encodings = self._tokenize(X)
-        # Pass None as labels because we are in inference
-        dataset = CodeBERTaDataset(encodings, labels=None)
         
-        use_fp16 = torch.cuda.is_available()
+        # Convert lists to tensors and move to device
+        inputs = {key: torch.tensor(val).to(self.device) for key, val in encodings.items()}
         
-        training_args = TrainingArguments(
-            output_dir="./pred_temp", 
-            per_device_eval_batch_size=self.params["batch_size_eval"],
-            fp16=use_fp16,
-            report_to="none",
-            no_cuda=not torch.cuda.is_available()
-        )
+        # Inference (no gradients, lightweight)
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            logits = outputs.logits
         
-        trainer = Trainer(model=self.model, args=training_args)
-        output = trainer.predict(dataset)
+        # Move back to CPU and convert to numpy
+        logits = logits.cpu().numpy()
         
-        # Clean up temporary prediction directory
-        if os.path.exists("./pred_temp"):
-            shutil.rmtree("./pred_temp")
-        
-        # Convert logits to probabilities
-        logits = output.predictions
+        # Sigmoid + Threshold
         probs = 1 / (1 + np.exp(-logits))
         
         # Apply a threshold of 0.5 (if prob > 0.5, predict 1 else 0)
@@ -387,7 +370,6 @@ class CodeBERTa(BaseModel):
         
         return preds_binary
     
-
     def save(self, path, model_name):
         """
         Save model locally and log to MLflow as artifact.
@@ -420,7 +402,6 @@ class CodeBERTa(BaseModel):
         except Exception as e:
             logger.error(f"Failed to log model artifacts to MLflow: {e}")
 
-
     def load(self, model_path):
         """
         Load model from a local path OR an MLflow URI.
@@ -447,14 +428,14 @@ class CodeBERTa(BaseModel):
         try:
             if not os.path.exists(local_model_path):
                 raise FileNotFoundError(f"Model path not found: {local_model_path}")
-
+            
             # Load tokenizer and model from local path
             self.tokenizer = AutoTokenizer.from_pretrained(local_model_path)
             self.model = AutoModelForSequenceClassification.from_pretrained(
-                local_model_path
+                local_model_path,
+                low_cpu_mem_usage=False  
             ).to(self.device)
             logger.info("Model loaded from local path successfully.")
-
         except Exception as e:
             logger.error(f"Failed to load model from local path: {e}")
             raise e

turing/modeling/models/graphCodeBert.py

@@ -353,39 +353,31 @@ class GraphCodeBERTClassifier(BaseModel):
 
         Returns:
             np.ndarray: Multi-Hot Encoded predictions (e.g., [[0, 1, 1, 0], ...])
+        Make predictions for Multi-Label classification using direct PyTorch inference.
         """
-
         if self.model is None:
             raise ValueError("Model is not trained. Call train() or load() before prediction.")
 
         # Set model to evaluation mode
         self.model.eval()
 
+        # Tokenize inputs
         encodings = self._tokenize(X)
-        # Pass None as labels because we are in inference
-        dataset = GraphCodeBERTDataset(encodings, labels=None)
-
-        use_fp16 = torch.cuda.is_available()
-
-        training_args = TrainingArguments(
-            output_dir="./pred_temp",
-            per_device_eval_batch_size=self.params["batch_size_eval"],
-            fp16=use_fp16,
-            report_to="none",
-            no_cuda=not torch.cuda.is_available(),
-        )
+        
+        # Convert lists to tensors and move to device
+        inputs = {key: torch.tensor(val).to(self.device) for key, val in encodings.items()}
 
-        trainer = Trainer(model=self.model, args=training_args)
-        output = trainer.predict(dataset)
+        # Inference (no gradients, lightweight)
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            logits = outputs.logits
 
-        # Clean up temporary prediction directory
-        if os.path.exists("./pred_temp"):
-            shutil.rmtree("./pred_temp")
+        # Move back to CPU and convert to numpy
+        logits = logits.cpu().numpy()
 
-        # Convert logits to probabilities
-        logits = output.predictions
+        # Sigmoid + Threshold
         probs = 1 / (1 + np.exp(-logits))
-
+        
         # Apply a threshold of 0.5 (if prob > 0.5, predict 1 else 0)
         preds_binary = (probs > 0.5).astype(int)
 
@@ -456,9 +448,10 @@ class GraphCodeBERTClassifier(BaseModel):
 
             # Load tokenizer and model from local path
             self.tokenizer = AutoTokenizer.from_pretrained(local_model_path)
-            self.model = AutoModelForSequenceClassification.from_pretrained(local_model_path).to(
-                self.device
-            )
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                local_model_path,
+                low_cpu_mem_usage=False  
+            ).to(self.device)
             logger.info("Model loaded from local path successfully.")
 
         except Exception as e:

turing/modeling/predict.py

@@ -39,6 +39,7 @@ class ModelInference:
         warnings.filterwarnings("ignore")
         self.dataset_manager = DatasetManager()
         self.use_best_model_tags = use_best_model_tags
+        self.loaded_models = {}
 
         # Initialize model registry based on configuration
         if use_best_model_tags:
@@ -141,20 +142,26 @@ class ModelInference:
         model_config = self.model_registry[language]
         run_id = model_config["run_id"]
         artifact_name = model_config["artifact"]
-        model_id = model_config["model_id"]
-
-        # Dynamically import model class
-        config_entry = MODEL_CONFIG[model_id]
-        module_name = config_entry["model_class_module"]
-        class_name = config_entry["model_class_name"]
-        module = importlib.import_module(module_name)
-        model_class = getattr(module, class_name)
-
-        # 2. Get Model Path (Local Cache or Download)
-        model_path = self._get_cached_model_path(run_id, artifact_name, language)
-
-        # Load Model
-        model = model_class(language=language, path=model_path)
+        if language not in self.loaded_models:
+            logger.info(f"Model for {language} not in memory. Loading...")
+            
+            model_id = model_config["model_id"]
+
+            # Dynamically import model class
+            config_entry = MODEL_CONFIG[model_id]
+            module_name = config_entry["model_class_module"]
+            class_name = config_entry["model_class_name"]
+            module = importlib.import_module(module_name)
+            model_class = getattr(module, class_name)
+
+            # Get Model Path (Local Cache or Download)
+            model_path = self._get_cached_model_path(run_id, artifact_name, language)
+
+            # Load Model and store in cache
+            self.loaded_models[language] = model_class(language=language, path=model_path)
+            logger.success(f"Model for {language} loaded into memory.")
+        
+        model = self.loaded_models[language]
 
         # 3. Predict
         raw_predictions = model.predict(texts)

turing/monitoring/locustfile.py

@@ -0,0 +1,46 @@
+import random
+
+from locust import HttpUser, between, task
+
+
+class TuringApiUser(HttpUser):
+    # Wait time between requests
+    wait_time = between(1, 5)
+
+    # List of supported languages
+    languages = ["python", "java", "pharo"]
+
+    # Code examples
+    code_snippets = {
+        "python": ["def init(self): pass", "print('Hello World')", "import os"],
+        "java": ["public static void main(String[] args)", "System.out.println(e);", "private int x = 0;"],
+        "pharo": ["Transcript show: 'Hello'.", "^ self size", "Object subclass: #Name"]
+    }
+
+    @task(1)
+    def health_check(self):
+        """
+        Checks if the API is alive.
+        """
+        self.client.get("/")
+
+    @task(3)
+    def predict_code_classification(self):
+        """
+        Sends a prediction request by choosing a random language.
+        """
+        # Randomly selects one of the three languages
+        selected_lang = random.choice(self.languages)
+        
+        #  Selects consistent snippets (
+        texts = self.code_snippets.get(selected_lang, ["generic code"])
+        
+        payload = {
+            "texts": texts,
+            "language": selected_lang  
+        }
+        
+        headers = {'Content-Type': 'application/json'}
+        
+        # Perform the request
+        self.client.post("/predict", json=payload, headers=headers, name="/predict (random lang)")