We write a program in Python to access YandexGPT using ChatGPT
In this program, you will be able to independently compose your own system massage (in the program this is called “Specialization”), and this is essentially programming the GPT model in natural language, you will also be able to change the temperature (in the program this is called “Creativity”), this changes the variability of answers , with a value of 0.0, the same question will always receive the same answer; with 1.0, there may be different answers with a similar meaning but different in verbal expression, you can also use two models YandexGPT and YandexGPT Lite, the second is faster and a little simpler but also cheaper four times. Description of the program in the “Information” menu section.
Well, now go straight into battle. Install the VPN extension in the browser – HolaVPN, the extension is turned on automatically, but sometimes you need to enable it manually or change the country in the settings if something does not load (I changed it to Canada), sometimes the extension itself blocks the loading of the site, then you need to click on the extension icon at the bottom right and close the window that appears with a lucrative offer) . Register on openai.com with an e-mail that does not end in .ru, vasapupkin@gmail.com will do. Let's go to ChatGPT 3.5 turbo here we will write a program. In the account settings section Customize ChatGPT → How would you like ChatGPT to respond? let's write → Answer in Russian, Python programming language.
Now let's prepare Yandex. Register in Yandex if you have an account, go to the service YandexGPT API.
We get here:
At the top left, click default, if not yet, create a payment account and put a small amount on it to try the service (that year they gave a thousand rubles as a gift for a couple of months).
What is circled in an oval is your default identifier, essentially a login that needs to be entered into our program to access YandexGPT, an example of an identifier is b2wek9sskl91crв1trub.
Next, go to “service accounts” and create a service account (blue button “Create service account”).
After creation, go to this account and create an API key (indicated by an arrow), select “Create API key” in the menu, copy the resulting key and save it somewhere (it is not stored in the account), you will need it to enter it into the program to access YandexGPT , if the key is lost, it can be created again, an example of a key is AQSA2cmr7ns2O6DqB4jv8gh3lR1M9av4pyHCwZwL.
Now download and install the IDE Visual Studio Code.
download Python 3.12.
Now everything is ready, you can create. If you have any questions during the preparation, don’t hesitate to ask ChatGPT, for example:
You
How to Run a Python Program in Visual Studio Code
ChatGPT
To run a Python program in Visual Studio Code, follow these steps:
Install Python if you haven't already. You can download it from the official Python website: https://www.python.org/downloads/
Install Visual Studio Code if you don't already have it. You can download it from the official website: https://code.visualstudio.com/
Open Visual Studio Code.
Create a new file or open an existing file with a .py (Python file) extension.
Press `Ctrl + “ (backtick) to open a terminal inside Visual Studio Code. You can also select “Terminal” -> “New Terminal” from the menu.
In the terminal, make sure your working directory (folder) is where your Python file is located.
Run your program by entering the command python filename.py, where filename.py is the name of your Python file.
For example, if your file is called hello.py, then the command would look like this:
Bash
Copy code
python hello.py
Or you can use the “Run” button (green triangle) at the top of the code editor to run the program. Before starting, make sure that the Python interpreter in Visual Studio Code is configured correctly. This may require installing the Python extension and specifying the path to the interpreter in the Visual Studio Code settings.
Or more :
You
How to install python libraries
ChatGPT
To install Python libraries, you can use the pip package management tool. Here's how to do it:
Open a terminal (command prompt) on your computer.
Type pip install library_name, where library_name is the name of the Python library you want to install. For example:
bash
Copy code
pip install requests
This will install the requests library.
If you want to install a specific version of a library, you can specify the version by adding == and the version number. For example:
bash
Copy code
pip install requests==2.25.1
If you want to update the library to the latest version, you can use the command:
bash
Copy code
pip install --upgrade имя_библиотеки
For example:
bash
Copy code
pip install --upgrade requests
If you are using a Python virtual environment (which is a good practice for isolating dependencies between projects), make sure your virtual environment is activated before running pip install.
Now you know how to install Python libraries using pip.
I used Windows PowerShell as a terminal, you can use cmd.exe, enter them into Windows search and find them there.
Here are examples of requests to ChatGPT when developing a program
you need to increase the width of the side lines of the main window
which library for python contains a graphical interface similar to windows style
how to load tkinter library as tk
Comment on this code in great detail, each line of function and variable (….example code…)
Now make it so that the data in the “Resultat” widget cannot be edited (….example code…)
I understand correctly – this function self.entry = tk.Text(self.root, wrap=”word”, width=70, height=7) passes its value to the entered_text variable (….code example….)
etc., etc., when making a request, do not forget to insert pieces of code where you need to make any changes or add something, you can insert the entire code for any request, but ChatGPT 3.5 has restrictions on the number of tokens (words) of the request and after 300-400 lines of code it starts writing “too long”. After successful changes, we save a backup copy so that if something happens, we can roll back to the working version, otherwise ChatGPT will mess up so much that you won’t be glad that you contacted it (just kidding).
Frequent errors of ChatGPT – for example, in the name of a variable, he often forgets to add self in order to use it in another function, gpt_model_uri_get and you need self.gpt_model_uri_get and the same with functions (methods), def show_registration():, but you need def show_registration(self): what I would call it through the self.show_registration construction.
In Visual Studio Code at the bottom there is a terminal window where error codes are also displayed, you can copy from there and ask ChatGPT about the error, select it and use the Ctrl+C keys to copy and then paste it into the ChatGPT request window via the context menu or Ctrl+V.
To compile the program into a finished .exe file, use the commands in the terminal.
Windows PowerShell or cmd.exe. Paste the program code into notepad and save it with a .py extension, for example SmartiksGPT.py
cd C:\Users\HP\Desktop – command to go to the working directory where the SmartiksGPT.py file is located (in this case, on the desktop).
pyinstaller –onefile –noconsole SmartiksGPT.py – compilation command into an .exe file (in this case, one file without a console).
The finished file will be located in the dist folder.
Well, that seems to be all.
Here is the actual code of the SmartiksGPT program with comments:
# Импорт библиотек
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, который ожидает действий пользователя (например нажатие кнопок, перемещение мыши) и обновляет графический интерфейс соответственно You can copy this code into notepad, save it with a .py extension, for example SmartiksGPT.py, download and install the interpreter Python 3.12 and use it.
When you first start the program, enter the default values and API key in the “Authorization” menu; in the “Specialization” window there are examples that can be modified and new ones added.
What else can be added to this program, for example, add work with GigaChat API and compare their work in hard sparring, you can add remembering the context of the conversation, for example, send the previous ones with the next request, you can attach RAG, you can add access to GPT 4 through the service proxyapi.ru and probably a lot more.
This program allows free use and any modification at its discretion for members of the habr community.
