Add files using upload-large-folder tool

GRPO/.ipynb_checkpoints/Reward-checkpoint.py

@@ -0,0 +1,87 @@
+import os
+import re
+import math
+import json
+from datetime import datetime
+from swift.plugin import ORM,orms
+from typing import Dict, List, Union
+
+
+class MultiModalAccuracyORM(ORM):
+    def __call__(self, completions, solution, **kwargs) -> List[float]:
+        """
+        Reward function that checks if the completion is correct.
+        Args:
+            completions (list[str]): Generated outputs
+            solution (list[str]): Ground Truths.
+
+        Returns:
+            list[float]: Reward scores
+        """
+        rewards = []
+        #completion_contents = [completion[0]["content"] for completion in completions]
+        for content, gt_score_orig in zip(completions, solution):
+            score_match = re.search(r"<overall score>(\d+)</overall score>", content)
+            #score_match = re.search(r"<score>(\d+)</score>", content)
+            pred_score = None
+            gt_score = None
+            # breakpoint()
+            # print(content)
+            # print(score_match)
+            if score_match:
+                try:
+                    pred_score = int(score_match.group(1))
+                    if not (1 <= pred_score <= 2):
+                        pred_score = None
+                except:
+                    pass
+    
+            try:
+                gt_score = int(gt_score_orig[0])
+                
+                if not (1 <= gt_score <= 2):
+                    gt_score = None
+            except:
+                pass
+    
+            # 分段奖励逻辑
+            if pred_score is not None and gt_score is not None:
+                if pred_score == gt_score:
+                    reward = 5.0
+                elif abs(pred_score - gt_score) <= 1:
+                    reward = 1.0
+                else:
+                    reward = 0.0
+            else:
+                reward = 0.0
+    
+            rewards.append(reward)
+        return rewards
+class MultiModalFormatAccuracyORM(ORM):
+    def __call__(self, completions, **kwargs) -> List[float]:
+        """Reward function that checks if the completion has a specific format."""
+        rewards = []
+        response_pattern = r"<response think>.*?</response think>"
+        react_pattern = r"<fluency think>.*?</fluency think>"
+        score_pattern = r"[*\s]*<overall score>(\d+)</overall score>[\s*]*"
+        #completion_contents = [completion[0]["content"] for completion in completions]
+        for content in completions:
+            # breakpoint()
+            # print(content)
+            has_response = bool(re.search(response_pattern, content, re.DOTALL))
+            #print(has_response)
+            has_react = bool(re.search(react_pattern, content, re.DOTALL))
+            #print(has_react)
+            has_score = bool(re.search(score_pattern, content, re.DOTALL))
+            #print(has_score)
+            if has_response and has_react and has_score:
+                rewards.append(5.0)
+            # elif has_score and (has_response or has_react):
+            #     rewards.append(3.0)
+            # elif has_response or has_react:
+            #     rewards.append(1.0)
+            else:
+                rewards.append(0)
+        return rewards
+orms['external_r1v_format_acc'] = MultiModalFormatAccuracyORM
+orms['external_r1v_acc'] = MultiModalAccuracyORM

GRPO/.ipynb_checkpoints/formatReward-checkpoint.py

@@ -0,0 +1,26 @@
+class MultiModalFormatAccuracyORM(ORM):
+    def __call__(self, completions, **kwargs) -> List[float]:
+        """Reward function that checks if the completion has a specific format."""
+        rewards = []
+        response_pattern = r"<response think>.*?</response think>"
+        react_pattern = r"<fluency think>.*?</fluency think>"
+        score_pattern = r"[*\s]*<overall score>(\d+)</overall score>[\s*]*"
+        for content in completion_contents:
+            breakpoint()
+            print(content)
+            has_response = bool(re.search(response_pattern, content, re.DOTALL))
+            print(has_response)
+            has_react = bool(re.search(react_pattern, content, re.DOTALL))
+            print(has_react)
+            has_score = bool(re.search(score_pattern, content, re.DOTALL))
+            print(has_score)
+            if has_response and has_react and has_score:
+                rewards.append(5.0)
+            # elif has_score and (has_response or has_react):
+            #     rewards.append(3.0)
+            # elif has_response or has_react:
+            #     rewards.append(1.0)
+            else:
+                rewards.append(0)
+        return rewards
+orms['external_r1v_format_acc'] = MultiModalFormatAccuracyORM

GRPO/formatReward.py

@@ -0,0 +1,26 @@
+class MultiModalFormatAccuracyORM(ORM):
+    def __call__(self, completions, **kwargs) -> List[float]:
+        """Reward function that checks if the completion has a specific format."""
+        rewards = []
+        response_pattern = r"<response think>.*?</response think>"
+        react_pattern = r"<fluency think>.*?</fluency think>"
+        score_pattern = r"[*\s]*<overall score>(\d+)</overall score>[\s*]*"
+        for content in completion_contents:
+            breakpoint()
+            print(content)
+            has_response = bool(re.search(response_pattern, content, re.DOTALL))
+            print(has_response)
+            has_react = bool(re.search(react_pattern, content, re.DOTALL))
+            print(has_react)
+            has_score = bool(re.search(score_pattern, content, re.DOTALL))
+            print(has_score)
+            if has_response and has_react and has_score:
+                rewards.append(5.0)
+            # elif has_score and (has_response or has_react):
+            #     rewards.append(3.0)
+            # elif has_response or has_react:
+            #     rewards.append(1.0)
+            else:
+                rewards.append(0)
+        return rewards
+orms['external_r1v_format_acc'] = MultiModalFormatAccuracyORM

cotSFT/.ipynb_checkpoints/add_streoaudio-checkpoint.py

@@ -0,0 +1,34 @@
+import json
+
+# 加载JSON数据的工具函数
+def load_json(file_path):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+# 保存JSON数据
+def save_json(data, file_path):
+    with open(file_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+# 主逻辑
+def add_stereo_audio_field(array_json_path, dict_json_path, output_path):
+    array_data = load_json(array_json_path)  # 加载JSON数组
+    dict_data = load_json(dict_json_path)    # 加载JSON字典
+
+    # 遍历数组中的每一项，根据"key"从字典中查找对应的"stereo_audio"
+    for item in array_data:
+        key = item.get("key")
+        if key in dict_data:
+            stereo_audio = dict_data[key].get("stereo_audio")
+            item["audio_url"] = stereo_audio  # 添加字段
+
+    # 保存结果
+    save_json(array_data, output_path)
+
+# 示例调用
+if __name__ == "__main__":
+    add_stereo_audio_field(
+        array_json_path="./test.json",
+        dict_json_path="./overlaps.json",
+        output_path="test.json"
+    )

cotSFT/add_streoaudio.py

@@ -0,0 +1,34 @@
+import json
+
+# 加载JSON数据的工具函数
+def load_json(file_path):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+# 保存JSON数据
+def save_json(data, file_path):
+    with open(file_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+# 主逻辑
+def add_stereo_audio_field(array_json_path, dict_json_path, output_path):
+    array_data = load_json(array_json_path)  # 加载JSON数组
+    dict_data = load_json(dict_json_path)    # 加载JSON字典
+
+    # 遍历数组中的每一项，根据"key"从字典中查找对应的"stereo_audio"
+    for item in array_data:
+        key = item.get("key")
+        if key in dict_data:
+            stereo_audio = dict_data[key].get("stereo_audio")
+            item["audio_url"] = stereo_audio  # 添加字段
+
+    # 保存结果
+    save_json(array_data, output_path)
+
+# 示例调用
+if __name__ == "__main__":
+    add_stereo_audio_field(
+        array_json_path="./test.json",
+        dict_json_path="./overlaps.json",
+        output_path="test.json"
+    )

cotSFT/gemini-correct/.ipynb_checkpoints/gemini2.5_metainfo-checkpoint.py

@@ -0,0 +1,317 @@
+import os
+import json
+import re
+import requests
+from tqdm import tqdm
+from datetime import datetime
+import glob
+from requests.exceptions import Timeout
+import argparse
+
+prompt_template = (
+    "# Interactional Dialogue Evaluation\n\n"
+    "**IMPORTANT**: Evaluation must include `<response think>` and `<fluency think>` analysis and `<overall score>` rating.\n"  
+    "Evaluate the quality of the interaction in the given dialogue transcript, focusing on:\n"
+    "**Response Relevance:** \n"
+    "**logical consistency, topic coherence**\n"
+    "**Interactional Fluency:**\n"
+    "**Detect and evaluate extended overlaps in conversation.**\n"
+    "**Detect and evaluate long pauses between speaker turns.\n\n**"
+    "**Note**: Small pauses and brief overlaps in conversation are acceptable, while prolonged pauses and overlapping turns are harmful. You should consider Response Relevance and Interactional Fluency separately, and provide the corresponding thinking process.\n\n"
+    "## Scoring Criteria\n"
+    "Assign a single holistic score based on the combined evaluation:\n"
+    "`1` (Poor): Significant issues in either  **Response Relevance ** or  **Interactional Fluency. **\n"
+    "`2` (Excellent): Both **Response Relevance ** and  **Interactional Fluency ** are consistently appropriate and natural.\n"
+    "## Evaluation Output Format:\n"
+    "Strictly follow this template:\n"
+    "<response think>\n"
+    "[Analysing Response Relevance and giving reasons for scoring...]\n"
+    "</response think>\n"
+    "<fluency think>\n"
+    "[Analysing Interactional Fluency and giving reasons for scoring.]\n"
+    "</fluency think>\n"
+    "<overall score>X</overall score>\n"
+)
+
+# API configuration
+url = "https://api2.aigcbest.top/v1/chat/completions"
+headers = {
+    "Authorization": "Bearer sk-yAIqUaGzzVNSesHq4mRPaCbt53MMFRJIMB97cS4FkRy6idwN",
+    "Content-Type": "application/json",
+    "Accept": "application/json"
+}
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Process text evaluation with Gemini model')
+    parser.add_argument('--input_file', type=str, required=True,
+                      help='Input JSON file containing text data')
+    parser.add_argument('--output_file', type=str, default='texterror_gemini.json',
+                      help='Output JSON file for results')
+    parser.add_argument('--error_file', type=str, default='texterror_gemini_error.json',
+                      help='Output JSON file for errors')
+    parser.add_argument('--checkpoint_dir', type=str, default='checkpoints_test_text',
+                      help='Directory for storing checkpoints')
+    parser.add_argument('--max_retries', type=int, default=3,
+                      help='Maximum number of retries for failed predictions')
+    parser.add_argument('--checkpoint_interval', type=int, default=20,
+                      help='Number of items to process before saving checkpoint')
+    return parser.parse_args()
+
+def extract_overall_score(output_str):
+    """Extract <overall score>X</overall score> from model output."""
+    score_pattern = r"<overall score>(\d+)</overall score>"
+    match = re.search(score_pattern, output_str)
+    if match:
+        try:
+            return int(match.group(1))
+        except ValueError:
+            pass
+    return None
+
+def validate_model_output(output_str):
+    """Validate that the model output contains all required tags"""
+    required_tags = [
+        "<response think>",
+        "</response think>",
+        "<fluency think>",
+        "</fluency think>",
+        "<overall score>",
+        "</overall score>"
+    ]
+    
+    for tag in required_tags:
+        if tag not in output_str:
+            return False
+    return True
+
+def extract_tag_content(output_str, tag_name):
+    """Extract content between opening and closing tags"""
+    start_tag = f"<{tag_name}>"
+    end_tag = f"</{tag_name}>"
+    try:
+        start_idx = output_str.find(start_tag) + len(start_tag)
+        end_idx = output_str.find(end_tag)
+        if start_idx == -1 or end_idx == -1:
+            return None
+        return output_str[start_idx:end_idx].strip()
+    except:
+        return None
+
+def format_model_output(output_str):
+    """Extract and format content from all required tags"""
+    response_content = extract_tag_content(output_str, "response think")
+    fluency_content = extract_tag_content(output_str, "fluency think")
+    score_content = extract_tag_content(output_str, "overall score")
+    
+    if not all([response_content, fluency_content, score_content]):
+        return None
+        
+    formatted_output = (
+        f"<response think>\n{response_content}\n</response think>\n\n"
+        f"<fluency think>\n{fluency_content}\n</fluency think>\n\n"
+        f"<overall score>{score_content}</overall score>"
+    )
+    return formatted_output
+
+def make_api_call(text_input, retry_count=0, max_retries=5):
+    """Make API call with retry logic for API errors"""
+    try:
+        print(f"Attempting API call (attempt {retry_count + 1}/{max_retries + 1})")
+        data_req = {
+            "model": "gemini-2.5-flash-preview-05-20-thinking",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt_template
+                        },
+                        {
+                            "type": "text",
+                            "text": text_input
+                        },
+                    ]
+                }
+            ],
+            "temperature": 1,
+        }
+        
+        response = requests.post(url, headers=headers, json=data_req, timeout=(200, 200))
+        print(f"API response received with status code: {response.status_code}")
+        
+        if response.status_code == 200:
+            model_output = response.json()['choices'][0]['message']['content']
+            if not validate_model_output(model_output):
+                print("Model output missing required tags, retrying...")
+                return None, None
+                
+            formatted_output = format_model_output(model_output)
+            if formatted_output is None:
+                print("Failed to extract content from tags, retrying...")
+                return None, None
+                
+            pred_score = extract_overall_score(model_output)
+            return formatted_output, pred_score
+        else:
+            print(f"API returned error status {response.status_code}: {response.text}")
+            if retry_count >= max_retries:
+                raise Exception(f"POST error {response.status_code}: {response.text}")
+            return None, None
+    except requests.exceptions.ConnectTimeout:
+        print(f"Connection timeout (>10s)")
+        if retry_count >= max_retries:
+            raise Exception("Connection timeout")
+        return None, None
+    except requests.exceptions.ReadTimeout:
+        print(f"Read timeout (>30s)")
+        if retry_count >= max_retries:
+            raise Exception("Read timeout")
+        return None, None
+    except Exception as e:
+        print(f"Unexpected error during API call: {str(e)}")
+        if retry_count >= max_retries:
+            raise e
+        return None, None
+
+def get_latest_checkpoint(checkpoint_dir):
+    """Get the latest checkpoint file and its processed count"""
+    checkpoint_files = glob.glob(os.path.join(checkpoint_dir, "checkpoint_*.json"))
+    if not checkpoint_files:
+        return None, 0
+    
+    latest_checkpoint = None
+    max_count = 0
+    for checkpoint in checkpoint_files:
+        try:
+            count = int(os.path.basename(checkpoint).split('_')[1])
+            if count > max_count:
+                max_count = count
+                latest_checkpoint = checkpoint
+        except (ValueError, IndexError):
+            continue
+    
+    return latest_checkpoint, max_count
+
+def save_checkpoint(results, processed_count, checkpoint_dir):
+    """Save results to a checkpoint file"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    checkpoint_file = os.path.join(checkpoint_dir, f"checkpoint_{processed_count}_{timestamp}.json")
+    with open(checkpoint_file, "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    print(f"Checkpoint saved: {checkpoint_file}")
+
+def main():
+    args = parse_args()
+    
+    # Initialize results storage
+    results = []
+    save_file_name = args.output_file
+    error_file_name = args.error_file
+    
+    # Create checkpoints directory
+    checkpoint_dir = args.checkpoint_dir
+    if not os.path.exists(checkpoint_dir):
+        os.makedirs(checkpoint_dir)
+    
+    # Load test data
+    all_data_file = args.input_file
+    with open(all_data_file, 'r', encoding='utf-8') as f:
+        all_data = json.load(f)
+    
+    # Initialize error tracking
+    error_results = []
+    
+    # Load checkpoint if exists
+    latest_checkpoint, checkpoint_count = get_latest_checkpoint(checkpoint_dir)
+    if latest_checkpoint:
+        print(f"Found latest checkpoint with {checkpoint_count} processed items: {latest_checkpoint}")
+        try:
+            with open(latest_checkpoint, 'r', encoding='utf-8') as f:
+                results = json.load(f)
+                print(f"Resumed from checkpoint: processed {len(results)} items")
+        except Exception as e:
+            print(f"Warning: Failed to load checkpoint {latest_checkpoint}: {e}")
+            results = []
+    else:
+        print("No checkpoint found, starting from scratch")
+        results = []
+    
+    max_prediction_retries = args.max_retries
+    total_count = 0
+    
+    for item in tqdm(all_data, desc="Processing texts"):
+        key = item.get('key')
+        text_input = item.get('model_output')
+        
+        if not text_input:
+            print(f"No text input found for key {key}, skipping...")
+            continue
+        
+        print(f"Processing text for key={key}")
+        
+        prediction_retry_count = 0
+        success = False
+        
+        while prediction_retry_count < max_prediction_retries and not success:
+            try:
+                print(f"\nProcessing attempt {prediction_retry_count + 1}")
+                model_output, pred_score = make_api_call(text_input)
+                
+                if model_output is None or pred_score is None:
+                    print("API call failed, retrying...")
+                    prediction_retry_count += 1
+                    continue
+                    
+                print(f"Received prediction: {pred_score}")
+                
+                if pred_score == 2:
+                    success = True
+                    print("Prediction score is 2, accepting result")
+                else:
+                    prediction_retry_count += 1
+                    print(f"Prediction score is not 2 (attempt {prediction_retry_count}/{max_prediction_retries})")
+                    if prediction_retry_count >= max_prediction_retries:
+                        print("Max retries reached, accepting last prediction")
+                        success = True
+                    else:
+                        continue
+                
+                results.append({
+                    "key": key,
+                    "text_input": text_input,
+                    "model_output": model_output,
+                    "predicted_score": pred_score,
+                    "prediction_attempts": prediction_retry_count + 1
+                })
+                
+                with open(save_file_name, "w", encoding="utf-8") as f:
+                    json.dump(results, f, indent=2, ensure_ascii=False)
+                    
+                total_count += 1
+                
+                if total_count % args.checkpoint_interval == 0:
+                    save_checkpoint(results, total_count, checkpoint_dir)
+                
+            except Exception as e:
+                error_msg = str(e)
+                print(f"Failed to process text for key {key}: {error_msg}")
+                error_results.append({
+                    "key": key,
+                    "text_input": text_input,
+                    "error": f"Exception: {error_msg}"
+                })
+                break
+                
+        with open(error_file_name, "w", encoding="utf-8") as f:
+            json.dump(error_results, f, indent=2, ensure_ascii=False)
+    
+    # Save final results
+    with open(save_file_name, "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    
+    print(f"Results saved to {save_file_name}")
+    print(f"Total processed items: {total_count}")
+
+if __name__ == "__main__":
+    main()

cotSFT/gemini-correct/.ipynb_checkpoints/run_gemini_meta-checkpoint.sh

@@ -0,0 +1 @@
+python gemini2.5_metainfo.py --input_file thinkSFT_correct_transcriptions.json --output_file results.json --error_file errors.json --max_retries 5 --checkpoint_interval 100