Upload 4 files

README.md

@@ -1,12 +1,36 @@
----
-title: Transformer
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+Моя нейросеть (~10M параметров)
+Это приложение реализует трансформерную модель с ~10M параметров для генерации текста. Модель использует PyTorch и предоставляет интерфейс через Gradio.
+Установка
+
+Убедитесь, что все зависимости установлены:
+
+torch==2.0.1
+gradio==4.44.0
+torchtext==0.15.2
+
+
+Для работы приложения требуется файл весов model.pt. Чтобы обучить модель:
+
+Запустите train.py локально или на облачной платформе (например, Google Colab) с вашим датасетом.
+Скопируйте полученный model.pt в корень репозитория.
+
+
+
+Использование
+
+Запустите приложение через Hugging Face Spaces или локально:python app.py
+
+
+Введите начальный текст в интерфейсе Gradio, и модель продолжит его.
+
+Обучение
+
+Для обучения замените sample_data в train.py на ваш текстовый датасет (например, WikiText).
+Запустите train.py на машине с GPU для ускорения.
+После обучения загрузите model.pt в репозиторий.
+
+Замечания
+
+Модель оптимизирована для работы на бесплатном оборудовании Hugging Face Spaces. Если возникают проблемы с памятью, уменьшите EMBED_SIZE или NUM_LAYERS в app.py и train.py.
+Для улучшения качества генерации увеличьте размер датасета и количество эпох обучения.
+

app.py

@@ -1,64 +1,110 @@
+import torch
+import torch.nn as nn
 import gradio as gr
-from huggingface_hub import InferenceClient
+from torch.nn import TransformerDecoder, TransformerDecoderLayer
+from torchtext.data.utils import get_tokenizer
+from torchtext.vocab import build_vocab_from_iterator
+import math
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# Параметры модели
+VOCAB_SIZE = 10000  # Размер словаря
+EMBED_SIZE = 256    # Размер эмбеддингов
+NUM_HEADS = 8       # Количество голов в трансформере
+NUM_LAYERS = 6      # Количество слоев
+FFN_DIM = 512       # Размер скрытого слоя в FFN
+DROPOUT = 0.1
 
+# Определение модели
+class TransformerModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, num_heads, num_layers, ffn_dim, dropout):
+        super(TransformerModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.pos_encoder = PositionalEncoding(embed_size, dropout)
+        decoder_layer = TransformerDecoderLayer(embed_size, num_heads, ffn_dim, dropout)
+        self.transformer_decoder = TransformerDecoder(decoder_layer, num_layers)
+        self.fc_out = nn.Linear(embed_size, vocab_size)
+        self.embed_size = embed_size
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+    def forward(self, src, src_mask=None):
+        src = self.embedding(src) * math.sqrt(self.embed_size)
+        src = self.pos_encoder(src)
+        output = self.transformer_decoder(src, memory=None, tgt_mask=src_mask)
+        output = self.fc_out(output)
+        return output
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+class PositionalEncoding(nn.Module):
+    def __init__(self, embed_size, dropout, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        pe = torch.zeros(max_len, embed_size)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, embed_size, 2).float() * (-math.log(10000.0) / embed_size))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0)
+        self.register_buffer('pe', pe)
 
-    messages.append({"role": "user", "content": message})
+    def forward(self, x):
+        x = x + self.pe[:, :x.size(1)]
+        return self.dropout(x)
 
-    response = ""
+# Подсчет параметров
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+# Токенизатор и словарь
+tokenizer = get_tokenizer('basic_english')
+def yield_tokens(data_iter):
+    for text in data_iter:
+        yield tokenizer(text)
 
-        response += token
-        yield response
+# Пример данных (замените на свой датасет)
+sample_data = ["Hello world", "This is a test", "Build a neural network"] * 1000
+vocab = build_vocab_from_iterator(yield_tokens(sample_data), specials=['<unk>', '<pad>'])
+vocab.set_default_index(vocab['<unk>'])
 
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+# Инициализация модели
+model = TransformerModel(
+    vocab_size=VOCAB_SIZE,
+    embed_size=EMBED_SIZE,
+    num_heads=NUM_HEADS,
+    num_layers=NUM_LAYERS,
+    ffn_dim=FFN_DIM,
+    dropout=DROPOUT
 )
+print(f"Количество параметров модели: {count_parameters(model)}")
+
+# Загрузка обученных весов (если есть)
+try:
+    model.load_state_dict(torch.load("model.pt"))
+except FileNotFoundError:
+    print("Веса модели не найдены. Запустите train.py для обучения.")
 
+# Функция генерации текста
+def generate_text(prompt, max_length=50):
+    model.eval()
+    tokens = tokenizer(prompt)
+    indices = [vocab[token] for token in tokens]
+    src = torch.tensor(indices, dtype=torch.long).unsqueeze(0)
+    for _ in range(max_length):
+        with torch.no_grad():
+            output = model(src)
+            next_token = output[:, -1, :].argmax(-1).item()
+            src = torch.cat([src, torch.tensor([[next_token]], dtype=torch.long)], dim=-1)
+            if next_token == vocab['<pad>']:
+                break
+    generated = [vocab.get_itos()[idx] for idx in src.squeeze().tolist()]
+    return ' '.join(generated)
+
+# Интерфейс Gradio
+iface = gr.Interface(
+    fn=generate_text,
+    inputs=gr.Textbox(lines=2, placeholder="Введите начало текста..."),
+    outputs="text",
+    title="Моя нейросеть (~10M параметров)",
+    description="Введите текст, и модель продолжит его."
+)
 
+# Запуск интерфейса
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch()

requirements.txt

@@ -1 +1,3 @@
-huggingface_hub==0.25.2
+torch==2.0.1 
+gradio==4.44.0 
+torchtext==0.15.2

train.py

@@ -0,0 +1,96 @@
+import torch
+import torch.nn as nn
+from torchtext.data.utils import get_tokenizer
+from torchtext.vocab import build_vocab_from_iterator
+
+# Параметры модели (должны совпадать с app.py)
+VOCAB_SIZE = 10000
+EMBED_SIZE = 256
+NUM_HEADS = 8
+NUM_LAYERS = 6
+FFN_DIM = 512
+DROPOUT = 0.1
+
+# Определение модели (копия из app.py для независимости)
+class TransformerModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, num_heads, num_layers, ffn_dim, dropout):
+        super(TransformerModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.pos_encoder = PositionalEncoding(embed_size, dropout)
+        decoder_layer = TransformerDecoderLayer(embed_size, num_heads, ffn_dim, dropout)
+        self.transformer_decoder = TransformerDecoder(decoder_layer, num_layers)
+        self.fc_out = nn.Linear(embed_size, vocab_size)
+        self.embed_size = embed_size
+
+    def forward(self, src, src_mask=None):
+        src = self.embedding(src) * math.sqrt(self.embed_size)
+        src = self.pos_encoder(src)
+        output = self.transformer_decoder(src, memory=None, tgt_mask=src_mask)
+        output = self.fc_out(output)
+        return output
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, embed_size, dropout, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        pe = torch.zeros(max_len, embed_size)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, embed_size, 2).float() * (-math.log(10000.0) / embed_size))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        x = x + self.pe[:, :x.size(1)]
+        return self.dropout(x)
+
+# Токенизатор и словарь
+tokenizer = get_tokenizer('basic_english')
+def yield_tokens(data_iter):
+    for text in data_iter:
+        yield tokenizer(text)
+
+# Пример данных (замените на свой датасет)
+sample_data = ["Hello world", "This is a test", "Build a neural network"] * 1000
+vocab = build_vocab_from_iterator(yield_tokens(sample_data), specials=['<unk>', '<pad>'])
+vocab.set_default_index(vocab['<unk>'])
+
+# Инициализация модели
+model = TransformerModel(
+    vocab_size=VOCAB_SIZE,
+    embed_size=EMBED_SIZE,
+    num_heads=NUM_HEADS,
+    num_layers=NUM_LAYERS,
+    ffn_dim=FFN_DIM,
+    dropout=DROPOUT
+)
+
+# Функция обучения
+def train_model(model, data, epochs=5, device='cpu'):
+    model = model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+    criterion = nn.CrossEntropyLoss()
+    model.train()
+    for epoch in range(epochs):
+        total_loss = 0
+        for text in data:
+            tokens = tokenizer(text)
+            indices = [vocab[token] for token in tokens][:50]  # Ограничение длины
+            if len(indices) < 2:
+                continue
+            src = torch.tensor(indices[:-1], dtype=torch.long).unsqueeze(0).to(device)
+            tgt = torch.tensor(indices[1:], dtype=torch.long).unsqueeze(0).to(device)
+            optimizer.zero_grad()
+            output = model(src)
+            loss = criterion(output.view(-1, VOCAB_SIZE), tgt.view(-1))
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        print(f"Epoch {epoch+1}, Loss: {total_loss / len(data)}")
+    torch.save(model.state_dict(), "model.pt")
+
+# Запуск обучения
+if __name__ == "__main__":
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train_model(model, sample_data, epochs=5, device=device)