Ускорение Python кода с использованием Numba

import numpy as np
from numba import jit

# Пример на Numba
@jit(nopython=True)
def sum_of_squares(arr):
    total = 0
    for i in arr:
        total += i * i
    return total

# Пример использования
arr = np.arange(1e6)

# Используем Numba
print("Numba: ", sum_of_squares(arr))

📌 Этот код демонстрирует использование библиотеки Numba для ускорения вычислений в Python. Numba компилирует функции на
лету, что позволяет быстро улучшить производительность без дополнительных шагов. Этот инструмент особенно полезен для
вычислительно интенсивных задач, таких как обработка массивов или научные вычисления.

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

Люди подстроятся под ботов

Любые технологии на самом деле немного ухудшают пользовательский опыт. Например, когда все перешли на цифровую связь (сотовые, IP телефония, видеоконференции), то автоматически получили задержку связи до 100 мс. Это дико много по сравнению с почти скоростью света, которая была доступна на проводных телефонах, соединённых через АТС.

Но все привыкли. Мы теперь делаем паузу после завершения своего монолога и немного ждём по завершению чужого. Попробуйте сейчас поговорить по проводному телефону — вы офигеете, насколько это удобнее ☎️

То же самое будет с тупыми чат-ботами, которые сейчас все навнедряли и которые всех бесят. Вы всё привыкнете. Вы научитесь говорить так и использовать такие запросы, которые с большей вероятностью будут понятны боту. Люди адаптивны, поэтому подстроятся под ботов 🙇

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

🔍 Кластеризация данных с K-средними

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs
import numpy as np

def prepare_data(n_samples: int = 300, n_features: int = 2, centers: int = 3) -> np.ndarray:
    # Создание случайных данных с центрами
    X, _ = make_blobs(n_samples=n_samples, n_features=n_features, centers=centers, random_state=42)
    return X

def cluster_data(X: np.ndarray, n_clusters: int = 3) -> np.ndarray:
    # Масштабирование данных
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)

    # Кластеризация методом K-средних
    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
    kmeans.fit(X_scaled)
    return kmeans.labels_

# Пример использования
if __name__ == "__main__":
    data = prepare_data()
    labels = cluster_data(data)
    print("Кластеры:", labels)

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

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

🔥 Распродажа на Stepik закончится 4 декабря в 23:59 🏃🏃‍♀️

👉 Самое время пройти Python: самый быстрый курс 🧐

👉 Или окунутся в мир Data Science на курсе Python Data Science: самый быстрый курс 🤓

👉 Быстро выучить JS на курсу JavaScript: самый быстрый курс 😎

👉 И наконец узнать все сразу в программе курсов Junior Python Developer и Data Scientist +интервью тест 🧑‍🎓

КУПИТЬ КУРСЫ МОЖНО ЗА СЧЕТ РАБОТАДАТЕЛЯ 📌📌📌

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

🚀 Поиск кратчайшего пути с использованием алгоритма A*

from heapq import heappop, heappush

def heuristic(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def a_star_search(graph, start, goal):
    open_set = []
    heappush(open_set, (0, start))
    came_from = {}
    g_score = {start: 0}
    f_score = {start: heuristic(start, goal)}

    while open_set:
        _, current = heappop(open_set)

        if current == goal:
            return reconstruct_path(came_from, current)

        for neighbor in graph.get(current, []):
            tentative_g_score = g_score + graph
            if tentative_g_score < g_score.get(neighbor, float('inf')):
                came_from = current
                g_score = tentative_g_score
                f_score = tentative_g_score + heuristic(neighbor, goal)
                if neighbor not in open_set:
                    heappush(open_set, (f_score, neighbor))

    return None

def reconstruct_path(came_from, current):
    total_path = 
    while current in came_from:
        current = came_from
        total_path.append(current)
    return total_path[::-1]

# Пример использования
graph = {
    (0, 0): {(1, 0): 1, (0, 1): 1},
    (1, 0): {(0, 0): 1, (1, 1): 1, (2, 0): 1},
    (0, 1): {(0, 0): 1, (1, 1): 1},
    (1, 1): {(1, 0): 1, (0, 1): 1, (2, 1): 1},
    (2, 0): {(1, 0): 1, (2, 1): 1},
    (2, 1): {(2, 0): 1, (1, 1): 1}
}

start = (0, 0)
goal = (2, 1)
path = a_star_search(graph, start, goal)
print("Кратчайший путь:", path)

📌 Этот код демонстрирует реализацию алгоритма A* для поиска кратчайшего пути на графе. Он использует эвристическую функцию для оценки наилучшего маршрута и поддерживает открытый список с приоритетом для исследования. Такой подход может быть полезен в приложениях навигации и разработке игр для поиска оптимальных путей.

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

📊 Прогнозирование временных рядов с использованием рекуррентных нейронных сетей (RNN)

import numpy as np
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

def prepare_data(series, time_step=1):
    X, y = [], []
    for i in range(len(series) - time_step):
        X.append(series)
        y.append(series)
    return np.array(X), np.array(y)

# Генерация временного ряда
data = np.sin(np.linspace(0, 100, 500)) + np.random.normal(0, 0.1, 500)
scaler = MinMaxScaler(feature_range=(0, 1))
data = scaler.fit_transform(data.reshape(-1, 1)).flatten()

# Подготовка данных
time_step = 10
X, y = prepare_data(data, time_step)
X = X.reshape(X.shape[0], X.shape[1], 1)

# Создание модели RNN
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(time_step, 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mean_squared_error')

# Обучение модели
model.fit(X, y, epochs=100, batch_size=32, verbose=1)

# Пример использования
test_data = data[-time_step:]
test_data = test_data.reshape(1, -1, 1)
prediction = model.predict(test_data)
print("Прогноз:", scaler.inverse_transform(prediction).flatten()[0])

📌 Этот код демонстрирует, как создать и обучить модель RNN для прогнозирования временных рядов. Он включает подготовку данных, нормализацию, создание модели с использованием LSTM-слоев и оценку прогноза. Такой подход полезен для анализа финансовых данных, погоды и других временных рядов.

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

Тестирование мета-роев

Простой пример работы мета-роя.

1️⃣ Получен вопрос от пользователя.
2️⃣ RAG-агенты из rag-роя параллельно начали поиск информации в своих знаниях.
3️⃣ Один RAG-агент нашёл у себя инфу, другой — нет.
4️⃣ Запустился мета-рой с входными данными от rag-роя.
5️⃣ User-agent в мета-рое нашёл полезную инфу и вернул её пользователю.

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

🎯 Создание рекомендательной системы на основе коллаборативной фильтрации

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def collaborative_filtering(user_item_matrix, user_id, top_n=5):
    # Вычисление косинусного сходства между пользователями
    user_similarity = cosine_similarity(user_item_matrix)
    
    # Получение рекомендаций для конкретного пользователя
    user_ratings = user_item_matrix
    similar_users = user_similarity
    
    # Умножение матрицы предпочтений на сходство и нормализация
    weighted_sum = similar_users @ user_item_matrix
    sum_of_weights = np.abs(similar_users).sum(axis=0)
    recommendations = weighted_sum / sum_of_weights
    
    # Избегаем уже оцененных пользователем элементов
    recommendations = 0
    
    # Получение топ-N рекомендаций
    top_recommendations = np.argsort(recommendations)[-top_n:][::-1]
    return top_recommendations

# Пример использования
user_item_matrix = np.array([
    [4, 0, 0, 5, 1],
    [0, 3, 4, 0, 0],
    [2, 0, 0, 3, 0],
    [0, 0, 4, 0, 4],
    [5, 4, 0, 0, 0]
])

user_id = 0
top_recommendations = collaborative_filtering(user_item_matrix, user_id)
print("Рекомендации для пользователя:", top_recommendations)

📌 Этот код реализует простую рекомендательную систему, использующую коллаборативную фильтрацию на основе пользовательского сходства. Косинусное сходство вычисляется для нахождения похожих пользователей, а затем используется для предсказания рейтингов товаров, которые пользователь ещё не оценил. Такой подход широко применяется в e-commerce для улучшения пользовательского опыта и увеличения продаж.

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

Сегодня закончится распродажа Stepik, чтобы взять все и сразу 👉 берите максимальную программу обучения FullStack Developer and Data Scientist (Python+JS+Data+CookBook) 🔥🔥🔥

КУПИТЬ КУРС МОЖНО ЗА СЧЕТ РАБОТАДАТЕЛЯ 📌📌📌

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

🤖 Разработка простого чат-бота с использованием NLP и TF-IDF

import nltk
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

nltk.download('punkt')

class SimpleChatBot:
    def __init__(self, responses):
        self.responses = responses
        self.vectorizer = TfidfVectorizer()
        self.tfidf_matrix = self.vectorizer.fit_transform(self.responses)

    def get_response(self, user_input):
        # Векторизация пользовательского ввода
        user_tfidf = self.vectorizer.transform()
        
        # Вычисление косинусного сходства
        similarities = cosine_similarity(user_tfidf, self.tfidf_matrix)
        
        # Выбор наилучшего ответа
        best_match_idx = np.argmax(similarities, axis=1)
        return self.responses[best_match_idx[0]]

# Пример использования
responses = [
    "Привет! Как я могу помочь?",
    "Я могу ответить на ваши вопросы.",
    "Извините, я не понимаю ваш запрос.",
    "Спасибо за обращение!"
]

chat_bot = SimpleChatBot(responses)
user_input = "Как вы можете помочь?"
response = chat_bot.get_response(user_input)
print("Бот:", response)

📌 Этот код демонстрирует создание простого чат-бота, который использует TF-IDF для анализа текста и поиска наиболее подходящего ответа на пользовательский запрос. Бот векторизует входные данные и вычисляет косинусное сходство, чтобы выбрать лучший ответ из списка заранее заданных фраз. Подобный подход может быть полезен в службах поддержки клиентов и для автоматизации простых текстовых взаимодействий.

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

🔄 Асинхронное скачивание веб-страниц с помощью asyncio

import asyncio
import aiohttp
from aiohttp import ClientError

async def fetch(session, url):
    try:
        async with session.get(url) as response:
            return await response.text()
    except ClientError as e:
        print(f"Ошибка при загрузке {url}: {e}")
        return None

async def download_pages(urls):
    async with aiohttp.ClientSession() as session:
        tasks = 
        return await asyncio.gather(*tasks)

# Пример использования
urls = [
    "https://example.com",
    "https://example.org",
    "https://example.net"
]

async def main():
    pages = await download_pages(urls)
    for i, page in enumerate(pages):
        if page:
            print(f"Содержимое страницы {urls} загружено.")
        else:
            print(f"Не удалось загрузить страницу {urls}.")

asyncio.run(main())

📌 Этот код позволяет асинхронно загружать несколько веб-страниц одновременно, что может существенно повысить скорость выполнения задачи по сравнению с последовательными HTTP-запросами. Он подходит для ситуаций, когда требуется обработка большого количества запросов с минимальной задержкой, например, при создании веб-скрейперов или загрузке данных из API.

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

Внедрение за две недели

Лучший свой MVP и сразу внедрение я сделал в ~2002 году, у меня был компьютерный салон (ну где школота за деньги могла рубиться в контру и прочие радости).

Я нанял работников, и выручка упала (стали воровать).

Тогда я сел и за две недели, не выходя из салона, написал систему управления компьютерным залом под Windows. TCP/IP, клиент-сервер и т.д.

Каждый день (ну, может, кроме первых 2-3 дней) я выкатывал новую версию на все компы и на комп админа. И сразу в бою тестировал. Были баги, глюки, хитрая школота находила способы убить мой процесс и разлочить комп. Но спустя две недели всё заработало как надо.

Больше таких скоростных внедрений и решения проблем бизнеса я не видел никогда. Была реальная понятная мне проблема, я смог посвятить этому 200% своего времени, то есть полный фокус, не было необходимости в коммуникации.

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

Кстати, скоро мы соберём фреймворк, на котором можно будет выкатить мультиагентную систему с RAG за 2-3 дня 🔥

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