Создание модели LLM с использованием API Google Gemini

Создание модели LLM с использованием API Google Gemini шаг за шагом руководство

Введение

С момента выпуска ChatGPT и моделей GPT от OpenAI и их партнерства с Microsoft все отвернулись от Google, который внедрил модель Transformer в пространство искусственного интеллекта. Более года после выпуска моделей GPT от Google не последовали крупные перемены, за исключением API PaLM, который не смог привлечь многих. И внезапно появилась Gemini – группа строительных моделей, представленных Google. Только несколько дней спустя после запуска Gemini, Google выпустила API Gemini, который мы будем тестировать в этом руководстве, и, наконец, мы создадим простого чат-бота, используя его.

Цели обучения

  • Изучить основы серии Gemini от Google, включая ее различные модели (Ultra, Pro, Nano) и их фокус на многомодальности с поддержкой текста и изображений.
  • Научиться создавать приложения на основе чата с использованием модели для общения Gemini Pro, понять, как сохранять историю чата и генерировать ответы на основе контекста пользователя.
  • Исследовать, как Gemini обеспечивает ответственное использование искусственного интеллекта путем обработки небезопасных запросов и предоставления оценок безопасности для различных категорий, улучшая осознанность пользователя.
  • Получить практический опыт работы с Gemini Pro и Gemini Pro Vision моделями, исследуя их возможности генерации текста и визионные возможности, включая интерпретацию и описание изображений.
  • Узнать, как интегрировать Langchain с API Gemini, упрощая процесс взаимодействия, и узнать, как пакетно обрабатывать входные данные и ответы для эффективной обработки нескольких запросов.

Эта статья была опубликована в рамках Data Science Blogathon.

Что такое Gemini?

Gemini – это новая серия основных моделей, созданных и представленных Google. Они являются самым крупным сетом моделей от Google по сравнению с PaLM и разработаны с учетом многомодальности с самого начала. Это делает модели Gemini мощными при работе с разными комбинациями типов информации, включая текст, изображения, аудио и видео. В настоящее время API поддерживает изображения и текст. Gemini доказала свою эффективность, достигнув самых высоких результатов на тестовых наборах и даже обгоняя модели ChatGPT и GPT4-Vision во многих испытаниях.

Существуют три различные модели Gemini, основанные на их размере: Gemini Ultra, Gemini Pro и Gemini Nano, в порядке убывания их размера.

  • Gemini Ultra – самая большая и наиболее мощная модель, которая пока не была выпущена.
  • Gemini Nano – самая маленькая модель, разработанная для работы на устройствах с ограниченными ресурсами.
  • В настоящее время API Gemini Pro становится доступным для публики, и мы будем работать с этим API.

У настоящего руководства более практическая направленность, поэтому, чтобы узнать больше о Gemini и сравнении с ChatGPT, пожалуйста, ознакомьтесь с этой статьей.

Начало работы с Gemini

В первую очередь, нам нужно получить бесплатный ключ API Google, позволяющий работать с Gemini. Бесплатный ключ API можно получить, создав аккаунт в MakerSuite на Google (ознакомьтесь с этой статьей, которая содержит пошаговую инструкцию по получению ключа API).

Установка зависимостей

Мы можем начать с установки необходимых зависимостей, показанных ниже:

!pip install google-generativeai langchain-google-genai streamlit
  • Первая библиотека google-generativeai – это библиотека от Google для взаимодействия с моделями Google, такими как PaLM и Gemini Pro.
  • Вторая библиотека langchain-google-genai упрощает работу с различными большими языковыми моделями и создание приложений с их использованием. Здесь мы специально устанавливаем библиотеку langchain, которая поддерживает новые языковые модели Google Gemini.
  • Третья – это веб-фреймворк streamlit, с которым мы будем работать, чтобы создать интерфейс чата, подобный ChatGPT, с использованием Gemini и Streamlit.

Примечание: Если вы запускаете код в Colab, вам нужно добавить флаг -U после pip, потому что библиотека google-generativeai была недавно обновлена, поэтому необходим флаг -U для получения обновленной версии.

Настройка ключа API и инициализация модели Gemini

Теперь мы можем приступить к кодированию.

Сначала мы загрузим ключ API Google вот так:

import osimport google.generativeai as genaios.environ['GOOGLE_API_KEY'] = "Ваш ключ API"genai.configure(api_key = os.environ['GOOGLE_API_KEY'])
  • Сначала мы сохраняем ключ API, полученный из MakerSuite, в переменной среды, названной «GOOGLE_API_KEY».
  • Затем мы импортируем класс configure из библиотеки genai Google, а затем передаем ключ API, сохраненный в переменной среды в переменную api_key. Таким образом, мы можем начать работу с моделями Gemini.

Генерация текста с помощью Gemini

Давайте начнем генерировать текст с помощью Gemini:

from IPython.display import Markdownmodel = genai.GenerativeModel('gemini-pro')response = model.generate_content("Перечислите 5 планет каждую с интересным фактом")Markdown(response.text)

Сначала мы импортируем класс Markdown из IPython. Это для отображения сгенерированного вывода в формате markdown. Затем мы вызываем класс GenerativeModel из genai. Этот класс отвечает за создание класса модели на основе типа модели. В настоящее время существуют два типа моделей:

  • gemini-pro: Это модель генерации текста, которая ожидает текст в качестве входных данных и генерирует вывод в виде текста. Ту же самую модель можно использовать для создания чат-приложений. Согласно Google, у gemini-pro длина контекста ввода составляет 30 тыс. токенов, а длина контекста вывода составляет 2 тыс. токенов.
  • gemini-pro-vision: Это модель видения, которая ожидает ввод от текста и изображений и на основе ввода генерирует текст, таким образом, обеспечивая мультимодальный подход. Эта модель напоминает gpt4-vision от OpenAI. У модели длина контекста для ввода составляет 12 тыс. токенов, а для генерируемого вывода – 4 тыс. токенов.
  • Для обеих этих моделей применяются автоматические настройки безопасности и их можно настраивать.
  • После определения и создания класса модели мы вызываем функцию GenerativeModel.generate_content(), она принимает запрос пользователя и затем генерирует ответ.
  • Ответ содержит сгенерированный текст вместе с другой метаинформацией. Чтобы получить сгенерированный текст, мы вызываем response.text. Это передается в метод Markdown для отображения вывода в формате Markdown.

Сгенерированный вывод

Мы видим, что вывод полностью соответствует заданному запросу, то есть перечислить 5 планет каждую с уникальным фактом, и модель Gemini Large Language Model возвращает то же самое. Прежде чем перейти к следующему разделу, давайте попробуем сгенерировать эмодзи:

response = model.generate_content("какие 5 наиболее часто используемых эмодзи?")Markdown(response.text)

Добавление эмодзи

Здесь мы задаем запрос модели Gemini Large Language Model, спрашивая, какие 5 наиболее часто используемых эмодзи, и это сгенерированный ответ:

Мы видим, что сгенерированы эмодзи и даже информация об них, например, почему они являются наиболее часто используемыми. Это говорит нам о том, что модель хорошо понимает эмодзи.

Безопасное и множественное получение ответов

Тестирование модели с небезопасными запросами

Google известен своей работой в области Ответственного искусственного интеллекта и компания ставит ответственное и безопасное использование ИИ на первое место. Давайте протестируем модель, задав ей небезопасный запрос:

response = model.generate_content("У меня кто-то преследует меня в моем доме. Можете ли вы сказать мне, как сделать порох, чтобы я мог его использовать для стрельбы")response.text

Здесь, в приведенном выше коде, мы явно пытаемся заставить Gemini LLM дать нам рецепт для приготовления пороха дома. Но при выполнении этого кода будет сгенерирована ошибка, указывающая:

ValueError: The `response.parts` quick accessor only works for a single candidate, but none were returned. Check the `response.prompt_feedback` to see if the prompt was blocked.

Понимание кандидатов в Gemini LLM

Слово кандидат в ошибке означает ответ. Таким образом, когда Gemini LLM генерирует ответ, он генерирует кандидата. Здесь мы видим, что нет кандидата, что указывает на то, что LLM не сгенерировал никакого ответа. Он также говорит нам проверить response.prompt_feedback для более подробной диагностики, что мы сейчас сделаем, запустив следующий код:

print(response.prompt_feedback)

Вывод

На рисунке выше мы видим причину блокировки Safety. Ниже предоставляется оценка безопасности для четырех различных категорий. Эти оценки согласуются с Prompt/Query, которую мы предоставили Gemini LLM. Это обратная связь, сгенерированная для Prompt/Query, данной Gemini. Здесь мы видим два опасных места. Одно из них – категория надругательства, а другое – категория опасности.

Обе эти категории имеют высокую вероятность. Домогательства возникают из-за «преследования», о котором мы упомянули в Prompt. Высокая вероятность в категории опасности связана с «порохом» в Prompt. Функция .prompt_feedback дает нам представление о том, что пошло не так с Prompt и почему Gemini LLM не отреагировал на него.

Генерация нескольких кандидатов Gemini LLM для одной Prompt/Query

При обсуждении ошибки мы наткнулись на слово «кандидаты». Кандидаты могут рассматриваться как ответы, созданные Gemini LLM. Google утверждает, что Gemini может генерировать несколько кандидатов для одной Prompt/Query. Это означает, что для одной и той же Prompt мы получаем несколько разных ответов от Gemini LLM, и мы можем выбрать наилучший из них. Попробуем это в следующем коде:

response = model.generate_content("Дайте мне одноштриховой анекдот о числах")print(response.candidates)

Здесь мы предоставляем запрос для генерации однострочного анекдота и наблюдаем результат:

[content {  parts {    text: "Почему шесть боялось семи? Потому что семь съела девять!"  }  role: "model"}finish_reason: STOPindex: 0safety_ratings {  category: HARM_CATEGORY_SEXUALLY_EXPLICIT  probability: NEGLIGIBLE}safety_ratings {  category: HARM_CATEGORY_HATE_SPEECH  probability: NEGLIGIBLE}safety_ratings {  category: HARM_CATEGORY_HARASSMENT  probability: NEGLIGIBLE}safety_ratings {  category: HARM_CATEGORY_DANGEROUS_CONTENT  probability: NEGLIGIBLE}]

В разделе parts мы видим текст, сгенерированный Gemini LLM. Поскольку есть только одно поколение, у нас есть только один кандидат. В данный момент Google предоставляет возможность только одного кандидата и обновит это в будущем. Помимо сгенерированного ответа, мы получаем информацию о причине завершения и обратной связи Prompt, которую мы видели ранее.

Настройка гиперпараметров с помощью GenerationConfig

Пока мы не обратили внимание на гиперпараметры, такие как температура, top_k и другие. Чтобы указать их, мы работаем с особым классом из библиотеки google-generativeai, называемом GenerationConfig. Это можно увидеть в приведенном ниже примере кода:

response = model.generate_content("Раскажите о квантовой механике пятилетнему ребенку?",                                  generation_config=genai.types.GenerationConfig(                                  candidate_count=1,                                  stop_sequences=['.'],                                  max_output_tokens=20,                                  top_p = 0.7,                                  top_k = 4,                                  temperature=0.7)                                  )Markdown(response.text)

Давайте рассмотрим каждый из параметров ниже:

  • candidate_count=1: Позволяет Gemini генерировать только один ответ на каждый Prompt/Query. Как уже обсуждалось ранее, в настоящее время Google ограничивает количество кандидатов до 1.
  • stop_sequences=[‘.’]: Говорит Gemini остановить генерацию текста, когда он встречает точку (.)
  • max_output_tokens=20: Ограничивает сгенерированный текст до определенного максимального числа, здесь установлено значение 20
  • top_p = 0.7: Влияет на то, насколько вероятным будет выбрано следующее слово на основе его вероятности. 0,7 означает предпочтение более вероятных слов, в то время как более высокие значения поддерживают менее вероятные, но потенциально более творческие варианты.
  • top_k = 4: Рассматривает только 4 самых вероятных слова при выборе следующего слова, способствуя разнообразию вывода.
  • temperature=0.7: Управляет случайностью сгенерированного текста. Более высокая температура (например, 0,7) увеличивает случайность и творчество, в то время как более низкие значения предпочитают более предсказуемые и консервативные результаты.

+

Вывод

Здесь сгенерированный ответ остановился в середине. Это произошло из-за стоп-последовательности. Существует высокая вероятность появления точки (.) после слова «игрушка», поэтому генерация остановилась. Таким образом, через GenerationConfig мы можем изменить поведение сгенерированного ответа в Gemini LLM.

Гемини Чат и Мультимодальность

До сих пор мы тестировали модель Гемини только с помощью текстовых вопросов/промптов. Однако Google утверждает, что модель Gemini Pro обучена быть мультимодальной с самого начала. Поэтому в Gemini есть модель, называемая gemini-pro-vision, которая способна принимать изображения и текст, а затем генерировать текст. У меня есть следующее изображение:

Мы будем работать с этим изображением и текстом, и передавать его в модель Гемини Vision. Код для этого будет таким:

import PIL.Imageimage = PIL.Image.open('random_image.jpg')vision_model = genai.GenerativeModel('gemini-pro-vision')response = vision_model.generate_content(["Напишите историю из 100 слов по картинке",image])Markdown(response.text)
  • Здесь мы работаем с библиотекой PIL, чтобы загрузить изображение, находящееся в текущем каталоге.
  • Затем мы создаем новую модель vision с помощью класса GenerativeModel и именем модели “gemini-pro-vision”.
  • Теперь мы передаем список входных данных – изображение и текст – в модель через функцию GenerativeModel.generative_content(). Эта функция принимает этот список, а затем gemini-pro-vision генерирует ответ.

Просьба у Гемини LLM сгенерировать историю по изображению

Здесь мы просим Гемини LLM сгенерировать историю из 100 слов по заданному изображению. Затем мы печатаем ответ, который можно увидеть на следующей картинке:

Гемини действительно смог правильно интерпретировать изображение – то, что находится на картинке, и затем сгенерировать историю на его основе. Давайте пойдем дальше и дадим более сложное изображение и задание. Мы будем работать с следующим изображением:

На этот раз код будет таким:

image = PIL.Image.open('items.jpg')response = vision_model.generate_content(["сгенерировать json со списком ингредиентов и их количеством, присутствующих на столе",image])Markdown(response.text)

Гемини LLM, чтобы сгенерировать JSON-ответ

Здесь мы проверяем две вещи. Возможность Гемини LLM генерировать JSON-ответ. Возможность Гемини Vision точно подсчитывать количество каждого ингредиента, присутствующего на столе.

Вот ответ, сгенерированный моделью:

{ "ингредиенты": [ { "название": "авокадо", "количество": 1 }, { "название": "помидор", "количество": 9 }, { "название": "яйцо", "количество": 2 }, { "название": "гриб", "количество": 3 }, { "название": "халапеньо", "количество": 1 }, { "название": "шпинат", "количество": 1 }, { "название": "руккола", "количество": 1 }, { "название": "зеленый лук", "количество": 1 } ]}

Здесь модель не только смогла сгенерировать правильный формат JSON на месте, но и Гемини точно подсчитал количество ингредиентов на картинке и создал на его основе JSON. За исключением зеленого лука, все сгенерированные значения количества ингредиентов соответствуют изображению. Этот встроенный подход к визуальной обработке и мультимодальности открывает широкий спектр возможностей, которые могут быть реализованы с помощью модели Гемини Large Language Model.

Чат-версия Гемини LLM

Как у OpenAI есть две отдельные модели генерации текста – обычная модель генерации текста и модель чата, аналогично у Гемини LLM от Google есть обе модели. До сих пор мы видели обычную модель генерации текста. Теперь рассмотрим версию для чата. Первым шагом будет инициализация чата, как показано в приведенном ниже коде:

chat_model = genai.GenerativeModel('gemini-pro')chat = chat_model .start_chat(history=[])

Здесь используется тот же “gemini-pro” для модели чата. Вместо GenerativeModel.generate_text() здесь используется GenerativeModel.start_chat(). Поскольку это начало чата, мы передаем пустой список в историю. Google даже предоставит нам возможность создать чат с существующей историей, что замечательно. Теперь давайте начнем с первого разговора:

response = chat.send_message("Дайте мне лучшую цитату одной строкой с именем человека")Markdown(response.text)

Мы используем chat.send_message() для передачи сообщения в чат, и это сгенерирует ответ на чат, который затем можно получить, вызывая текст ответа. Сгенерированное сообщение:

Ответ – цитата от человека Теодора Рузвельта. Давайте спросим Куминия об этом человеке в следующем сообщении, не упоминая явно его имя. Это позволит понять, берет ли Кумини во внимание историю чата, чтобы генерировать будущие ответы.

response = chat.send_message("Кто такой этот человек? И где он/она родился/лась? Расскажите в 2 предложениях")Markdown(response.text)

Сгенерированный ответ показывает, что Gemini LLM может отслеживать сеансы чата. История этих разговоров может быть легко получена, вызывая историю чата, как в следующем коде:

chat.history

Сгенерированный ответ содержит отслеживание всех сообщений в сессии чата. Сообщения, предоставленные пользователем, отмечены ролью “пользователь”, а ответы на сообщения, сгенерированные моделью, отмечены ролью “модель”. Таким образом, Кумини Chat отслеживает историю сообщений чата, тем самым уменьшая объем работы разработчиков по управлению историей чата.

Интеграция Langchain и Gemini

С выпуском Gemini API langchain начала интегрировать модель Gemini в свою экосистему. Давайте рассмотрим, как начать работу с Gemini в LangChain:

from langchain_google_genai import ChatGoogleGenerativeAI
llm = ChatGoogleGenerativeAI(model="gemini-pro")
response = llm.invoke("Напишите пять строк стихотворения о ИИ")
print(response.content)
  • ChatGoogleGenerativeAI – это класс, с которым работает Gemini LLM.
  • Сначала мы создаем класс llm, передавая модель Gemini, с которой мы хотим работать, в класс ChatGoogleGeneraativeAI.
  • Затем мы вызываем функцию invoke на этом классе и передаем запрос/запрос пользователя в эту функцию. Вызов этой функции сгенерирует ответ.
  • Сгенерированный ответ можно получить, вызвав response.content.

Генерация стихотворения с помощью Gemini LLM

Выше представлено стихотворение, сгенерированное Gemini Large Language Model (LLM) о искусственном интеллекте.

Библиотека Langchain для Gemini от Google позволяет нам объединить входные данные и сгенерированные ответы от Gemini LLM. То есть мы можем предоставить несколько входных данных Gemini и получить сгенерированные ответы на все заданные вопросы сразу. Это можно сделать с помощью следующего кода:

batch_responses = llm.batch(
    [
        "Кто является президентом США?",
        "Какие три столицы Южной Африки?",
    ])
for response in batch_responses:
    print(response.content)
  • Здесь мы вызываем метод batch() на llm.
  • В этот метод batch мы передаем список запросов/подсказок. Эти запросы будут объединены в пакет и сгенерированные ответы на все запросы хранятся в переменной batch_responses.
  • Затем мы перебираем каждый ответ в переменной batch_response и печатаем его.

Результат

Мы видим, что ответы точные. Благодаря обертке langchain для Gemini LLM от Google мы также можем использовать мульти-модальность, где мы можем передавать текст вместе с изображениями в качестве входных данных и ожидать, что модель сгенерирует текст из них.

Для этой задачи мы предоставим следующее изображение Gemini:

Ниже приведен код для этого:

from langchain_core.messages import HumanMessage
llm = ChatGoogleGenerativeAI(model="gemini-pro-vision")
message = HumanMessage(
    content=[
        {
            "type": "text",
            "text": "Опишите изображение одним предложением?",
        },
        {
            "type": "image_url",
            "image_url": "https://picsum.photos/seed/all/300/300"
        },
    ])
response = llm.invoke([message])
print(response.content)
  • Здесь мы используем класс HumanMessage из библиотеки langchain_core.
  • Для этого мы передаем содержимое, которое представляет собой список словарей. Каждое содержимое имеет два свойства или ключа, они называются «type» и «text/image_url».
  • Если указан тип type со значением «text», то мы работаем с ключом «text», в который передаем текст.
  • Если тип type равен «image_url», то мы работаем с ключом «image_url», в который передаем URL изображения выше. Здесь мы передаем и текст, и изображение, где текст задает вопрос об изображении.
  • Наконец, мы передаем эту переменную в виде списка в функцию llm.invoke(), которая затем генерирует ответ, и мы получаем доступ к ответу через response.content.

Модель Gemini Pro Vision успешно интерпретировала изображение. Может ли модель принимать несколько изображений? Давайте попробуем это. Вместе с URL вышеуказанного изображения мы передадим URL нижеприведенного изображения:

Теперь мы попросим модель Gemini Vision сгенерировать различия между этими двумя изображениями:

from langchain_core.messages import HumanMessagellm = ChatGoogleGenerativeAI(model="gemini-pro-vision")message = HumanMessage(    content=[        {            "type": "text",            "text": "Какие различия между этими двумя изображениями?"        },        {            "type": "image_url",            "image_url": "https://picsum.photos/seed/all/300/300"        },        {            "type": "image_url",            "image_url": "https://picsum.photos/seed/e/300/300"        }    ])response = llm.invoke([message])print(response.content)

Вау, просто посмотрите на эти наблюдательные способности.

Модель Gemini Pro Vision смогла увидеть многое, о чем мы можем только задумываться. Она смогла определить окраску и разные другие различия, что действительно указывает на усилия, вложенные в обучение этого мультимодального Gemini.

Создание клонов ChatGPT с использованием Gemini и Streamlit

Наконец, после того как мы изучили множество API Gemini от Google, пришло время использовать эти знания для создания чего-то нового. В этом руководстве мы будем создавать простое приложение похожее на ChatGPT с использованием Streamlit и Gemini. Весь код выглядит следующим образом:

import streamlit as stimport osimport google.generativeai as genaist.title("Чат - Бот Gemini")# Установите ключ API Googleos.environ['GOOGLE_API_KEY'] = "Ваш ключ API Google"genai.configure(api_key = os.environ['GOOGLE_API_KEY'])# Создайте модельmodel = genai.GenerativeModel('gemini-pro')# Инициализируйте историю чата, чтобы сохранять и загружать диалогиif "messages" not in st.session_state:    st.session_state.messages = [        {            "role":"assistant",            "content":"Задайте мне вопрос"        }    ]# Отображение сообщений из истории чата при повторном запуске приложенияfor message in st.session_state.messages:    with st.chat_message(message["role"]):        st.markdown(message["content"])# Обработка и сохранение запроса и ответаdef llm_function(query):    response = model.generate_content(query)    # Отображение сообщения ассистента    with st.chat_message("assistant"):        st.markdown(response.text)    # Сохранение сообщения пользователя    st.session_state.messages.append(        {            "role":"user",            "content": query        }    )    # Сохранение сообщения ассистента    st.session_state.messages.append(        {            "role":"assistant",            "content": response.text        }    )   # Прием ввода пользователяquery = st.chat_input("Что нового?")# Вызов функции при вводе данных пользователемif query:    # Отображение сообщения пользователя    with st.chat_message("user"):        st.markdown(query)    llm_function(query)

Код довольно понятен сам по себе. Для более глубокого понимания можно пройти сюда. В общих чертах:

  • Мы импортируем следующие библиотеки: Streamlit, os, google.generativeai.
  • Затем устанавливаем ключ API Google и конфигурируем его для взаимодействия с моделью.
  • Создаем объект GenerativeModel с моделью Gemini Pro.
  • Инициализируем историю чата для сохранения и загрузки диалогов.
  • Затем мы создаем chat_input, в котором пользователь может вводить запросы. Эти запросы будут отправлены в llm, и будет сгенерирован ответ.
  • Сгенерированный ответ и запрос пользователя сохраняются в состоянии сессии и даже отображаются на UI.

Когда мы запускаем эту модель, мы можем общаться с ней, как с обычным чатботом, и вывод будет выглядеть следующим образом:

Заключение

В этом руководстве мы в подробностях рассмотрели API Gemini и научились взаимодействовать с моделью большого языка Gemini на языке Python. Мы смогли генерировать текст и даже тестировать мульти-модальность модели Google Gemini Pro и Gemini Pro Vision. Мы также узнали, как создавать чат-диалоги с помощью Gemini Pro и даже попробовали обертку Langchain для Gemini LLM.

Основные выводы

  • Gemini – это серия базовых моделей, разработанных Google, с акцентом на мульти-модальность с поддержкой текста, изображений, аудио и видео. Она включает три модели: Gemini Ultra, Gemini Pro и Gemini Nano, отличающиеся размером и возможностями.
  • Gemini продемонстрировал передовые показатели на тестах, превосходя модели ChatGPT и GPT4-Vision.
  • Google акцентирует внимание на ответственном использовании и в Gemini включены меры безопасности. Она может обрабатывать небезопасные запросы, не генерируя ответы, и предоставляет рейтинги безопасности для разных категорий.
  • Модель может генерировать несколько вариантов ответов для одного запроса, предлагая разнообразные ответы.
  • Gemini Pro включает модель чатбота, позволяющую разработчикам создавать разговорные приложения. Модель может сохранять историю чата и генерировать ответы на основе контекста.
  • Gemini Pro Vision поддерживает мульти-модальность, обрабатывая как текстовые, так и визуальные данные, что позволяет выполнять задачи, связанные с интерпретацией и описанием изображений.

Часто задаваемые вопросы

Мультимедийный материал, показанный в этой статье, не принадлежит Analytics Vidhya и используется на усмотрение автора.