В данной программе можно будет самостоятельно составлять собственные system massage (в программе это называется «Специализация»), а это по сути своей программирование GPT модели естественным языком, так же можно будет изменять temperature (в программе это названо «Креативность») это изменяет вариативность ответов, при значении 0.0 на один и тот же вопрос будет получен всё время одинаковый ответ при 1.0 могут быть разные ответы с похожим смыслом но разные по словесному выражению, так же можно использовать две модели YandexGPT и YandexGPT Lite, вторая быстрее и чуть попроще но и дешевле в четыре раза. Описание программы в разделе меню «Информация».
Ну а теперь сразу в бой. Устанавливаем VPN расширение в браузере – HolaVPN, расширение включается автоматически, но иногда нужно включать вручную или менять страну в настройках если что-то не грузится (я менял на Канаду) , иногда само расширение блокирует загрузку сайта тогда нужно внизу справа щёлкнуть на значке расширения и закрыть появившееся окно с выгодным предложением ). Регистрируемся на openai.com с e-mail не оканчивающийся на .ru, vasapupkin@gmail.com подойдёт. Заходим в ChatGPT 3.5 turbo здесь будем писать программу. В разделе настроек аккаунта Customize ChatGPT → How would you like ChatGPT to respond? пропишем → Отвечать по русски, язык программирования Python.
Теперь подготовим Яндекс. Регистрируемся в Яндексе если есть аккаунт заходим в сервис YandexGPT API.
Попадаем вот сюда:
Вверху слева щёлкаем default, если ещё нет то создаём платёжный аккаунт и пополняем его небольшой суммой для пробы сервиса (в том году тысячу р. дарили в подарок на пару месяцев).
То что обведено овалом это ваш идентификатор default по сути логин который нужно вводить в нашу программу для доступа к YandexGPT , пример идентификатора – b2wek9sskl91crв1trub.
Далее переходим в «сервисные аккаунты» и создаём сервисный аккаунт (синяя кнопка «Создать сервисный аккаунт»).
После создания заходим в этот аккаунт и создаём ключ API (указано стрелкой) в меню выбираем «Создать API ключ», копируем полученный ключ и где-нибудь его сохраняем (в аккаунте он не хранится), он понадобиться для ввода в программу для доступа к YandexGPT, если ключ будет утерян его можно будет создать заново, пример ключа - AQSA2cmr7ns2O6DqB4jv8gh3lR1M9av4pyHCwZwL.
Теперь скачаем и устанавливаем среду разработки IDE Visual Studio Code.
скачиваем Python 3.12.
Теперь всё готово, можно творить. Если по ходу подготовки возникнут вопросы не стесняемся задаём ChatGPT, например:
Вы
Как запустить Python программу в Visual Studio Code
ChatGPT
Для запуска Python программы в Visual Studio Code следуйте этим шагам:
Установите Python, если вы еще этого не сделали. Можно загрузить его с официального сайта Python: https://www.python.org/downloads/
Установите Visual Studio Code, если у вас его еще нет. Можно загрузить его с официального сайта: https://code.visualstudio.com/
Откройте Visual Studio Code.
Создайте новый файл или откройте существующий файл с расширением .py (Python файл).
Нажмите `Ctrl + `` (обратная кавычка) для открытия терминала внутри Visual Studio Code. Можно также выбрать "Terminal" -> "New Terminal" из меню.
В терминале убедитесь, что ваш рабочий каталог (папка) находится в том месте, где находится ваш Python файл.
Запустите свою программу, введя команду python имя_файла.py, где имя_файла.py - имя вашего Python файла.
Например, если ваш файл называется hello.py, то команда будет выглядеть так:
Bash
Copy code
python hello.py
Или вы можете использовать кнопку "Run" (зеленый треугольник) в верхней части редактора кода, чтобы запустить программу. Перед запуском убедитесь, что правильно настроен интерпретатор Python в Visual Studio Code. Для этого может потребоваться установка расширения Python и указание пути к интерпретатору в настройках Visual Studio Code.
Или ещё :
Вы
Как инсталлировать библиотеки python
ChatGPT
Чтобы установить библиотеки Python, вы можете использовать инструмент управления пакетами pip. Вот как это сделать:
Откройте терминал (командную строку) на вашем компьютере.
Введите команду pip install имя_библиотеки, где имя_библиотеки - это имя библиотеки Python, которую вы хотите установить. Например:
bash
Copy code
pip install requests
Это установит библиотеку requests.
Если вы хотите установить конкретную версию библиотеки, вы можете указать версию, добавив == и номер версии. Например:
bash
Copy code
pip install requests==2.25.1
Если вы хотите обновить библиотеку до последней версии, вы можете использовать команду:
bash
Copy code
pip install --upgrade имя_библиотеки
Например:
bash
Copy code
pip install --upgrade requests
Если вы используете виртуальное окружение Python (что является хорошей практикой для изоляции зависимостей между проектами), убедитесь, что ваше виртуальное окружение активировано перед выполнением команды pip install.
Теперь вы знаете, как устанавливать библиотеки Python с помощью pip.
В качестве терминала я использовал Windows PowerShell можно использовать cmd.exe, забиваем в поиск Windows там их и находим.
Вот примеры запросов к ChatGPT при разработке программы
нужно увеличить ширину боковых линий главного окна
какая библиотека для python содержит графический интерфейс похожий на windows стиль
как загрузить библиотеку tkinter as tk
Прокомментируй этот код очень подробно каждую строчку функцию и переменную (….пример кода…)
Теперь сделай так что бы данные в виджете "Resultat" не могли редактироваться (….пример кода…)
Правильно я понимаю - вот эта функция self.entry = tk.Text(self.root, wrap="word", width=70, height=7) передаёт своё значение в переменную entered_text (….пример кода….)
и т. д. и т.п., не забываем при запросе вставлять куски кода где надо сделать какие либо изменения или что то добавить, можно вставлять весь код при любом запросе, но у ChatGPT 3.5 есть ограничения на количество токенов (слов) запроса и после 300-400 строчек кода начинает писать «слишком long». После удачных изменений сохраняем резервную копию что бы если что откатиться на рабочую версию а то бывает ChatGPT накосячит столько что не рад будешь что связался (шутка).
Частые ошибки ChatGPT - например в имении переменной часто забывает добавить self чтобы использовать её в другой функции, gpt_model_uri_get а надо self.gpt_model_uri_get и то же самое с функциями (методами), def show_registration():, а надо def show_registration(self): что бы её вызвать через конструкцию self.show_registration.
В Visual Studio Code внизу есть окно терминала где так же выводятся коды ошибок, можно оттуда копировать и спрашивать про ошибку у ChatGPT, выделяем и через клавиши Ctrl+C копируем и потом вставляем в окно запроса ChatGPT через контекстное меню или Ctrl+V.
Для компиляции программы в готовый .exe файл используем команды в терминале.
Windows PowerShell или cmd.exe. Вставляем код программы в блокнот и сохраняем его с расширением .py например SmartiksGPT.py
cd C:\Users\HP\Desktop - команда перехода в рабочий каталог где находится файйл SmartiksGPT.py (в данном случае на рабочем столе).
pyinstaller --onefile --noconsole SmartiksGPT.py - команда компиляции в .exe файл (в данном случае одним файлом без консоли).
Готовый файл будет находиться в папке dist.
Ну вот вроде и всё.
Вот собственно код программы SmartiksGPT с комментариями :
# Импорт библиотек
import tkinter as tk
from tkinter import ttk
from tkinter import Menu
from tkinter import messagebox
import requests
import json
import os
from transliterate import translit
import winsound
import re
# Определение класса DraggableWindow
class DraggableWindow:
def __init__(self, root):
# Инициализация окна
self.root = root
self.root.title("SmartiksGPT") # Заголовок окна
self.is_dragging = False
initial_width = 838
initial_height = 780
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
x = (screen_width - initial_width) // 2
y = (screen_height - initial_height) // 2
self.root.geometry(f"{initial_width}x{initial_height}+{x}+{y}") # Установка размеров и позиции окна
self.root.option_add('*BorderWidth', 3)
self.root.option_add('*highlightThickness', 0)
self.root.resizable(False, False) # Запрет изменения размеров окна
self.create_specialization_data()
# Создание меню
self.root = root
self.main_menu = tk.Menu(root)
self.info_menu = tk.Menu(self.main_menu, tearoff=0)
self.main_menu.add_cascade(label="Информация", menu=self.info_menu)
self.main_menu.add_command(label="Авторизация", command=self.show_registration) # Добавление пункта "Регистрация"
self.info_menu.add_command(label="Руководство", command=self.show_guide)
self.info_menu.add_command(label="О программе", command=self.show_about)
self.root.config(menu=self.main_menu)
self.gpt_model_uri = tk.StringVar(value="yandexgpt") # Присваиваем переменной self.gpt_model_uri строковое значение "yandexgpt", эта переменная используется в строке "modelUri": f"gpt://...логин папки.../{self.gpt_model_uri_get}
self.gpt_model_uri_get = self.gpt_model_uri.get() # Присваиваем переменной self.gpt_model_uri_get значение self.gpt_model_uri (очищаем от ненужных атрибутов tk.StringVar что бы корректно работало в запросе"modelUri": f"gpt://...логин папки.../{self.gpt_model_uri_get})
self.description_text = "" # Устанавливаем значение self.description_text пустое
self.system_message = "Ты умный ассистент"
self.selected_value = tk.StringVar() # Переменная для хранения значения креативности
self.selected_value.set("0.6") # Устанавливаем значение креативности по умолчанию
self.selected_specialization = tk.StringVar(value="Список специализаций") # Присваиваем переменной self.selected_specialization строковое значение value="Список специализаций"
# Добавляем строку чтобы создать атрибут selected_specialization
self.selected_specialization = tk.StringVar(root)
self.selected_specialization.set("Список специализаций")
# Виджет для вывода результата
self.result_label = tk.Text(self.root, wrap="word", width=100, height=35, padx=5, state='disabled')
self.result_label.grid(row=0, column=0, columnspan=10, sticky="ew", pady=2)
# Метка для ввода сообщения пользователя
self.entry_label = tk.Label(self.root, text="Введите сообщение :") # Cоздаём экземпляр класса tk.Label (просто текст) и присваивается ему наименование self.entry_label
self.entry_label.grid(row=1, column=0, padx=5, pady=10)
# Виджет для ввода сообщения пользователем
self.entry = tk.Text(self.root, wrap="word", width=70, height=5, padx=2) # Cоздаём экземпляр класса tk.Text (текстовый виджет) и присваивается ему наименование self.entry, wrap="word" означает что текст будет переносится по словам
self.entry.grid(row=1, column=1, columnspan=5, pady=10, padx=10, sticky="ew")
self.entry_context_menu = tk.Menu(root, tearoff=0)
self.entry_context_menu.add_command(label="Копировать", command=self.copy_entry_text)
self.entry_context_menu.add_command(label="Вставить", command=self.paste_entry_text)
self.entry.bind("<Button-3>", self.show_entry_context_menu)
# Кнопка для отправки сообщения
self.submit_button = tk.Button(self.root, text="Отправить", command=self.on_submit)
self.submit_button.grid(row=1, column=6, pady=5)
# Назначение клавиш Enter и Shift-Enter для отправки сообщения
self.entry.bind("<Return>", self.handle_enter_key)
self.entry.bind("<Shift-Return>", self.handle_shift_enter_key)
self.entry.focus_set()
# Контекстное меню для результата
self.context_menu = tk.Menu(root, tearoff=0)
self.context_menu.add_command(label="Копировать", command=self.copy_text)
self.result_label.bind("<Button-3>", self.show_context_menu)
# Кнопка и виджет для специализации
self.specialization_button = tk.Button(self.root, text="Специализация", command=self.show_specialization_popup)
self.specialization_button.grid(row=2, column=0, pady=5, padx=15, sticky="w")
self.specialization_widget = tk.Text(self.root, wrap="word", width=40, height=1, padx=2, state='disabled')
self.specialization_widget.grid(row=2, column=1, pady=5, padx=0, sticky="w")
# Установка по умолчанию текста "Ассистент" в виджет специализации
self.specialization_widget.config(state='normal') # Включаем режим редактирования
self.specialization_widget.insert(tk.END, "Ассистент")
self.specialization_widget.config(state='disabled') # Заново отключаем режим редактирования
# Кнопка для установки креативности
self.creativity_button = tk.Button(self.root, text="Креативность", command=self.show_creativity_popup)
self.creativity_button.grid(row=2, column=2, pady=5, padx=5, sticky="e")
# Виджет для отображения числового значения креативности
self.numbers_widget = tk.Text(self.root, wrap="word", width=3, height=1, state='disabled')
self.numbers_widget.grid(row=2, column=3, pady=5, padx=15, sticky="w")
# Кнопка для очистки беседы
self.clear_button = tk.Button(self.root, text="Очистить беседу", command=self.clear_result_label)
self.clear_button.grid(row=2, column=6, pady=5, padx=5, sticky="w")
# Обновляем виджет с числовым значением при создании окна
self.update_numbers_widget()
# Словарь для хранения данных специализации
self.specialization_data = {}
# Виджет Выбор модели YandexGPT
self.model_selection_frame = tk.Frame(self.root)
self.model_selection_frame.grid(row=3, column=1, pady=10, padx=0, sticky="w")
tk.Label(self.model_selection_frame, text="Используемая модель:", anchor="w").pack(side=tk.LEFT)
tk.Radiobutton(self.model_selection_frame, text="YandexGPT", variable=self.gpt_model_uri, value="yandexgpt", command=lambda: self.update_gpt_model_uri("yandexgpt")).pack(side=tk.LEFT)
tk.Radiobutton(self.model_selection_frame, text="YandexGPT-lite", variable=self.gpt_model_uri, value="yandexgpt-lite", command=lambda: self.update_gpt_model_uri("yandexgpt-lite")).pack(side=tk.LEFT)
default_folder, api_key = self.read_login_credentials('Login_SmartiksGPT.json') # Загружаем из файла Login_SmartiksGPT.json данные в переменные default_folder и api_key
if default_folder is not None and api_key is not None:
print("Значения из файла успешно загружены:")
print("Default Folder:", default_folder)
print("API Key:", api_key)
else:
messagebox.showwarning("Внимание", "Для работы программы необходимо авторизоваться в YandexGPT API и ввести в программу данные авторизации - идентификатор default folder и API ключ") # Системное сообщение если нет файла с default_folder и api_key
print("Не удалось загрузить значения из файла.")
# Функция обновления значения переменной self.gpt_model_uri_get для использования модели yandexgpt или yandexgpt-lite
def update_gpt_model_uri(self, value):
self.gpt_model_uri.set(value) # Присваиваем переменной self.gpt_model_uri выбранное значение tk.Radiobutton
self.gpt_model_uri_get = self.gpt_model_uri.get() # Присваиваем переменной self.gpt_model_uri_get значение self.gpt_model_uri (очищаем от ненужных атрибутов tk.StringVar что бы корректно работало в запросе"modelUri": f"gpt://...логин папки.../{self.gpt_model_uri_get})
# Функция окна Авторизации
def show_registration(self):
registration_window = tk.Toplevel(self.root)
self.registration_window_close = registration_window # Создаём переменную self.registration_window_close для использования в функции def register_user(self) для закрытия окна регистрации
registration_window.title("Авторизация в YandexGPT API")
# Добавление элементов интерфейса для регистрации
tk.Label(registration_window, text="Введите идентификатор default folder:").grid(row=0, column=0, padx=10, pady=10)
self.name_entry = tk.Text(registration_window,wrap="word", width=40, height=1)
self.name_entry.bind('<KeyRelease>', lambda event: self.validate_input(event, registration_window))
self.name_entry.grid(row=1, column=0, padx=10, pady=0)
tk.Label(registration_window, text="Введите API ключ:").grid(row=2, column=0, padx=10, pady=10)
self.password_entry = tk.Text(registration_window, wrap="word", width=40, height=1)
self.password_entry.bind('<KeyRelease>', lambda event: self.validate_input(event, registration_window))
self.password_entry.grid(row=3, column=0, padx=10, pady=0)
register_button = tk.Button(registration_window, text=" Войти ", command=self.register_user)
register_button.grid(row=4, columnspan=2, padx=10, pady=15)
# Добавление контекстного меню для self.name_entry
name_context_menu = tk.Menu(registration_window, tearoff=0)
name_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.name_entry))
name_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.name_entry))
self.name_entry.bind("<Button-3>", lambda event: name_context_menu.post(event.x_root, event.y_root))
# Добавление контекстного меню для self.password_entry
password_context_menu = tk.Menu(registration_window, tearoff=0)
password_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.password_entry))
password_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.password_entry))
self.password_entry.bind("<Button-3>", lambda event: password_context_menu.post(event.x_root, event.y_root))
# Установка размеров и позиции окна регистрации
registration_window_width = 355
registration_window_height = 194
registration_window.resizable(False, False) # Запрет изменения размеров окна
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
x = (screen_width - registration_window_width) // 2
y = (screen_height - registration_window_height) // 2
registration_window.geometry(f"{registration_window_width}x{registration_window_height}+{x}+{y}")
# Настройка окна регистрации как transient и открытие его в модальном режиме
registration_window.transient(self.root)
registration_window.wait_visibility() # Ждем, пока окно станет видимым
registration_window.grab_set_global() # Глобально захватываем фокус
# Захват фокуса и установка активности окна регистрации
registration_window.grab_set()
registration_window.focus_force()
self.root.wait_window(registration_window)
# Функция проверки символов в окне Авторизации
def register_user(self):
# Получаем значения из виджетов
default_folder_reg = self.name_entry.get("1.0", "end-1c").strip()
api_key_reg = self.password_entry.get("1.0", "end-1c").strip()
# Проверка на отсутствие символов и превышение количества символов
if not default_folder_reg.strip():
messagebox.showwarning("Предупреждение", "Введите идентификатор default folder")
return
if len(default_folder_reg.strip()) > 40:
messagebox.showwarning("Предупреждение", "Превышено количество символов идентификаторе default folder (максимум 40 символов).")
return
if not api_key_reg.strip():
messagebox.showwarning("Предупреждение", "Введите API ключ")
return
if len(api_key_reg.strip()) > 40:
messagebox.showwarning("Предупреждение", "Превышено количество символов в API ключе (максимум 40 символов)")
return
# Проверка, что все символы логина и пароля являются латинскими буквами или цифрами
if not default_folder_reg.isalnum() or not default_folder_reg.isascii():
messagebox.showwarning("Предупреждение", "Идентификатор default folder должен содержать только латинские буквы и цифры")
return
if not api_key_reg.isalnum() or not api_key_reg.isascii():
messagebox.showwarning("Предупреждение", "API ключ должен содержать только латинские буквы и цифры")
return
self.default_folder = default_folder_reg
self.api_key = api_key_reg
# Создаем словарь для JSON
data = {
"self.default_folder": self.default_folder,
"self.api_key": self.api_key
}
filename = "Login_SmartiksGPT.json" # Создаем JSON файл
with open(filename, "w") as file:
json.dump(data, file, indent=4)
print(f"JSON файл '{filename}' создан успешно.")
self.registration_window_close.destroy() # Закрываем окно регистрации
# Функция проверки вводимых символов (должны быть латинские или цифры)
def validate_input(self, event, registration_window):
key_code = event.keycode # Получаем код клавиши
if key_code == 8 or key_code in {37, 38, 39, 40} or (event.keysym == "Shift_L" or event.keysym == "Shift_R" or event.keysym == "Alt_L" or event.keysym == "Alt_R"): # Проверяем, что это не Backspace, стрелки или Shift или Alt что бы не было ложного срабатывания messagebox
return True
new_text = event.widget.get("1.0", "end-1c")
max_chars = 40 # Устанавливаем количество символов
if len(new_text) >= max_chars:
return "break" # Останавливаем ввод новых символов
if new_text == "": # Проверяем, что поле ввода не пустое
return True
if new_text and not re.match(r'^[a-zA-Z0-9\s]*$', new_text):
registration_window.grab_set()
tk.messagebox.showerror("Предупреждение", "Допустимы только латинские буквы и цифры")
return False
# Функция чтения файла Логина и пароля self.default_folder и self.api_key
def read_login_credentials(self, file_path):
try:
with open(file_path, 'r') as file:
data = json.load(file)
self.default_folder = data.get('self.default_folder')
self.api_key = data.get('self.api_key')
#print("Значения из файла успешно загружены:")
#print("Default Folder:", self.default_folder)
#print("API Key:", self.api_key)
return self.default_folder, self.api_key
except FileNotFoundError:
print(f"Файл {file_path} не найден.")
return None, None
except json.JSONDecodeError:
print(f"Ошибка при декодировании файла {file_path}.")
return None, None
# Обработчик события для клавиши Enter
def handle_enter_key(self, event):
if event.state & 0x1: # Проверка, что нажата клавиша Shift (bitwise AND с 0x1)
self.entry.insert(tk.INSERT, '\n') # Вставляем символ новой строки
else:
self.on_submit()
def handle_shift_enter_key(self, event):
self.entry.insert(tk.INSERT, '\n')
# Функция всплывающего окна для установки значения креативности в главном окне
def show_creativity_popup(self):
popup = tk.Toplevel(self.root)
popup.title("Выберите значение")
values = ["0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0"]
dropdown = tk.OptionMenu(popup, self.selected_value, *values)
dropdown.pack(pady=10)
apply_button = tk.Button(popup, text="Применить", command=lambda: self.update_temperature_and_close(popup))
apply_button.pack(pady=10)
# Установка размеров и позиции всплывающего окна
popup_width = 170
popup_height = 100
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
x = (screen_width - popup_width) // 2
y = (screen_height - popup_height) // 2
popup.geometry(f"{popup_width}x{popup_height}+{x}+{y}")
popup.transient(self.root)
popup.grab_set()
popup.resizable(width=False, height=False) # Блокировка изменения размеров окна
popup.focus_force() # Установка фокуса (всплывающее окно становиться активным)
self.root.wait_window(popup)
# Функция для обновления виджета с числовым значением
def update_numbers_widget(self):
self.numbers_widget.config(state='normal')
self.numbers_widget.delete("1.0", tk.END)
self.numbers_widget.insert(tk.END, self.selected_value.get())
self.numbers_widget.config(state='disabled')
# Функция для обновления температуры и закрытия всплывающего окна
def update_temperature_and_close(self, popup):
self.update_numbers_widget()
popup.destroy()
# Функция при нажатии кнопки "Отправить"
def on_submit(self):
entered_text = self.entry.get("1.0", "end-1c").strip() # Получение текста из виджета self.entry
# Если entered_text пусто, показываем всплывающее сообщение "Введите описание специализации"
if not entered_text:
messagebox.showwarning("Предупреждение", "Введите сообщение")
return
# Проверка количества символов в сообщении
entered_text_previshenie = len(entered_text) - 19000 # Вычисление количества превысивших символов
if len(entered_text) > 19000:
messagebox.showwarning("Предупреждение", f"Количество символов в сообщении превысило лимит на {entered_text_previshenie} шт.")
return
if not entered_text: # Проверка, что введенный текст не пустой
return
user_message = f" Пользователь: \n{entered_text}\n" # Вставка в переменную user_message выражения Пользователь: \n{entered_text}\n в котором находится значение переменной entered_text и всё это обрамляется {} т.к. стоит f
self.insert_to_result_label(user_message)
self.entry.delete("1.0", tk.END)
# Устанавливается значение переменной system_message в зависимости от наличия текста в переменной self.description_text (описание промпта при выборе из списка специализаций)
if self.description_text: # Если self.description_text истинно (там есть какоке то значение)
system_message = self.description_text # то system_message примет значение self.system_message = "Ты умный ассистент"
else: # Иначе (self.description_text пусто (ложно)
system_message = self.system_message # system_message примет значение self.system_message
# Обновляем значение параметра temperature в методе answer_from_yandex_gpt
user_temperature_str = self.selected_value.get()
if not user_temperature_str:
return
user_temperature = float(user_temperature_str) # Преобразование строки значения температуры в число с плавающей запятой и присваивание значения user_temperature
self.user_temperature = user_temperature # Присваивание значения user_temperature в self.user_temperature
self.answer_from_yandex_gpt(entered_text, system_message, user_temperature, self.default_folder, self.api_key) # Вызов метода answer_from_yandex_gpt с передачей в него введенного текста и температуры (entered_text, system_message, user_temperature)
# Функция очистки беседы при нажатии кнопки "Очистить"
def clear_result_label(self):
self.result_label.config(state='normal')
self.result_label.delete('1.0', tk.END)
self.result_label.config(state='disabled')
# Функция для вставки сообщение окна беседы с YandexGPT result_label
def insert_to_result_label(self, message):
self.result_label.config(state='normal')
self.result_label.insert(tk.END, message)
self.result_label.see(tk.END)
self.result_label.config(state='disabled')
# Функция формирование запроса к Yandex GPT
def answer_from_yandex_gpt(self, user_input, system_message, user_temperature, default_folder, api_key):
prompt = {
"modelUri": f"gpt://{default_folder}/{self.gpt_model_uri_get}",
"completionOptions": {
"stream": False,
"temperature": user_temperature,
"maxTokens": "2000"
},
"messages": [
{"role": "system", "text": system_message},
{"role": "user", "text": user_input}
]
}
#print("Prompt temperature:", prompt["completionOptions"]["temperature"])
# Отправка запроса к Yandex GPT
url = "https://llm.api.cloud.yandex.net/foundationModels/v1/completion"
headers = {
"Content-Type": "application/json",
"Authorization": f"Api-Key {api_key}"
}
response = requests.post(url, headers=headers, json=prompt)
result = response.text
result_json = json.loads(result)
assistant_text = result_json['result']['alternatives'][0]['message']['text']
response_temperature = result_json['result']['alternatives'][0]['message'].get('temperature')
if response_temperature is not None:
print("Response temperature:", response_temperature)
# Выводим значение system_message в консоль
print("Температура запроса:", prompt["completionOptions"]["temperature"])
print("Системное сообщение:", system_message)
print("Используемая модель:", self.gpt_model_uri_get)
# Вывод данных специализации в консоль
#self.print_specialization_data()
# Отображение ответа от YandexGPT в программе
self.insert_to_result_label(f" YandexGPT: \n{assistant_text}\n\n")
# Вывод ответа от YandexGPT в консоль
print(result)
# Создание нового всплывающего окна (Toplevel) "Специализация" и установка его заголовка
def show_specialization_popup(self):
popup = tk.Toplevel(self.root)
popup.title("Специализация")
# Устанавливает значение креативности по умолчанию
self.selected_value.set("0.0")
# Установка "Список специализаций" по умолчанию при каждом запуске
self.selected_specialization.set("Список специализаций")
# Загрузка данных из файла specialization_data.pkl
try:
with open("specialization_data.json", "rb") as file:
self.specialization_data = json.load(file)
except FileNotFoundError:
print("Файл specialization_data.json не найден.")
# Если файл отсутствует, устанавливаем пустой словарь
self.specialization_data = {}
# Присваиваем "Список специализаций" при отсутствии файла
self.selected_specialization.set("Список специализаций")
# Получение списка name из словаря self.specialization_data
specialization_keys = [spec['name'] for spec in self.specialization_data.values()]
tk.Label(popup, text="Специализация").grid(row=0, column=0, pady=10)
# Ограничение длины ключей до символов
max_key_length = 40
filtered_specialization_keys = [key[:max_key_length] for key in specialization_keys]
# Создание виджета OptionMenu и передача списка ключей
if filtered_specialization_keys: # Проверяет, есть ли какие-либо значения в переменной filtered_specialization_keys
specialization_dropdown = tk.OptionMenu(popup, self.selected_specialization, *filtered_specialization_keys, command=self.on_specialization_select) # Если условие из предыдущей строчки истинно, то создается выпадающий список (OptionMenu). self.selected_specialization это переменная которая будет использоваться для отслеживания выбранного значения
else: # Если в выпадающем списке (переменная filtered_specialization_keys) нет значений
specialization_dropdown = tk.OptionMenu(popup, self.selected_specialization, "Нет данных") # будет только один пункт с текстом "Нет данных"
specialization_dropdown.grid(row=0, column=1, columnspan=2, padx=25, pady=10, sticky="ew") # Размещение выпадающего списка на сетке окна
specialization_dropdown.config(height=1, anchor="n", width=40) # anchor="n" выравнивает текст по высоте внутри виджета и смещает его сверху в центр
delete_button = tk.Button(popup, text=" Удалить ", command=lambda: self.delete_selected_specialization(popup), fg="red", activeforeground="red")
delete_button.grid(row=0, column=3, padx=14, pady=10, sticky="e")
# Создание виджета для ввода параметров специализации
tk.Label(popup, text="Создание и редактирование специализации:").grid(row=1, column=0, columnspan=7, pady=10)
# Создание метки и виджета для ввода названия специализации
tk.Label(popup, text="Название:").grid(row=2, column=0, padx=5, pady=10)
self.specialization_entry = tk.Text(popup,wrap="word", width=40, height=1, padx=2)
self.specialization_entry.bind("<Key>", self.enforce_maxlength) # Привязываем метод ограничения символов (elf.enforce_maxlength) к событию Key
self.specialization_entry.grid(row=2, column=1, padx=5, pady=10)
self.specialization_entry.bind("<KeyPress-Return>", lambda e: "break") # Отключаем клавишу Enter в виджете что бы корректно сохранялось название Специализации
# Добавление контекстного меню для виджета specialization_entry
entry_context_menu = Menu(popup, tearoff=0)
entry_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.specialization_entry))
entry_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.specialization_entry))
self.specialization_entry.bind("<Button-3>", lambda event: entry_context_menu.post(event.x_root, event.y_root))
# Создание метки и виджета для выбора параметра креативности
tk.Label(popup, text="Креативность:").grid(row=3, column=0, padx=5, pady=10)
creativity_values = ["0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0"]
self.creativity_dropdown = tk.OptionMenu(popup, self.selected_value, *creativity_values)
self.creativity_dropdown.grid(row=3, column=1, padx=5, pady=10)
# Создание метки и виджета для ввода описания специализации
tk.Label(popup, text="Описание:").grid(row=4, column=0, padx=5, pady=10)
self.description_text_spec = tk.Text(popup, wrap="word", width=40, height=5, padx=2)
self.description_text_spec.grid(row=4, column=1, padx=5, pady=10)
# Добавление контекстного меню для виджета self.description_text_spec
description_context_menu = tk.Menu(popup, tearoff=0)
description_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.description_text_spec))
description_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.description_text_spec))
self.description_text_spec.bind("<Button-3>", lambda event: description_context_menu.post(event.x_root, event.y_root))
# Создание кнопки для применения и привязка к ней метода apply_specialization с передачей параметров
self.apply_button = tk.Button(popup, text="Применить", command=lambda: self.apply_specialization(popup, self.specialization_entry.get("1.0", tk.END), self.description_text_spec))
self.apply_button.grid(row=4, column=3, padx=5, pady=10)
# Установка размеров и позиции всплывающего окна
popup_width = 530
popup_height = 307
popup.resizable(False, False) # Запрет изменения размеров окна
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
x = (screen_width - popup_width) // 2
y = (screen_height - popup_height) // 2
popup.geometry(f"{popup_width}x{popup_height}+{x}+{y}")
# Настройка всплывающего окна как transient и открытие его в модальном режиме
popup.transient(self.root)
popup.wait_visibility() # Ждем, пока окно станет видимым
popup.grab_set_global() # Глобально захватываем фокус
# Захват фокуса и установка активности всплывающего окна
popup.grab_set()
popup.focus_force()
self.root.wait_window(popup.winfo_toplevel())
# Функция ограничения количества символов вводимых в название специализации
def enforce_maxlength(self, event):
max_chars = 40
if len(self.specialization_entry.get("1.0", "end-1c")) >= max_chars:
if event.keysym not in ["BackSpace", "Delete"]: # Разрешаем удаление символов
return "break"
# Получение данных о выбранной специализации из self.specialization_data
def on_specialization_select(self, specialization):
specialization_data = self.specialization_data.get(specialization, {})
self.key = specialization_data.get('key', '')
# Обновление виджетов в соответствии с данными о специализации
self.specialization_entry.delete('1.0', tk.END) # Очистка текстового поля
self.specialization_entry.insert('1.0', specialization_data.get('name', '')) # Вставка названия специализации
selected_creativity = specialization_data.get('creativity', '') # Получение креативности специализации
self.selected_value.set(selected_creativity) # Установка выбранной креативности в выпадающем списке
self.description_text_spec.delete('1.0', tk.END) # Очистка текстового поля
self.description_text_spec.insert('1.0', specialization_data.get('description', '')) # Вставка описания специализации
# Функция Копировать для окна "Специализация"
def copy_text_to_clipboard(self, widget):
selected_text = widget.get("sel.first", "sel.last")
self.root.clipboard_clear()
self.root.clipboard_append(selected_text)
self.root.update()
def paste_text_from_clipboard(self, widget):
try:
# Получение выделенного текста в виджете
selected_text = widget.get(tk.SEL_FIRST, tk.SEL_LAST)
# Если есть выделенный текст, удаляем его
if selected_text:
widget.delete(tk.SEL_FIRST, tk.SEL_LAST)
except tk.TclError:
# Обработка ошибки, если выделенного текста нет
pass
# Вставка текста из буфера обмена в виджет
text_to_paste = self.root.clipboard_get()
widget.insert(tk.INSERT, text_to_paste)
# Функция кнопки "Применить" в окне "Специализация"
def apply_specialization(self, popup, specialization_name, description_text_spec):
if isinstance(description_text_spec, tk.Text): # Проверка, является ли description_text_spec объектом класса tk.Text. Если это так, то извлекается текст из виджета tk.Text и сохраняется в переменной system_message
system_message = description_text_spec.get("1.0", tk.END).strip()
else: # Если нет, то используется строковое представление description_text_spec
system_message = str(description_text_spec).strip()
variable_name = specialization_name[:40] # Создание переменной variable_name, которая содержит первые 40 символов из строки specialization_name. Это используется в качестве уникального идентификатора для данных о специализации.
formatted_text = specialization_name # Создание переменной formatted_text, которая получает значение specialization_name
# Если specialization_name пусто, показываем всплывающее сообщение "Введите название специализации"
if not specialization_name.strip(): # strip() очищает specialization_name от символов пробела и перевода строки для корректной работы условия
messagebox.showwarning("Предупреждение", "Введите название специализации")
return
# Если system_message пусто, показываем всплывающее сообщение "Введите описание специализации"
if not system_message:
messagebox.showwarning("Предупреждение", "Введите описание специализации")
return
# Проверка количества символов в названии специализации
if len(specialization_name.strip()) > 40:
messagebox.showwarning("Предупреждение", "Количество символов в названии специализации превысело 40 символов")
return
# Проверка количества символов в описании специализации
system_message_previshenie = len(system_message) - 3800 # Вычисление количества превысевших символов
if len(system_message) > 3800:
messagebox.showwarning("Предупреждение", f"Количество символов в описании специализации превысило лимит на {system_message_previshenie} шт.")
return
self.specialization_widget.config(state='normal') # Установка состояния виджета self.specialization_widget в 'normal' (возможность редактирования)
self.specialization_widget.delete("1.0", tk.END) # Очистка содержимого виджета self.specialization_widget с начала (строка "1.0") до конца (tk.END)
self.specialization_widget.insert(tk.END, formatted_text) # Вставка текста из formatted_text в виджет self.specialization_widget в конец (tk.END)
self.specialization_widget.config(state='disabled') # Установка состояния виджета self.specialization_widget в 'disabled' (невозможность редактирования)
# Обновляем user_temperature из выбранного значения креативности
user_temperature_str = self.selected_value.get() # Получение значения из переменной self.selected_value и сохранение его в user_temperature_str
if user_temperature_str: # Проверка, что user_temperature_str не является пустой строкой
self.user_temperature = float(user_temperature_str) # Преобразование строки user_temperature_str в число с плавающей запятой и сохранение результата в self.user_temperature
self.update_numbers_widget() # Вызов метода update_numbers_widget для обновления числового виджета
#user_input = "Привет" # Присвоение переменной user_input значения "Привет" что бы при создании специализации (промпта) к YandexGPT отправлялся запрос от пользователя и приходил ответ от YandexGPT, если не будет ответа будет ошибка с отсутствием ответа (result)
# Переназначение значения переменной из виджета Описание для того что бы промпт (system_message) не сбрасывался на значение по умолчанию или не оставался отпредыдущего значения после выбора из Списка специализаций
self.description_text_value = description_text_spec.get("1.0", tk.END).strip() # Преобразуем содержимое из виджета Описание в текст
self.system_message = self.description_text_value # Присвоение self.description_text_value значению по умолчанию self.system_message (по умолчанию "Отвечай как ассистент")
self.description_text = self.system_message # Присвоение полученное self.system_message переменной self.description_text (значение которого остаётся после выбора из списка специализаций)
# Отправление запроса к yandex_gpt при нажатии кнопки "Применить"
#self.answer_from_yandex_gpt(user_input, self.description_text_value, self.user_temperature) # Вызов метода answer_from_yandex_gpt с передачей параметров user_input, system_message и self.user_temperature
# Убирает \n (перевод строки) из key name (откуда они там берутся не выяснил)
variable_name = variable_name.strip()
specialization_name = specialization_name.strip()
# Проверяем, совпадает ли выбранная специализация с каким-либо ключом в словаре
if self.selected_specialization.get() in self.specialization_data.keys():
del self.specialization_data[self.selected_specialization.get()] # Если да, удаляем этот ключ и его значение из словаря
# Добавление данных о специализации в словарь self.specialization_data с использованием variable_name в качестве ключа
self.specialization_data[variable_name] = {
"name": specialization_name,
"description": system_message,
"creativity": self.user_temperature
}
self.save_specialization_data() # Сохранение данных о специализации в файл на локальном жёстком диске
popup.destroy() # Закрываем всплывающее окно
# Функция удаления выбранно специализации
def delete_selected_specialization(self, popup):
if self.selected_specialization.get() in self.specialization_data.keys():
del self.specialization_data[self.selected_specialization.get()]
else:
print("Выбранной специализации нет в данных")
self.save_specialization_data()
popup.destroy()
# Функция отображение контекстного меню для результата
def show_context_menu(self, event):
self.context_menu.post(event.x_root, event.y_root)
# Копирование выделенного текста результата
def copy_text(self):
selected_text = self.result_label.get("sel.first", "sel.last")
self.root.clipboard_clear()
self.root.clipboard_append(selected_text)
self.root.update()
# Отображение контекстного меню для ввода сообщения
def show_entry_context_menu(self, event):
self.entry_context_menu.post(event.x_root, event.y_root)
# Копирование выделенного текста ввода сообщения
def copy_entry_text(self):
selected_text = self.entry.get("sel.first", "sel.last")
self.root.clipboard_clear()
self.root.clipboard_append(selected_text)
self.root.update()
def paste_entry_text(self):
try:
# Получение выделенного текста в виджете
selected_text = self.entry.get(tk.SEL_FIRST, tk.SEL_LAST)
# Если есть выделенный текст, удаляем его
if selected_text:
self.entry.delete(tk.SEL_FIRST, tk.SEL_LAST)
except tk.TclError:
# Обработка ошибки, если выделенного текста нет
pass
# Вставка текста из буфера обмена в текущую позицию курсора в виджет ввода сообщения
text_to_paste = self.root.clipboard_get()
self.entry.insert(tk.INSERT, text_to_paste)
# Функция для транслитерации текста в латиницу
def transliterate_to_latin(self, text):
return translit(text, 'ru', reversed=True)
# Функция для сохранения специализаций в файл JSON на компьютер
def save_specialization_data(self, filename="specialization_data.json"):
try:
with open(filename, "w") as file:
json.dump(self.specialization_data, file)
print(f"Специализация успешно сохранена в файле: {filename}")
except Exception as e:
print(f"Ошибка при сохранении специализации: {e}")
# Функция загрузки данных о специализациях из файла JSON
def load_specialization_data(self, filename="specialization_data.json"):
try:
with open(filename, "r") as file:
self.specialization_data = json.load(file)
print(f"Специализация успешно загружена из файла: {filename}")
except FileNotFoundError:
print("Файл specialization_data.json не найден.")
self.specialization_data = {}
except Exception as e:
print(f"Ошибка при загрузке специализации из файла: {e}")
# Функция для создания JSON файла с данными специализации при первом запуске
def create_specialization_data(self):
filename = "specialization_data.json"
if os.path.exists(filename): # Проверяем наличие файла
print("Файл уже существует. Пропускаем создание нового файла.")
return
# Данные для записи в JSON файл Специализации
specialization_data_new = {
"Переводчик с английского на русский язык": {
"name": "Переводчик с английского на русский язык",
"description": "Переводи на русский язык полученные сообщения",
"creativity": 0.6
},
"Исправление грамматических ошибок": {
"name": "Исправление грамматических ошибок",
"description": "Исправь грамматические, орфографические и пунктуационные ошибки в тексте. Сохраняй исходный порядок слов.",
"creativity": 0.0
},
"Генерация описания товара": {
"name": "Генерация описания товара",
"description": "Ты — маркетолог. Напиши описание товара для маркетплейса. Используй заданные название товара, категорию и ключевые слова.",
"creativity": 0.0
},
"Генерация рекламного объявления": {
"name": "Генерация рекламного объявления",
"description": "Ты — профессиональный маркетолог с опытом написания высококонверсионной рекламы. Для генерации рекламного текста ты изучаешь потенциальную целевую аудиторию и оптимизируешь рекламный текст так, чтобы он обращался именно к этой целевой аудитории. Напиши рекламный текст для следующих продуктов/услуг. Создай текст объявления с привлекающим внимание заголовком и убедительным призывом к действию, который побуждает пользователей к целевому действию.",
"creativity": 0.0
},
"Генерация ответа на отзыв клиента": {
"name": "Генерация ответа на отзыв клиента",
"description": "Ты — коммьюнити-менеджер и работаешь с обратной связью клиентов на продукты и сервисы компании. Напиши вежливый ответ на отзыв покупателя в Интернете.",
"creativity": 0.0
},
"Переписывание шаблонного ответа": {
"name": "Переписывание шаблонного ответа",
"description": "Ты — оператор клиентской поддержки. Переформулируй ответ так, будто он составлен оператором поддержки.",
"creativity": 0.0
},
"Классификация обращений": {
"name": "Классификация обращений",
"description": "Классифицируй обращения клиента в подходящую категорию. Категории: Статус заказа, Возврат и обмен товаров, Характеристики продукта, Технические проблемы, Другое. В ответе укажи только категорию.",
"creativity": 0.0
},
"Распознавание именованных сущностей": {
"name": "Распознавание именованных сущностей",
"description": "Найди все упомянутые даты и время в тексте. Выведи их, каждый с новой строки. Пример результата: 22-01-2019 17:00 Завтра 18:15 Вчера Если в тексте нет дат, верни 0.",
"creativity": 0.0
},
"Нормализация чисел и дат": {
"name": "Нормализация чисел и дат",
"description": "Перепиши текст, заменяя все числа цифрами.",
"creativity": 0.0
},
"Краткий пересказ статьи": {
"name": "Краткий пересказ статьи",
"description": "Выдели основные мысли из статьи.",
"creativity": 0.0
},
"Ассистент": {
"name": "Ассистент",
"description": "Ты умный ассистент",
"creativity": 0.6
},
"Маркетинговый текст": {
"name": "Маркетинговый текст",
"description": "Ты — опытный копирайтер. Напиши маркетинговый текст с учётом вида текста и заданной темы.",
"creativity": 0.0
},
"Шеф-повар": {
"name": "Шеф-повар",
"description": "Я хочу, чтобы ты был моим личным шеф-поваром. Я расскажу тебе о своих диетических предпочтениях и аллергиях, а ты предложишь мне попробовать рецепты. В ответе ты должен указать только те рецепты, которые ты порекомендуешь, и ничего больше. Не пиши объяснений.",
"creativity": 0.5
},
"Толкователь снов": {
"name": "Толкователь снов",
"description": "Я хочу, чтобы ты выступил в роли толкователя снов. Я дам тебе описания моих снов, а ты предоставишь толкования, основанные на символах и темах, присутствующих во сне. Не содержат личных мнений или предположений о сновидце. Предоставляют только фактические интерпретации, основанные на предоставленной информации.",
"creativity": 0.8
},
"Генератор идей для стартапа": {
"name": "Генератор идей для стартапа",
"description": "Генерируйте идеи для стартапов, основываясь на пожеланиях людей. Например, когда я говорю: \"Я бы хотел, чтобы в моём маленьком городке был большой торговый центр\", вы создаёте бизнес-план для стартапа, включающий название идеи, краткую характеристику целевого пользователя, ключевые точки пользователя, основные ценностные предложения, каналы продаж и маркетинга, источники доходов, структуру затрат, ключевых партнёров, этапы проверки идеи, предполагаемую стоимость работы в течение 1 года и потенциальные бизнес-задачи, на которые следует обратить внимание.",
"creativity": 0.9
}
}
with open(filename, "w", encoding="utf-8") as file: # Записываем данные в JSON файл
json.dump(specialization_data_new, file, ensure_ascii=False, indent=4) # ensure_ascii=False указывает, что необходимо сохранять не-ASCII, indent=4 задает отступ в 4 пробела для форматирования записываемых данных для лучшей читаемости
print(f"JSON файл '{filename}' успешно создан.")
def show_guide(self):
guide_window = tk.Toplevel(self.root)
guide_window.title("Руководство")
# Создаем виджет tk.Text
self.guide_text = tk.Text(guide_window, wrap="word", padx=7)
self.guide_text.insert("1.0", """ SmartiksGPT это программа для доступа к модели ИИ (Искусственного Интеллекта) YandexGPT с возможностью формирования системных сообщений (system massage, в программе называется «Описание специализации») и изменения temperature (в программе называется «Креативность»). Изменяя «Описание специализации» и «Креативность», вы в широких пределах можете изменять и регулировать поведение модели YandexGPT.
SmartiksGPT предназначена для творчества и для работы в ней можно получить ответы на вопросы, написать творческое произведение, написать стих, автоматизировать рутинные информационные процессы и многое другое что вы сможете придумать или уже придумали другие. Пробуйте, получайте опыт взаимодействия с новейшей информационной системой ИИ YandexGPT.
Сообщение к модели (YandexGPT) состоит из system massage (в программе это описание специализации) + текст вашего сообщения которое вы вводите в главном окне программы и temperature (в программе это называется креативность).
В system massage (описание специализации) вы можете поместить:
•Краткое описание модели (например: ты менеджер по продажам, ты бывалый моряк, ты детский сказочник и т. д. и т.п.)
•Личные качества модели (например: ты умный, ты гений, ты смелый ты гордый и т. д.)
•Инструкции или правила, которым вы хотели бы, чтобы следовала модель (например отвечай кратко, отвечай очень подробно, не употребляй слова в превосходной степени и т. д.)
•Данные или информация, необходимые для модели, например какие либо примеры (например: Все даты и фамилии из статьи собери в одно место например:
Даты:
Фамилии:
Описание специализации предназначено для автоматизации процесса общения то есть если вы хотите что бы модель отвечала вам определённым образом и каждый раз не вводить свои пожелания и инструкции вы их помещаете в описание и они каждый раз при вашем запросе добавляются перед вашим запросом. Например описание специализации: «Переводи на русский язык полученные сообщения», ваш текст : I'm sitting at my computer для модели будут выглядить так : «Переводи на русский язык полученные сообщения I'm sitting at my computer» и вы получите ожидаемый ответ : «Я сижу за своим компьютером». По сути "Описание специализации" (system massage) это программа для GPT модели т.е. инструкции которая она должна выполнить.
Для первоначальных экспериментов для подбора описания специализации используйте специализацию «Ассистент» которая установлена по умолчанию при запуске программы там в качестве system massage используется «Ты умный ассистент», так же «Ассистент» можно использовать просто для общения с YandexGPT.
В программе есть встроенные специализации которые можно найти нажав кнопку «Специализация» и выбрав в виджете с названием «Список специализаций». Так же в этом окне вы можете создавать свои варианты внеся своё название и описание в нужные поля так же можно выбрать уровень креативности (по умолчанию 0.0) после нажатия кнопки «Применить» вы можете её использовать при дальнейшем общении с моделью и эта специализация сохранится в файле. Так же можно редактировать сохранённые Специализации.
Если вы задаёте вопрос модели (YandexGPT) и получаете ответ на него то это не значит что она даёт вам ответ, модель просто генерирует дальнейшую последовательность слов (токенов) которые заложены в её модели используя текст для старта который вы ей прислали, который соответственно состоит из system massage (описание специализации) и вашего текста введённого в окно для отправки сообщения, модель не работает по принципу вопрос-ответ она работает по принципу генерации текста после сообщения полученного от вас, но так как после вопросов часто идут ответы (в текстах на которых она училась) вы получаете ответ на ваш вопрос, эту фундаментальную особенность технологии GPT важно понимать что бы в итоге получить ожидаемое для вас поведение модели.
Вариативность (изменчивость) ответа зависит от параметра креативности (от 0 до 1.0) т.е. при креативности = 0 на один и то же сообщение вы получите абсолютно одинаковый ответ, а при креативности 1.0 вы получите всегда разные ответы может быть одинаковые по смыслу но разные по словесному выражению. Так же чем выше креативность тем выше риск в качестве ответа получить галлюцинацию это когда текст не имеет смысла или не соответствует фактам. Вариативность подбирается опытным путём и исходя из желаемого поведения модели, например для ответов по вопросам о математике лучше поставить 0, а при составлении текста на творческую тему 0.8 – 1.0, в качестве отправной точки пробуйте 0,6 дальше экспериментируйте.
При работе вы можете в качестве эксперимента изменять креативность в главном окне но после закрытия программы эта креативность в файле описания специализации не сохранится, что бы её сохранить вызовите окно «Специализация» - в списке специализаций выберите нужное название и установите нужное значение потом нажмите кнопку «Применить» так же там можете менять описание (system massage) и название и после нажатия кнопки «Применить» будут использоваться новые данные при дальнейшей работе, и они сохранятся в файле специализаций, т.е. при работе вы можете оперативно менять параметры работы с моделью и после нажатия кнопки «Применить» данные сохраняются в файл и дальнейшее общение уже идёт с обновлёнными данными.
На данном этапе развития модель YandexGPT не помнит контекст разговора, то есть о чём вы говорили в предыдущих сообщениях, это надо учитывать при формировании ваших запросов и описании специализации (system massage) и это не особенность или слабость YandexGPT это генеративная сущность любой GPT модели, для того что бы модель начала помнить контекст разговора ей надо программными методами каждый раз при новом запросе упаковывать предыдущие сообщения и отправлять при каждом новом запросе, но это работа программной обвязки модели и применяются в готовых программных продуктах для конечного пользователя.
Внизу окна программы можно выбрать испльзуемую модель YandexGPT или YandexGPT-lite. YandexGPT более мощная, но она тарифицируется в четыре раза дороже.
При составлении запросов и описаний специализации (system massage) учитывайте данные рекомендации:
•Отделяйте текст от задания например:
Хуже - Резюмируйте приведенный ниже текст в виде сводного списка наиболее важных моментов (далее ваш текст).
Лучше - Резюмируйте приведенный ниже текст в виде сводного списка наиболее важных моментов.
Текст:
(здесь ваш текст)
•Будьте конкретны, описательны и как можно более подробны в отношении желаемого контекста, результата, продолжительности, формата, стиля и т. Д
Хуже - Напишите стихотворение о природе.
Лучше - Напишите короткое вдохновляющее стихотворение о природе, посвященное тайге и великим рекам России в стиле А. С. Пушкина
•Сформулируйте желаемый формат вывода с помощью примеров
Хуже - Извлеките сущности, упомянутые в тексте ниже. Извлеките следующие 4 типа сущностей: названия компаний, имена людей, конкретные разделы и тематики.Текст: { ваш текст}
Лучше - Извлеките важные объекты, упомянутые в тексте ниже. Сначала извлеките названия всех компаний, затем извлеките имена всех сотрудников, затем извлеките конкретные темы, соответствующие содержанию, и, наконец, извлеките общие, всеобъемлющие темы
Желаемый формат
Названия компаний: -||-
Имена сотрудников: -||-
Конкретные темы: -||-
Общие темы: -||-
Текст: {ваш текст}
•Сократите количество размытых и неточных описаний.
Хуже - Описание этого продукта должно быть довольно коротким, всего в нескольких предложениях, и не более того.
Лучше - Описание этого продукта должно состоять из 3-5 предложений.
Составление запросов (промптов) это тонкий процесс и это можно назвать творчеством, небольшое изменение описания специализации и креативности может сильно повлиять на результат.
Справочная информация:
Допустимое количество символов в сообщении вместе с пробелами и переносом строки – 19000 символов ≈3000 слов ≈ 4-6 листа машинописного текста А4 ≈ 4000 токенов (1 слово ≈ 1,5 токена)
Допустимое количество символов в описании специализации вместе с пробелами и переносом строки – 3800 символов ≈ 500 слов ≈ 1 лист машинописного текста А4 ≈ 800 токенов.
Максимальное количество токенов в ответе YandexGPT – 2000 токенов ≈ 1300 слов.
Для перехода на новую строку в окошке сообщения нажмите «Shift» и не отпуская её клавишу «Ввод» («Enter»).
Для прокрутки текста в окне наведите мышку на окошко и колёсиком прокручивайте текст.
specialization_data.json - Это файл где хранятся данные специализаций программы.
Login_SmartiksGPT.json - это файл где хранятся идентификатор default folder и API ключ
Инстукция по получению идентификатора default folder и ключа API
Зарегестрироваться в Яндексе → зайти по адресу https://cloud.yandex.ru/ru/services/yandexgpt →
Нажать кнопку "Открыть сервис" (откроется консоль по адресу https://console.cloud.yandex.ru/folders/) →
вверху будет название папки (пример - b1gzvco24o5932ufhx5o) это будет идентификатор default folder →
вверху справа нажать кнопку "Создать сервисный аккаунт" → создать сервисный аккаунт и получить ключ API (пример - AQCN9cmr7nfdO6RqB4jv1u43lR1q2av4pyQCwZrL).
Полезные ссылки
Документация по YandexGPT API - https://cloud.yandex.ru/ru/docs/yandexgpt/
Статья про Yandex Cloud - https://habr.com/ru/companies/yandex_cloud_and_infra/articles/760252/
""")
# Создание контекстного меню "Копировать" для Руководства
self.context_menu_guide = Menu(self.guide_text, tearoff=0)
self.context_menu_guide.add_command(label="Копировать", command=self.copy_text_show_guide)
self.guide_text.bind("<Button-3>", self.context_menu_guide_vizov) # Привязка контекстного меню к виджету Text
self.guide_text.pack(expand=True, fill="both", padx=0, pady=0) # Установка ширины окантовки окна
self.guide_text.config(state="disabled") # Установка запрета редактирования текста
# Установка размеров и позиции всплывающего окна
popup_width = 600
popup_height = 600
guide_window.resizable(False, False) # Запрет изменения размеров окна
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
x = (screen_width - popup_width) // 2
y = (screen_height - popup_height) // 2
guide_window.geometry(f"{popup_width}x{popup_height}+{x}+{y}")
# Настройка всплывающего окна как transient и открытие его в модальном режиме
guide_window.transient(self.root)
guide_window.wait_visibility() # Ждем, пока окно станет видимым
guide_window.grab_set_global() # Глобально захватываем фокус
# Захват фокуса и установка активности всплывающего окна
guide_window.grab_set()
guide_window.focus_force()
self.root.wait_window(guide_window.winfo_toplevel())
# Функция messagebox "О программе"
def show_about(self):
winsound.Beep(37, 1) # Отключаем звук в messagebox воспроизводя звук с частотой 2 Гц и 1 миллисекунду
messagebox.showinfo("О программе", " SmartiksGPT v. 1.0 2024 год \n программа доступа к YandexGPT \n разработчик smartiksgpt@mail.ru")
# Функции для контекстного меню "Копировать" в Руководстве def context_menu_guide_vizov и def copy_text_show_guide
def context_menu_guide_vizov(self, event):
self.context_menu_guide.post(event.x_root, event.y_root)
def copy_text_show_guide(self):
selected_text = self.guide_text.get("sel.first", "sel.last")
self.root.clipboard_clear()
self.root.clipboard_append(selected_text)
self.root.update()
# Основной блок, создание главного окна и экземпляра класса DraggableWindow
if __name__ == "__main__":
root = tk.Tk() # Cоздает экземпляр класса Tk главное окно
app = DraggableWindow(root) # Cоз дает экземпляр класса DraggableWindow и передает ему главное окно root
root.mainloop() # Запускает бесконечный цикл обработки событий Tkinter, который ожидает действий пользователя (например нажатие кнопок, перемещение мыши) и обновляет графический интерфейс соответственно Можно данный код скопировать в блокнот, сохранить с расширением .py например SmartiksGPT.py, скачать и установить интерпретатор Python 3.12 и пользоваться.
При первом запуске программы вводим значения default и API ключ в меню «Авторизация», в окне «Специализация» есть примеры которые можно модифицировать и добавлять новые.
Что можно ещё добавить к этой программе, ну например, добавить работу с GigaChat API и сравнивать их работу в жёстком спаринге, можно добавить запоминание контекста разговора, например при следующем запросе отправлять предыдущие, можно прикрутить RAG, можно добавить доступ к GPT 4 через сервис proxyapi.ru и наверно много чего ещё.
Данная программа допускает свободное использование и любую модификацию на своё усмотрение для членов habr сообщества.
Комментарии (3)
S0mbre
23.04.2024 18:01+6Все моё нутро восстаёт против такого "программирования на минималках". Но, видимо, от этого уже никуда не денешься. Эпоха скрипт-кидди перешла в эпоху гпт-кидди.
GennPen
Например, gpt4free. Но нужно выбирать сервисы, многие без VPN не работают и постоянно обновлять библиотеку. Либо сделать на его основе небольшой прокси-сервис на иностранном VPS/VDS.