# tokviz/visualization.py
from IPython.display import HTML, display
from transformers import AutoTokenizer

def token_visualizer(text, models=['openai-community/gpt2']):
    """
    Compares tokenization patterns across different language models and visualizes the results.

    Args:
        text (str): The input text to tokenize and compare.
        models (list): A list of language model names or identifiers to compare.
                       Default is ['gpt-2'].
    """
    for model in models:
        tokenizer = AutoTokenizer.from_pretrained(model)
        tokenizer_visualizer(text, tokenizer, model)

def tokenizer_visualizer(text, tokenizer, model_name):
    tokens = tokenizer.tokenize(text)
    token_colors = get_token_colors(tokens)
    
    num_tokens = len(tokens)
    num_chars = len(text)
    
    display(HTML(f"<h2>Model: {model_name}</h2>"))
    display(HTML(f"<p><b>Number of Tokens:</b> {num_tokens}</p>"))
    display(HTML(f"<p><b>Number of Characters:</b> {num_chars}</p>"))
    
    visualize_tokens(tokenizer, tokens, token_colors)

def visualize_tokens(tokenizer, tokens, token_colors):
    """
    Visualizes tokenized text with color-coded highlighting.

    Args:
        tokens (list): List of tokens.
        token_colors (dict): Dictionary mapping tokens to their corresponding colors.
    """
    colored_text = ""
    for token in tokens:
        token_str = tokenizer.convert_tokens_to_string([token])
        color = token_colors[token]
        colored_text += f'<span style="background-color: {color}; padding: 2px;">{token_str}</span> '
    display(HTML(colored_text))

def get_token_colors(tokens):
    """
    Generates colors for tokens in the input text.

    Args:
        tokens (list): List of tokens.

    Returns:
        dict: Dictionary mapping tokens to their corresponding colors.
    """
    unique_tokens = list(set(tokens))
    token_colors = {token: number_to_color(hash(token)) for token in unique_tokens}
    return token_colors

def number_to_color(number):
    """
    Generates a color based on a numerical value.

    Args:
        number (int): The numerical value.

    Returns:
        str: A color value in HSL format.
    """
    golden_ratio_conjugate = 0.618033988749895
    a = 1664525
    c = 1013904223
    m = 2**32

    pseudorandom = (a * number + c) % m
    hue = ((pseudorandom * golden_ratio_conjugate) % 1) * 360
    s = 60 + (pseudorandom % 21)
    l = 70 + (pseudorandom % 21)

    return f"hsl({hue}, {s}%, {l}%)"

# from tokviz import token_visualizer

text = "Альпака - домашнее мозоленогое животное, предположительно произошедшее от викуньи (вигони). Разводят в высокогорном поясе Южной Америки (Анды). На сегодняшний день там обитает около трёх миллионов альпак, большая часть из которых населяет Перу. Выращивают альпак для стрижки шерсти, из которой делают тёплые и мягкие одеяла, пледы и одежду, а из меха делают предметы для дома."

token_visualizer(text, models=["FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview","ai-sage/GigaChat-20B-A3B-instruct","msu-rcc-lair/RuadaptQwen2.5-32B-instruct"])

# from tokviz import token_visualizer

text = """Алгоритм быстрой сортировки (quicksort) — это эффективный алгоритм сортировки, использующий метод "разделяй и властвуй". Он основан на принципе выбора опорного элемента (pivot) из массива, затем разделения массива на две подмассива: один с элементами, меньшими или равными опорному, и другой — с элементами, большими опорного. Затем рекурсивно применяется тот же процесс к подмассивам. Абсолютное преимущество быстрой сортировки состоит в том, что она выполняется за время \(O(n \log n)\) в среднем и в лучшем случаях. На языке Python алгоритм быстрой сортировки может быть реализован следующим образом: ```python def quicksort(arr): # Обработка ошибок: пустой массив или массив с одним элементом if arr is None: raise ValueError("Input array cannot be None.") if len(arr) <= 1: return arr # Выбор опорного элемента (в данном случае первый элемент массива) pivot = arr[0] # Разделение массива на две части less = [x for x in arr[1:] if x <= pivot] # Элементы меньше или равные опорному greater = [x for x in arr[1:] if x > pivot] # Элементы больше опорного # Рекурсивная сортировка подмассивов и объединение результатов return quicksort(less) + [pivot] + quicksort(greater) # Пример использования: try: array = [3, 6, 8, 10, 1, 2, 1] sorted_array = quicksort(array) print("Сортированный массив:", sorted_array) except ValueError as e: print("Ошибка:", e) ``` ### Обработка ошибок: 1. В начале функции проверяется, не передан ли `None` вместо массива, и генерируется исключение `ValueError` в таком случае. 2. Если массив содержит один или ноль элементов, он считается уже отсортированным, функция возвращает его без изменений. ### Обработка дубликатов: У нас есть условие `x <= pivot` в списке `less`, что позволяет корректно обрабатывать массивы с дубликатами. ### Ошибочный код: Предоставленный вами фрагмент ошибочного кода использует неправильные операторы сравнения в list comprehensions: ```python def quicksort_wrong(arr): if len(arr) <= 1: return arr pivot = arr[0] less = [x for x in arr[1:] if x < pivot] # Включая равные в greater! greater = [x for x in arr[1:] if x >= pivot] # Включая равные в less! return quicksort_wrong(less) + [pivot] + quicksort_wrong(greater) ``` **Проблема:** В этом варианте все элементы, равные опорному, попадают в массив `greater`. В случае наличия значительного количества повторяющихся элементов это может привести к недостаточной разбиению массива, что, в худшем случае, замедлит работу алгоритма до \(O(n^2)\) времени. Кроме того, в ситуации, когда все элементы в массиве равны, функция может вызываться рекурсивно каждый раз с одним и тем же массивом, что приводит к бесконечной rekурсии и ошибке переполнения стека вызовов."""

token_visualizer(text, models=["FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview","ai-sage/GigaChat-20B-A3B-instruct","msu-rcc-lair/RuadaptQwen2.5-32B-instruct"])

<>:3: SyntaxWarning: invalid escape sequence '\('
<>:3: SyntaxWarning: invalid escape sequence '\('
/tmp/ipykernel_458952/3167544564.py:3: SyntaxWarning: invalid escape sequence '\('
  text = """Алгоритм быстрой сортировки (quicksort) — это эффективный алгоритм сортировки, использующий метод "разделяй и властвуй". Он основан на принципе выбора опорного элемента (pivot) из массива, затем разделения массива на две подмассива: один с элементами, меньшими или равными опорному, и другой — с элементами, большими опорного. Затем рекурсивно применяется тот же процесс к подмассивам. Абсолютное преимущество быстрой сортировки состоит в том, что она выполняется за время \(O(n \log n)\) в среднем и в лучшем случаях. На языке Python алгоритм быстрой сортировки может быть реализован следующим образом: ```python def quicksort(arr): # Обработка ошибок: пустой массив или массив с одним элементом if arr is None: raise ValueError("Input array cannot be None.") if len(arr) <= 1: return arr # Выбор опорного элемента (в данном случае первый элемент массива) pivot = arr[0] # Разделение массива на две части less = [x for x in arr[1:] if x <= pivot] # Элементы меньше или равные опорному greater = [x for x in arr[1:] if x > pivot] # Элементы больше опорного # Рекурсивная сортировка подмассивов и объединение результатов return quicksort(less) + [pivot] + quicksort(greater) # Пример использования: try: array = [3, 6, 8, 10, 1, 2, 1] sorted_array = quicksort(array) print("Сортированный массив:", sorted_array) except ValueError as e: print("Ошибка:", e) ``` ### Обработка ошибок: 1. В начале функции проверяется, не передан ли `None` вместо массива, и генерируется исключение `ValueError` в таком случае. 2. Если массив содержит один или ноль элементов, он считается уже отсортированным, функция возвращает его без изменений. ### Обработка дубликатов: У нас есть условие `x <= pivot` в списке `less`, что позволяет корректно обрабатывать массивы с дубликатами. ### Ошибочный код: Предоставленный вами фрагмент ошибочного кода использует неправильные операторы сравнения в list comprehensions: ```python def quicksort_wrong(arr): if len(arr) <= 1: return arr pivot = arr[0] less = [x for x in arr[1:] if x < pivot] # Включая равные в greater! greater = [x for x in arr[1:] if x >= pivot] # Включая равные в less! return quicksort_wrong(less) + [pivot] + quicksort_wrong(greater) ``` **Проблема:** В этом варианте все элементы, равные опорному, попадают в массив `greater`. В случае наличия значительного количества повторяющихся элементов это может привести к недостаточной разбиению массива, что, в худшем случае, замедлит работу алгоритма до \(O(n^2)\) времени. Кроме того, в ситуации, когда все элементы в массиве равны, функция может вызываться рекурсивно каждый раз с одним и тем же массивом, что приводит к бесконечной rekурсии и ошибке переполнения стека вызовов."""

from transformers import AutoTokenizer

source_model_id = "FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview"

source_tokenizer = AutoTokenizer.from_pretrained(source_model_id)
source_tokenizer

LlamaTokenizerFast(name_or_path='FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview', vocab_size=151643, model_max_length=16384, is_fast=True, padding_side='left', truncation_side='right', special_tokens={'bos_token': '<｜begin▁of▁sentence｜>', 'eos_token': '<｜end▁of▁sentence｜>', 'pad_token': '<｜end▁of▁sentence｜>'}, clean_up_tokenization_spaces=False, added_tokens_decoder={
	151643: AddedToken("<｜end▁of▁sentence｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151644: AddedToken("<｜User｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151645: AddedToken("<｜Assistant｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151646: AddedToken("<｜begin▁of▁sentence｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151647: AddedToken("<|EOT|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151648: AddedToken("<think>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151649: AddedToken("</think>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151650: AddedToken("<|quad_start|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151651: AddedToken("<|quad_end|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151652: AddedToken("<|vision_start|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151653: AddedToken("<|vision_end|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151654: AddedToken("<|vision_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151655: AddedToken("<|image_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151656: AddedToken("<|video_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151657: AddedToken("<tool_call>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151658: AddedToken("</tool_call>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151659: AddedToken("<|fim_prefix|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151660: AddedToken("<|fim_middle|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151661: AddedToken("<|fim_suffix|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151662: AddedToken("<|fim_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151663: AddedToken("<|repo_name|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151664: AddedToken("<|file_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
}
)

from transformers import AutoTokenizer

giga_model_id = "ai-sage/GigaChat-20B-A3B-instruct"

giga_tokenizer = AutoTokenizer.from_pretrained(giga_model_id)
giga_tokenizer

PreTrainedTokenizerFast(name_or_path='ai-sage/GigaChat-20B-A3B-instruct', vocab_size=128000, model_max_length=1000000000000000019884624838656, is_fast=True, padding_side='right', truncation_side='right', special_tokens={'bos_token': '<s>', 'eos_token': '<|message_sep|>', 'additional_special_tokens': ['<|role_sep|>', '<|message_sep|>', '[', ']', '<|role_sep|>', '<|message_sep|>', '[', ']']}, clean_up_tokenization_spaces=True, added_tokens_decoder={
	1: AddedToken("<s>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	61: AddedToken("[", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	63: AddedToken("]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	128000: AddedToken("<|role_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	128001: AddedToken("<|message_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
}
)

from transformers import AutoTokenizer

giga_model_id = "ai-sage/GigaChat-20B-A3B-instruct"

tokenizer = AutoTokenizer.from_pretrained(giga_model_id)
tokenizer.add_bos_token = False
tokenizer.model_max_length = 32768
tokenizer.add_special_tokens({"bos_token": ""})
tokenizer.add_special_tokens(source_tokenizer.special_tokens_map)
tokenizer.add_tokens([x.content for x in source_tokenizer.added_tokens_decoder.values()])

tokenizer.clean_up_tokenization_spaces = False

vocab_size = len(tokenizer.get_vocab())
print("vocab_size", vocab_size)

tokenizer

vocab_size 128024

PreTrainedTokenizerFast(name_or_path='ai-sage/GigaChat-20B-A3B-instruct', vocab_size=128000, model_max_length=32768, is_fast=True, padding_side='right', truncation_side='right', special_tokens={'bos_token': '<｜begin▁of▁sentence｜>', 'eos_token': '<｜end▁of▁sentence｜>', 'pad_token': '<｜end▁of▁sentence｜>', 'additional_special_tokens': ['<|role_sep|>', '<|message_sep|>', '[', ']', '<|role_sep|>', '<|message_sep|>', '[', ']']}, clean_up_tokenization_spaces=False, added_tokens_decoder={
	1: AddedToken("<s>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	61: AddedToken("[", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	63: AddedToken("]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	128000: AddedToken("<|role_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	128001: AddedToken("<|message_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	128002: AddedToken("<｜begin▁of▁sentence｜>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128003: AddedToken("<｜end▁of▁sentence｜>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128004: AddedToken("<｜User｜>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128005: AddedToken("<｜Assistant｜>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128006: AddedToken("<|EOT|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128007: AddedToken("<think>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128008: AddedToken("</think>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128009: AddedToken("<|quad_start|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128010: AddedToken("<|quad_end|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128011: AddedToken("<|vision_start|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128012: AddedToken("<|vision_end|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128013: AddedToken("<|vision_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128014: AddedToken("<|image_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128015: AddedToken("<|video_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128016: AddedToken("<tool_call>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128017: AddedToken("</tool_call>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128018: AddedToken("<|fim_prefix|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128019: AddedToken("<|fim_middle|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128020: AddedToken("<|fim_suffix|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128021: AddedToken("<|fim_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128022: AddedToken("<|repo_name|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
	128023: AddedToken("<|file_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=False),
}
)

 # tokenizer.chat_template = '{%- if tools %}\n    {{- \'<|im_start|>system\\n\' }}\n    {%- if messages[0][\'role\'] == \'system\' %}\n        {{- messages[0][\'content\'] }}\n    {%- else %}\n        {{- \'You are a helpful assistant.\' }}\n    {%- endif %}\n    {{- "\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>" }}\n    {%- for tool in tools %}\n        {{- "\\n" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- "\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\"name\\": <function-name>, \\"arguments\\": <args-json-object>}\\n</tool_call><|im_end|>\\n" }}\n{%- else %}\n    {%- if messages[0][\'role\'] == \'system\' %}\n        {{- \'<|im_start|>system\\n\' + messages[0][\'content\'] + \'<|im_end|>\\n\' }}\n    {%- else %}\n        {{- \'<|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n\' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}\n        {{- \'<|im_start|>\' + message.role + \'\\n\' + message.content + \'<|im_end|>\' + \'\\n\' }}\n    {%- elif message.role == "assistant" %}\n        {{- \'<|im_start|>\' + message.role }}\n        {%- if message.content %}\n            {{- \'\\n\' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- \'\\n<tool_call>\\n{"name": "\' }}\n            {{- tool_call.name }}\n            {{- \'", "arguments": \' }}\n            {{- tool_call.arguments | tojson }}\n            {{- \'}\\n</tool_call>\' }}\n        {%- endfor %}\n        {{- \'<|im_end|>\\n\' }}\n    {%- elif message.role == "tool" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}\n            {{- \'<|im_start|>user\' }}\n        {%- endif %}\n        {{- \'\\n<tool_response>\\n\' }}\n        {{- message.content }}\n        {{- \'\\n</tool_response>\' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}\n            {{- \'<|im_end|>\\n\' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- \'<|im_start|>assistant\\n\' }}\n{%- endif %}\n'
tokenizer.chat_template = source_tokenizer.chat_template
tokenizer.chat_template

"{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% set ns = namespace(is_first=false, is_tool=false, is_output_first=true, system_prompt='') %}{%- for message in messages %}{%- if message['role'] == 'system' %}{% set ns.system_prompt = message['content'] %}{%- endif %}{%- endfor %}{{bos_token}}{{ns.system_prompt}}{%- for message in messages %}{%- if message['role'] == 'user' %}{%- set ns.is_tool = false -%}{{'<｜User｜>' + message['content']}}{%- endif %}{%- if message['role'] == 'assistant' and message['content'] is none %}{%- set ns.is_tool = false -%}{%- for tool in message['tool_calls']%}{%- if not ns.is_first %}{{'<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\\n' + '```json' + '\\n' + tool['function']['arguments'] + '\\n' + '```' + '<｜tool▁call▁end｜>'}}{%- set ns.is_first = true -%}{%- else %}{{'\\n' + '<｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\\n' + '```json' + '\\n' + tool['function']['arguments'] + '\\n' + '```' + '<｜tool▁call▁end｜>'}}{{'<｜tool▁calls▁end｜><｜end▁of▁sentence｜>'}}{%- endif %}{%- endfor %}{%- endif %}{%- if message['role'] == 'assistant' and message['content'] is not none %}{%- if ns.is_tool %}{{'<｜tool▁outputs▁end｜>' + message['content'] + '<｜end▁of▁sentence｜>'}}{%- set ns.is_tool = false -%}{%- else %}{% set content = message['content'] %}{% if '</think>' in content %}{% set content = content.split('</think>')[-1] %}{% endif %}{{'<｜Assistant｜>' + content + '<｜end▁of▁sentence｜>'}}{%- endif %}{%- endif %}{%- if message['role'] == 'tool' %}{%- set ns.is_tool = true -%}{%- if ns.is_output_first %}{{'<｜tool▁outputs▁begin｜><｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>'}}{%- set ns.is_output_first = false %}{%- else %}{{'\\n<｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>'}}{%- endif %}{%- endif %}{%- endfor -%}{% if ns.is_tool %}{{'<｜tool▁outputs▁end｜>'}}{% endif %}{% if add_generation_prompt and not ns.is_tool %}{{'<｜Assistant｜>'}}{% endif %}"

# from tokviz import token_visualizer

text = """Алгоритм быстрой сортировки (quicksort) — это эффективный алгоритм сортировки, использующий метод "разделяй и властвуй". Он основан на принципе выбора опорного элемента (pivot) из массива, затем разделения массива на две подмассива: один с элементами, меньшими или равными опорному, и другой — с элементами, большими опорного. Затем рекурсивно применяется тот же процесс к подмассивам. Абсолютное преимущество быстрой сортировки состоит в том, что она выполняется за время \(O(n \log n)\) в среднем и в лучшем случаях. На языке Python алгоритм быстрой сортировки может быть реализован следующим образом: ```python def quicksort(arr): # Обработка ошибок: пустой массив или массив с одним элементом if arr is None: raise ValueError("Input array cannot be None.") if len(arr) <= 1: return arr # Выбор опорного элемента (в данном случае первый элемент массива) pivot = arr[0] # Разделение массива на две части less = [x for x in arr[1:] if x <= pivot] # Элементы меньше или равные опорному greater = [x for x in arr[1:] if x > pivot] # Элементы больше опорного # Рекурсивная сортировка подмассивов и объединение результатов return quicksort(less) + [pivot] + quicksort(greater) # Пример использования: try: array = [3, 6, 8, 10, 1, 2, 1] sorted_array = quicksort(array) print("Сортированный массив:", sorted_array) except ValueError as e: print("Ошибка:", e) ``` ### Обработка ошибок: 1. В начале функции проверяется, не передан ли `None` вместо массива, и генерируется исключение `ValueError` в таком случае. 2. Если массив содержит один или ноль элементов, он считается уже отсортированным, функция возвращает его без изменений. ### Обработка дубликатов: У нас есть условие `x <= pivot` в списке `less`, что позволяет корректно обрабатывать массивы с дубликатами. ### Ошибочный код: Предоставленный вами фрагмент ошибочного кода использует неправильные операторы сравнения в list comprehensions: ```python def quicksort_wrong(arr): if len(arr) <= 1: return arr pivot = arr[0] less = [x for x in arr[1:] if x < pivot] # Включая равные в greater! greater = [x for x in arr[1:] if x >= pivot] # Включая равные в less! return quicksort_wrong(less) + [pivot] + quicksort_wrong(greater) ``` **Проблема:** В этом варианте все элементы, равные опорному, попадают в массив `greater`. В случае наличия значительного количества повторяющихся элементов это может привести к недостаточной разбиению массива, что, в худшем случае, замедлит работу алгоритма до \(O(n^2)\) времени. Кроме того, в ситуации, когда все элементы в массиве равны, функция может вызываться рекурсивно каждый раз с одним и тем же массивом, что приводит к бесконечной rekурсии и ошибке переполнения стека вызовов."""
text = tokenizer.apply_chat_template([{"role": "user", "content":text}], tokenize=False)

tokenizer_visualizer(text, tokenizer, "FuseAI-Flash-merge-32B")

<>:3: SyntaxWarning: invalid escape sequence '\('
<>:3: SyntaxWarning: invalid escape sequence '\('
/tmp/ipykernel_458952/141869410.py:3: SyntaxWarning: invalid escape sequence '\('
  text = """Алгоритм быстрой сортировки (quicksort) — это эффективный алгоритм сортировки, использующий метод "разделяй и властвуй". Он основан на принципе выбора опорного элемента (pivot) из массива, затем разделения массива на две подмассива: один с элементами, меньшими или равными опорному, и другой — с элементами, большими опорного. Затем рекурсивно применяется тот же процесс к подмассивам. Абсолютное преимущество быстрой сортировки состоит в том, что она выполняется за время \(O(n \log n)\) в среднем и в лучшем случаях. На языке Python алгоритм быстрой сортировки может быть реализован следующим образом: ```python def quicksort(arr): # Обработка ошибок: пустой массив или массив с одним элементом if arr is None: raise ValueError("Input array cannot be None.") if len(arr) <= 1: return arr # Выбор опорного элемента (в данном случае первый элемент массива) pivot = arr[0] # Разделение массива на две части less = [x for x in arr[1:] if x <= pivot] # Элементы меньше или равные опорному greater = [x for x in arr[1:] if x > pivot] # Элементы больше опорного # Рекурсивная сортировка подмассивов и объединение результатов return quicksort(less) + [pivot] + quicksort(greater) # Пример использования: try: array = [3, 6, 8, 10, 1, 2, 1] sorted_array = quicksort(array) print("Сортированный массив:", sorted_array) except ValueError as e: print("Ошибка:", e) ``` ### Обработка ошибок: 1. В начале функции проверяется, не передан ли `None` вместо массива, и генерируется исключение `ValueError` в таком случае. 2. Если массив содержит один или ноль элементов, он считается уже отсортированным, функция возвращает его без изменений. ### Обработка дубликатов: У нас есть условие `x <= pivot` в списке `less`, что позволяет корректно обрабатывать массивы с дубликатами. ### Ошибочный код: Предоставленный вами фрагмент ошибочного кода использует неправильные операторы сравнения в list comprehensions: ```python def quicksort_wrong(arr): if len(arr) <= 1: return arr pivot = arr[0] less = [x for x in arr[1:] if x < pivot] # Включая равные в greater! greater = [x for x in arr[1:] if x >= pivot] # Включая равные в less! return quicksort_wrong(less) + [pivot] + quicksort_wrong(greater) ``` **Проблема:** В этом варианте все элементы, равные опорному, попадают в массив `greater`. В случае наличия значительного количества повторяющихся элементов это может привести к недостаточной разбиению массива, что, в худшем случае, замедлит работу алгоритма до \(O(n^2)\) времени. Кроме того, в ситуации, когда все элементы в массиве равны, функция может вызываться рекурсивно каждый раз с одним и тем же массивом, что приводит к бесконечной rekурсии и ошибке переполнения стека вызовов."""

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

pretrained_model_dir = "FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview"

from datasets import Dataset, load_dataset, concatenate_datasets
from transformers import set_seed

args_seed = 14
set_seed(args_seed)

import torch

def f_tokenize(input_messages):
    input_prompt = source_tokenizer.apply_chat_template(input_messages, tokenize=False, add_special_tokens=False)
    input_ids = source_tokenizer.encode(input_prompt, return_tensors="pt", add_special_tokens=False)[0]
    attention_mask = torch.ones_like(input_ids)
    return {"tokens": input_ids, "attention_mask": attention_mask, "text": input_prompt}

import re

def f_ds_example(row):
    convs = []
    convs.append({"role": "user", "content": row["ru_query"]})
    convs.append({"role": "assistant", "content": row["response"]})
    tokenized = f_tokenize(convs)
    return {"input_ids": tokenized["tokens"], "attention_mask": tokenized["attention_mask"], "text": tokenized["text"]}

ds_example = load_dataset("mizinovmv/ru_example_DeepSeek-R1-Distill-Qwen-32B")["train"]
ds_example = ds_example.map(f_ds_example, num_proc=8, remove_columns=ds_example.column_names)
ds_example = ds_example.filter(lambda x: len(re.findall(r'[\u4e00-\u9fff]+', x["text"])) == 0)
ds_example

Dataset({
    features: ['input_ids', 'attention_mask', 'text'],
    num_rows: 223
})

ds_example[0]["text"]

'<｜begin▁of▁sentence｜><｜User｜>Опишите, что делает алгоритм быстрой сортировки (quicksort), и реализуйте его на языке программирования вашего выбора. Ваша реализация должна включать возможность обработки дублирующихся элементов в массиве входных данных и должна иметь временную сложность O(nlogn).\n\nКроме того, включите обработку ошибок в коде для обработки сценариев, в которых массив входных данных пуст или содержит только один элемент.\n\nЧтобы увеличить сложность, предоставьте фрагмент ошибочного кода в качестве ссылки для увеличения отирровки (запутанности):\n\n```python\ndef quicksort(arr):\n    if len(arr) <= 1:\n        return arr\n    \n    pivot = arr[0]\n    less = [x for x in arr[1:] if x <= pivot]\n    greater = [x for x in arr[1:] if x > pivot]\n\n    return quicksort(less) + [pivot] + quicksort(greater)\n\n# Ошибочный код\ndef quicksort_wrong(arr):\n    if len(arr) <= 1:\n        return arr\n    \n    pivot = arr[0]\n    less = [x for x in arr[1:] if x < pivot]\n    greater = [x for x in arr[1:] if x >= pivot]\n\n    return quicksort_wrong(less) + [pivot] + quicksort_wrong(greater)\n```\n\nВ этом переписанном задании предоставлен альтернативный, недопустимый вариант алгоритма быстрой сортировки в качестве ссылочного кода. Ошибочный код использует неправильные операторы неравенства в list comprehensions, что приведет к некорректной сортировке и потенциально к бесконечной рекурсии в определенных сценариях.<｜Assistant｜>\n\nДля реализации алгоритма быстрой сортировки (quicksort) на Python, который обрабатывает дублирующиеся элементы и ошибки, выполним следующие шаги:\n\n1. **Проверка на пустой массив или массив с одним элементом**: Если длина массива <= 1, возвращаем его как есть.\n2. **Выбор опорного элемента (pivot)**: Используем первый элемент массива.\n3. **Разделение массива**: Создаем два подмассива — `less` для элементов <= pivot и `greater` для элементов > pivot.\n4. **Рекурсивная сортировка**: Рекурсивно сортируем `less` и `greater`, затем объединяем результаты.\n5. **Обработка ошибок**: Проверяем, что входные данные — это список, иначе выбрасываем TypeError.\n\n**Код:**\n\n```python\ndef quicksort(arr):\n    if not isinstance(arr, list):\n        raise TypeError("Input must be a list")\n    if len(arr) <= 1:\n        return arr.copy()  # Возвращаем копию, чтобы не изменять исходный список\n    \n    pivot = arr[0]\n    less = [x for x in arr[1:] if x <= pivot]\n    greater = [x for x in arr[1:] if x > pivot]\n    \n    return quicksort(less) + [pivot] + quicksort(greater)\n```\n\n**Объяснение ошибочного кода:**\n\nВ предоставленном ошибочном коде `quicksort_wrong`:\n- `less` включает элементы < pivot, а `greater` — >= pivot.\n- Это приводит к проблемам при дублирующихся элементах, так как они могут попасть в `greater`, вызывая бесконечную рекурсию.\n\n**Пример использования:**\n\n```python\ntry:\n    arr = [3, 1, 4, 1, 5]\n    sorted_arr = quicksort(arr)\n    print("Отсортированный массив:", sorted_arr)\nexcept TypeError as e:\n    print("Ошибка:", e)\n```\n\n**Вывод:**\n\nЭта реализация обеспечивает корректную сортировку массива, включая обработку дубликатов и ошибок, с временной сложностью O(n log n) в среднем случае.<｜end▁of▁sentence｜>'

def f_qwq_cot(row):
    convs = []
    convs.append({"role": "user", "content": row["problem"]})
    convs.append({"role": "assistant", "content": row["qwq"]})
    tokenized = f_tokenize(convs)
    return {"input_ids": tokenized["tokens"], "attention_mask": tokenized["attention_mask"], "text": tokenized["text"]}

qwq_ds = load_dataset("amphora/QwQ-LongCoT-130K")["train"].filter(lambda x: (len(x["qwq"]) < 2*1024) & (x["source"] == "qwq-magpie")).select(range(900))
qwq_ds = qwq_ds.map(f_qwq_cot, num_proc=8, remove_columns=qwq_ds.column_names)
qwq_ds

Map (num_proc=8):   0%|          | 0/900 [00:00<?, ? examples/s]

Dataset({
    features: ['input_ids', 'attention_mask', 'text'],
    num_rows: 900
})

# from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from gptqmodel import GPTQModel, QuantizeConfig, get_best_device

quantize_config = QuantizeConfig(
    bits=4,
    group_size=32,
    desc_act=True,
    sym=True,
    lm_head=False,
    damp_percent=0.1,
    damp_auto_increment=0.0015
)

model = GPTQModel.from_pretrained(
    pretrained_model_dir,
    quantize_config,
    device_map="cpu",
    trust_remote_code=True,
)
model.config.use_cache = False
model

INFO - Effective Quantization BPW (bits per weight): 5.0 bpw, based on [bits: 4, group_size: 32]

Fetching 22 files:   0%|          | 0/22 [00:00<?, ?it/s]

Loading checkpoint shards:   0%|          | 0/14 [00:00<?, ?it/s]

Qwen2GPTQ(
  (model): Qwen2ForCausalLM(
    (model): Qwen2Model(
      (embed_tokens): Embedding(152064, 5120)
      (layers): ModuleList(
        (0-63): 64 x Qwen2DecoderLayer(
          (self_attn): Qwen2Attention(
            (q_proj): Linear(in_features=5120, out_features=5120, bias=True)
            (k_proj): Linear(in_features=5120, out_features=1024, bias=True)
            (v_proj): Linear(in_features=5120, out_features=1024, bias=True)
            (o_proj): Linear(in_features=5120, out_features=5120, bias=False)
          )
          (mlp): Qwen2MLP(
            (gate_proj): Linear(in_features=5120, out_features=27648, bias=False)
            (up_proj): Linear(in_features=5120, out_features=27648, bias=False)
            (down_proj): Linear(in_features=27648, out_features=5120, bias=False)
            (act_fn): SiLU()
          )
          (input_layernorm): Qwen2RMSNorm((5120,), eps=1e-05)
          (post_attention_layernorm): Qwen2RMSNorm((5120,), eps=1e-05)
        )
      )
      (norm): Qwen2RMSNorm((5120,), eps=1e-05)
      (rotary_emb): Qwen2RotaryEmbedding()
    )
    (lm_head): Linear(in_features=5120, out_features=152064, bias=False)
  )
)

import logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logging.debug("test")

DEBUG:root:test

quant_dataset = concatenate_datasets([ds_example, qwq_ds])
quant_dataset = quant_dataset.shuffle(seed=14)
quant_dataset

DEBUG:fsspec.local:open file: /home/mmv/.cache/huggingface/datasets/mizinovmv___ru_example_deep_seek-r1-distill-qwen-32_b/default/0.0.0/0b70e6cc2460f7d4434d233d59812676c733befc/tmpc_fb8hd6

Dataset({
    features: ['input_ids', 'attention_mask', 'text'],
    num_rows: 1123
})

from gptqmodel.utils.backend import BACKEND

# TODO https://github.com/ModelCloud/GPTQModel/blob/v1.7.3/gptqmodel/models/base.py#L780 time.sleep(0.15)
# /home/mmv/.pyenv/versions/3.12.5/versions/3.12.5/lib/python3.12/site-packages/gptqmodel/models/base.py

model.quantize(quant_dataset, batch_size=1, calibration_enable_gpu_cache=False, tokenizer=tokenizer)

INFO - Auto pick kernel based on compatibility: <class 'gptqmodel.nn_modules.qlinear.exllama.ExllamaQuantLinear'>

  |----------------------------------------| 0:00:00 / 0:00:00 [1/64] 1.6%

  0%|          | 0/1123 [00:00<?, ?it/s]

INFO - {'layer': 0, 'module': 'self_attn.k_proj', 'loss': '0.21932', 'damp': '0.10000', 'time': '1.539', 'fwd_time': '181.555'}
INFO - {'layer': 0, 'module': 'self_attn.v_proj', 'loss': '0.06990', 'damp': '0.10000', 'time': '1.339', 'fwd_time': '181.555'}
INFO - {'layer': 0, 'module': 'self_attn.q_proj', 'loss': '0.63353', 'damp': '0.10000', 'time': '1.497', 'fwd_time': '181.555'}

  0%|          | 0/1123 [00:00<?, ?it/s]

INFO - {'layer': 0, 'module': 'self_attn.o_proj', 'loss': '1.53644', 'damp': '0.10000', 'time': '1.496', 'fwd_time': '180.229'}

  0%|          | 0/1123 [00:00<?, ?it/s]

INFO - {'layer': 0, 'module': 'mlp.up_proj', 'loss': '0.48136', 'damp': '0.10000', 'time': '2.423', 'fwd_time': '180.524'}
INFO - {'layer': 0, 'module': 'mlp.gate_proj', 'loss': '0.52939', 'damp': '0.10000', 'time': '2.411', 'fwd_time': '180.524'}

  0%|          | 0/1123 [00:00<?, ?it/s]

INFO - {'layer': 0, 'module': 'mlp.down_proj', 'loss': '0.60040', 'damp': '0.10000', 'time': '11.206', 'fwd_time': '194.950'}

model.save_quantized("FuseAI-Flash-merge-32B_GPTQ-4q32g")

INFO - Pre-Quantized model size: 62492.22MB, 61.03GB
INFO - Quantized model size: 20191.62MB, 19.72GB
INFO - Size difference: 42300.60MB, 41.31GB - 67.69%

source_tokenizer.save_pretrained("FuseAI-Flash-merge-32B_GPTQ-4q32g")

('FuseAI-Flash-merge-32B_GPTQ-4q32g/tokenizer_config.json',
 'FuseAI-Flash-merge-32B_GPTQ-4q32g/special_tokens_map.json',
 'FuseAI-Flash-merge-32B_GPTQ-4q32g/tokenizer.json')

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

source_model_id = "FuseAI-Flash-merge-32B_GPTQ-4q32g"

device_map = "auto"
max_memory = {0:"24GiB", 1: "24GiB"}

model = AutoModelForCausalLM.from_pretrained(
    source_model_id,
    attn_implementation="flash_attention_2",
    torch_dtype=torch.float16,
    device_map=device_map,
    max_memory=max_memory
)

model

/home/mmv/dev/AutoGPTQ/auto_gptq/nn_modules/triton_utils/kernels.py:410: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.
  @custom_fwd
/home/mmv/dev/AutoGPTQ/auto_gptq/nn_modules/triton_utils/kernels.py:418: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.
  @custom_bwd
/home/mmv/dev/AutoGPTQ/auto_gptq/nn_modules/triton_utils/kernels.py:461: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.
  @custom_fwd(cast_inputs=torch.float16)
`loss_type=None` was set in the config but it is unrecognised.Using the default loss: `ForCausalLMLoss`.

Qwen2ForCausalLM(
  (model): Qwen2Model(
    (embed_tokens): Embedding(152064, 5120)
    (layers): ModuleList(
      (0-63): 64 x Qwen2DecoderLayer(
        (self_attn): Qwen2Attention(
          (k_proj): QuantLinear()
          (o_proj): QuantLinear()
          (q_proj): QuantLinear()
          (v_proj): QuantLinear()
        )
        (mlp): Qwen2MLP(
          (act_fn): SiLU()
          (down_proj): QuantLinear()
          (gate_proj): QuantLinear()
          (up_proj): QuantLinear()
        )
        (input_layernorm): Qwen2RMSNorm((5120,), eps=1e-05)
        (post_attention_layernorm): Qwen2RMSNorm((5120,), eps=1e-05)
      )
    )
    (norm): Qwen2RMSNorm((5120,), eps=1e-05)
    (rotary_emb): Qwen2RotaryEmbedding()
  )
  (lm_head): Linear(in_features=5120, out_features=152064, bias=False)
)

from transformers import AutoTokenizer

source_tokenizer = AutoTokenizer.from_pretrained(source_model_id)
source_tokenizer

LlamaTokenizerFast(name_or_path='FuseAI-Flash-merge-32B_GPTQ-4q32g', vocab_size=151643, model_max_length=16384, is_fast=True, padding_side='left', truncation_side='right', special_tokens={'bos_token': '<｜begin▁of▁sentence｜>', 'eos_token': '<｜end▁of▁sentence｜>', 'pad_token': '<｜end▁of▁sentence｜>'}, clean_up_tokenization_spaces=False, added_tokens_decoder={
	151643: AddedToken("<｜end▁of▁sentence｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151644: AddedToken("<｜User｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151645: AddedToken("<｜Assistant｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151646: AddedToken("<｜begin▁of▁sentence｜>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151647: AddedToken("<|EOT|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151648: AddedToken("<think>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151649: AddedToken("</think>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151650: AddedToken("<|quad_start|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151651: AddedToken("<|quad_end|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151652: AddedToken("<|vision_start|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151653: AddedToken("<|vision_end|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151654: AddedToken("<|vision_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151655: AddedToken("<|image_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151656: AddedToken("<|video_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	151657: AddedToken("<tool_call>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151658: AddedToken("</tool_call>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151659: AddedToken("<|fim_prefix|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151660: AddedToken("<|fim_middle|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151661: AddedToken("<|fim_suffix|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151662: AddedToken("<|fim_pad|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151663: AddedToken("<|repo_name|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
	151664: AddedToken("<|file_sep|>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=False),
}
)

%%time

prompt = "Write quick sort on python"
messages = [
    {"role": "user", "content": prompt}
]
text = source_tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
print(text)
model_inputs = source_tokenizer([text], return_tensors="pt").to(model.device)

with torch.inference_mode():
    generated_ids = model.generate(
        **model_inputs,
        max_new_tokens=128
    )
generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]

response = source_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

Setting `pad_token_id` to `eos_token_id`:151643 for open-end generation.

<｜begin▁of▁sentence｜><｜User｜>Write quick sort on python<｜Assistant｜>
<think>
Okay, I need to write a quick sort algorithm in Python. Hmm, I remember that quick sort is a divide-and-conquer algorithm. So, the basic idea is to pick a pivot element and partition the array around it, then recursively sort the subarrays.

Wait, how do I choose the pivot? Oh right, there are different strategies. For simplicity, maybe I'll just pick the last element as the pivot each time. That seems straightforward.

So, first, I'll write a function called quick_sort that takes an array as input. Then, I'll handle the base case: if the array has one or zero
CPU times: user 27.2 s, sys: 26.6 ms, total: 27.2 s
Wall time: 27.1 s

%%time

prompt = "Напиши рассказ про достопримечательности Москвы используя Python"
messages = [
    {"role": "user", "content": prompt}
]
text = source_tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
print(text)
model_inputs = source_tokenizer([text], return_tensors="pt").to(model.device)

with torch.inference_mode():
    generated_ids = model.generate(
        **model_inputs,
        max_new_tokens=4*1024
    )
generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]

response = source_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

Setting `pad_token_id` to `eos_token_id`:151643 for open-end generation.

<｜begin▁of▁sentence｜><｜User｜>Напиши рассказ про достопримечательности Москвы используя Python<｜Assistant｜>
<think>
Хорошо, мне нужно написать рассказ о достопримечательностях Москвы, используя Python. Сначала подумаю, как лучше это сделать. Возможно, стоит использовать функции для вывода информации о разных местах.

Начну с основного списка достопримечательностей: Красная площадь, Кремль, Белый дом, Арбат, Третьяковская галерея, Зоопарк, Парк Победы и Музей космонавтики. Это основные места, которые обычно включают в такие рассказы.

Теперь подумаю, как структурировать программу. Может быть, создать функцию, которая выводит заголовок, и отдельные функции для каждой достопримечательности, описывающие их. Или, возможно, использовать цикл, чтобы перебрать список мест и выводить их описания по очереди.

Но, возможно, будет проще создать функцию для каждого места, чтобы можно было их вызывать по отдельности или все вместе. Например, функция red_square() описывает Красную площадь, kremlin() — Кремль и так далее.

Также стоит подумать о том, как оформить вывод: использовать цвета или просто текст. В Python можно использовать библиотеки, например, colorama, для цветного вывода, но, возможно, это усложнит программу. В данном случае, возможно, ограничиться обычным текстом будет проще.

Начну с написания основного кода: импортировать необходимые модули, возможно, time для задержек между выводами, чтобы было более плавно.

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

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

Также можно добавить введение и заключение, чтобы рассказ выглядел более целостно.

Нужно убедиться, что код правильно работает и не вызывает ошибок. Проверю, правильно ли определены функции, правильно ли вызываются, и нет ли опечаток в названиях.

Возможно, стоит добавить разделительные линии или другие оформительские элементы, чтобы разделить описания разных мест.

Также подумаю о том, чтобы сделать код модульным, чтобы в будущем можно было легко добавить новые достопримечательности или изменить существующие.

В итоге, программа должна выводить информацию о достопримечательностях Москвы в понятной и структурированной форме, используя Python.
</think>

Вот пример программы на Python, которая рассказывает о достопримечательностях Москвы:

```python
def introduction():
    print("Добро пожаловать в Москву, город, который сочетает в себе древнюю историю и современную культуру.")
    print("Сегодня мы познакомимся с некоторыми из самых известных достопримечательностей Москвы.")
    print()

def red_square():
    print("Красная площадь")
    print("Сердце Москвы и одна из самых знаменитых площадей в мире.")
    print("Здесь вы можете увидеть Кремль, Спасскую башню с курантами и собор Покрова на Рву.")
    print()

def kremlin():
    print("Кремль")
    print("Государственный историко-архитектурный и культурный музей-заповедник.")
    print("Это комплекс древнерусской архитектуры, включающий соборы, башни и терема.")
    print()

def white_house():
    print("Белый дом")
    print("Главное здание правительства России.")
    print("Это современное здание с архитектурой, отражающей силу и стабильность.")
    print()

def arbat():
    print("Арбат")
    print("Старинная улица, которая стала символом русской культуры.")
    print("Здесь вы можете увидеть старинные дома, художников и музыкантов.")
    print()

def tretyakov_gallery():
    print("Третьяковская галерея")
    print("Одна из крупнейших художественных галерей в мире.")
    print("Здесь представлены работы русских художников от древнерусского искусства до советского периода.")
    print()

def zoo():
    print("Московский зоопарк")
    print("Один из старейших зоопарков в Европе.")
    print("Здесь обитает более 6 тысяч животных из 800 видов.")
    print()

def victory_park():
    print("Парк Победы")
    print("Памятник победе в Великой Отечественной войне.")
    print("Здесь находится монументalая скульптура 'Триумфальная арка' и музей.")
    print()

def cosmonautics_museum():
    print("Музей космонавтики")
    print("Музей, посвященный истории космонавтики и космических исследований.")
    print("Здесь вы можете увидеть ракеты, спутники и космические корабли.")
    print()

def conclusion():
    print("Спасибо за внимание!")
    print("Москва — это город, который值得_visiting и изучения.")
    print()

def main():
    introduction()
    red_square()
    kremlin()
    white_house()
    arbat()
    tretyakov_gallery()
    zoo()
    victory_park()
    cosmonautics_museum()
    conclusion()

if __name__ == "__main__":
    main()
```

Эта программа выводит информацию о различных достопримечательностях Москвы, используя функции для каждой локации. Она начинается с введения, затем перечисляет основные места и заканчивается заключением. Каждая функция выводит название и краткое описание достопримечательности.
CPU times: user 15min 12s, sys: 634 ms, total: 15min 13s
Wall time: 15min 12s

import torch
from torch import nn
from safetensors import safe_open

with safe_open(source_model_id + "/model.safetensors", framework="pt", device="cpu") as f:
    for k in f.keys():
        if "model.embed_tokens.weight" in k:
            embeddings_src = torch.nn.Parameter(f.get_tensor(k)).to(torch.float32)

with safe_open(source_model_id + "/model.safetensors", framework="pt", device="cpu") as f:
    for k in f.keys():
        if "lm_head" in k:
            lm_head_src = torch.nn.Parameter(f.get_tensor(k)).to(torch.float32)

embeddings_src_size = embeddings_src.shape[0]
print("embeddings_src_size", embeddings_src_size)

embeddings_src_size 152064

torch_dtype = torch.float16

with torch.no_grad():
    input_emb_mean = torch.mean(embeddings_src[:embeddings_src_size], dim=0).to(torch_dtype).to("cuda:0")
    output_emb_mean = torch.mean(lm_head_src[:embeddings_src_size], dim=0).to(torch_dtype).to("cuda:1")
print(input_emb_mean)
print(output_emb_mean)

tensor([-0.0012, -0.0008, -0.0008,  ...,  0.0029,  0.0003,  0.0006],
       device='cuda:0', dtype=torch.float16)
tensor([-0.0001,  0.0008,  0.0003,  ..., -0.0019, -0.0008, -0.0025],
       device='cuda:1', dtype=torch.float16)

# https://github.com/RefalMachine/ruadapt/blob/main/ruadapt/tokenization/replace_tokenizer.py
def if_hex(token):
    return token.startswith('<0x') and token.endswith('>')

def convert_token_to_string_universal(token, tokenizer_dst, tokeniser_src_vocab, tokenizer_dst_properties):
    if if_hex(token):
        if token in tokeniser_src_vocab:
            return token
        
        token = chr(convert_ascii_hex(token))
        if token in tokeniser_src_vocab:
            return token
        
    token = [token]
    if tokenizer_dst_properties['force_leading_space']:
        token = [tokenizer_dst_properties['space']] + token

    text_token = tokenizer_dst.convert_tokens_to_string(token)
    if len(text_token) == 1 and ord(text_token) == 65533:
        return token[-1]

    return text_token

def convert_token_universal(token_str, tokenizer, vocab, tokenizer_prop):
    assert tokenizer.is_fast
    pre_tokenizer = tokenizer._tokenizer.pre_tokenizer
    if pre_tokenizer is not None:
        token_str = pre_tokenizer.pre_tokenize_str(token_str)
        token_str = ''.join([t[0] for t in token_str])

    if tokenizer_prop['space'] == '▁':
        token_str = token_str.replace(' ', '▁')

    if if_hex(token_str) and token_str in vocab:
        return tokenizer.convert_tokens_to_ids([token_str])

    return [t.id for t in tokenizer._tokenizer.model.tokenize(token_str)]

spec_tokens = [x.content for x in source_tokenizer.added_tokens_decoder.values()]
spec_tokens

['<｜end▁of▁sentence｜>',
 '<｜User｜>',
 '<｜Assistant｜>',
 '<｜begin▁of▁sentence｜>',
 '<|EOT|>',
 '<think>',
 '</think>',
 '<|quad_start|>',
 '<|quad_end|>',
 '<|vision_start|>',
 '<|vision_end|>',
 '<|vision_pad|>',
 '<|image_pad|>',
 '<|video_pad|>',
 '<tool_call>',
 '</tool_call>',
 '<|fim_prefix|>',
 '<|fim_middle|>',
 '<|fim_suffix|>',
 '<|fim_pad|>',
 '<|repo_name|>',
 '<|file_sep|>']

from tqdm.auto import tqdm

tokenizer_src_vocab = source_tokenizer.get_vocab()

EMBED_SIZE = 128024
IN_FEATURES = 5120

model.vocab_size = EMBED_SIZE
model.model.vocab_size = EMBED_SIZE
model.config.vocab_size = EMBED_SIZE
model.model.embed_tokens = nn.Embedding(model.config.vocab_size, model.config.hidden_size, model.config.pad_token_id)
model.lm_head = nn.Linear(IN_FEATURES, EMBED_SIZE, bias=False)

logs = []
with torch.no_grad():
    for i in tqdm(range(vocab_size)):
        token = tokenizer.decode(i)
        if token in spec_tokens:
            token_idx = source_tokenizer._tokenizer.token_to_id(token)
            embed_tokens_ids = [token_idx]
            if token_idx is None:
                embed_tokens_ids = None
            token_str = token
        else:
            token_str = convert_token_to_string_universal(token, tokenizer, tokenizer_src_vocab, {'force_leading_space': False}) 
            embed_tokens_ids = convert_token_universal(token_str, source_tokenizer, tokenizer_src_vocab, {'force_leading_space': False, 'space': '▁'})
        
        logs.append({'token_id': i, 'token_repr': token, 'token_str': token_str, 'tokens_src': embed_tokens_ids})

        if embed_tokens_ids is None:
            input_emb_vec = input_emb_mean
        else:
            input_emb_vec = embeddings_src[embed_tokens_ids].mean(axis=0).to(torch_dtype)

        if input_emb_vec.norm() < 1e-12:
            input_emb_vec = input_emb_mean

        model.model.embed_tokens.weight.data[i].copy_(input_emb_vec)

        if embed_tokens_ids is None:
            output_emb_vec = output_emb_mean
        else:
            output_emb_vec = lm_head_src[embed_tokens_ids].mean(axis=0).to(torch_dtype)
        if output_emb_vec.norm() < 1e-12:
            logs[-1]['output_emb_vec_mean'] = True
            output_emb_vec = output_emb_mean

        model.lm_head.weight.data[i].copy_(output_emb_vec)


model.model.embed_tokens.to(torch_dtype).to("cuda:0")
model.lm_head.to(torch_dtype).to("cuda:1")
del input_emb_mean
del output_emb_mean
del embeddings_src
del lm_head_src

torch.cuda.empty_cache()

len(logs)

  0%|          | 0/128024 [00:00<?, ?it/s]

128024

def model_dtypes(model):
    # Verifying the datatypes.
    dtypes = {}
    for name, p in model.named_parameters():
        dtype = p.dtype
        if dtype not in dtypes: dtypes[dtype] = 0
        dtypes[dtype] += p.numel()
    total = 0
    for k, v in dtypes.items(): total+= v
    for k, v in dtypes.items():
        print(k, v, v/total * 100)

def print_trainable_parameters(model, is_logging=False):
    """
    Prints the number of trainable parameters in the model.
    """
    trainable_params = 0
    all_param = 0
    for k, param in model.named_parameters():
        all_param += param.numel()
        if param.requires_grad:
            if is_logging:
                print(k)
            trainable_params += param.numel()
    print(
        f"trainable params: {trainable_params} || all params: {all_param} || trainables%: {100 * trainable_params / all_param}"
    )

print_trainable_parameters(model)
model_dtypes(model)

trainable params: 1311626240 || all params: 1311626240 || trainables%: 100.0
torch.float16 1311626240 100.0

from transformers import GenerationConfig

input_messages = [
    {"role": "user", "content": "Напиши рассказ про достопримечательности Москвы используя Python"}
]

text = tokenizer.apply_chat_template(input_messages, tokenize=False, add_generation_prompt=True)
print(text)
input_ids = tokenizer.encode(text, return_tensors="pt", add_special_tokens=False)
print(input_ids.shape)

with torch.inference_mode():
    inp = input_ids.to("cuda")
    labels = input_ids.clone()

    output_ids = model.generate(inp, pad_token_id=tokenizer.eos_token_id, max_new_tokens=128, eos_token_id=tokenizer.eos_token_id)
    outputs = model(inp, labels = labels, pad_token_id=tokenizer.eos_token_id, max_new_tokens=128, eos_token_id=tokenizer.eos_token_id)
    neg_log_likelihood = outputs.loss
    print(neg_log_likelihood)
    ppl = torch.exp(torch.stack([neg_log_likelihood]).mean())
    print(ppl)

ouput_str = tokenizer.decode(output_ids[0])
print(ouput_str)

The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.

<｜begin▁of▁sentence｜><｜User｜>Напиши рассказ про достопримечательности Москвы используя Python<｜Assistant｜>
torch.Size([1, 11])
tensor(13.4576, device='cuda:1')
tensor(699152., device='cuda:1')
<｜begin▁of▁sentence｜><｜User｜>Напиши рассказ про достопримечательности Москвы используя Python<｜Assistant｜><think>
Okay, the user wrote "Нпи рассказ проот Москвыу Python". It looks like there are some typos here. Maybe they meant "Напиши рассказ про от Москвы до Python"? That would make sense, like a story from Moscow to Python, perhaps about learning Python in Moscow or something related to programming there. I should ask for a bit more clarity to make sure I understand what they need. I'll respond in Russian to keep it natural for them.
</think>

Кажется, вы хотите, чтобы я написал рассказ на тему "от Москвы до Python". Возможно, вы имеете в вид

Tokenizer¶

Model: FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview

Model: ai-sage/GigaChat-20B-A3B-instruct

Model: msu-rcc-lair/RuadaptQwen2.5-32B-instruct

Model: FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-Flash-32B-Preview

Model: ai-sage/GigaChat-20B-A3B-instruct

Model: msu-rcc-lair/RuadaptQwen2.5-32B-instruct

Model: FuseAI-Flash-merge-32B

GPTQ¶

Base model¶

Replace embeddings¶

generation¶