mirror of
https://github.com/InternLM/InternBootcamp.git
synced 2026-04-25 17:10:49 +00:00
290 lines
10 KiB
Python
Executable file
290 lines
10 KiB
Python
Executable file
"""# 谜题训练场开发任务
|
||
|
||
## 任务概述
|
||
你是一位资深程序员，我需要你帮我实现一个特定谜题的训练场环境类。这个类继承自`Basebootcamp`，用于生成谜题实例并验证解答。
|
||
|
||
## 背景说明
|
||
我正在开发一系列谜题训练场，每个训练场对应一个特定类型的谜题。训练场类命名为`{PuzzleName}bootcamp`，其中`PuzzleName`是谜题的名称。
|
||
|
||
每个训练场类主要提供两个核心功能：
|
||
1. 生成该谜题类型的问题实例
|
||
2. 验证用户对问题的回答是否正确
|
||
|
||
## 技术接口规范
|
||
|
||
### 类方法实现要求
|
||
|
||
```python
|
||
class {PuzzleName}bootcamp(Basebootcamp):
|
||
def __init__(self, **params):
|
||
\"\"\"
|
||
请你自定义params，以保存该puzzle相关的参数，例如网格大小等，参数配有默认值
|
||
\"\"\"
|
||
pass
|
||
|
||
def case_generator(self):
|
||
\"\"\"
|
||
生成谜题实例，提示：为保证谜题有解，可以先生成结果再对结果处理得到谜题
|
||
返回：一个可JSON序列化的字典（避免包含set等无法通过json.dumps处理的数据结构）
|
||
\"\"\"
|
||
pass
|
||
|
||
@staticmethod
|
||
def prompt_func(question_case) -> str:
|
||
\"\"\"
|
||
将case_generator生成的谜题实例转换为文本形式的问题，问题中包含问题背景、对谜题规则的介绍、具体要解决的谜题实例、期望最终答案的格式，
|
||
例如：你是xxxx，请你解答yyyy，规则如下：yyyy，最终答案放置在：zzzzz
|
||
|
||
参数:
|
||
question_case: 由case_generator生成的谜题实例
|
||
|
||
返回:
|
||
str: 格式化的问题字符串
|
||
|
||
注意:
|
||
1. 需考虑问题的格式，以便后续能正确提取
|
||
2. 问题描述中应包含期望的答案格式说明，以便后续能正确提取，为了避免抽取时匹配出干扰项，请要求模型将答案放在特定标签，如[answer] [/answer]内
|
||
\"\"\"
|
||
pass
|
||
|
||
@staticmethod
|
||
def extract_output(output):
|
||
\"\"\"
|
||
从LLM的回复中提取符合格式要求的答案，如有多个，请抽取最后一个，避免使用re.search等只抽取第一个结果的方式。
|
||
|
||
参数:
|
||
output: LLM的完整输出（包含原始问题和回答）
|
||
|
||
返回:
|
||
提取的答案，若未找到符合格式的答案则返回None
|
||
\"\"\"
|
||
pass
|
||
|
||
@classmethod
|
||
def _verify_correction(cls, solution, identity):
|
||
\"\"\"
|
||
验证提取的答案是否正确，注意一个问题可以能有多个解，按照谜题规则进行检验，不要直接匹配可能的答案。
|
||
|
||
参数:
|
||
solution: extract_output提取的答案
|
||
identity: case_generator生成的谜题实例
|
||
|
||
返回:
|
||
bool: 答案是否正确
|
||
\"\"\"
|
||
pass
|
||
```
|
||
|
||
### 验证评分方法（基类已实现）
|
||
|
||
```python
|
||
@classmethod
|
||
def verify_score(cls, model_output, identity:dict, format_score=0.1) -> float:
|
||
\"\"\"
|
||
验证输出结果并评分。
|
||
|
||
参数:
|
||
model_output: 模型的完整输出
|
||
identity: 谜题实例（由case_generator生成）
|
||
format_score: 答案格式正确时的基础分数
|
||
|
||
返回:
|
||
float: 评分结果（0-1之间）
|
||
\"\"\"
|
||
score = 0.
|
||
try:
|
||
extract_solution = cls.extract_output(model_output)
|
||
if extract_solution is None:
|
||
return score
|
||
else:
|
||
score = format_score # 格式正确时的基础分数
|
||
if cls._verify_correction(extract_solution, identity):
|
||
score = 1. # 答案完全正确时的满分
|
||
except Exception as e:
|
||
# 处理异常情况
|
||
pass
|
||
return score
|
||
```
|
||
|
||
### 使用示例
|
||
|
||
```python
|
||
# 初始化谜题训练场
|
||
bootcamp = Puzzlebootcamp()
|
||
|
||
# 生成谜题实例
|
||
case = bootcamp.case_generator()
|
||
|
||
# 将谜题转换为文本问题
|
||
prompt = Puzzlebootcamp.prompt_func(case)
|
||
|
||
# 获取LLM对问题的解答
|
||
response = get_response(prompt, \"LLM\")
|
||
|
||
# 从完整对话中提取答案
|
||
extracted_output = Puzzlebootcamp.extract_output(prompt + response)
|
||
|
||
# 验证答案并评分
|
||
score = Puzzlebootcamp.verify_score(extracted_output, case)
|
||
```
|
||
|
||
## 你的任务
|
||
请根据以下谜题描述（谜题描述可能不完整，请先结合你的知识澄清规则），实现一个完整的谜题训练场类：
|
||
|
||
### 谜题描述
|
||
|
||
**Skyscrapers Puzzle Rules (General Form):**
|
||
|
||
1. **Grid Structure**:
|
||
- The puzzle is played on an N×N grid (e.g., 5×5, 6×6).
|
||
- Each cell must contain a number from 1 to N, representing the height of a \"skyscraper.\"
|
||
|
||
2. **Core Rules**:
|
||
- **Unique Heights**: Each row and column must contain every number from 1 to N exactly once (similar to Sudoku).
|
||
- **Visibility Clues**: Numbers are provided on the edges of the grid, indicating how many skyscrapers are visible from that direction.
|
||
|
||
3. **Visibility Definition**:
|
||
- A skyscraper is \"visible\" if it is taller than all buildings between it and the edge of the grid.
|
||
- Example: In a row with heights [3, 1, 4, 2], looking from the left, you see 3 (blocks 1) and 4 (blocks 2). The clue here would be **2**.
|
||
|
||
4. **Clue Placement**:
|
||
- **Edge Clues**: Numbers outside the grid correspond to the count of visible skyscrapers when looking inward:
|
||
- **Top/Bottom**: Clues for columns (viewed top-to-bottom or bottom-to-top).
|
||
- **Left/Right**: Clues for rows (viewed left-to-right or right-to-left).
|
||
|
||
5. **Objective**:
|
||
- Fill the grid so that all row/column uniqueness constraints are satisfied, and the visibility counts match the provided clues.
|
||
|
||
**Key Idea**: Taller buildings block shorter ones behind them, and clues enforce how many \"peaks\" are observable from each edge.
|
||
|
||
|
||
请完成上述谜题的训练场环境类实现，包括所有必要的方法。
|
||
"""
|
||
|
||
from bootcamp import Basebootcamp
|
||
import random
|
||
import re
|
||
|
||
class Skyscrapersbootcamp(Basebootcamp):
|
||
def __init__(self, n=4):
|
||
self.n = n
|
||
|
||
def case_generator(self):
|
||
n = self.n
|
||
square = self.generate_latin_square(n)
|
||
clues = {
|
||
'left': [],
|
||
'right': [],
|
||
'top': [],
|
||
'bottom': []
|
||
}
|
||
|
||
for row in square:
|
||
clues['left'].append(self.compute_view(row))
|
||
clues['right'].append(self.compute_view(row[::-1]))
|
||
|
||
for j in range(n):
|
||
column = [square[i][j] for i in range(n)]
|
||
clues['top'].append(self.compute_view(column))
|
||
clues['bottom'].append(self.compute_view(column[::-1]))
|
||
|
||
return {'n': n, 'clues': clues}
|
||
|
||
@staticmethod
|
||
def generate_latin_square(n):
|
||
square = []
|
||
for i in range(n):
|
||
row = [(i + j) % n + 1 for j in range(n)]
|
||
square.append(row)
|
||
random.shuffle(square)
|
||
square = list(map(list, zip(*square)))
|
||
random.shuffle(square)
|
||
square = list(map(list, zip(*square)))
|
||
return square
|
||
|
||
@staticmethod
|
||
def compute_view(view):
|
||
max_h = -1
|
||
count = 0
|
||
for h in view:
|
||
if h > max_h:
|
||
count += 1
|
||
max_h = h
|
||
return count
|
||
|
||
@staticmethod
|
||
def prompt_func(question_case):
|
||
n = question_case['n']
|
||
clues = question_case['clues']
|
||
example = "\n".join([" ".join(['1'] * n)] * n)
|
||
prompt = (
|
||
"你正在解决一个数织谜题（Skyscrapers Puzzle）。规则如下：\n"
|
||
"1. 在{}×{}网格中填入1至{}，每行每列数字不重复。\n"
|
||
"2. 周围数字表示从该方向能看到的摩天大楼数量（较高建筑会遮挡后面较矮的）。\n\n"
|
||
"谜题线索：\n"
|
||
"- 网格大小：{}×{}\n"
|
||
"- 顶部线索（各列从上至下可见数）：{}\n"
|
||
"- 底部线索（各列从下至上可见数）：{}\n"
|
||
"- 左侧线索（各行从左至右可见数）：{}\n"
|
||
"- 右侧线索（各行从右至左可见数）：{}\n\n"
|
||
"请填入符合要求的网格，并将答案放在[answer]和[/answer]之间。格式示例：\n"
|
||
"[answer]\n{}[/answer]"
|
||
).format(
|
||
n, n, n, n, n,
|
||
' '.join(map(str, clues['top'])),
|
||
' '.join(map(str, clues['bottom'])),
|
||
' '.join(map(str, clues['left'])),
|
||
' '.join(map(str, clues['right'])),
|
||
example
|
||
)
|
||
return prompt
|
||
|
||
@staticmethod
|
||
def extract_output(output):
|
||
matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
|
||
if not matches:
|
||
return None
|
||
solution_str = matches[-1].strip()
|
||
solution = []
|
||
for line in solution_str.split('\n'):
|
||
line = line.strip()
|
||
if not line:
|
||
continue
|
||
parts = line.split()
|
||
if not all(part.isdigit() for part in parts):
|
||
return None
|
||
solution.append([int(part) for part in parts])
|
||
return solution
|
||
|
||
@classmethod
|
||
def _verify_correction(cls, solution, identity):
|
||
if not solution:
|
||
return False
|
||
n = identity['n']
|
||
clues = identity['clues']
|
||
|
||
if len(solution) != n or any(len(row) != n for row in solution):
|
||
return False
|
||
|
||
for row in solution:
|
||
if sorted(row) != list(range(1, n+1)):
|
||
return False
|
||
|
||
for col in range(n):
|
||
column = [solution[row][col] for row in range(n)]
|
||
if sorted(column) != list(range(1, n+1)):
|
||
return False
|
||
|
||
for i in range(n):
|
||
row = solution[i]
|
||
if (cls.compute_view(row) != clues['left'][i] or
|
||
cls.compute_view(row[::-1]) != clues['right'][i]):
|
||
return False
|
||
|
||
for j in range(n):
|
||
col = [solution[i][j] for i in range(n)]
|
||
if (cls.compute_view(col) != clues['top'][j] or
|
||
cls.compute_view(col[::-1]) != clues['bottom'][j]):
|
||
return False
|
||
|
||
return True
|