model.py

import numpy as np
import random
import re
from bs4 import BeautifulSoup
import requests
import wikipedia
greets = [
    'Добрый день!',
    'Здравствуй',
    'Привет, как могу помочь?',
    'Здравствуйте',
    'Приветики',
    'Привет, как дела!',
    'Привет, Привет и ещё раз Привет!'
]
searches = [
    'Ищу в интернете...',
    'Идёт поиск...',
    'Скоро отвечу...',
    'Секунду...',
    'Одну секунду...',
    'Сейчас найду...',
    'Ищу информацию...',
    'Источники не врут, нужно изучить информацию...',
    'Я сейчас...',
    'Подождите минутку...'
]
defaults = [
    'Не понял, повторите',
    'Я не расслышал, можете повторить',
    'Я вас не понял, скажите снова',
    'Вы говорите тихо, скажите пожалуйста погромче.',
    'Я вас не смог понять, можете повторить?'
]

class NeuralNet:
    def __init__(self, input_size, hidden_size, output_size):
        self.Wxh = np.random.randn(hidden_size, input_size) * 0.01
        self.Whh = np.random.randn(hidden_size, hidden_size) * 0.01
        self.Why = np.random.randn(output_size, hidden_size) * 0.01
        self.bh = np.zeros((hidden_size, 1))
        self.by = np.zeros((output_size, 1))
        
    def forward(self, inputs, h_prev):
        h = np.tanh(np.dot(self.Wxh, inputs) + np.dot(self.Whh, h_prev) + self.bh)
        y = np.dot(self.Why, h) + self.by
        return y, h
        
    def train(self, X, Y, learning_rate=0.01, epochs=1000):
        for epoch in range(epochs):
            loss = 0
            h_prev = np.zeros((self.Whh.shape[0], 1))
            
            for i in range(len(X)):
                x = np.array(X[i]).reshape(-1, 1)
                y_true = np.array(Y[i]).reshape(-1, 1)
                
                # Forward pass
                y_pred, h_prev = self.forward(x, h_prev)
                
                # Compute loss
                loss += np.sum((y_pred - y_true) ** 2)
                
                # Backward pass
                dy = y_pred - y_true
                dWhy = np.dot(dy, h_prev.T)
                dby = dy
                
                dh = np.dot(self.Why.T, dy)
                dh_raw = (1 - h_prev ** 2) * dh
                
                dWxh = np.dot(dh_raw, x.T)
                dWhh = np.dot(dh_raw, h_prev.T)
                dbh = dh_raw
                
                # Update weights
                self.Wxh -= learning_rate * dWxh
                self.Whh -= learning_rate * dWhh
                self.Why -= learning_rate * dWhy
                self.bh -= learning_rate * dbh
                self.by -= learning_rate * dby
            
            if epoch % 100 == 0:
                print(f'Epoch {epoch}, Loss: {loss}')

class MaestroAssistant:
    def __init__(self):
        self.wake_word = "эй маэстро"
        self.vocab = {}
        self.intents = {
            'greet': ['привет', 'здравствуй', 'добрый день'],
            'search': ['найди', 'поищи', 'что такое', 'кто такой'],
            'joke': ['расскажи шутку', 'пошути', 'анекдот'],
            'time': ['который час', 'сколько времени', 'время']
        }
        self.responses = {
            'greet': greets,
            'search': searches,
            'joke': 'Я не умею шутить, но могу найти сайт с шутками!',
            'default': defaults
        }
        
        
        self.init_vocab()
        input_size = len(self.vocab)
        hidden_size = 64
        output_size = len(self.intents)
        self.nn = NeuralNet(input_size, hidden_size, output_size)
        
        
        self.train()
        
    def init_vocab(self):
        
        words = set()
        for intent in self.intents.values():
            for phrase in intent:
                words.update(phrase.split())
        self.vocab = {word: i for i, word in enumerate(words)}
        
    def text_to_vector(self, text):
        
        vector = np.zeros(len(self.vocab))
        for word in text.split():
            if word in self.vocab:
                vector[self.vocab[word]] += 1
        return vector
        
    def train(self):
    
        X = []
        y = []
        for i, (intent, phrases) in enumerate(self.intents.items()):
            for phrase in phrases:
                X.append(self.text_to_vector(phrase))
                y_vec = np.zeros(len(self.intents))
                y_vec[i] = 1
                y.append(y_vec)
        
        
        X = np.array(X)
        y = np.array(y)
        
        
        self.nn.train(X, y, epochs=1000, learning_rate=0.01)
        
    def predict_intent(self, text):
        
        vector = self.text_to_vector(text)
        output, _ = self.nn.forward(vector.reshape(-1, 1), np.zeros((self.nn.Whh.shape[0], 1)))
        intent_idx = np.argmax(output)
        return list(self.intents.keys())[intent_idx]
        
    def handle_command(self, command):
    
        if not command.startswith(self.wake_word):
            return None
            
        command = command[len(self.wake_word):].strip()
        intent = self.predict_intent(command)
        
        if intent == 'greet':
            return random.choice(self.responses['greet'])
        elif intent == 'joke':
            return random.choice(self.responses['joke'])
        elif intent == 'search':
            query = re.sub(r'(найди|поищи|что такое|кто такой)', '', command).strip()
            return self.search(query)
        else:
            return random.choice(self.responses['default'])
            
    def search(self, query):
        
        try:
            wikipedia.set_lang('ru')
            result = wikipedia.summary(query, sentences=2)
            return f"Вот что я нашел в Википедии: {result}"
        except:
            pass
            
        
        try:
            url = f"https://www.google.com/search?q={query}"
            headers = {'User-Agent': 'Mozilla/5.0'}
            response = requests.get(url, headers=headers)
            soup = BeautifulSoup(response.text, 'html.parser')
            
            
            result = soup.find('div', class_='BNeawe').text
            return f"Вот что я нашел: {result[:200]}..."
        except Exception as e:
            return f"Не удалось найти информацию: {str(e)}"