Upload folder using huggingface_hub

__pycache__/advanced_rag.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8f50eecfb78de9572a90521d5496aa1ac5e4f9119bf0856405d383227e0345a8
-size 114726
+oid sha256:d68b1e6a80f0f4ca6dd86ed864bf6a85ea9ab118f467cc5035c3e5dc5abe0c2b
+size 129736

advanced_rag.py

@@ -4,6 +4,7 @@ import datetime
 import functools
 import traceback
 from typing import List, Optional, Any, Dict, Tuple
+from pydantic import Field
 import csv
 import pandas as pd
 import tempfile
@@ -63,6 +64,102 @@ except Exception as e:
 # API Key Configuration
 NEBIUS_API_KEY = os.environ.get("NEBIUS_API_KEY", "")
 
+# Define NebiusLLM class at module level to avoid pickle issues
+class NebiusLLM(LLM):
+    """Nebius LLM wrapper with proper response validation."""
+    
+    model: str = Field(..., description="The model name to use")
+    api_key: str = Field(..., description="API key for Nebius")
+    base_url: str = "https://api.studio.nebius.com/v1"
+    max_tokens: int = 2048
+    temperature: float = 0.7
+    top_p: float = 0.95
+    top_k: int = 50
+    
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not self.model:
+            raise ValueError("Model name cannot be empty")
+    
+    @property
+    def _llm_type(self) -> str:
+        return "nebius"
+    
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Call the Nebius API and return the response."""
+        
+        try:
+            from openai import OpenAI
+            
+            debug_print(f"Nebius API call: model={self.model}, max_tokens={self.max_tokens}")
+            
+            # Create OpenAI client with Nebius base URL
+            client = OpenAI(base_url=self.base_url, api_key=self.api_key)
+            
+            completion = client.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=self.temperature,
+                top_p=self.top_p,
+                max_tokens=self.max_tokens
+            )
+            
+            # Extract the text content with proper validation
+            if completion.choices and len(completion.choices) > 0:
+                choice = completion.choices[0]
+                
+                # Handle different response formats
+                if hasattr(choice.message, 'content') and choice.message.content:
+                    text = choice.message.content
+                elif hasattr(choice, 'text'):
+                    text = choice.text
+                else:
+                    debug_print(f"WARNING: Unexpected response format: {choice}")
+                    text = str(choice.message) if hasattr(choice, 'message') else str(choice)
+                
+                # Validate that we got actual text
+                if text is None:
+                    debug_print(f"WARNING: Received None text from API response")
+                    return "I apologize, but I received an empty response. Please try rephrasing your question."
+                
+                if not isinstance(text, str):
+                    text = str(text)
+                
+                if not text.strip():
+                    debug_print(f"WARNING: Received empty text from API")
+                    return "I apologize, but I received an empty response. Please try rephrasing your question."
+                
+                return text.strip()
+            else:
+                debug_print(f"WARNING: No choices in API response")
+                return "I apologize, but I didn't receive a valid response. Please try again."
+                
+        except ImportError:
+            error_msg = "OpenAI package is required for Nebius models. Please install it with: pip install openai"
+            debug_print(error_msg)
+            return error_msg
+        except Exception as e:
+            error_msg = f"Error calling Nebius API: {str(e)}"
+            debug_print(error_msg)
+            return f"API error: {str(e)}"
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        """Return identifying parameters."""
+        return {
+            "model": self.model,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "max_tokens": self.max_tokens,
+        }
+
 # Add batch processing helper functions
 def generate_parameter_values(min_val, max_val, num_values):
     """Generate evenly spaced values between min and max"""
@@ -906,12 +1003,185 @@ class ElevatedRagChain:
         return input_data["question"]
 
     # Improve error handling in the ElevatedRagChain class
+    def calculate_safe_max_tokens(self, backend_model, prompt_text="", max_tokens_override=None):
+        """Calculate safe max_tokens based on model context limits and input length."""
+        
+        # Model context limits (total tokens including input + output) - from Nebius documentation
+        nebius_context_limits = {
+            "openai/gpt-oss-120b": 131000,
+            "openai/gpt-oss-20b": 131000,
+            "google/gemma-3-27b-it": 131000,
+            "deepseek-ai/DeepSeek-R1-0528": 164000,
+            "deepseek-ai/DeepSeek-V3": 128000,
+            "llama-3.1-70b-instruct": 128000,
+            "Meta-Llama-3.1-405B-Instruct": 128000,
+            "Qwen/Qwen3-235B-A22B": 262000,
+            "Qwen/Qwen3-32B": 41000,           # Correct limit: 41K context
+            "NousResearch/Hermes-4-405B": 128000,
+            "zai-org/GLM-4.5-Air": 128000
+        }
+        
+        context_limit = nebius_context_limits.get(backend_model, 32768)
+        
+        # Better token estimation
+        def estimate_tokens(text):
+            """Rough token estimation: 1 token ≈ 3.5-4 characters for most models."""
+            if not text:
+                return 0
+            # More conservative estimate
+            return int(len(str(text)) / 3.5)
+        
+        # Estimate input tokens from various sources
+        input_tokens = 0
+        
+        # Add tokens from retrieved documents
+        if hasattr(self, 'retrieved_docs') and self.retrieved_docs:
+            docs_text = ' '.join([doc.page_content for doc in self.retrieved_docs])
+            input_tokens += estimate_tokens(docs_text)
+        
+        # Add tokens from prompt/query
+        input_tokens += estimate_tokens(prompt_text)
+        
+        # Add tokens from system prompts and formatting (rough estimate)
+        input_tokens += 500  # Buffer for system messages, formatting, etc.
+        
+        # Calculate safe max_tokens
+        available_tokens = context_limit - input_tokens
+        
+        # Apply user override if provided, but cap it at available tokens
+        if max_tokens_override:
+            requested_tokens = min(max_tokens_override, available_tokens - 100)  # 100 token safety buffer
+        else:
+            # Default to 25% of available tokens, capped at reasonable limits
+            requested_tokens = min(
+                int(available_tokens * 0.25),  # 25% of available space
+                8192  # Reasonable upper limit for generation
+            )
+        
+        # Ensure minimum viable response length
+        safe_max_tokens = max(512, requested_tokens)
+        
+        debug_print(f"Token calculation for {backend_model}:")
+        debug_print(f"  Context limit: {context_limit}")
+        debug_print(f"  Estimated input tokens: {input_tokens}")
+        debug_print(f"  Available tokens: {available_tokens}")
+        debug_print(f"  Safe max_tokens: {safe_max_tokens}")
+        
+        if safe_max_tokens <= 512:
+            raise ValueError(f"Input too long for model {backend_model}. Input: {input_tokens} tokens, Context limit: {context_limit}")
+        
+        return safe_max_tokens
+
     def create_llm_pipeline(self, max_tokens_override=None):
         from langchain.llms.base import LLM  # Import LLM here so it's always defined
-        from typing import Optional, List, Any
+        from typing import Optional, List, Any, Dict
         from pydantic import PrivateAttr
         
-        # Extract the model name without the flag emoji prefix
+        # Check for Nebius models FIRST (before any normalization)
+        debug_print(f"Checking for Nebius model: {self.llm_choice}")
+        print(f"DEBUG: Checking for Nebius model: {self.llm_choice}")
+        if self.llm_choice in ["🟦 GPT OSS 120b (Nebius)", "🟦 GPT OSS 20b (Nebius)", "🟦 Google Gemma 3 27b-Instruct (Nebius)",
+                              "🟦 DeepSeek-R1-0528 (Nebius)", "🟦 DeepSeek-V3 (Nebius)", "🟦 Meta-Llama-3.1-70B-Instruct (Nebius)",
+                              "🟦 Meta-Llama-3.1-405B-Instruct (Nebius)", "🟦 Qwen3-235B-A22B (Nebius)", "🟦 Qwen3-32B (Nebius)",
+                              "🟦 Hermes 4 405B (Nebius)", "🟦 GLM-4.5 AIR (Nebius)"]:
+            debug_print(f"Found Nebius model: {self.llm_choice}")
+            print(f"DEBUG: Found Nebius model: {self.llm_choice}")
+            
+            if not OPENAI_AVAILABLE:
+                raise ImportError("openai package is required for NEBIUS models.")
+            
+            # Map display names to backend names
+            nebius_model_mapping = {
+                "🟦 GPT OSS 120b (Nebius)": "openai/gpt-oss-120b",
+                "🟦 GPT OSS 20b (Nebius)": "openai/gpt-oss-20b",
+                "🟦 Google Gemma 3 27b-Instruct (Nebius)": "google/gemma-3-27b-it",
+                "🟦 DeepSeek-R1-0528 (Nebius)": "deepseek-ai/DeepSeek-R1-0528",
+                "🟦 DeepSeek-V3 (Nebius)": "deepseek-ai/DeepSeek-V3",
+                "🟦 Meta-Llama-3.1-70B-Instruct (Nebius)": "llama-3.1-70b-instruct",
+                "🟦 Meta-Llama-3.1-405B-Instruct (Nebius)": "Meta-Llama-3.1-405B-Instruct",
+                "🟦 Qwen3-235B-A22B (Nebius)": "Qwen/Qwen3-235B-A22B",
+                "🟦 Qwen3-32B (Nebius)": "Qwen/Qwen3-32B",
+                "🟦 Hermes 4 405B (Nebius)": "NousResearch/Hermes-4-405B",
+                "🟦 GLM-4.5 AIR (Nebius)": "zai-org/GLM-4.5-Air"
+            }
+            
+            # Set appropriate token limits for Nebius models
+            # These are MAXIMUM GENERATION tokens, not total context length
+            nebius_token_limits = {
+                "openai/gpt-oss-120b": 8192,      # Conservative limit
+                "openai/gpt-oss-20b": 8192,       # Conservative limit
+                "google/gemma-3-27b-it": 4096,    # Conservative for 8K context
+                "deepseek-ai/DeepSeek-R1-0528": 8192,
+                "deepseek-ai/DeepSeek-V3": 16384,
+                "meta-llama/Meta-Llama-3.1-70B-Instruct": 32768,
+                "meta-llama/Meta-Llama-3.1-405B-Instruct": 32768,
+                "Qwen/Qwen3-235B-A22B": 8192,
+                "Qwen/Qwen3-32B": 8192,           # Reduced from 32768 - model has 40K total context
+                "NousResearch/Hermes-4-405B": 32768,
+                "zai-org/GLM-4.5-Air": 16384
+            }
+            
+            # Model context limits (total tokens including input + output) - from Nebius documentation
+            nebius_context_limits = {
+                "openai/gpt-oss-120b": 131000,
+                "openai/gpt-oss-20b": 131000,
+                "google/gemma-3-27b-it": 131000,
+                "deepseek-ai/DeepSeek-R1-0528": 164000,
+                "deepseek-ai/DeepSeek-V3": 128000,
+                "meta-llama/Meta-Llama-3.1-70B-Instruct": 128000,
+                "meta-llama/Meta-Llama-3.1-405B-Instruct": 128000,
+                "Qwen/Qwen3-235B-A22B": 262000,
+                "Qwen/Qwen3-32B": 41000,           # Correct limit: 41K context
+                "NousResearch/Hermes-4-405B": 128000,
+                "zai-org/GLM-4.5-Air": 128000
+            }
+            
+            backend_model = nebius_model_mapping[self.llm_choice]
+            
+            # Calculate safe max_tokens based on context limit
+            context_limit = nebius_context_limits.get(backend_model, 32768)
+            
+            # Calculate safe max_tokens dynamically
+            try:
+                # Get current prompt if available
+                current_prompt = getattr(self, 'current_query', '')
+                max_tokens = self.calculate_safe_max_tokens(
+                    backend_model, 
+                    current_prompt, 
+                    max_tokens_override
+                )
+            except ValueError as e:
+                debug_print(f"Token calculation error: {str(e)}")
+                # Fallback to model-specific token limits
+                max_tokens = nebius_token_limits.get(backend_model, 2048)
+            
+            debug_print(f"Creating Nebius LLM for model: {backend_model} with max_tokens: {max_tokens}")
+            print(f"DEBUG: Creating Nebius LLM for model: {backend_model} with max_tokens: {max_tokens}")
+            
+            
+            try:
+                api_key = NEBIUS_API_KEY or os.environ.get("NEBIUS_API_KEY")
+                if not api_key:
+                    raise ValueError("Please set the NEBIUS_API_KEY either in the code or as an environment variable.")
+                
+                nebius_llm = NebiusLLM(
+                    model=backend_model, 
+                    api_key=api_key,
+                    temperature=self.temperature, 
+                    top_p=self.top_p, 
+                    top_k=self.top_k, 
+                    max_tokens=max_tokens
+                )
+                debug_print("Nebius API pipeline created successfully.")
+                print(f"DEBUG: Nebius API pipeline created successfully for {self.llm_choice}")
+                return nebius_llm
+            except Exception as e:
+                error_msg = f"Failed to create Nebius LLM: {str(e)}"
+                debug_print(error_msg)
+                print(f"DEBUG: {error_msg}")
+                raise ValueError(error_msg)
+        
+        # Extract the model name without the flag emoji prefix (for non-Nebius models)
         clean_llm_choice = self.llm_choice.split(" ", 1)[-1] if " " in self.llm_choice else self.llm_choice
         normalized = clean_llm_choice.lower()
         print(f"Normalized model name: {normalized}")
@@ -1019,8 +1289,8 @@ class ElevatedRagChain:
                 debug_print(f"OpenAI {model} pipeline created successfully.")
                 return OpenAILLM()
             
-            # Meta-Llama-3 model
-            elif "meta-llama" in normalized or "llama" in normalized:
+            # Meta-Llama-3 model (but not Nebius models)
+            elif ("meta-llama" in normalized or "llama" in normalized) and "nebius" not in normalized:
                 debug_print("Creating remote Meta-Llama-3 pipeline via Hugging Face Inference API...")
                 from huggingface_hub import InferenceClient
                 repo_id = "meta-llama/Meta-Llama-3-8B-Instruct"
@@ -1132,81 +1402,6 @@ class ElevatedRagChain:
                 debug_print("Mistral API pipeline created successfully.")
                 return mistral_llm
             
-            # Nebius models
-            elif self.llm_choice in ["🟦 GPT OSS 120b (Nebius)", "🟦 GPT OSS 20b (Nebius)", "🟦 Google Gemma 3 27b-Instruct (Nebius)",
-                                    "🟦 DeepSeek-R1-0528 (Nebius)", "🟦 DeepSeek-V3 (Nebius)", "🟦 Meta-Llama-3.1-70B-Instruct (Nebius)",
-                                    "🟦 Meta-Llama-3.1-405B-Instruct (Nebius)", "🟦 Qwen3-235B-A22B (Nebius)", "🟦 Qwen3-32B (Nebius)",
-                                    "🟦 Hermes 4 405B (Nebius)", "🟦 GLM-4.5 AIR (Nebius)"]:
-                
-                if not OPENAI_AVAILABLE:
-                    raise ImportError("openai package is required for NEBIUS models.")
-                
-                # Map display names to backend names
-                nebius_model_mapping = {
-                    "🟦 GPT OSS 120b (Nebius)": "openai/gpt-oss-120b",
-                    "🟦 GPT OSS 20b (Nebius)": "openai/gpt-oss-20b",
-                    "🟦 Google Gemma 3 27b-Instruct (Nebius)": "google/gemma-3-27b-it",
-                    "🟦 DeepSeek-R1-0528 (Nebius)": "deepseek-ai/DeepSeek-R1-0528",
-                    "🟦 DeepSeek-V3 (Nebius)": "deepseek-ai/DeepSeek-V3",
-                    "🟦 Meta-Llama-3.1-70B-Instruct (Nebius)": "meta-llama/Meta-Llama-3.1-70B-Instruct",
-                    "🟦 Meta-Llama-3.1-405B-Instruct (Nebius)": "meta-llama/Meta-Llama-3.1-405B-Instruct",
-                    "🟦 Qwen3-235B-A22B (Nebius)": "Qwen/Qwen3-235B-A22B",
-                    "🟦 Qwen3-32B (Nebius)": "Qwen/Qwen3-32B",
-                    "🟦 Hermes 4 405B (Nebius)": "NousResearch/Hermes-4-405B",
-                    "🟦 GLM-4.5 AIR (Nebius)": "zai-org/GLM-4.5-Air"
-                }
-                
-                backend_model = nebius_model_mapping[self.llm_choice]
-                
-                class NebiusLLM(LLM):
-                    model: str
-                    temperature: float = 0.5
-                    top_p: float = 0.95
-                    top_k: int = 50
-                    max_tokens: int = 3000
-                    _client: Any = PrivateAttr()
-
-                    def __init__(self, model: str, temperature: float = 0.5, top_p: float = 0.95, top_k: int = 50, max_tokens: int = 3000, **kwargs: Any):
-                        if not OPENAI_AVAILABLE:
-                            raise ImportError("openai package is required for NEBIUS models.")
-                        super().__init__(**kwargs)
-                        api_key = NEBIUS_API_KEY or os.environ.get("NEBIUS_API_KEY")
-                        if not api_key:
-                            raise ValueError("Please set the NEBIUS_API_KEY either in the code or as an environment variable.")
-                        self.model = model
-                        self.temperature = temperature
-                        self.top_p = top_p
-                        self.top_k = top_k
-                        self.max_tokens = max_tokens
-                        # Use object.__setattr__ to bypass Pydantic field validation
-                        object.__setattr__(self, "_client", OpenAI(base_url="https://api.studio.nebius.com/v1/", api_key=api_key))
-                                            
-                    @property
-                    def _llm_type(self) -> str:
-                        return "nebius_llm"
-
-                    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
-                        try:
-                            completion = self._client.chat.completions.create(
-                                model=self.model,
-                                messages=[{"role": "user", "content": prompt}],
-                                temperature=self.temperature,
-                                top_p=self.top_p,
-                                max_tokens=self.max_tokens
-                            )
-                            return completion.choices[0].message.content if hasattr(completion.choices[0].message, 'content') else str(completion.choices[0].message)
-                        except Exception as e:
-                            return f"Error from Nebius: {str(e)}"
-                    
-                    @property
-                    def _identifying_params(self) -> dict:
-                        return {"model": self.model, "temperature": self.temperature, "top_p": self.top_p}
-                
-                debug_print(f"Creating Nebius LLM for model: {backend_model}")
-                nebius_llm = NebiusLLM(model=backend_model, temperature=self.temperature, top_p=self.top_p, top_k=self.top_k, max_tokens=self.max_tokens)
-                debug_print("Nebius API pipeline created successfully.")
-                return nebius_llm
-            
             else:
                 raise ValueError(f"Unsupported model choice: {self.llm_choice}")
                 
@@ -2374,48 +2569,35 @@ def create_csv_from_batch_results(results: List[Dict], job_id: str,
     
     # Extract short names for filename
     def get_short_name(full_name, prefix_length=2):
-        """Extract short name from full model name"""
+        """Extract complete name from full model name for better clarity"""
         if not full_name:
             return "unknown"
+        
         # Remove emojis and get the actual model name
         clean_name = full_name.split(" ", 1)[-1] if " " in full_name else full_name
         
         # Remove parentheses and replace with underscores, also clean other special characters
         clean_name = clean_name.replace("(", "_").replace(")", "").replace(" ", "_").replace(",", "").replace("-", "_")
         
-        # For embedding models, extract the unique suffix part
+        # For embedding models, return the complete suffix after sentence_transformers/
         if "sentence_transformers/" in clean_name:
-            # Extract the part after "sentence_transformers/"
+            # Extract the complete part after "sentence_transformers/"
             suffix = clean_name.replace("sentence_transformers/", "")
-            # Take the last part after the last underscore for uniqueness
-            if "_" in suffix:
-                parts = suffix.split("_")
-                # Take the last 2-3 parts to ensure uniqueness
-                if len(parts) >= 2:
-                    return "_".join(parts[-2:])
-                else:
-                    return suffix
-            else:
-                return suffix
+            return suffix
         else:
-            # For other models, use a cleaner approach
-            # Remove common prefixes and take meaningful parts
+            # For other models, return the complete cleaned name
             if "Nebius" in clean_name:
-                # For Nebius models, extract the model name part
+                # For Nebius models, return the complete model name without common words
                 parts = clean_name.split("_")
-                # Filter out common words and take meaningful parts
-                meaningful_parts = [p for p in parts if p not in ["Nebius", "the", "and", "or", "of", "in", "on", "at", "to", "for", "with", "by"]]
+                # Filter out only the most common words but keep the model name complete
+                meaningful_parts = [p for p in parts if p not in ["Nebius"]]
                 if meaningful_parts:
-                    return "_".join(meaningful_parts[-2:]) if len(meaningful_parts) >= 2 else meaningful_parts[0]
+                    return "_".join(meaningful_parts)
                 else:
                     return clean_name
             else:
-                # For other models, take first and last parts
-                parts = clean_name.split("_")
-                if len(parts) >= 2:
-                    return "_".join([parts[0], parts[-1]])
-                else:
-                    return clean_name
+                # For other models, return the complete cleaned name
+                return clean_name
     
     def get_param_variation_name(param_configs):
         """Get the parameter that was varied"""

batch_all_MiniLM_L6_v2__384_dim_fast_GPT_OSS_120b__const_20250917_224047.csv

@@ -0,0 +1,21 @@
+Temperature,Top-p,Top-k,BM25 Weight,Model,Main Answer,Input Tokens,Output Tokens,Conversation History,Progress,Elapsed Time (s)
+0.5,0.95,50,0.6,🟦 GPT OSS 120b (Nebius),"**Key Concepts that Function as Criteria for Holding an Agent Accountable**  
+
+| # | Concept (English term) | How the text employs the term as a gate‑keeper for accountability | Why it qualifies as a “criterion” |
+|---|------------------------|-------------------------------------------------------------------|---------------------------------|
+| 1 | **Voluntary Action** | The work repeatedly stresses that “Moral Choice is plainly voluntary” (Chapter IV) and that “voluntary” is the broader category that includes moral choice. Actions that are not voluntary are excluded from blame. | If an act is classified as voluntary, the agent is deemed capable of owning the act; otherwise the agent is excused. |
+| 2 | **Involuntary Action** | Involuntary actions are split into “compulsion” (external force) and “ignorance” (lack of self‑caused knowledge) (Chapter III‑IV). The author notes that “the man who acts by compulsion … is not blamed” and that ignorance “is not self‑caused” can mitigate responsibility. | The presence of involuntariness removes or reduces accountability, making it a decisive test. |
+| 3 | **Moral Choice (Deliberate Selection)** | Defined as “the object of Moral Choice is … that which after Deliberation has been preferred to something else” (Chapter VII). The text treats Moral Choice as the *starting‑point* of moral agency. | Only actions that arise from a genuine Moral Choice are subject to evaluation; the existence of such a choice signals full responsibility. |
+| 4 | **Knowledge (True Opinion)** | The treatise distinguishes “true conclusions and right moral choice” from false ones (Chapter VIII) and links knowledge to the “right movement of the Will.” It also says that “the man who knows … is simply entitled to the designations who abides or not by the true opinion.” | Possessing correct knowledge about the relevant facts and principles is required for being answerable; ignorance of self‑caused facts can excuse. |
+| 5 | **Self‑Control (Perfected Self‑Mastery)** | Extensive discussion of “Self‑Control” and “Imperfect Self‑Control” (multiple chapters). The author states that “Self‑Control is a good state and the Imperfection of it a bad one” and that the “man of Self‑Control … abides by his resolutions.” | The capacity to regulate passions determines whether an agent can be held to his own resolutions; lack of self‑control can explain failure to act responsibly. |
+| 6 | **Passion (Lust, Anger, Fear)** | Passions are repeatedly presented as forces that can “prevent his acting in accordance with Right Reason” (Chapter VIII) and as “the irrational feelings … must be avoided.” The text contrasts actions “from Lust” with those “from Moral Choice.” | When an action is driven primarily by an uncontrolled passion, the agent’s responsibility is attenuated; the presence or absence of passion is a diagnostic factor. |
+| 7 | **Deliberation (Practical Reasoning)** | The author notes that “Deliberation has for its object whatever may be done through one’s own instrumentality” (Chapter VII) and that “the mean state … is according to the dictates of Right Reason.” Deliberation is required before Moral Choice can be formed. | An agent who has deliberated correctly is fully accountable; failure to deliberate (or deliberation based on false premises) reduces responsibility. |
+| 8 | **Remorse / Moral Awareness after the Act** | The text says that the “Imperfect Self‑Control … is almost made up of remorse” (Chapter VIII) and that “the man of Imperfect Self‑Control … is blamed, not as an error merely but also as being a vice.” | The presence of genuine remorse signals that the agent recognized the moral quality of the act, reinforcing responsibility; lack of remorse can indicate diminished culpability. |
+| 9 | **Justice vs. Injustice (Proportional Equality)** | Justice is defined as “the moral state … in virtue of which the just man … makes division … proportionably equal” (Chapter VIII). Injustice is “both excess and defect because it aims at producing excess and defect.” | An action judged as just or unjust, according to proportional equality, is a benchmark for assessing whether the agent acted responsibly. |
+| 10 | **Equity (Fair Adjustment of the Law)** | The treatise treats the “Equitable” as “Just but better than one form of Just” (Chapter XVI) and links it to “the tendency to choose and carry out these principles” rather than “press the letter of the law on the worse side.” | When an agent’s conduct aligns with equitable judgment rather than strict literalism, the agent is considered to have exercised the higher standard of responsibility. |
+
+**Why these ten were selected**
+
+- Each term appears **explicitly** in the source material and is **thematically linked** to the question of when an agent can be praised or blamed.
+- The concepts together **cover the full spectrum** of the treatise’s analysis: the *ontological status* of the act (voluntary vs. involuntary), the *cognitive pre‑conditions* (knowledge, deliberation), the *affective conditions* (passion, self‑control, remorse), and the *normative evaluation* (justice, equity).
+- By citing the **specific passages** where the author uses the term, the list demonstrates that the criteria are not modern inventions but are rooted in the historical philosophical discussion presented in the document.",N/A,N/A,0,Query 1/1,0.00

batch_all_MiniLM_L6_v2__384_dim_fast_Meta_Llama_3.1_405B_Instruct__const_20250917_223651.csv

@@ -0,0 +1,24 @@
+Temperature,Top-p,Top-k,BM25 Weight,Model,Main Answer,Input Tokens,Output Tokens,Conversation History,Progress,Elapsed Time (s)
+0.5,0.95,50,0.6,🟦 Meta-Llama-3.1-405B-Instruct (Nebius),"Based on the uploaded document, which appears to be a translation of Aristotle's Nicomachean Ethics, I have identified the following 10 prominent concepts that describe criteria for moral responsibility:
+
+1. **Voluntariness**: Aristotle emphasizes the importance of voluntariness in moral actions, stating that ""the voluntary is that which is done with knowledge"" (Book III, Chapter 1). This concept is crucial in determining moral responsibility, as it implies that individuals can only be held accountable for actions they perform knowingly and intentionally.
+
+2. **Deliberation**: Aristotle discusses the role of deliberation in moral decision-making, arguing that ""we deliberate not about ends, but about means"" (Book III, Chapter 3). This concept highlights the importance of rational consideration in moral actions, which is essential for moral responsibility.
+
+3. **Choice**: Aristotle distinguishes between voluntary actions and choices, stating that ""choice is a deliberate desire of things in our own power"" (Book III, Chapter 3). This concept emphasizes the importance of intentional decision-making in moral actions, which is a key criterion for moral responsibility.
+
+4. **Knowledge**: Aristotle stresses the importance of knowledge in moral actions, arguing that ""the voluntary is that which is done with knowledge"" (Book III, Chapter 1). This concept is essential for moral responsibility, as individuals can only be held accountable for actions they perform with full knowledge of the circumstances.
+
+5. **Intention**: Aristotle discusses the role of intention in moral actions, stating that ""the intention is the principle of the action"" (Book III, Chapter 5). This concept highlights the importance of an individual's goals and motivations in determining moral responsibility.
+
+6. **Self-Control**: Aristotle emphasizes the importance of self-control in moral actions, arguing that ""the man of perfected self-mastery is he who can do what he should do without being affected by passion"" (Book II, Chapter 3). This concept is crucial for moral responsibility, as individuals must be able to regulate their emotions and desires to make moral decisions.
+
+7. **Rationality**: Aristotle discusses the role of rationality in moral decision-making, arguing that ""the rational part of the soul is the principle of the virtues"" (Book I, Chapter 7). This concept highlights the importance of rational consideration in moral actions, which is essential for moral responsibility.
+
+8. **Habit**: Aristotle emphasizes the importance of habit in moral development, arguing that ""we are what we repeatedly do"" (Book II, Chapter 1). This concept highlights the importance of consistent behavior in shaping moral character, which is essential for moral responsibility.
+
+9. **Pleasure and Pain**: Aristotle discusses the role of pleasure and pain in moral decision-making, arguing that ""pleasure and pain are the test of the moral character"" (Book II, Chapter 3). This concept highlights the importance of emotional regulation in moral actions, which is essential for moral responsibility.
+
+10. **Character**: Aristotle emphasizes the importance of character in moral decision-making, arguing that ""the character is the principle of the action"" (Book III, Chapter 5). This concept highlights the importance of an individual's moral disposition in determining moral responsibility.
+
+These concepts were selected based on their prominence in the text and their relevance to moral responsibility. Aristotle's Nicomachean Ethics provides a comprehensive framework for understanding moral responsibility, and these concepts are central to his theory.",N/A,N/A,0,Query 1/1,0.00

batch_all_MiniLM_L6_v2__384_dim_fast_Meta_Llama_3.1_70B_Instruct__const_20250917_223512.csv

@@ -0,0 +1,2 @@
+Temperature,Top-p,Top-k,BM25 Weight,Model,Main Answer,Input Tokens,Output Tokens,Conversation History,Progress,Elapsed Time (s)
+0.5,0.95,50,0.6,🟦 Meta-Llama-3.1-70B-Instruct (Nebius),API error: Error code: 404 - {'detail': 'The model `meta-llama/Meta-Llama-3.1-70B-Instruct` does not exist.'},N/A,N/A,0,Query 1/1,0.00

batch_dim_fast_20b__const_20250917_213830.csv

@@ -0,0 +1,4 @@
+Temperature,Top-p,Top-k,BM25 Weight,Model,Main Answer,Input Tokens,Output Tokens,Conversation History,Progress,Elapsed Time (s)
+0.5,0.95,50,0.6,Unknown,"Error: 1 validation error for Generation
+text
+  none is not an allowed value (type=type_error.none.not_allowed)",N/A,N/A,0,Query 1/1,0.00