Этот код демонстрирует основную концепцию квантовой запутанности, где изменение состояния одного кубита мгновенно влияет на состояние другого, даже если они находятся на большом расстоянии друг от друга.

import pennylane as qml
from pennylane import numpy as np

# Создаем устройство с двумя кубитами
dev = qml.device("default.qubit", wires=2)

# Определяем квантовую схему
@qml.qnode(dev)
def circuit(param):
    # Применяем поворот к первому кубиту
    qml.RX(param, wires=0)
    # Запутываем кубиты с помощью операции CNOT
    qml.CNOT(wires=[0, 1])
    # Возвращаем ожидаемые значения операторов Паули Z для обоих кубитов
    return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))

# Значение параметра, определяющее степень запутанности
param_value = np.pi / 2

# Выполняем квантовую схему и выводим результаты измерений
result = circuit(param_value)
print(result)

### Объяснение кода

1. Импорт библиотек: Импортируем необходимые модули из библиотеки PennyLane для работы с квантовыми схемами.
2. Создание устройства: Определяем квантовое устройство с двумя кубитами.
3. Определение квантовой схемы:
- Используется декоратор @qml.qnode(dev), чтобы создать квантовую схему.
- Применяется операция поворота к первому кубиту, что изменяет его состояние.
- Затем применяется операция CNOT, которая запутывает два кубита.
- Возвращаются ожидаемые значения операторов Паули Z для каждого кубита, что позволяет оценить их состояния после измерения.
4. Выполнение схемы: Устанавливаем значение параметра для максимизации запутанности и выводим результаты измерений.

Подпишись 👉🏻 @KodduuPython 🤖

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

class Particle:
    def __init__(self, name, type_, charge, mass, spin):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass
        self.spin = spin

    def __str__(self):
        return f"{self.name}: {self.type_}, Charge: {self.charge}, Mass: {self.mass} GeV/c², Spin: {self.spin}"


# Создаем частицы
particles = [
    # Кварки
    Particle("Up", "Quark", "+2/3", 0.0022, "1/2"),
    Particle("Down", "Quark", "-1/3", 0.0047, "1/2"),
    Particle("Charm", "Quark", "+2/3", 1.27, "1/2"),
    Particle("Strange", "Quark", "-1/3", 0.096, "1/2"),
    Particle("Top", "Quark", "+2/3", 173.1, "1/2"),
    Particle("Bottom", "Quark", "-1/3", 4.18, "1/2"),
    
    # Лептоны
    Particle("Electron", "Lepton", "-1", 0.000511, "1/2"),
    Particle("Electron Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    Particle("Muon", "Lepton", "-1", 0.105, "1/2"),
    Particle("Muon Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    Particle("Tau", "Lepton", "-1", 1.777, "1/2"),
    Particle("Tau Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    
    # Бозоны
    Particle("Photon", "Boson", "0", "0", "1"),
    Particle("W+", "Boson", "+1", 80.379, "1"),
    Particle("W-", "Boson", "-1", 80.379, "1"),
    Particle("Z", "Boson", "0", 91.1876, "1"),
    Particle("Gluon", "Boson", "0", "0", "1"),
    Particle("Higgs", "Boson", "0", 125.1, "0"),
]

# Группируем частицы по типу
grouped_particles = {}
for particle in particles:
    grouped_particles.setdefault(particle.type_, []).append(particle)

# Выводим информацию о частицах
for type_, particles_list in grouped_particles.items():
    print(f"{type_}s:")
    for particle in particles_list:
        print(f"  - {particle}")
    print()

### Вывод программы
Этот код создает объект Particle, который содержит свойства, такие как название, тип, заряд, масса и спин частицы. Затем он группирует частицы по категориям (кварки, лептоны, бозоны) и выводит их список.

Пример вывода:

Quarks:
  - Up: Quark, Charge: +2/3, Mass: 0.0022 GeV/c², Spin: 1/2
  - Down: Quark, Charge: -1/3, Mass: 0.0047 GeV/c², Spin: 1/2
  ...

Leptons:
  - Electron: Lepton, Charge: -1, Mass: 0.000511 GeV/c², Spin: 1/2
  - Electron Neutrino: Lepton, Charge: 0, Mass: <0.000001 GeV/c², Spin: 1/2
  ...

Bosons:
  - Photon: Boson, Charge: 0, Mass: 0 GeV/c², Spin: 1
  - W+: Boson, Charge: +1, Mass: 80.379 GeV/c², Spin: 1
  ...

Этот подход позволяет не только увидеть все частицы Стандартной модели, но и понять различия между ними по заряду, массе и спину.

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода на Python, который показывает, как из частиц Стандартной модели формируются атомы и молекулы.

class Particle:
    def __init__(self, name, type_, charge, mass):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass

class Proton:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "+1"

class Neutron:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "0"

class Atom:
    def __init__(self, protons, neutrons, electrons):
        self.protons = protons
        self.neutrons = neutrons
        self.electrons = electrons

    def atomic_number(self):
        return len(self.protons)

    def mass_number(self):
        return len(self.protons) + len(self.neutrons)

    def is_neutral(self):
        return len(self.protons) == len(self.electrons)

    def __str__(self):
        return (f"Atom: Atomic Number = {self.atomic_number()}, Mass Number = {self.mass_number()}, "
                f"Neutral = {self.is_neutral()}")

class Molecule:
    def __init__(self, atoms):
        self.atoms = atoms

    def molecular_formula(self):
        element_count = {}
        for atom in self.atoms:
            symbol = f"Element-{atom.atomic_number()}"
            element_count[symbol] = element_count.get(symbol, 0) + 1
        return "".join(f"{symbol}{count if count > 1 else ''}" for symbol, count in element_count.items())

    def __str__(self):
        return f"Molecule: {self.molecular_formula()}"

# Пример: Создание атомов водорода и кислорода
hydrogen = Atom(protons=[Proton()], neutrons=[Neutron()], electrons=[Particle("Electron", "Lepton", "-1", 0.000511)])
oxygen = Atom(protons=[Proton() for _ in range(8)],
              neutrons=[Neutron() for _ in range(8)],
              electrons=[Particle("Electron", "Lepton", "-1", 0.000511) for _ in range(8)])

# Пример: Создание молекулы воды (H2O)
water = Molecule(atoms=[hydrogen, hydrogen, oxygen])

# Вывод информации
print(hydrogen)
print(oxygen)
print(water)

Этот код создает атомы, используя протоны, нейтроны и электроны, а затем объединяет атомы в молекулы.

Пример:

1. Атомы водорода и кислорода строятся из протонов, нейтронов и электронов.
2. Молекула воды (H₂O) создается из двух атомов водорода и одного атома кислорода.

Когда вы запустите этот код, вы получите вывод, показывающий структуру атомов и молекул. Например:

Atom: Atomic Number = 1, Mass Number = 2, Neutral = True
Atom: Atomic Number = 8, Mass Number = 16, Neutral = True
Molecule: Element-1H2Element-8O

Подпишись 👉🏻 @KodduuPython 🤖

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

class Particle:
    def __init__(self, name, type_, charge, mass):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass

class Proton:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "+1"

class Neutron:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "0"

class Atom:
    def __init__(self, protons, neutrons, electrons):
        self.protons = protons
        self.neutrons = neutrons
        self.electrons = electrons

    def atomic_number(self):
        return len(self.protons)

    def mass_number(self):
        return len(self.protons) + len(self.neutrons)

    def is_neutral(self):
        return len(self.protons) == len(self.electrons)

    def __str__(self):
        return (f"Atom: Atomic Number = {self.atomic_number()}, Mass Number = {self.mass_number()}, "
                f"Neutral = {self.is_neutral()}")

class Element:
    def __init__(self, symbol, name, atomic_number, atomic_mass):
        self.symbol = symbol
        self.name = name
        self.atomic_number = atomic_number
        self.atomic_mass = atomic_mass

    def __str__(self):
        return f"{self.symbol} ({self.name}): Atomic Number = {self.atomic_number}, Atomic Mass = {self.atomic_mass}"

class PeriodicTable:
    def __init__(self):
        self.elements = []

    def add_element(self, element):
        self.elements.append(element)

    def display(self):
        for element in sorted(self.elements, key=lambda e: e.atomic_number):
            print(element)

# Создание элементов
hydrogen = Element("H", "Hydrogen", 1, 1.008)
helium = Element("He", "Helium", 2, 4.0026)
lithium = Element("Li", "Lithium", 3, 6.94)
beryllium = Element("Be", "Beryllium", 4, 9.0122)
boron = Element("B", "Boron", 5, 10.81)
carbon = Element("C", "Carbon", 6, 12.011)
nitrogen = Element("N", "Nitrogen", 7, 14.007)
oxygen = Element("O", "Oxygen", 8, 15.999)
fluorine = Element("F", "Fluorine", 9, 18.998)
neon = Element("Ne", "Neon", 10, 20.180)

# Создание таблицы Менделеева
periodic_table = PeriodicTable()
periodic_table.add_element(hydrogen)
periodic_table.add_element(helium)
periodic_table.add_element(lithium)
periodic_table.add_element(beryllium)
periodic_table.add_element(boron)
periodic_table.add_element(carbon)
periodic_table.add_element(nitrogen)
periodic_table.add_element(oxygen)
periodic_table.add_element(fluorine)
periodic_table.add_element(neon)

# Вывод таблицы
periodic_table.display()

Подпишись 👉🏻 @KodduuPython 🤖

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

import random

# Базовые элементы языка
nouns = ["человек", "кошка", "собака", "дерево", "река", "птица"]
verbs = ["идёт", "бежит", "летит", "плавает", "прыгает", "поёт"]
adjectives = ["красивый", "быстрый", "медленный", "зелёный", "громкий", "маленький"]
prepositions = ["на", "в", "под", "за", "перед", "около"]

# Функция для создания случайного предложения
def generate_sentence():
    noun1 = random.choice(nouns)
    noun2 = random.choice(nouns)
    verb = random.choice(verbs)
    adjective = random.choice(adjectives)
    preposition = random.choice(prepositions)

    # Создание структуры предложения
    sentence = f"{noun1.capitalize()} {verb} {preposition} {adjective} {noun2}."
    return sentence

# Генерация нескольких предложений
for _ in range(5):
    print(generate_sentence())

### Пример вывода:

Кошка летит перед красивый человек.
Птица прыгает на громкий собака.
Человек идёт за зелёный река.
Собака поёт под маленький дерево.
Дерево плавает в быстрый птица.

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

Подпишись 👉🏻 @KodduuPython 🤖

Не все человеческие языки следуют "классическим" правилам, включающим существительные, глаголы, прилагательные и предлоги. В некоторых языках элементы структуры предложения могут отличаться. Например:

- Языки изолирующего типа (например, китайский) имеют минимальные изменения словоформ.
- Агглютинативные языки (например, турецкий) создают длинные слова, соединяя морфемы.
- Некоторые языки не имеют временных форм глаголов или даже разделения на части речи.

Пример необычного языка можно смоделировать так:

import random

# Элементы для необычного языка
root_words = ["ba", "ka", "ta", "zi", "lo", "mu"]
modifiers = ["-li", "-ta", "-ku", "-zo", "-na"]  # Префиксы или суффиксы
actions = ["повтор", "ударение", "смена тона"]  # В языке смысл передаётся через интонации или повторения

# Генерация случайного слова
def generate_word():
    root = random.choice(root_words)
    modifier = random.choice(modifiers)
    word = root + modifier
    return word

# Генерация "предложения"
def generate_sentence_unusual():
    sentence = []
    for _ in range(random.randint(3, 6)):  # Количество слов в "предложении"
        word = generate_word()
        if random.choice([True, False]):
            word = word * 2  # Повторение для усиления смысла
        if random.choice([True, False]):
            word += "!"  # Интонация: добавление эмоционального контекста
        sentence.append(word)
    return " ".join(sentence)

# Генерация и вывод примеров
print("Пример языка с необычной структурой:")
for _ in range(5):
    print(generate_sentence_unusual())

### Пример вывода:

Пример языка с необычной структурой:
balita balita! kazona kazona ziku!
muza! kalili kalili! lozoku!
kali kali! lozoku! tazona!
zili zili muza! zoku!
balita kazona muza muza!

### Особенности этого подхода:
1. Отсутствие грамматических категорий: здесь нет различий между существительными, глаголами и прилагательными.
2. Повторения: в некоторых языках повторение звуков усиливает значение.
3. Интонация: добавление "!" симулирует использование тона для изменения смысла.
4. Агглютинация: морфемы (например, -li, `-na`) используются для модификации корней.

Это демонстрирует, что не все языки основаны на привычных частях речи. Смысл может передаваться через звук, интонацию, порядок слов или даже повторения.

Подпишись 👉🏻 @KodduuPython 🤖

Создадим пример инопланетного языка, который использует совсем иные принципы, отличающиеся от всех земных языков. Пусть язык основан на многомерных концепциях:

1. Одновременная передача нескольких значений в одном "слове" (каждое "слово" кодирует объект, действие и состояние).
2. Цветовая ассоциация слов: "значение" зависит от цвета, который "представляется" слову.
3. Динамика звучания: слово меняет смысл в зависимости от изменения его структуры во времени (например, удлинение или сокращение).

### Код моделирования:

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Генерация "предложения"
def generate_alien_sentence():
    sentence = []
    for _ in range(random.randint(3, 5)):  # Количество "слов"
        word = generate_base_word()
        word = apply_color(word)
        word = apply_modification(word)
        sentence.append(word)
    return " | ".join(sentence)

# Генерация примеров
print("Пример инопланетного языка:")
for _ in range(5):
    print(generate_alien_sentence())

### Пример вывода:

Пример инопланетного языка:
красный @#$% | синий %&@* растяжение: %&@*-- | чёрный $*#$ импульс: $*#$~ | зелёный @@@ сжатие: @@
жёлтый @$%* сжатие: @$% | синий #$%& растяжение: #$%&- | красный &@*$ эхо: &@*$*$@&
чёрный *%# растяжение: *%#- | зелёный @#$% импульс: @#$%~ | жёлтый @# эхо: @##@
зелёный *&$ импульс: *&$~ | красный #%& растяжение: #%&-- | чёрный @# сжатие: @
красный %&@ сжатие: %& | синий @#$ растяжение: @#$- | жёлтый $% эхо: $%$%

### Особенности инопланетного языка:
1. Слова как многомерные структуры: каждое слово кодирует базовую форму, цвет, динамическую модификацию, что добавляет слои значения.
2. Цветовые значения: цвет добавляет семантику (например, "зелёный" может означать вопрос, "красный" — действие).
3. Динамика времени: модификации, такие как растяжение или эхо, добавляют эмоциональные или контекстуальные оттенки.
4. Нелинейная структура: слово может включать отражение (эхо) или импульсы, что невозможно в линейной речи.

Это демонстрирует язык, выходящий за рамки человеческого восприятия, делая акцент на уникальной многослойной структуре.

Подпишись 👉🏻 @KodduuPython 🤖

Вот код, который кодирует сообщение в созданном ранее инопланетном языке, но я не скажу, какое именно сообщение закодировано.

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Кодирование сообщения
message = "С Новым 2025 годом!"
encoded_message = []
for char in message:
    if char.strip():  # Пропускаем пробелы и пустые символы
        base_word = generate_base_word()
        colored_word = apply_color(base_word)
        modified_word = apply_modification(colored_word)
        encoded_message.append(modified_word)
    else:
        encoded_message.append("пробел")

# Вывод закодированного сообщения
print("Закодированное сообщение:")
for encoded_word in encoded_message:
    print(encoded_word)

Подпишись 👉🏻 @KodduuPython 🤖

Я добавил функцию для декодирования сообщения. Теперь код может раскодировать сообщение, используя упрощённые правила. Запусти обновлённый скрипт, чтобы проверить результат! 🚀

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Кодирование сообщения
message = "С Новым 2025 годом!"
encoded_message = []
coding_map = {}  # Карта соответствия символов

for char in message:
    if char.strip():  # Пропускаем пробелы и пустые символы
        base_word = generate_base_word()
        colored_word = apply_color(base_word)
        modified_word = apply_modification(colored_word)
        encoded_message.append(modified_word)
        coding_map[modified_word] = char  # Сохраняем соответствие символа и кодировки
    else:
        encoded_message.append("пробел")
        coding_map["пробел"] = " "

# Вывод закодированного сообщения
print("Закодированное сообщение:")
for encoded_word in encoded_message:
    print(encoded_word)

# Раскодирование сообщения
def decode_message(encoded_message, coding_map):
    decoded_message = []
    for encoded_word in encoded_message:
        decoded_message.append(coding_map.get(encoded_word, "?"))  # Используем карту для точного восстановления
    return "".join(decoded_message)

# Пример декодирования
print("\nДекодированное сообщение:")
decoded_message = decode_message(encoded_message, coding_map)
print(decoded_message)

Подпишись 👉🏻 @KodduuPython 🤖

Как поднять свой chatGPT?

На начало 2025 года одной из популярных тем является использование генеративного AI для текстов, изображений и кода с помощью библиотек, таких как OpenAI, Hugging Face и Stability AI. Вот пример кода на Python, который использует библиотеку Hugging Face Transformers для генерации текста:

### Код: Генерация текста с использованием модели GPT

from transformers import AutoTokenizer, AutoModelForCausalLM

# Загрузка токенайзера и модели
model_name = "gpt2"  # Вы можете использовать более продвинутую модель, например, "gpt-neo" или "gpt-j"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Начальная строка текста
prompt = "In the year 2025, artificial intelligence"

# Подготовка входных данных
input_ids = tokenizer.encode(prompt, return_tensors="pt")

# Генерация текста
output = model.generate(
    input_ids,
    max_length=50,  # Максимальная длина текста
    num_return_sequences=1,  # Количество генерируемых текстов
    temperature=0.7,  # "Креативность" текста (0.7 - сбалансированное значение)
    top_k=50,  # Фильтрация вероятностей (top-k sampling)
    top_p=0.9,  # Нуклеус-сэмплирование (top-p sampling)
    do_sample=True,  # Включение сэмплирования
)

# Декодирование и вывод текста
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print("Generated Text:\n", generated_text)

### Что делает этот код:
1. Загружает предобученную языковую модель (GPT-2 в данном случае).
2. Принимает начальную строку текста (`prompt`) для создания контекста.
3. Генерирует продолжение текста на основе введенного промпта.
4. Настраивает параметры генерации, чтобы управлять креативностью и качеством.

### Как улучшить:
- Использовать более мощные модели, такие как GPT-4 (если есть доступ через API).
- Включить дообучение модели на собственных данных.
- Интегрировать код в веб-приложение или чат-бота для интерактивности.

❗️ Для работы код потребует установки и конфигурации библиотек по интсрукции https://pytorch.org/get-started/locally/. Плюс место для самой модели chatGPT2.

👉 Попробуйте поменять prompt в коде для получения других отвтеов, либо допишиет код, чтобы он принимал prompy с ввода.

Подпишись 👉🏻 @KodduuPython 🤖

Вот обновленный код, который принимает prompt из консоли + пофишены проблемы с tokens:

from transformers import AutoTokenizer, AutoModelForCausalLM

# Загрузка токенайзера и модели
model_name = "gpt2"  # Вы можете заменить на более продвинутую модель
print("Loading model...")
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
print("Model loaded.")

# Установка pad_token_id, если он отсутствует
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# Получение prompt из консоли
prompt = input("Enter your prompt: ")
if not prompt.strip():
    print("Prompt cannot be empty!")
    exit()

# Подготовка входных данных
input_ids = tokenizer.encode(prompt, return_tensors="pt")
attention_mask = input_ids.ne(tokenizer.pad_token_id).long()  # Создание attention mask

# Генерация текста
print("Generating text...")
output = model.generate(
    input_ids,
    attention_mask=attention_mask,  # Передача attention_mask
    max_length=50,  # Максимальная длина текста
    num_return_sequences=1,  # Количество генерируемых текстов
    temperature=0.7,  # "Креативность" текста
    top_k=50,  # Фильтрация вероятностей (top-k sampling)
    top_p=0.9,  # Нуклеус-сэмплирование (top-p sampling)
    do_sample=True,  # Включение сэмплирования
    pad_token_id=tokenizer.pad_token_id,  # Установка токена-заполнителя
)

# Декодирование и вывод текста
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print("\nGenerated Text:\n", generated_text)

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

Подпишись 👉🏻 @KodduuPython 🤖

Обучение модели на собственной Wiki можно организовать с использованием библиотеки Hugging Face Transformers. Вот общий план, как это сделать:

---

### 1. Подготовка данных
#### Шаги:
1. Соберите данные:
- Экспортируйте содержимое вашей Wiki в текстовый формат (например, .txt, .json, или `.csv`).
- Убедитесь, что текст чистый: удалите разметку, HTML-теги, ненужные символы.

2. Форматируйте данные:
- Для обучения лучше всего использовать формат, где каждая строка представляет отдельный пример:

     Article 1 content...
     Article 2 content...
     

#### Пример:
Если у вас данные в JSON:

[
    {"title": "Article 1", "content": "Content of article 1"},
    {"title": "Article 2", "content": "Content of article 2"}
]

Превратите это в простой текстовый файл:

import json

with open("wiki.json") as f:
    data = json.load(f)

with open("wiki_texts.txt", "w") as f:
    for item in data:
        f.write(item["content"] + "\n")

---

### 2. Выберите модель
- Используйте предобученную модель (например, gpt2, bert, или `t5`), которую можно дообучить на ваших данных.

---

### 3. Установите библиотеки
Убедитесь, что установлены все необходимые библиотеки:

pip install transformers datasets

---

### 4. Создайте скрипт для дообучения
Вот пример дообучения модели GPT-2:

from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments
from datasets import load_dataset

# Шаг 1: Загрузка данных
dataset = load_dataset("text", data_files={"train": "wiki_texts.txt"})

# Шаг 2: Загрузка модели и токенайзера
model_name = "gpt2"  # Или любая другая предобученная модель
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Шаг 3: Токенизация данных
def tokenize_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)

tokenized_dataset = dataset.map(tokenize_function, batched=True)

# Шаг 4: Настройка аргументов обучения
training_args = TrainingArguments(
    output_dir="./results",
    overwrite_output_dir=True,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    save_steps=10_000,
    save_total_limit=2,
    prediction_loss_only=True
)

# Шаг 5: Создание Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
)

# Шаг 6: Запуск обучения
trainer.train()

# Сохранение модели
trainer.save_model("./fine_tuned_model")
tokenizer.save_pretrained("./fine_tuned_model")

---

### 5. Тестирование модели
После дообучения протестируйте модель на ваших данных:

from transformers import AutoTokenizer, AutoModelForCausalLM

model_path = "./fine_tuned_model"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)

prompt = "What is the purpose of this Wiki?"
input_ids = tokenizer.encode(prompt, return_tensors="pt")

output = model.generate(input_ids, max_length=50, num_return_sequences=1, temperature=0.7)
print(tokenizer.decode(output[0], skip_special_tokens=True))

---

### 6. Дополнительные рекомендации
1. Объем данных:
- Для значительных улучшений вам потребуется большой объем текстов.
- Если данных мало, используйте методы дообучения с регуляризацией, такие как LoRA или Adapter Layers.

2. Выбор модели:
- Для более структурированных текстов можно попробовать модели, такие как T5 или BERT.

3. Разделение на тренировочные и валидационные данные:
- Важно выделить часть данных (например, 10-20%) для проверки качества модели.

4. Инфраструктура:
- Для обучения потребуется GPU. Локально можно использовать CUDA, или обратиться к облачным сервисам, таким как Google Colab или AWS.

Подпишись 👉🏻 @KodduuPython 🤖

Код демонстрирует использование различных возможностей высокоуровневой типизации в Python, включая Callable, Union, Optional, Tuple, List и Any. Эти инструменты делают код более читаемым и безопасным благодаря четкому определению ожидаемых типов данных.

# Демонстрация использования функций высокоуровневой типизации в Python
from typing import Callable, List, Tuple, Union, Optional, Any

# 1. Callable: Описание функций как аргументов
# Функция принимает другую функцию и число, возвращает результат вызова функции

def apply_function(func: Callable[[int], int], value: int) -> int:
    """Применяет переданную функцию к значению."""
    print(f"Applying function to {value}")
    return func(value)

# Пример использования

def increment(x: int) -> int:
    return x + 1

result = apply_function(increment, 5)
print(f"Result: {result}")  # Result: 6

# 2. Union: Параметр может быть нескольких типов

def parse_input(value: Union[int, str]) -> str:
    """Преобразует значение в строку."""
    if isinstance(value, int):
        return f"Integer: {value}"
    return f"String: {value}"

print(parse_input(42))  # Integer: 42
print(parse_input("Hello"))  # String: Hello

# 3. Optional: Тип может быть None

def describe_item(item: Optional[str]) -> str:
    """Возвращает описание элемента."""
    if item is None:
        return "No item provided"
    return f"Item: {item}"

print(describe_item("Book"))  # Item: Book
print(describe_item(None))  # No item provided

# 4. Tuple: Фиксированный набор типов

def get_coordinates() -> Tuple[float, float]:
    """Возвращает координаты."""
    return (42.0, -71.0)

coordinates = get_coordinates()
print(f"Coordinates: {coordinates}")  # Coordinates: (42.0, -71.0)

# 5. List: Список элементов одного типа

def square_numbers(numbers: List[int]) -> List[int]:
    """Возвращает список квадратов чисел."""
    return [x ** 2 for x in numbers]

squares = square_numbers([1, 2, 3, 4])
print(f"Squares: {squares}")  # Squares: [1, 4, 9, 16]

# 6. Any: Общий тип для произвольных объектов

def echo(value: Any) -> Any:
    """Возвращает значение как есть."""
    return value

print(echo(123))  # 123
print(echo("Dynamic typing!"))  # Dynamic typing!

Подпишись 👉🏻 @KodduuPython 🤖

Код демонстрирует использование операторов объединения словарей | и |= в Python 3.9 и новее.

Оператор | создает новый словарь, объединяя ключи и значения из двух словарей. Если ключи совпадают, приоритет имеет значение из правого словаря.
Оператор |= изменяет существующий словарь, добавляя или заменяя ключи и значения из другого словаря.

# Демонстрация использования операторов объединения словарей в Python

# Операторы объединения словарей (Python 3.9+) позволяют легко объединять два словаря. 
# Оператор `|` возвращает новый словарь, объединяя два исходных, а оператор `|=` изменяет 
# существующий словарь, добавляя элементы из другого.

# Создание двух словарей
user_preferences = {
    "theme": "dark",
    "notifications": True
}

default_settings = {
    "theme": "light",
    "language": "en",
    "notifications": False
}

# Использование оператора `|` для объединения словарей
combined_settings = default_settings | user_preferences
print("Combined settings (using |):", combined_settings)
# {'theme': 'dark', 'language': 'en', 'notifications': True}

# Использование оператора `|=` для изменения существующего словаря
user_preferences |= {"language": "ru"}
print("Updated user preferences (using |=):", user_preferences)
# {'theme': 'dark', 'notifications': True, 'language': 'ru'}

Подпишись 👉🏻 @KodduuPython 🤖