|
--- |
|
library_name: transformers |
|
datasets: |
|
- Vikhrmodels/GrandMaster-PRO-MAX |
|
- attn-signs/kolmogorov-3 |
|
- attn-signs/russian-code |
|
base_model: |
|
- RefalMachine/RuadaptQwen2.5-32B-Pro-Beta |
|
license: apache-2.0 |
|
language: |
|
- ru |
|
--- |
|
|
|
# Watari 32B (V2) |
|
|
|
### [EN] |
|
Qwen2.5-based model, adapted for russian text generation tasks. |
|
- The model has extended tokenizer and proper adapted chat template. |
|
- The model was trained using LoRA adapters. |
|
- The model was trained for **2 stages** |
|
### [RU] |
|
Finetune версия Qwen2.5, адаптированная для генерации русского текста. |
|
- Модель имеет расширенный токенайзер и правильный адаптированный чат темплейт (произведена работа над ошибками). |
|
- Модель была обучена с использованием низкоранговых адаптеров LoRA. |
|
- Модель была обучена в **2 стадии** |
|
|
|
### Previous models (considering parameters / states): |
|
- Watari-7b-v1 |
|
- Watari-32b-v0 |
|
|
|
## Model Details / Детализация модели |
|
### [EN] |
|
LoRA supervised finetuning version was performed on **2xA100 NVIDIA** GPUs for **~8 days**. |
|
**Datasets used:** |
|
- GrandMaster [Vikhrmodels/GrandMaster-PRO-MAX] (0.6 epochs) |
|
- Kolmogorov-3 [attn-signs/kolmogorov-3] (1 epochs) |
|
- Russian Code [attn-signs/russian/code] (1 epochs) |
|
The model has extended tokenizer based on arxiv paper and works of RefalMachine (RuAdapt / Moscow State University). |
|
**Huge thanks to Mikhail Tikhomirov for hard scientific work and tokenizer extension methods developed.** |
|
The model generation in russian is 60% more cheaper and faster due to the extended tokenizer (see the research at the end). |
|
|
|
**Base model**: https://huggingface.co/RefalMachine/RuadaptQwen2.5-32B-Pro-Beta |
|
|
|
### [RU] |
|
SFT LoRA обучение было выполнено на **двух NVIDIA A100**, обучение длилось около **8 дней**. |
|
**Использованные датасеты:** |
|
- GrandMaster [Vikhrmodels/GrandMaster-PRO-MAX] (0.6 эпохи) |
|
- Kolmogorov-3 [attn-signs/kolmogorov-3] (1 эпоха) |
|
- Russian Code [attn-signs/russian/code] (1 эпоха) |
|
Модель имеет расширенный токенайзер, метод основан на arxiv статье и работах RefalMachine (RuAdapt / Московский Государственный Университет). |
|
**Выражаю большое уважение Михаилу Тихомирову за его научные работы и методы расширения токенайзера.** |
|
Генерация модели, благодаря методу на 60% более быстрая и менее дорогая (см. исследование токенайзера в конце статьи). |
|
|
|
**Базовая модель**: https://huggingface.co/RefalMachine/RuadaptQwen2.5-32B-Pro-Beta |
|
|
|
### Model Description / Описание модели |
|
|
|
- **Developed by:** [Reisen Raumberg (Attention Signs team)] |
|
- **Language(s) (NLP):** [RU/EN] |
|
- **Finetuned from model:** [Qwen2.5, RuAdapt version] |
|
|
|
**Distributed training:** |
|
- DeepSpeed (Stage 3) |
|
- HuggingFace Accelerator |
|
|
|
**Fusion:** |
|
- Flash Attention 2 |
|
- Fused AdamW |
|
- Liger Kernel (swiglu, fused linear xentropy) |
|
|
|
**GPU hours**: ~384h of NVIDIA A100 |
|
**GPU mem**: |
|
- Stage 1: 50-55GB of VRAM (both GPUs) |
|
- Stage 2: 79GB of VRAM (both GPUs) |
|
|
|
### Training configuration / Конфигурация обучения |
|
The model was trained using MyLLM framework: |
|
|
|
--== [MyLLM](https://github.com/Raumberg/myllm) ==-- |
|
|
|
**Model training / Обучение модели** |
|
|
|
The model was trained utilizing 2 stages: |
|
- Stage 1: |
|
- Datasets: GrandMaster |
|
- LoRA: rank=128, alpha=256 |
|
- Stage 2: |
|
- Datasets: Kolmogorov-3, Russian Code |
|
- LoRA: rank=256, alpha=256 |
|
|
|
All configs are available in MyLLM repository. |
|
|
|
### Using the model / Как запустить? |
|
|
|
```python |
|
from transformers import AutoTokenizer, AutoModelForCausalLM |
|
|
|
repo = 'attn-signs/Watari-32b-v2' |
|
|
|
model = AutoModelForCausalLM.from_pretrained(repo) |
|
tokenizer = AutoTokenizer.from_pretrained(repo) |
|
|
|
model.to('cuda') |
|
|
|
prompt = 'Расскажи мне про теорию категорий. Как мне построить коммутативную диаграмму? Знаешь ли ты что-то про театры ходжа-аракелова?' |
|
# Model does not know about Θ±ell-Hodge theaters, it must say that it does not know. |
|
# Модель не знает про театры ходжа, поэтому говорит, что не знает, чтобы не путать пользователя |
|
# Hodge Theaters are taken from ABC conjecture proof from source: https://www.kurims.kyoto-u.ac.jp/~gokun/DOCUMENTS/abc2018Jul13.pdf |
|
# Театры Ходжа-Аракелова были взяты из доказательства ABC гипотезы в источнике: https://www.kurims.kyoto-u.ac.jp/~gokun/DOCUMENTS/abc2018Jul13.pdfм |
|
messages = [ |
|
{"role": "system", "content": "Ты Ватари, ассистент и помощник в решении различных задач. Отвечай на вопросы пользователя, рассуждая."}, |
|
{"role": "user", "content": prompt} |
|
] |
|
text = tokenizer.apply_chat_template( |
|
messages, |
|
tokenize=False, |
|
add_generation_prompt=True |
|
) |
|
model_inputs = tokenizer([text], return_tensors="pt").to(model.device) |
|
|
|
generated_ids = model.generate( |
|
**model_inputs, |
|
max_new_tokens=32768 |
|
) |
|
generated_ids = [ |
|
output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids) |
|
] |
|
|
|
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0] |
|
|
|
print(response) |
|
``` |
|
|
|
``` |
|
Теория категорий — это раздел математики, который изучает абстрактные структуры и их взаимосвязи. Она предоставляет общий язык для описания математических объектов и преобразований между ними. Основные понятия теории категорий включают категории, объекты, морфизмы (стрелки), композиции морфизмов и коммутативные диаграммы. |
|
|
|
**Коммутативная диаграмма** — это визуальное представление того, как различные морфизмы взаимодействуют друг с другом. Чтобы построить её: |
|
|
|
1. **Определите объекты**: Выберите математические объекты (например, множества, группы, векторные пространства), которые будут вершинами диаграммы. |
|
2. **Укажите морфизмы**: Нарисуйте стрелки между объектами, обозначающие функции или отображения между ними. |
|
3. **Убедитесь в коммутативности**: Убедитесь, что для любой пары путей из одной вершины в другую, композиция морфизмов вдоль этих путей дает одинаковое преобразование. Это означает, что независимо от выбранного пути результат будет одинаковым. |
|
|
|
Пример: Если у вас есть объекты A, B, C и морфизмы f: A → B, g: B → C, h: A → C, то диаграмма коммутирует, если g ∘ f = h. |
|
|
|
Для построения диаграмм часто используют программы вроде TikZ в LaTeX, где можно точно указать расположение объектов и стрелки между ними. |
|
|
|
Что касается **театров Ходжа-Аракелова**, я не располагаю информацией о таком понятии. Возможно, имеется в виду теория Ходжа или Аракеловская геометрия, но "театры" не являются стандартным термином в математике. Если вы имеете в виду конкретную концепцию или предмет исследования, уточните, пожалуйста, чтобы я мог предоставить точный ответ. |
|
``` |
|
**Coding task (example from attn-signs/russian-code dataset) / Задача на python код (пример из собственного датасета)** |
|
``` |
|
# prompt is: |
|
# Пожалуйста, помоги мне написать код на Python и функцию, которая принимает в качестве входных данных три числа: текущее_значение, ставку и время. Функция должна рассчитать аннуитетный платеж на основе заданной текущей стоимости, процентной ставки и времени и вернуть результат. |
|
# model answer is: |
|
|
|
Для расчета аннуитетного платежа можно использовать формулу: |
|
|
|
\[ |
|
A = P \times \frac{r(1 + r)^n}{(1 + r)^n - 1} |
|
\] |
|
|
|
где: |
|
- \( A \) — аннуитетный платеж, |
|
- \( P \) — текущая стоимость (present value), |
|
- \( r \) — периодическая процентная ставка (ставка за период), |
|
- \( n \) — количество периодов. |
|
|
|
Периодическая процентная ставка рассчитывается как годовая ставка, деленная на количество периодов в году. Если периоды указаны в годах, то годовая ставка используется напрямую. |
|
|
|
Вот пример реализации функции на Python: |
|
|
|
# python-code |
|
def calculate_annuity_payment(present_value, rate, time): |
|
|
|
if present_value <= 0 or rate <= 0 or time <= 0: |
|
raise ValueError("Present value, rate, and time must be positive numbers.") |
|
|
|
# Calculate the periodic rate assuming annual compounding |
|
periodic_rate = rate / 100 # Convert rate from percentage to decimal |
|
|
|
# Calculate the annuity payment using the formula |
|
numerator = periodic_rate * (1 + periodic_rate) ** time |
|
denominator = (1 + periodic_rate) ** time - 1 |
|
annuity_payment = present_value * (numerator / denominator) |
|
|
|
return annuity_payment |
|
|
|
# Пример использования: |
|
present_value = 10000 |
|
rate = 5 # 5% annual interest rate |
|
time = 5 # 5 years |
|
|
|
payment = calculate_annuity_payment(present_value, rate, time) |
|
print(f"The annuity payment is: {payment:.2f}") |
|
|
|
|
|
Обратите внимание, что функция проверяет входные параметры на положительные значения и вызывает исключение `ValueError`, если это не так. Это помогает избежать математических ошибок при вычислении. Также предполагается, что процентная ставка указана в процентах годовых, а время — в годах. Если требуется другая периодичность (например, ежемесячная), необходимо соответствующим образом скорректировать расчет периодической ставки. |
|
``` |
|
|
|
### Tokenizer research / Исследование токенайзера: |
|
You can verify and see the internals of tokenization yourself by the python code provided below: |
|
Можно рассмотреть внутренности токенизации самостоятельно, для этого прилагается следующий python код: |
|
```python |
|
input_text = "Привет! Я Ватари, интеллектуальный помощник в решении различных задач." |
|
|
|
# Tokenize |
|
tokenized = tokenizer(input_text, return_tensors="pt", return_offsets_mapping=True) |
|
tokens = tokenizer.convert_ids_to_tokens(tokenized["input_ids"][0]) |
|
|
|
# Print raw tokens and decoded versions |
|
print("Tokenization Analysis:\n") |
|
for i, (token, offset) in enumerate(zip(tokens, tokenized.offset_mapping[0])): |
|
# Get start/end positions in original text |
|
start, end = offset.tolist() |
|
original_slice = input_text[int(start):int(end)] |
|
|
|
# Clean token representation and replace Ġ (which represent the whitespace) |
|
cleaned_token = token.replace('Ġ', ' ').replace('▁', ' ') |
|
|
|
print(f"Token {i}:") |
|
print(f" Raw: {token}") |
|
print(f" Cleaned: {cleaned_token}") |
|
print(f" Decoded: {tokenizer.decode(tokenized['input_ids'][0][i])}") |
|
print(f" Original text slice: '{original_slice}'") |
|
print(f" Byte representation: {list(token.encode('utf-8'))}") |
|
print("-" * 50) |
|
|
|
# Verify full reconstruction |
|
print("\nFull Reconstruction:", tokenizer.decode(tokenized["input_ids"][0])) |
|
``` |
|
**Output / Результат:** |
|
|
|
``` |
|
... |
|
-------------------------------------------------- |
|
Token 8: |
|
Raw: ĠинÑĤеллекÑĤ |
|
Cleaned: инÑĤеллекÑĤ |
|
Decoded: интеллект |
|
Original text slice: ' интеллект' |
|
Byte representation: [196, 160, 195, 144, 194, 184, 195, 144, 194, 189, 195, 145, 196, 164, 195, 144, 194, 181, 195, 144, 194, 187, 195, 144, 194, 187, 195, 144, 194, 181, 195, 144, 194, 186, 195, 145, 196, 164] |
|
-------------------------------------------------- |
|
Token 9: |
|
Raw: Ñĥ |
|
Cleaned: Ñĥ |
|
Decoded: у |
|
Original text slice: 'у' |
|
Byte representation: [195, 145, 196, 165] |
|
... |
|
Token 13: |
|
Raw: ĠÑĢеÑĪении |
|
Cleaned: ÑĢеÑĪении |
|
Decoded: решении |
|
Original text slice: ' решении' |
|
Byte representation: [196, 160, 195, 145, 196, 162, 195, 144, 194, 181, 195, 145, 196, 170, 195, 144, 194, 181, 195, 144, 194, 189, 195, 144, 194, 184, 195, 144, 194, 184] |
|
-------------------------------------------------- |
|
Token 14: |
|
Raw: ĠÑĢазлиÑĩнÑĭÑħ |
|
Cleaned: ÑĢазлиÑĩнÑĭÑħ |
|
Decoded: различных |
|
Original text slice: ' различных' |
|
Byte representation: [196, 160, 195, 145, 196, 162, 195, 144, 194, 176, 195, 144, 194, 183, 195, 144, 194, 187, 195, 144, 194, 184, 195, 145, 196, 169, 195, 144, 194, 189, 195, 145, 196, 173, 195, 145, 196, 167] |
|
-------------------------------------------------- |
|
Full Reconstruction: Привет! Я Ватари, интеллектуальный помощник в решении различных задач. |
|
``` |
