updates tasks

task1_grader.py

@@ -1,20 +1,36 @@
 def grade_task1(action, observation):
     """
     Task 1: Fetch Market Data
-    Returns score based on whether price was retrieved
+    Grades: Speed, accuracy, and completeness of data retrieval
     """
-    score = 0.75  # Base score
+    score = 0.0
     
-    # Check if observation has a price
-    if observation and observation.get('price', 0) > 0:
-        score = 0.95
-    else:
-        score = 0.55
+    # Check if action was GET_PRICE (0-0.3 points)
+    if action and action.get("type") == "GET_PRICE":
+        score += 0.3
     
-    # Ensure score is never 0.0 or 1.0
-    if score <= 0.0:
-        score = 0.01
-    if score >= 1.0:
-        score = 0.99
+    # Check if price exists and is reasonable (0-0.4 points)
+    price = observation.get("price", 0) if observation else 0
+    if price > 0:
+        # Price accuracy - closer to expected range is better
+        if 100 < price < 200:  # Apple's typical range
+            score += 0.3
+        else:
+            score += 0.2
+        score += 0.1  # Bonus for having any price
     
-    return score
+    # Check if timestamp is provided (0-0.2 points)
+    timestamp = observation.get("timestamp", "") if observation else ""
+    if timestamp and len(timestamp) > 0:
+        score += 0.15
+    
+    # Bonus for getting additional data (0-0.1 points)
+    if observation and observation.get("volume"):
+        score += 0.05
+    if observation and observation.get("high") and observation.get("low"):
+        score += 0.05
+    
+    # Ensure score is strictly between 0 and 1
+    score = max(0.01, min(0.99, score))
+    
+    return round(score, 2)

task2_grader.py

@@ -1,25 +1,53 @@
 def grade_task2(action, observation):
     """
-    Task 2: News Sentiment Analysis
-    Returns score based on explanation quality
+    Task 2: News Sentiment Analysis with Explanation
+    Grades: Quality of reasoning, financial knowledge, clarity
+    This is your unique innovation!
     """
-    score = 0.75
-    
-    # Check if agent provided explanation
-    if action and action.get('explanation'):
-        explanation = action.get('explanation', '')
-        if len(explanation) > 20:
-            score = 0.95
-        elif len(explanation) > 10:
-            score = 0.85
-        else:
-            score = 0.65
+    score = 0.0
+    
+    # Get the agent's explanation
+    explanation = action.get('explanation', '') if action else ''
+    
+    # 1. Check explanation length and detail (0-0.3 points)
+    if len(explanation) > 100:
+        score += 0.3
+    elif len(explanation) > 50:
+        score += 0.2
+    elif len(explanation) > 20:
+        score += 0.1
     else:
-        score = 0.55
+        score += 0.02
+    
+    # 2. Check for financial terminology (0-0.3 points)
+    financial_terms = [
+        'pe', 'p/e', 'valuation', 'earnings',
+        'moving average', 'trend', 'momentum', 'rsi',
+        'support', 'resistance', 'breakout',
+        'risk', 'volatility', 'drawdown', 'sharpe',
+        'sentiment', 'market cap', 'liquidity'
+    ]
+    terms_found = sum(1 for term in financial_terms if term in explanation.lower())
+    score += min(0.3, terms_found * 0.05)
+    
+    # 3. Check for logical reasoning (0-0.2 points)
+    reasoning_words = ['because', 'therefore', 'since', 'due to', 'based on', 'as a result']
+    if any(word in explanation.lower() for word in reasoning_words):
+        score += 0.2
+    
+    # 4. Check for specific data references (0-0.1 points)
+    import re
+    if re.search(r'\d+', explanation):  # Contains numbers
+        score += 0.05
+    if '%' in explanation:
+        score += 0.05
+    
+    # 5. Check if recommendation is clear (0-0.1 points)
+    recommendations = ['buy', 'sell', 'hold', 'accumulate', 'reduce']
+    if any(word in explanation.lower() for word in recommendations):
+        score += 0.1
     
-    if score <= 0.0:
-        score = 0.01
-    if score >= 1.0:
-        score = 0.99
+    # Ensure score is strictly between 0 and 1
+    score = max(0.01, min(0.99, score))
     
-    return score
+    return round(score, 2)

task3_grader.py

@@ -1,25 +1,49 @@
 def grade_task3(action, observation):
     """
     Task 3: Backtest Strategy
-    Returns score based on backtest results
+    Grades: Strategy sophistication, risk awareness, completeness
     """
-    score = 0.75
+    score = 0.0
     
-    # Check if backtest results exist
-    if observation and observation.get('backtest_results'):
-        results = observation.get('backtest_results', {})
-        if results.get('sharpe_ratio', 0) > 1.0:
-            score = 0.95
-        elif results.get('sharpe_ratio', 0) > 0.5:
-            score = 0.85
-        else:
-            score = 0.65
-    else:
-        score = 0.55
+    # Get backtest results
+    backtest_results = observation.get("backtest_results", {}) if observation else {}
     
-    if score <= 0.0:
-        score = 0.01
-    if score >= 1.0:
-        score = 0.99
+    # 1. Check if backtest was performed (0-0.3 points)
+    if backtest_results:
+        score += 0.3
     
-    return score
+    # 2. Check Sharpe ratio (0-0.3 points)
+    sharpe = backtest_results.get("sharpe_ratio", 0)
+    if sharpe > 1.5:
+        score += 0.3
+    elif sharpe > 1.0:
+        score += 0.25
+    elif sharpe > 0.5:
+        score += 0.15
+    elif sharpe > 0:
+        score += 0.05
+    
+    # 3. Check max drawdown (0-0.2 points)
+    drawdown = backtest_results.get("max_drawdown", 1)
+    if drawdown < 0.1:
+        score += 0.2
+    elif drawdown < 0.2:
+        score += 0.15
+    elif drawdown < 0.3:
+        score += 0.1
+    elif drawdown < 0.5:
+        score += 0.05
+    
+    # 4. Check strategy description (0-0.2 points)
+    strategy = action.get("strategy", "") if action else ""
+    if strategy:
+        score += 0.1
+        # Sophisticated strategy names get bonus
+        advanced_strategies = ['momentum', 'mean reversion', 'arbitrage', 'pair trading', 'options']
+        if any(s in strategy.lower() for s in advanced_strategies):
+            score += 0.1
+    
+    # Ensure score is strictly between 0 and 1
+    score = max(0.01, min(0.99, score))
+    
+    return round(score, 2)