`."
+ ),
+ },
+ {
+ "role": "user",
+ "content": question,
+ },
+ ],
+ "ability": "math",
+ "reward_model": {"style": "rule", "ground_truth": solution},
+ "extra_info": {
+ "split": split,
+ "index": idx,
+ "answer": answer_raw,
+ "question": question_raw,
+ "need_tools_kwargs": True,
+ "tools_kwargs": {
+ "calc_gsm8k_reward": {
+ "create_kwargs": {"ground_truth": solution},
+ # "execute_kwargs": {},
+ # "calc_reward_kwargs": {},
+ # "release_kwargs": {},
+ },
+ },
+ "interaction_kwargs": {
+ "query": question,
+ "ground_truth": solution,
+ },
+ },
+ }
+ return data
+
+ return process_fn
+
+ train_dataset = train_dataset.map(function=make_map_fn("train"), with_indices=True)
+ test_dataset = test_dataset.map(function=make_map_fn("test"), with_indices=True)
+
+ hdfs_dir = args.hdfs_dir
+ local_save_dir = args.local_dir
+ if local_save_dir is not None:
+ print("Warning: Argument 'local_dir' is deprecated. Please use 'local_save_dir' instead.")
+ else:
+ local_save_dir = args.local_save_dir
+
+ train_dataset.to_parquet(os.path.join(local_save_dir, "train.parquet"))
+ test_dataset.to_parquet(os.path.join(local_save_dir, "test.parquet"))
+
+ if hdfs_dir is not None:
+ makedirs(hdfs_dir)
+ copy(src=local_save_dir, dst=hdfs_dir)
diff --git a/code/RL_model/verl/verl_train/examples/data_preprocess/hellaswag.py b/code/RL_model/verl/verl_train/examples/data_preprocess/hellaswag.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc73a810a80570d406bb727099f5524037be2370
--- /dev/null
+++ b/code/RL_model/verl/verl_train/examples/data_preprocess/hellaswag.py
@@ -0,0 +1,108 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Preprocess Hellaswag dataset.
+
+"""
+
+import argparse
+import os
+import re
+
+import datasets
+
+from verl.utils.hdfs_io import copy, makedirs
+
+
+def preprocess(text):
+ text = text.strip()
+ # NOTE: Brackets are artifacts of the WikiHow dataset portion of HellaSwag.
+ text = text.replace(" [title]", ". ")
+ text = re.sub("\\[.*?\\]", "", text)
+ text = text.replace(" ", " ")
+ return text
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--local_dir", default=None, help="The save directory for the preprocessed dataset.")
+ parser.add_argument("--hdfs_dir", default=None)
+ parser.add_argument("--local_dataset_path", default=None, help="The local path to the raw dataset, if it exists.")
+ parser.add_argument(
+ "--local_save_dir", default="~/data/hellaswag", help="The save directory for the preprocessed dataset."
+ )
+
+ args = parser.parse_args()
+ local_dataset_path = args.local_dataset_path
+
+ data_source = "Rowan/hellaswag"
+
+ if local_dataset_path is not None:
+ dataset = datasets.load_dataset(local_dataset_path)
+ else:
+ dataset = datasets.load_dataset(data_source, trust_remote_code=True)
+
+ train_dataset = dataset["train"]
+ val_dataset = dataset["validation"]
+ test_dataset = dataset["test"]
+
+ instruction = "Please complete the following sentence.\n"
+
+ def make_map_fn(split):
+ def process_fn(doc, idx):
+ ctx = doc["ctx_a"] + " " + doc["ctx_b"].capitalize()
+ query = preprocess(doc["activity_label"] + ": " + ctx)
+ choices = [preprocess(ending) for ending in doc["endings"]]
+ gold = int(doc["label"])
+
+ data = {
+ "data_source": data_source,
+ "prompt": [{"role": "user", "content": query}],
+ "ability": "nlp",
+ "reward_model": {
+ "style": "model",
+ "eval": "multiple_choice", # using loglikelihood
+ "ground_truth": gold,
+ "choices": choices,
+ },
+ "extra_info": {"split": split, "index": idx},
+ }
+ return data
+
+ return process_fn
+
+ # filter data that doesn't have a label
+ train_dataset = train_dataset.filter(lambda x: len(x["label"]) > 0)
+ val_dataset = val_dataset.filter(lambda x: len(x["label"]) > 0)
+ test_dataset = test_dataset.filter(lambda x: len(x["label"]) > 0)
+
+ train_dataset = train_dataset.map(function=make_map_fn("train"), with_indices=True)
+ val_dataset = val_dataset.map(function=make_map_fn("validation"), with_indices=True)
+ test_dataset = test_dataset.map(function=make_map_fn("test"), with_indices=True)
+
+ hdfs_dir = args.hdfs_dir
+ local_save_dir = args.local_dir
+ if local_save_dir is not None:
+ print("Warning: Argument 'local_dir' is deprecated. Please use 'local_save_dir' instead.")
+ else:
+ local_save_dir = args.local_save_dir
+
+ train_dataset.to_parquet(os.path.join(local_save_dir, "train.parquet"))
+ val_dataset.to_parquet(os.path.join(local_save_dir, "validation.parquet"))
+ test_dataset.to_parquet(os.path.join(local_save_dir, "test.parquet"))
+
+ if hdfs_dir is not None:
+ makedirs(hdfs_dir)
+
+ copy(src=local_save_dir, dst=hdfs_dir)
diff --git a/code/RL_model/verl/verl_train/examples/data_preprocess/math_dataset.py b/code/RL_model/verl/verl_train/examples/data_preprocess/math_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..b23a032fb1207a47dcd1bc77194a7c1a124aad55
--- /dev/null
+++ b/code/RL_model/verl/verl_train/examples/data_preprocess/math_dataset.py
@@ -0,0 +1,106 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Preprocess the MATH-lighteval dataset to parquet format
+"""
+
+import argparse
+import json
+import os
+
+import datasets
+
+from verl.utils.hdfs_io import copy, makedirs
+from verl.utils.reward_score.math_reward import last_boxed_only_string, remove_boxed
+
+
+def extract_solution(solution_str):
+ return remove_boxed(last_boxed_only_string(solution_str))
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--local_dir", default=None)
+ parser.add_argument("--hdfs_dir", default=None)
+ parser.add_argument("--local_dataset_path", default=None, help="The local path to the raw dataset, if it exists.")
+ parser.add_argument(
+ "--local_save_dir", default="~/data/math", help="The save directory for the preprocessed dataset."
+ )
+
+ args = parser.parse_args()
+ local_dataset_path = args.local_dataset_path
+
+ # 'lighteval/MATH' is no longer available on huggingface.
+ # Use mirror repo: DigitalLearningGmbH/MATH-lighteval
+ data_source = "DigitalLearningGmbH/MATH-lighteval"
+ print(f"Loading the {data_source} dataset from huggingface...", flush=True)
+ if local_dataset_path is not None:
+ dataset = datasets.load_dataset(
+ local_dataset_path,
+ )
+ else:
+ dataset = datasets.load_dataset(
+ data_source,
+ )
+
+ train_dataset = dataset["train"]
+ test_dataset = dataset["test"]
+
+ instruction_following = "Let's think step by step and output the final answer within \\boxed{}."
+
+ # add a row to each data item that represents a unique id
+ def make_map_fn(split):
+ def process_fn(example, idx):
+ question = example.pop("problem")
+
+ question = question + " " + instruction_following
+
+ answer = example.pop("solution")
+ solution = extract_solution(answer)
+ data = {
+ "data_source": data_source,
+ "prompt": [{"role": "user", "content": question}],
+ "ability": "math",
+ "reward_model": {"style": "rule", "ground_truth": solution},
+ "extra_info": {"split": split, "index": idx},
+ }
+ return data
+
+ return process_fn
+
+ train_dataset = train_dataset.map(function=make_map_fn("train"), with_indices=True)
+ test_dataset = test_dataset.map(function=make_map_fn("test"), with_indices=True)
+
+ local_save_dir = args.local_dir
+ if local_save_dir is not None:
+ print("Warning: Argument 'local_dir' is deprecated. Please use 'local_save_dir' instead.")
+ else:
+ local_save_dir = args.local_save_dir
+
+ local_dir = os.path.expanduser(local_save_dir)
+ hdfs_dir = args.hdfs_dir
+
+ train_dataset.to_parquet(os.path.join(local_dir, "train.parquet"))
+ test_dataset.to_parquet(os.path.join(local_dir, "test.parquet"))
+ # Save one example as JSON for reference
+ example = train_dataset[0]
+ with open(os.path.join(local_dir, "train_example.json"), "w") as f:
+ json.dump(example, f, indent=2)
+ example = test_dataset[0]
+ with open(os.path.join(local_dir, "test_example.json"), "w") as f:
+ json.dump(example, f, indent=2)
+ if hdfs_dir is not None:
+ makedirs(hdfs_dir)
+
+ copy(src=local_dir, dst=hdfs_dir)
diff --git a/code/RL_model/verl/verl_train/examples/data_preprocess/multiturn.py b/code/RL_model/verl/verl_train/examples/data_preprocess/multiturn.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bf0192b817d3acfc41f7e4a74a4a891d3ae61d6
--- /dev/null
+++ b/code/RL_model/verl/verl_train/examples/data_preprocess/multiturn.py
@@ -0,0 +1,125 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Create a simple multi-turn dataset for testing
+"""
+
+import argparse
+import os
+
+import pandas as pd
+
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--local_dir", default="~/data/multiturn")
+ parser.add_argument("--hdfs_dir", default=None)
+ args = parser.parse_args()
+
+ # Create example conversations
+ conversations = []
+
+ # Conversation 1
+ conversations.append(
+ {
+ "messages": [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "What is the capital of France?"},
+ {"role": "assistant", "content": "The capital of France is Paris."},
+ {"role": "user", "content": "And what about Germany?"},
+ {"role": "assistant", "content": "The capital of Germany is Berlin."},
+ ]
+ }
+ )
+
+ # Conversation 2
+ conversations.append(
+ {
+ "messages": [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Can you explain quantum computing?"},
+ {
+ "role": "assistant",
+ "content": "Quantum computing is a type of computing that uses quantum-mechanical phenomena, "
+ "such as superposition and entanglement, to perform operations on data.",
+ },
+ {"role": "user", "content": "How is it different from classical computing?"},
+ {
+ "role": "assistant",
+ "content": "Classical computing uses bits that are either 0 or 1, while quantum computing uses "
+ "quantum bits or qubits that can exist in multiple states simultaneously due to superposition.",
+ },
+ ]
+ }
+ )
+
+ # Conversation 3
+ conversations.append(
+ {
+ "messages": [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Write a simple Python function to calculate factorial."},
+ {
+ "role": "assistant",
+ "content": (
+ "```python\ndef factorial(n):\n if n == 0 or n == 1:\n return 1\n else:\n "
+ "return n * factorial(n-1)\n```\n\nThis is a recursive function to calculate the "
+ "factorial of a number."
+ ),
+ },
+ {"role": "user", "content": "Can you make it iterative instead?"},
+ {
+ "role": "assistant",
+ "content": (
+ "```python\ndef factorial(n):\n result = 1\n for i in range(1, n+1):\n "
+ "result *= i\n return result\n```\n\nThis is an iterative version of the factorial function."
+ ),
+ },
+ ]
+ }
+ )
+
+ # Create train and test datasets
+ train_data = conversations[:2] # First 2 conversations for training
+ test_data = conversations[2:] # Last conversation for testing
+
+ # Create output directory
+ local_dir = os.path.expanduser(args.local_dir)
+ os.makedirs(local_dir, exist_ok=True)
+
+ # Save to parquet files
+ train_df = pd.DataFrame(train_data)
+ test_df = pd.DataFrame(test_data)
+
+ train_df.to_parquet(os.path.join(local_dir, "train.parquet"))
+ test_df.to_parquet(os.path.join(local_dir, "test.parquet"))
+
+ # Handle HDFS if specified
+ if args.hdfs_dir is not None:
+ try:
+ from verl.utils.hdfs_io import copy, makedirs
+
+ makedirs(args.hdfs_dir)
+ copy(src=local_dir, dst=args.hdfs_dir)
+ except ImportError:
+ print("Warning: HDFS support not available. Skipping HDFS copy.")
+
+ # Print statistics
+ print(f"Train dataset size: {len(train_df)}")
+ print(f"Test dataset size: {len(test_df)}")
+ print(f"Data saved to {local_dir}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/code/RL_model/verl/verl_train/examples/data_preprocess/pokemon.py b/code/RL_model/verl/verl_train/examples/data_preprocess/pokemon.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bbf4d4b46ee98669eaa40a9a9084f918791f50d
--- /dev/null
+++ b/code/RL_model/verl/verl_train/examples/data_preprocess/pokemon.py
@@ -0,0 +1,75 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+"""
+Preprocess the llamafactory/pokemon-gpt4o-captions dataset to parquet format
+"""
+
+import argparse
+import os
+
+import datasets
+
+from verl.utils.hdfs_io import copy, makedirs
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--local_dir", default=None)
+ parser.add_argument("--hdfs_dir", default=None)
+ parser.add_argument("--local_dataset_path", default=None, help="The local path to the raw dataset, if it exists.")
+ parser.add_argument(
+ "--local_save_dir",
+ default="~/data/pokemon-gpt4o-captions",
+ help="The save directory for the preprocessed dataset.",
+ )
+
+ args = parser.parse_args()
+ local_dataset_path = args.local_dataset_path
+
+ data_source = "llamafactory/pokemon-gpt4o-captions"
+
+ if local_dataset_path is not None:
+ dataset = datasets.load_dataset(
+ local_dataset_path,
+ )
+ else:
+ dataset = datasets.load_dataset(
+ data_source,
+ )
+
+ def map_fn(row: dict):
+ messages = []
+ conversation = row.pop("conversations")
+ for conv in conversation:
+ if conv["from"] == "gpt":
+ role = "assistant"
+ elif conv["from"] == "human":
+ role = "user"
+ else:
+ raise ValueError(f"Unknown role: {conv['from']}")
+ messages.append(
+ {
+ "role": role,
+ "content": conv["value"],
+ }
+ )
+
+ row["messages"] = messages
+ return row
+
+ dataset = dataset["train"].map(map_fn, num_proc=16)
+ dataset = dataset.train_test_split(test_size=0.1)
+ train_dataset = dataset["train"]
+ test_dataset = dataset["test"]
+
+ hdfs_dir = args.hdfs_dir
+ local_save_dir = args.local_dir
+ if local_save_dir is not None:
+ print("Warning: Argument 'local_dir' is deprecated. Please use 'local_save_dir' instead.")
+ else:
+ local_save_dir = args.local_save_dir
+
+ train_dataset.to_parquet(os.path.join(local_save_dir, "train.parquet"))
+ test_dataset.to_parquet(os.path.join(local_save_dir, "test.parquet"))
+
+ if hdfs_dir is not None:
+ makedirs(hdfs_dir)
+ copy(src=local_save_dir, dst=hdfs_dir)
diff --git a/code/RL_model/verl/verl_train/examples/data_preprocess/preprocess_search_r1_dataset.py b/code/RL_model/verl/verl_train/examples/data_preprocess/preprocess_search_r1_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0c10d59b9c006ae7234ce21f7bdb25562259b23
--- /dev/null
+++ b/code/RL_model/verl/verl_train/examples/data_preprocess/preprocess_search_r1_dataset.py
@@ -0,0 +1,178 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2023-2024 SGLang Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import logging
+import os
+import tempfile
+
+import pandas as pd
+from huggingface_hub import hf_hub_download
+from huggingface_hub.utils import EntryNotFoundError
+
+from verl.utils.hdfs_io import copy, makedirs
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Configuration constants
+DEFAULT_SYSTEM_CONTENT = "You are a helpful and harmless assistant."
+DEFAULT_USER_CONTENT_PREFIX = (
+ "Answer the given question. You must conduct reasoning inside and "
+ "first every time you get new information. After reasoning, if you find you lack "
+ "some knowledge, you can call a search engine by query "
+ "and it will return the top searched results between and "
+ ". You can search as many times as your want. If you find no "
+ "further external knowledge needed, you can directly provide the answer inside "
+ " and , without detailed illustrations. For example, "
+ " Beijing . Question: "
+)
+
+
+def process_single_row(row, current_split_name, row_index):
+ """
+ Process a single row of data for SearchR1-like format.
+
+ Args:
+ row: DataFrame row containing the original data
+ current_split_name: Name of the current split (train/test)
+ row_index: Index of the row in the DataFrame
+
+ Returns:
+ pd.Series: Processed row data in the required format
+ """
+ question = row.get("question", "")
+
+ # Build prompt structure
+ user_content = user_content_prefix.rstrip("\n") + question
+ prompt = [{"role": "system", "content": system_content}, {"role": "user", "content": user_content}]
+
+ # Extract ground truth from reward_model or fallback to golden_answers
+ reward_model_data = row.get("reward_model")
+ if isinstance(reward_model_data, dict) and "ground_truth" in reward_model_data:
+ ground_truth = reward_model_data.get("ground_truth")
+ else:
+ ground_truth = row.get("golden_answers", [])
+
+ # Process data source
+ data_source_tagged = "searchR1_" + str(row.get("data_source", ""))
+
+ # Build tools kwargs structure
+ tools_kwargs = {
+ "search": {
+ "create_kwargs": {"ground_truth": ground_truth, "question": question, "data_source": data_source_tagged}
+ }
+ }
+
+ # Build complete extra_info structure
+ extra_info = {
+ "index": row_index,
+ "need_tools_kwargs": True,
+ "question": question,
+ "split": current_split_name,
+ "tools_kwargs": tools_kwargs,
+ }
+
+ return pd.Series(
+ {
+ "data_source": data_source_tagged,
+ "prompt": prompt,
+ "ability": row.get("ability"),
+ "reward_model": reward_model_data,
+ "extra_info": extra_info,
+ "metadata": row.get("metadata"),
+ }
+ )
+
+
+def main():
+ local_save_dir = os.path.expanduser(args.local_dir)
+ os.makedirs(local_save_dir, exist_ok=True)
+
+ processed_files = []
+
+ # Download and process files using temporary directory
+ with tempfile.TemporaryDirectory() as tmp_download_dir:
+ for split in ["train", "test"]:
+ parquet_filename = f"{split}.parquet"
+ logger.info(f"Processing {split} split...")
+
+ try:
+ # Download Parquet file from HuggingFace
+ logger.info(f"Downloading {parquet_filename} from {args.hf_repo_id}")
+ local_parquet_filepath = hf_hub_download(
+ repo_id=args.hf_repo_id,
+ filename=parquet_filename,
+ repo_type="dataset",
+ local_dir=tmp_download_dir,
+ local_dir_use_symlinks=False,
+ )
+
+ # Load and process Parquet file
+ df_raw = pd.read_parquet(local_parquet_filepath)
+ logger.info(f"Loaded {len(df_raw)} rows from {parquet_filename}")
+
+ def apply_process_row(row, split_name=split):
+ return process_single_row(row, current_split_name=split_name, row_index=row.name)
+
+ df_processed = df_raw.apply(apply_process_row, axis=1)
+
+ # Save processed DataFrame
+ output_file_path = os.path.join(local_save_dir, f"{split}.parquet")
+ df_processed.to_parquet(output_file_path, index=False)
+ logger.info(f"Saved {len(df_processed)} processed rows to {output_file_path}")
+ processed_files.append(output_file_path)
+
+ except EntryNotFoundError:
+ logger.warning(f"{parquet_filename} not found in repository {args.hf_repo_id}")
+ except Exception as e:
+ logger.error(f"Error processing {split} split: {e}")
+
+ if not processed_files:
+ logger.warning("No data was processed or saved")
+ return
+
+ logger.info(f"Successfully processed {len(processed_files)} files to {local_save_dir}")
+
+ # Copy to HDFS if specified
+ if args.hdfs_dir:
+ try:
+ makedirs(args.hdfs_dir)
+ copy(src=local_save_dir, dst=args.hdfs_dir)
+ logger.info(f"Successfully copied files to HDFS: {args.hdfs_dir}")
+ except Exception as e:
+ logger.error(f"Error copying files to HDFS: {e}")
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(description="Download Search-R1 from HuggingFace, process, and save to Parquet.")
+ parser.add_argument(
+ "--hf_repo_id", default="PeterJinGo/nq_hotpotqa_train", help="HuggingFace dataset repository ID."
+ )
+ parser.add_argument(
+ "--local_dir",
+ default="~/data/searchR1_processed_direct",
+ help="Local directory to save the processed Parquet files.",
+ )
+ parser.add_argument("--hdfs_dir", default=None, help="Optional HDFS directory to copy the Parquet files to.")
+
+ args = parser.parse_args()
+
+ # System and user content configuration
+ system_content = DEFAULT_SYSTEM_CONTENT
+ user_content_prefix = DEFAULT_USER_CONTENT_PREFIX
+
+ main()
diff --git a/code/RL_model/verl/verl_train/examples/gmpo_trainer/README.md b/code/RL_model/verl/verl_train/examples/gmpo_trainer/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..71d0bb212235ad7e1297822ad6c130711d19d262
--- /dev/null
+++ b/code/RL_model/verl/verl_train/examples/gmpo_trainer/README.md
@@ -0,0 +1,59 @@
+
+
+# Geometric-Mean Policy Optimization
+
+
+This is the official implementaion of paper [***Geometric-Mean Policy Optimization***](https://arxiv.org/abs/2507.20673).
+
+
+
+
Error: Server Error
\nThe server encountered a temporary error and could not complete your request.
Please try again in 30 seconds.\n
\n