🧑‍🎓 Грокаем с агентом школьные математические задачки

Учу считать ChatGPT  :-) 
- Сколько букв в слове зачёт?
- Слово "зачёт" состоит из 6 букв.
- Из каких?
- Слово "зачёт" на русском языке состоит из следующих букв: ... (дальше перечисляет 5 букв)
- И где шестая?
- Прошу прощения за путаницу. Действительно, слово "зачёт" состоит только из пяти букв

Будьте аккуратны, токены на этом задании улетают очень быстро.

Мама, давай напишем агента для решения математических задач

Мама: но у нас дома для решения математических задач есть доступ к GPT-3.5

GPT-3.5:

Сравните ответы после решения)

# Реализуйте функции

@tool

def add_numbers(num1, num2):

    """Складывает два числа"""

    return num1 + num2

@tool

def convert_meters_to_cm(num):

    """Переводит метры в сантиметры"""

    return num * 100

@tool

def convert_cubic_cm_to_liters(num):

    """Переводит кубические сантиметры в литры."""

    return num / 1000

@tool

def compute_rectangle_perimeter(a, b):

    """Вычисляет периметр прямоугольника"""

    return (a + b) * 2

@tool

def compute_circle_area(radius):

    """Вычисляет площадь круга по заданному радиусу."""

    if radius < 0:

        raise ValueError("Радиус не может быть отрицательным")

    return math.pi * radius ** 2

@tool

def compute_cylinder_volume(radius, height):

    """Вычисляет объем цилиндра по заданному радиусу основания и высоте."""

    if radius < 0 or height < 0:

        raise ValueError("Радиус и высота должны быть положительными числами")

    base_area = math.pi * radius ** 2

    volume = base_area * height

    return volume

@tool

def compute_cube_volume(a):

    """Вычисляет объем куба по заданной длине ребра."""

    if a < 0:

        raise ValueError("Длина ребра куба должна быть положительным числом")

    volume = a ** 3

    return volume

@tool

def convert_binary_to_decimal(binary_number: str) -> int:

    """Переводит число из двоичной системы счисления в десятичную систему счисления."""

    return int(binary_number, 2)

@tool

def convert_decimal_to_binary(decimal_number: int) -> str:

    """Переводит число из десятичной системы счисления в двоичную систему счисления."""

    try:

        # Если входное значение - строка, пробуем преобразовать в число

       if isinstance(decimal_number, str):

           decimal_number = float(decimal_number)

       # Если число с плавающей точкой, разделяем целую и дробную части

       if isinstance(decimal_number, float):

           integer_part = int(decimal_number)

       fractional_part = decimal_number - integer_part

       # Конвертируем целую часть

       integer_binary = bin(integer_part)[2:]

       # Конвертируем дробную часть (если есть)

       if fractional_part > 0:

           fractional_binary = ''

           for _ in range(10): # Ограничиваем до 10 знаков после запятой

               fractional_part *= 2

               bit = int(fractional_part)

               fractional_binary += str(bit)

               fractional_part -= bit

               return f"{integer_binary}.{fractional_binary}"

       else:

           return integer_binary

    else:

      # Если целое число, просто конвертируем

       return bin(int(decimal_number))[2:]

except ValueError:

     return "Ошибка: Невозможно преобразовать входное значение в число"

@tool

def get_count_ones(number: str) -> int:

    """Находит количество единиц в двоичном представлении числа."""

    return number.count('1')

@tool

def compute_triangle_area(a: float, b: float, c: float) -> float:

    """Вычисляет площадь треугольника по длинам его сторон, используя формулу Герона."""

    # Проверка на существование треугольника

    if a <= 0 or b <= 0 or c <= 0:

        raise ValueError("Длины сторон должны быть положительными числами")

    if a + b <= c or a + c <= b or b + c <= a:

         raise ValueError("Сумма длин любых двух сторон должна быть больше длины третьей стороны")

# Поместите все написанные функции в tools

tools = [compute_arc_length, compute_triangle_area, add_numbers, convert_meters_to_cm, convert_cubic_cm_to_liters, compute_rectangle_perimeter, compute_circle_area, compute_cylinder_volume, compute_cube_volume, convert_binary_to_decimal, convert_decimal_to_binary, get_count_ones]

...

df['answer'] = ''

for i, task in enumerate(tqdm(df['task'])):

    response = agent.run(f'Дана задача: {task}. Выведи только число и ничего другого!')

    # numeric_response = int(response.strip())

    df.at[i, 'answer'] = response

все решение указывать не буду, оно +- у всех одно, покажу лишь цикл

df['answer'] = None

for idx, task in enumerate(tqdm(df['task'])):

ans = agent.run(f'Реши задачу: {task} В ответе укажи только число и ничего больше')

f_ans = llm.invoke(f"Дан ответ модели: {ans}. В ответе отдай число, которое содержится по ключу 'action_input' или иному, или после символа /n но по смыслу связанному с ответом, если дано просто число отдай его без изменений. Запомни, только число и ничего больше").content

df.at[idx, 'answer'] = f_ans

Решение на 8 из 10 

Раз 5-6 упал на 9 вопросе вообще без каких-либо объективных причин, но в итоге все таки смог отработать. Магия какая-то

Меня тоже раздражает, что используются деприкейтед методы, пытался на локальной оламе (лама3 инстракт) реализовать, как не мучился - не получилось. Оказалось, не вывозила сама лама, локальная моделька не может работать с агентами сложности свыше 1 тул = 1 агент. Решил с мистралем из хагинг фейс:
 

import os
from tqdm import tqdm
from math import pi, sqrt
import pandas as pd
from langchain.agents import tool, AgentType
from langchain.agents import initialize_agent
from langchain_community.llms import HuggingFaceEndpoint
os.environ['HUGGINGFACEHUB_API_TOKEN'] = 'ххх'
llm = HuggingFaceEndpoint(repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1")  #самая норм пока что
@tool
def compute_arc_length(radius, angle_in_degrees):
    """Calculates the arc length given radius and angle in degrees"""
    return (angle_in_degrees / 360) * 2 * pi * radius
@tool
def compute_triangle_area(a, b, c):
    """Calculates the area of a triangle given the lengths of its sides"""
    if a + b <= c or a + c <= b or b + c <= a:
        return "Стороны не могут образовать треугольник"
    s = (float(a) + b + c) / 2
    return sqrt(s * (s - float(a)) * (s - float(b)) * (s - float(c)))
@tool
def add_numbers(num1, num2):
    """Adds two numbers"""
    return num1 + num2
@tool
def convert_meters_to_cm(num):
    """Converts meters to centimeters"""
    return num * 100
@tool
def convert_cubic_cm_to_liters(num):
    """Converts cubic centimeters to liters"""
    return int(num) / 1000
@tool
def compute_rectangle_perimeter(a, b):
    """Calculates the perimeter of a rectangle"""
    return 2 * (a + b)
@tool
def compute_circle_area(radius):
    """Calculates the area of a circle"""
    print(radius)
    return pi * radius ** 2
@tool
def compute_cylinder_volume(radius, height):
    """Calculates the volume of a cylinder"""
    return pi * radius ** 2 * height
@tool
def compute_cube_volume(a):
    """Calculates the volume of a cube"""
    return a ** 3
@tool
def convert_binary_to_decimal(binary_number: str):
    """Converts a binary number to a decimal number"""
    return int(binary_number, 2)
@tool
def convert_decimal_to_binary(decimal_number):
    """Converts a decimal number to a binary number"""
    print(f"decimal number is: {decimal_number}")
    return bin(int(decimal_number))[2:]
@tool
def get_count_ones(number: str):
    """Finds the number of ones in a binary representation of a number"""
    return number.count('1')
tools = [compute_arc_length, compute_triangle_area, convert_cubic_cm_to_liters, add_numbers, convert_meters_to_cm,
         compute_rectangle_perimeter, compute_circle_area, get_count_ones, convert_decimal_to_binary, compute_cube_volume,
         compute_cylinder_volume, convert_binary_to_decimal]
agent = initialize_agent(
    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
    tools=tools,
    llm=llm,
    verbose=True,
handle_parsing_errors=True
)
df = pd.read_csv("https://stepik.org/media/attachments/lesson/1110884/custom_math_tools.csv")
answers = []
for task in tqdm(df['task']):
    result = agent(task)
    print(task + " " + str(result))
    answers.append(result['output'])
# Добавляем ответы в DataFrame и сохраняем его в CSV файл
df['answer'] = answers
df.to_csv('math_solutions.csv', index=False)

как делать не надо (решение на 7 из 10):

from langchain.output_parsers import ResponseSchema
from langchain.output_parsers import StructuredOutputParser
from langchain.prompts import ChatPromptTemplate
out_schema = ResponseSchema(name="out",
                             description="Выдай результат вычислений  одним числом , например: 700, 7.2, 0")

response_schemas = [out_schema]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
# получаем инструкции по форматированию ответа
format_instructions = output_parser.get_format_instructions()

template = """
Из текста оставь только последнее число
текст: {text} 
{format_instructions}
"""
prompt = ChatPromptTemplate.from_template(template)

agent = initialize_agent(
    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION
    , tools = tools
    , llm = llm
    , handle_parsing_errors=True
 #   , output_parser = output_parser
)
answer = []
for task in tqdm(df['task']):
    try:
        messages = prompt.format_messages(text=agent.run(f'{task}'), 
                                format_instructions=format_instructions)
        response = llm.invoke(messages)
        output_dict = output_parser.parse(response.content)
        print(output_dict['out'], "____", task, "____", messages)
        if abs(int(output_dict['out']) - output_dict['out']) < 0.000001:
            output_dict['out'] = int(output_dict['out'])
        answer.append(output_dict['out'])
    except:
        print(task)
        answer.append(0)

Так и не понял, как консистентного ответа от агента. Иногда он выдает словарь с output: 700, а иногда с инпутом для следующей цепочки

Мёрдж двух запусков GPT 3.5
template = """{text}

{format_instructions}
"""
math_answer_schema = ResponseSchema(name="math_answer",
 description="""Если ответ нецелый то округлить до 2 знаков float. Если целый то в вернуть в формате int. Не допускаеться в ответе содержания слов""")
и с 

description="""Ответ должен быть представлен в виде int, если возможно иначе float. Не допускаеться в ответе содержания слов""")

Парсинг ответа агента

def agent_str_dict_out(output_json):
    if type(output_json) is str:
        cleaned_response_json = output_json.replace('\n', '').strip()
        cleaned_response_json = json.loads(output_json)
    else:
        cleaned_response_json = output_json
    #print({cleaned_response_json})
    if 'action_input' in cleaned_response_json:
        act_in = cleaned_response_json['action_input']
        if type(act_in) is str:
            math_dict = json.loads(act_in)
        else: 
            math_dict = act_in
    else:
        math_dict = cleaned_response_json
    return math_dict

Решил с помощью Gemini от Google. Работает стабильнее, чем ChatGPT, почему-то...

не буду все указывать, основные моменты:
- дать описание входных параметров в функциях с декоратором tool;
- давать итоговый ответ агента в модель с промптом по типу "тебе дан развернутый ответ на задачу - верни число, являющееся непосредственно ответом"