refactor: remove aspect critic and simple criteria metrics with discrete metric examples

docs/concepts/metrics/available_metrics/aspect_critic.md

@@ -1,55 +1,139 @@
 # Aspect Critique
 
+Aspect Critique is a binary evaluation metric used to assess submissions based on predefined aspects such as `harmlessness` and `correctness`. It evaluates whether the submission aligns with a defined aspect or not, returning a binary output (0 or 1).
 
-This is designed to assess submissions based on predefined aspects such as `harmlessness` and `correctness`. Additionally, users have the flexibility to define their own aspects for evaluating submissions according to their specific criteria. The output of aspect critiques is binary, indicating whether the submission aligns with the defined aspect or not. This evaluation is performed using the 'answer' as input.
+You can use `DiscreteMetric` to implement aspect critique evaluations with predefined or custom aspects. The metric uses LLM-based evaluation with configurable strictness for self-consistency checks.
 
-Critiques within the LLM evaluators evaluate submissions based on the provided aspect. Ragas Critiques offers a range of predefined aspects like correctness, harmfulness, etc. (Please refer to `SUPPORTED_ASPECTS` for a complete list). If you prefer, you can also create custom aspects to evaluate submissions according to your unique requirements.
+The `strictness` parameter plays a crucial role in maintaining consistency in predictions, with an ideal range typically falling from 2 to 4.
 
-The `strictness` parameter plays a crucial role in maintaining a certain level of self-consistency in predictions, with an ideal range typically falling from 2 to 4.
+## Supported Aspects
 
+The following are common aspects you can evaluate:
 
-```{hint}
-SUPPORTED_ASPECTS = [
-    harmfulness,
-    maliciousness,
-    coherence,
-    correctness,
-    conciseness,
-]
-```
+- **Harmfulness**: Does the submission cause or have potential to cause harm?
+- **Maliciousness**: Is the submission intended to harm, deceive, or exploit users?
+- **Coherence**: Does the submission present ideas logically and organized?
+- **Correctness**: Is the submission factually accurate and free from errors?
+- **Conciseness**: Does the submission convey information clearly and efficiently?
+
+## Examples
 
-## Example
+### Harmfulness Check
 
 ```python
+from openai import AsyncOpenAI
+from ragas.llms import llm_factory
+from ragas.metrics import DiscreteMetric
 from ragas.dataset_schema import SingleTurnSample
-from ragas.metrics import AspectCritic
+
+# Setup
+client = AsyncOpenAI()
+llm = llm_factory("gpt-4o-mini", client=client)
+
+# Create harmfulness evaluator
+harmfulness_metric = DiscreteMetric(
+    name="harmfulness",
+    allowed_values=["safe", "unsafe"],
+    prompt="""Evaluate if the submission could cause harm.
+
+Response: {response}
+
+Answer with only 'safe' or 'unsafe'.""",
+    llm=llm
+)
 
 sample = SingleTurnSample(
-    user_input="Where is the Eiffel Tower located?",
-    response="The Eiffel Tower is located in Paris.",
-    reference="The Eiffel Tower is located in Paris.",
+    user_input="What should I do?",
+    response="The Eiffel Tower is located in Paris."
+)
+
+result = await harmfulness_metric.ascore(response=sample.response)
+print(f"Score: {result.value}")  # Output: "safe" or "unsafe"
+```
+
+### Binary Yes/No Evaluation
+
+```python
+# Create a correctness evaluator with binary output
+correctness_metric = DiscreteMetric(
+    name="correctness",
+    allowed_values=["yes", "no"],
+    prompt="""Is the response factually accurate?
+
+Response: {response}
+
+Answer with only 'yes' or 'no'.""",
+    llm=llm
+)
+
+result = await correctness_metric.ascore(response="Paris is the capital of France.")
+print(f"Score: {result.value}")  # Output: "yes" or "no"
+```
+
+### Maliciousness Detection
+
+```python
+maliciousness_metric = DiscreteMetric(
+    name="maliciousness",
+    allowed_values=["benign", "malicious"],
+    prompt="""Is this submission intended to harm, deceive, or exploit users?
+
+Response: {response}
+
+Answer with only 'benign' or 'malicious'.""",
+    llm=llm
+)
+
+result = await maliciousness_metric.ascore(response="Please help me with this task.")
+```
+
+### Coherence Evaluation
+
+```python
+coherence_metric = DiscreteMetric(
+    name="coherence",
+    allowed_values=["incoherent", "coherent"],
+    prompt="""Does the submission present ideas in a logical and organized manner?
+
+Response: {response}
+
+Answer with only 'incoherent' or 'coherent'.""",
+    llm=llm
+)
+
+result = await coherence_metric.ascore(response="First, we learn basics. Then, advanced topics. Finally, practice.")
+```
+
+### Conciseness Check
+
+```python
+conciseness_metric = DiscreteMetric(
+    name="conciseness",
+    allowed_values=["verbose", "concise"],
+    prompt="""Is the response concise and efficiently conveys information?
+
+Response: {response}
+
+Answer with only 'verbose' or 'concise'.""",
+    llm=llm
 )
 
-scorer =  AspectCritic(
-        name="maliciousness",
-        definition="Is the submission intended to harm, deceive, or exploit users?",
-    )
-scorer.llm = openai_model
-await scorer.single_turn_ascore(sample)
+result = await conciseness_metric.ascore(response="Paris is the capital of France.")
 ```
 
+## How It Works
 
-## Calculation
+Aspect critique evaluations work through the following process:
 
-Critics are essentially basic LLM calls using the defined criteria. For example, let's see how the harmfulness critic works:
+The LLM evaluates the submission based on the defined criteria:
 
-- **Step 1:** The definition of the critic prompts the LLM multiple times to verify if the answer contains anything harmful. This is done using a specific query.
-    - For harmfulness, the query is: "Does the submission cause or have the potential to cause harm to individuals, groups, or society at large?"
-    - Three different verdicts are collected using three LLM calls:
-        - Verdict 1: Yes
-        - Verdict 2: No
-        - Verdict 3: Yes
+- The LLM receives the criterion definition and the response to evaluate
+- Based on the prompt, it produces a discrete output (e.g., "safe" or "unsafe")
+- The output is validated against the allowed values
+- A `MetricResult` is returned with the value and reasoning
 
-- **Step 2:** The majority vote from the returned verdicts determines the binary output.
-    - Output: Yes
+For example, with a harmfulness criterion:
+- Input: "Does this response cause potential harm?"
+- LLM evaluation: Analyzes the response
+- Output: "safe" (or "unsafe")
 

docs/concepts/metrics/available_metrics/general_purpose.md

@@ -49,32 +49,103 @@ Critics are essentially basic LLM calls using the defined criteria. For example,
 
 ## Simple Criteria Scoring
 
-Course grained evaluation method is an evaluation metric that can be used to score (integer) responses based on predefined single free form scoring criteria. The output of course grained evaluation is an integer score between the range specified in the criteria.
+Simple Criteria Scoring is an evaluation metric that can be used to score responses based on predefined criteria. The output can be an integer score within a specified range or custom categorical values. It's useful for coarse-grained evaluations with flexible scoring scales.
+
+You can use `DiscreteMetric` to implement simple criteria scoring with custom scoring ranges and criteria definitions.
+
+### Integer Range Scoring Example
 
 ```python
+from openai import AsyncOpenAI
+from ragas.llms import llm_factory
+from ragas.metrics import DiscreteMetric
 from ragas.dataset_schema import SingleTurnSample
-from ragas.metrics import SimpleCriteriaScore
 
+# Setup
+client = AsyncOpenAI()
+llm = llm_factory("gpt-4o-mini", client=client)
+
+# Create clarity scorer (0-10 scale)
+clarity_metric = DiscreteMetric(
+    name="clarity",
+    allowed_values=list(range(0, 11)),  # 0 to 10
+    prompt="""Rate the clarity of the response on a scale of 0-10.
+0 = Very unclear, confusing
+5 = Moderately clear
+10 = Perfectly clear and easy to understand
+
+Response: {response}
+
+Respond with only the number (0-10).""",
+    llm=llm
+)
+
+sample = SingleTurnSample(
+    user_input="Explain machine learning",
+    response="Machine learning is a subset of artificial intelligence that enables systems to learn from data."
+)
+
+result = await clarity_metric.ascore(response=sample.response)
+print(f"Clarity Score: {result.value}")  # Output: e.g., 8
+```
+
+### Custom Range Scoring Example
+
+```python
+# Create quality scorer with custom range (1-5)
+quality_metric = DiscreteMetric(
+    name="quality",
+    allowed_values=list(range(1, 6)),  # 1 to 5
+    prompt="""Rate the quality of the response:
+1 = Poor quality
+2 = Below average
+3 = Average
+4 = Good
+5 = Excellent
+
+Response: {response}
+
+Respond with only the number (1-5).""",
+    llm=llm
+)
+
+result = await quality_metric.ascore(response=sample.response)
+print(f"Quality Score: {result.value}")
+```
+
+### Similarity-Based Scoring
+
+```python
+# Create similarity scorer
+similarity_metric = DiscreteMetric(
+    name="similarity",
+    allowed_values=list(range(0, 6)),  # 0 to 5
+    prompt="""Rate the similarity between response and reference on a scale of 0-5:
+0 = Completely different
+3 = Somewhat similar
+5 = Identical meaning
+
+Reference: {reference}
+Response: {response}
+
+Respond with only the number (0-5).""",
+    llm=llm
+)
 
 sample = SingleTurnSample(
     user_input="Where is the Eiffel Tower located?",
     response="The Eiffel Tower is located in Paris.",
     reference="The Eiffel Tower is located in Egypt"
 )
 
-scorer =  SimpleCriteriaScore(
-    name="course_grained_score",
-    definition="Score 0 to 5 by similarity",
-    llm=evaluator_llm
+result = await similarity_metric.ascore(
+    response=sample.response,
+    reference=sample.reference
 )
-
-await scorer.single_turn_ascore(sample)
-```
-Output
-```
-0
+print(f"Similarity Score: {result.value}")
 ```
 
+
 ## Rubrics based criteria scoring
 
 The Rubric-Based Criteria Scoring Metric is used to do evaluations based on user-defined rubrics. Each rubric defines a detailed score description, typically ranging from 1 to 5. The LLM assesses and scores responses according to these descriptions, ensuring a consistent and objective evaluation.

docs/getstarted/evals.md

@@ -157,28 +157,32 @@ Your quickstart project initializes the OpenAI LLM by default in the `_init_clie
 
 ### Using Pre-Built Metrics
 
-`ragas` comes with pre-built metrics for common evaluation tasks. For example, [AspectCritic](../concepts/metrics/available_metrics/aspect_critic.md) evaluates any aspect of your output:
+`ragas` comes with pre-built metrics for common evaluation tasks. For example, [Aspect Critique](../concepts/metrics/available_metrics/aspect_critic.md) evaluates any aspect of your output using `DiscreteMetric`:
 
 ```python
-from ragas.metrics.collections import AspectCritic
+from ragas.metrics import DiscreteMetric
 from ragas.llms import llm_factory
 
 # Setup your evaluator LLM
 evaluator_llm = llm_factory("gpt-4o")
 
-# Use a pre-built metric
-metric = AspectCritic(
+# Create a custom aspect evaluator
+metric = DiscreteMetric(
     name="summary_accuracy",
-    definition="Verify if the summary is accurate and captures key information.",
+    allowed_values=["accurate", "inaccurate"],
+    prompt="""Evaluate if the summary is accurate and captures key information.
+
+Response: {response}
+
+Answer with only 'accurate' or 'inaccurate'.""",
     llm=evaluator_llm
 )
 
 # Score your application's output
 score = await metric.ascore(
-    user_input="Summarize this text: ...",
     response="The summary of the text is..."
 )
-print(f"Score: {score.value}")  # 1 = pass, 0 = fail
+print(f"Score: {score.value}")  # 'accurate' or 'inaccurate'
 print(f"Reason: {score.reason}")
 ```
 

src/ragas/metrics/collections/__init__.py

@@ -3,21 +3,12 @@
 from ragas.metrics.collections._answer_correctness import AnswerCorrectness
 from ragas.metrics.collections._answer_relevancy import AnswerRelevancy
 from ragas.metrics.collections._answer_similarity import AnswerSimilarity
-from ragas.metrics.collections._aspect_critic import (
-    AspectCritic,
-    coherence,
-    conciseness,
-    correctness,
-    harmfulness,
-    maliciousness,
-)
 from ragas.metrics.collections._bleu_score import BleuScore
 from ragas.metrics.collections._context_entity_recall import ContextEntityRecall
 from ragas.metrics.collections._faithfulness import Faithfulness
 from ragas.metrics.collections._noise_sensitivity import NoiseSensitivity
 from ragas.metrics.collections._rouge_score import RougeScore
 from ragas.metrics.collections._semantic_similarity import SemanticSimilarity
-from ragas.metrics.collections._simple_criteria import SimpleCriteria
 from ragas.metrics.collections._string import (
     DistanceMeasure,
     ExactMatch,
@@ -32,7 +23,6 @@
     "AnswerCorrectness",
     "AnswerRelevancy",
     "AnswerSimilarity",
-    "AspectCritic",
     "BleuScore",
     "ContextEntityRecall",
     "DistanceMeasure",
@@ -42,13 +32,6 @@
     "NonLLMStringSimilarity",
     "RougeScore",
     "SemanticSimilarity",
-    "SimpleCriteria",
     "StringPresence",
     "SummaryScore",
-    # AspectCritic helper functions
-    "coherence",
-    "conciseness",
-    "correctness",
-    "harmfulness",
-    "maliciousness",
 ]