🚀 Поиск кратчайшего пути с использованием алгоритма 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 🤖

📸 Обработка изображений с помощью OpenCV

import cv2
import numpy as np

def apply_grayscale_and_edges(image_path: str):
    # Загрузка изображения
    image = cv2.imread(image_path)
    if image is None:
        raise FileNotFoundError(f"Не удалось загрузить изображение: {image_path}")
    
    # Преобразование в градации серого
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Обнаружение границ с помощью Canny
    edges = cv2.Canny(gray_image, 100, 200)
    
    # Отображение результатов
    cv2.imshow("Grayscale", gray_image)
    cv2.imshow("Edges", edges)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# Пример использования
image_path = "example.jpg"
try:
    apply_grayscale_and_edges(image_path)
except FileNotFoundError as e:
    print(e)

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

🛠 Установите OpenCV с помощью: pip install opencv-python-headless

🔍 Применяйте этот код в своих проектах для обработки изображений.

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

🔍 Эффективность использования Generators vs. List Comprehensions в Python

def list_comprehension_example(n: int):
    return 

def generator_example(n: int):
    return (x * x for x in range(n))

# Пример использования
if __name__ == "__main__":
    n = 10**6

    # Использование спискового включения
    squares_list = list_comprehension_example(n)
    print(f"Сгенерирован список квадратов длиной {len(squares_list)}")

    # Использование генератора
    squares_generator = generator_example(n)
    print("Сгенерирован генератор квадратов")

    # Пример итерации по генератору
    sum_of_squares = sum(squares_generator)
    print(f"Сумма квадратов до {n}: {sum_of_squares}")

📌 Этот код демонстрирует два подхода к созданию последовательностей в Python: списковые включения и генераторы.

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

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

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