Разработка рекомендационных систем с Python и использованием Collaborative Filtering.

Рекомендации, которые понимают тебя лучше, чем друзья? Звучит как магия! Но на самом деле — это математика и немного Python. Сегодня мы погрузимся в мир рекомендационных систем и узнаем, как с их помощью можно строить персонализированные советы — будь то фильмы, книги или товары. А точнее — разберём один из самых популярных подходов: Collaborative Filtering.

Что такое Collaborative Filtering?
Это метод, который работает по следующей логике: «Если пользователь A и пользователь B оценили много объектов одинаково, то, скорее всего, то, что понравилось B, понравится и A». В этом подходе нет необходимости знать содержимое самих объектов — только поведение пользователей.

В Python есть несколько удобных библиотек для реализации коллаборативной фильтрации. Для базовой версии отлично подойдёт библиотека Surprise (да, именно так называется — она действительно способна удивить).

Установим её:

pip install scikit-surprise

Теперь время кода:

from surprise import Dataset, Reader
from surprise import KNNBasic
from surprise.modelselection import traintestsplit
from surprise import accuracy

# Пример данных: userid, itemid, rating (1–5)
data = Dataset.loadfromdf(
[
("user1", "item1", 5),
("user1", "item2", 3),
("user2", "item1", 4),
("user2", "item3", 2),
("user3", "item2", 4),
("user3", "item3", 5),
],
Reader(ratingscale=(1, 5))
)

trainset, testset = traintestsplit(data, testsize=0.2)

# Модель на основе user-based collaborative filtering
algo = KNNBasic(simoptions={"userbased": True})
algo.fit(trainset)
predictions = algo.test(testset)

# Посмотрим на точность
print(f"RMSE: {accuracy.rmse(predictions):.4f}")

# Предсказать интерес пользователя
userid = "user1"
itemid = "item3"
pred = algo.predict(userid, itemid)
print(f"Predicted rating for {userid} on {itemid}: {pred.est:.2f}")

Что тут происходит? Мы берём искусственный датафрейм с оценками пользователей, делим данные на тренировочные и тестовые, строим модель на K-ближайших соседях, основываясь на схожести пользователей. А потом... начинаем предсказывать, насколько понравится товар user1, если он ещё не взаимодействовал с ним.

Можно легко переключиться на item-based подход, просто поменяв userbased на False — тогда схожесть будет оцениваться между объектами, что тоже иногда даёт отличные результаты.

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

Так что если вы хотите построить своему пользователю «Netflix в миниатюре» — попробуйте collaborative filtering. Это не так сложно, как кажется, особенно с Python в руках.

Как автоматизировать создание и обновление отчетов с Python.

Вы когда-нибудь оказались в ситуации, когда нужно сгенерировать отчет с сотнями строк данных, а затем каждую неделю обновлять его вручную? Excel зависает, числа в глазах двоятся, а дедлайны дышат в затылок. В такой момент Python становится супергероем офисной автоматизации. Сегодня я покажу, как автоматизировать создание и обновление отчетов с помощью Python — быстро, просто и без боли.

На помощь приходят проверенные бойцы: pandas, openpyxl и matplotlib. Они помогут работать с данными, редактировать Excel-файлы и даже строить графики. Начнем с простого отчета: есть CSV-файл с продажами по регионам, нам нужно собрать сумму продаж, построить график и сохранить всё это в Excel-отчет.

Пример исходных данных в sales.csv:

region,date,sales
North,2024-05-01,1200
South,2024-05-01,950
North,2024-05-02,1340
... и так далее.

Сначала читаем и обрабатываем данные:

import pandas as pd

data = pd.read_csv("sales.csv", parse_dates=["date"])
summary = data.groupby("region")["sales"].sum().reset_index()

Хотим добавить график, чтобы отчет был не только полезный, но и красивый? Без проблем:

import matplotlib.pyplot as plt

plt.figure(figsize=(6, 4))
plt.bar(summary["region"], summary["sales"], color="skyblue")
plt.title("Sales by Region")
plt.xlabel("Region")
plt.ylabel("Total Sales")
plt.tight_layout()
plt.savefig("sales_chart.png")
plt.close()

Теперь создаем Excel-файл с таблицей и вставляем туда наш график:

from openpyxl import Workbook
from openpyxl.drawing.image import Image
from openpyxl.utils.dataframe import dataframe_to_rows

wb = Workbook()
ws = wb.active
ws.title = "Sales Report"

# Вставляем таблицу
for row in dataframe_to_rows(summary, index=False, header=True):
    ws.append(row)

# Вставляем картинку с графиком
img = Image("sales_chart.png")
img.anchor = "E2"  # координаты вставки
ws.add_image(img)

wb.save("sales_report.xlsx")

Что получилось: из CSV-файла мы автоматически получили сводную таблицу по регионам, построили визуализацию и сохранили все это в виде Excel-файла. Всё генерируется буквально за секунды. Можно запускать этот скрипт каждый день или неделю через планировщик задач — и больше не мучиться с отчетами вручную.

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

Python не просто сокращает время, он освобождает его. Отчеты, которые раньше отнимали часы, можно теперь генерировать в одно касание. И вместо унылого копирования цифр — больше времени на анализ, развитие и создание чего-то действительно важного.

Создание и манипуляция изображениями с использованием OpenCL и Python.

Когда дело доходит до обработки изображений, Python уже давно считается мощным инструментом: PIL, OpenCV, NumPy — все это знакомо многим. Но что, если скорость критична, а массивы пикселей требуют обработки параллельно? Добро пожаловать в мир OpenCL.

OpenCL (Open Computing Language) — это фреймворк для написания программ, которые исполняются на гетерогенных устройствах: CPU, GPU и других ускорителях. Да, это немного ближе к низкому уровню, но Python умеет работать с этим элегантно благодаря библиотеке PyOpenCL.

Сегодня мы разберем, как писать простой код на Python для обработки изображения с использованием OpenCL: от чтения файла до применения фильтра размытия с GPU.

Установка PyOpenCL:

pip install pyopencl Pillow numpy

Пример: фильтр размытия изображения.

Начнем с загрузки изображения и подготовки его к обработке:

from PIL import Image
import pyopencl as cl
import numpy as np

# Загрузка изображения
img = Image.open("input.jpg").convert("L") # Преобразуем в оттенки серого
imgarray = np.array(img).astype(np.uint8)
height, width = imgarray.shape

# Подготовка выходного массива
resultarray = np.emptylike(imgarray)

Теперь создаем контекст OpenCL и компилируем ядро:

ctx = cl.createsomecontext()
queue = cl.CommandQueue(ctx)

# OpenCL-ядро для размытия
kernelcode = """
kernel void blurimage(global const uchar *input,
global uchar *output,
const int width,
const int height) {
int x = getglobalid(0);
int y = getglobalid(1);
int idx = y * width + x;

if (x > 0 && y > 0 && x < width - 1 && y < height - 1) {
int sum = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
int nx = x + dx;
int ny = y + dy;
sum += input[ny * width + nx];
}
output[idx] = sum / 9;
} else {
output[idx] = input[idx];
}
}
"""

program = cl.Program(ctx, kernelcode).build()

# Создание буферов
mf = cl.memflags
inputbuf = cl.Buffer(ctx, mf.READONLY | mf.COPYHOSTPTR, hostbuf=imgarray)
outputbuf = cl.Buffer(ctx, mf.WRITEONLY, resultarray.nbytes)

# Запуск ядра
program.blurimage(queue, (width, height), None,
inputbuf, outputbuf,
np.int32(width), np.int32(height))

# Копирование результата обратно
cl.enqueuecopy(queue, resultarray, outputbuf)

# Сохранение выходного изображения
Image.fromarray(resultarray).save("output.jpg")

Что мы сделали:

- Считали изображение и преобразовали в массив.
- Подали его в ядро OpenCL, в котором политики памяти максимально эффективны.
- Обработали каждый пиксель параллельно, благодаря GPU.
- Получили примерно в 10-20 раз более быструю обработку по сравнению с чистым Python.

Почему это важно?

Когда вы имеете дело с изображениями высокого разрешения, производительность становится критична. Даже простое размытие может занимать секунды. OpenCL позволяет разгрузить CPU, переложив вычисления на GPU, даже встроенный.

К тому же, PyOpenCL — это не просто мост между Python и OpenCL. Он предоставляет удобные средства работы с памятью, компиляцией и управления устройствами.

Заключение

Если вы работаете с изображениями и чувствуете, что Python не справляется, не спешите уходить к C++. PyOpenCL — мощный способ ускорить вычисления, не теряя гибкости Python. Попробуйте, результат вас удивит.

Как настраивать поддержку многоязычных интерфейсов в приложениях Django.

Как настраивать поддержку многоязычных интерфейсов в приложениях Django.

Многоязычие в Django: как заставить ваше приложение "говорить" по-английски, по-русски и не только

Создаёте веб-приложение и хотите, чтобы им пользовались люди со всего мира? Добро пожаловать в мульти-языковой мир Django. Этот фреймворк предоставляет полноценные средства для локализации интерфейсов — от перевода текстов до управления пользовательскими языковыми настройками. Ниже — конкретно и без воды о том, как всё это настроить.

🔹 Шаг 1: Включим поддержку перевода

В settings.py активируем интернационализацию:

USE_I18N = True
USE_L10N = True

LANGUAGE_CODE = 'en'

LANGUAGES = [
    ('en', 'English'),
    ('ru', 'Russian'),
]

LOCALE_PATHS = [
    BASE_DIR / 'locale',
]

Параметр LANGUAGES важен — это список поддерживаемых языков. Именно здесь вы определяете, на какие языки будет переведён ваш интерфейс.

🔹 Шаг 2: Готовим строки к переводу

Все строки, которые должны быть переведены, нужно пометить специальными функциями. Django предоставляет gettext() и gettext_lazy() (чаще используется ugettext_lazy, но начиная с Django 4.0 используется просто gettext_lazy).

Пример в шаблоне:

<h1>{% trans "Welcome to my website!" %}</h1>

Пример в Python-коде:

from django.utils.translation import gettext_lazy as _

class Product(models.Model):
    name = models.CharField(max_length=100, verbose_name=_("Product Name"))

🔹 Шаг 3: Собираем переводимые строки

После пометок — соберём все строки для перевода. Выполняем команду:

django-admin makemessages -l ru

В результате появится файл locale/ru/LC_MESSAGES/django.po. Именно в нём вы вписываете переводы:

msgid "Welcome to my website!"
msgstr "Добро пожаловать на мой сайт!"

🔹 Шаг 4: Компилируем переводы

Чтобы Django мог использовать переведённые строки, необходимо скомпилировать .po в .mo:

django-admin compilemessages

Теперь переводы готовы к использованию.

🔹 Шаг 5: Автоматическое определение языка

Добавьте LocaleMiddleware в MIDDLEWARE:

MIDDLEWARE = [
    # ...
    'django.middleware.locale.LocaleMiddleware',
    # ...
]

Этот middleware анализирует заголовки браузера или куки и подставляет нужный язык.

Хотите переключать язык вручную? Создайте URL:

from django.conf.urls.i18n import i18n_patterns

urlpatterns = i18n_patterns(
    path('admin/', admin.site.urls),
    path('products/', include('products.urls')),
)

Теперь URL-адрес будет содержать префикс языка (/ru/products/), а Django подстроится под локаль.

🔹 Шаг 6: Динамическое переключение языка

Можно переключать язык прямо во время выполнения, например, через форму или селектор:

from django.utils import translation

def set_language_view(request):
    user_language = 'ru'
    translation.activate(user_language)
    response = HttpResponse("Привет!")
    response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
    return response

🎉 Готово!

Теперь ваше Django-приложение умеет "разговаривать" на нескольких языках. Это открывает дорогу к глобальному рынку и делает интерфейс дружелюбнее к пользователю.

Локализация в Django — это не просто nice-to-have. Это must-have, если вы хотите выйти за пределы одного языка. Делая ваш сайт многоязычным, вы делаете его доступным. А значит — полезным.

Обзор архитектуры микросервисов и их реализация на Python.

🚀 Микросервисы на Python: как всё устроено?

В последние годы микросервисная архитектура стала настоящим мейнстримом. Неудивительно — она даёт масштабируемость, гибкость в разработке и возможность легко поддерживать большие системы. Сегодня мы разберемся, как создаются микросервисы на Python, какие инструменты стоит использовать и с какими нюансами ты столкнёшься на практике.

🔧 Что такое микросервисы?

Если коротко — микросервисная архитектура подразумевает разделение приложения на отдельные, автономные сервисы. Каждый из них выполняет небольшую, четко определённую задачу и взаимодействует с остальными через API, обычно по HTTP или через очередь сообщений. В отличие от монолита, где всё связано, микросервисы «разведены» по своим зонам ответственности, что позволяет им развиваться независимо.

🎯 Почему Python?

Python отлично подходит для микросервисов благодаря своей лаконичности, огромному количеству библиотек и фреймворков, а также простоте интеграции с современными DevOps-инструментами и брокерами сообщений.

🔥 Основные инструменты

Рассмотрим три популярных подхода к созданию микросервисов на Python.

1. Flask/FastAPI — REST API сервисы

Для простых REST-сервисов FastAPI — просто бомба. Он быстрый (благодаря ASGI), прост в использовании и умеет сам генерировать документацию (Swagger, ReDoc).

Пример простого микросервиса:

from fastapi import FastAPI

app = FastAPI()

@app.get("/ping")
def ping():
    return {"message": "pong"}

Такой сервис легко развернуть, протестировать или масштабировать.

2. Celery + Redis/RabbitMQ — асинхронные задачи

Если ты хочешь, чтобы один микросервис "бросал задание", а другой — "его делал", без ожидания, пригодится Celery. Пример с использованием Redis:

worker.py

from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

@app.task
def add_numbers(a, b):
    return a + b

caller.py

from worker import add_numbers

result = add_numbers.delay(3, 5)
print(result.get())

Celery превращает Python-функции в асинхронные задачи, которые можно распределять между машинами и масштабировать.

3. gRPC — бинарный, быстрый, строгий

Для микросервисов с высоким трафиком, строгими контрактами и необходимостью работать быстро — gRPC отличное решение. Он использует Protocol Buffers вместо JSON и позволяет создавать строго типизированные API.

Пример на базе библиотек grpcio и protobuf выходит чуть длиннее, но даёт большой выигрыш в производительности и безопасности.

👀 Взаимодействие микросервисов

Варианты связки сервисов:

- HTTP-запросы (Flask/FastAPI)
- Очереди сообщений (RabbitMQ, Kafka, Redis Streams)
- gRPC
- GraphQL gateway

Для оркестрации и развертывания чаще всего используют Docker и Kubernetes.

🧩 Где подводные камни?

- Сложность: микросервисы — это дополнительная логика: деплой, мониторинг, логирование, безопасность.
- Сетевые накладные расходы.
- Управление версиями API.

Тем не менее, если архитектура продумана и под задачи системы микросервисы подходят — Python обеспечит тебе мощный и гибкий стек.

📦 Заключение

Python и микросервисы — отличная пара. Благодаря таким фреймворкам, как FastAPI, Celery и gRPC, ты можешь легко строить масштабируемые и надёжные системы. Вопрос только в задачах и грамотном проектировании — всё остальное уже есть в твоем распоряжении.

Следующий шаг — выбирать инструменты под конкретную задачу и не забывать про тестирование и наблюдаемость (observability). Удачного микросервисинга! 💡

Первичные шаги в создании персонализированных чат-ботов с NLP.

Привет, друзья! Сегодня мы с вами заглянем под капот одного из самых интересных применений Python – создание собственных чат-ботов с помощью Natural Language Processing (NLP). Да, тех самых "ботиков", которые понимают речь, здороваются, отвечают на вопросы и даже могут разрядить неловкую паузу в чате.

Сразу озвучу честно: мы не будем сейчас писать конкуренту ChatGPT — это немного другой уровень. Но понять, как создаются простые персонализированные чат-боты на Python, — вполне по силам даже начинающему разработчику.

Итак, для начала нам понадобятся следующие инструменты:

- библиотека nltk — для базовой обработки человеческой речи;
- библиотека random — чтобы бот не казался шаблонным;
- немного Python-мозгов — оно у вас точно есть ;)

Установка нужных библиотек:

pip install nltk

Импортируем всё, что нужно, и подгрузим ресурсы:

import nltk
import random
from nltk.chat.util import Chat, reflections

nltk.download('punkt')

Теперь разберёмся с основой: Chat в nltk работает по принципу паттерн-ответ. То есть, когда бот видит "привет", он ищет подходящий шаблон и отвечает заготовленной фразой.

Создадим набор диалогов:

pairs = [
    [
        r"привет|здравствуй|хай",
        ["Привет!", "Здравствуйте!", "Хаюшки :)"]
    ],
    [
        r"как дела\??",
        ["Всё отлично, а у тебя?", "Лучше не бывает!", "Пишу код, как обычно!"]
    ],
    [
        r"что ты умеешь\??",
        ["Я умею болтать и поддерживать диалог, как любой вежливый бот.", 
         "Моя задача — делать твоё общение с компьютером чуть приятнее."]
    ],
    [
        r"пока|до свидания",
        ["Пока-пока!", "До встречи!", "Счастливо!"]
    ],
    [
        r"(.*)",
        ["Извини, я пока не знаю, как на это ответить.", 
         "Попробуй переформулировать вопрос.", 
         "Интересно… но не совсем понятно :)"]
    ]
]

Если вы заметили, шаблоны — это регулярные выражения. Они ловят фразы, похожие на заданный паттерн. Это просто, но мощно! Последний шаблон r"(.*)" — запасной план, "уловка на всё", если бот не понял, что вы сказали.

Теперь создаём и запускаем нашего чат-бота:

def run_bot():
    print("Привет! Я — твой простой NLP-бот. Напиши что-нибудь, чтобы начать (или 'пока' для выхода).")
    chat = Chat(pairs, reflections)
    chat.converse()

run_bot()

Кстати, переменная reflections — это словарь с заменами типа "я" -> "ты", "мой" -> "твой", что делает диалог чуть-чуть более персонализированным. Хотите больше — можно под себя переписать.

Что можно улучшить?

1. Добавить понимание эмоций: анализировать тональность текста, например, с помощью TextBlob.
2. Интегрировать с Telegram, Discord или веб-интерфейсом.
3. Хранить историю диалога, "тренировать" бота под вашу специфику.

Создание собственного NLP-бота — это как завести ручного интеллекта: вы растите его сами, программируя каждую реакцию. Это отличный способ прокачать свои навыки Python, регулярных выражений и понимания языка.

Впереди ещё много интересного: препроцессинг текста, машинное обучение, векторизации фраз — но об этом в следующих постах. А пока — вперед, создать своего первого "говоруна"! 🧠🤖

Как создавать графические интерфейсы с библиотекой PySimpleGUI.

Привет! Сегодня разберёмся с тем, как легко и просто создавать графические интерфейсы на Python с помощью библиотеки PySimpleGUI.

Если вас пугают слова вроде "Qt", "Tkinter" или "canvas", вы не одиноки. Многие считают, что GUI на Python — это сложно, громоздко и требует много времени. Но PySimpleGUI с этим не согласен. Его девиз — «сделай быстро и просто». Он оборачивает популярные GUI-библиотеки (Tkinter, Qt, WxPython, Remi) в простой, читаемый интерфейс. Это буквально Python-код, который читается как псевдоязык.

Давайте не терять время и перейдём к практике.

Установка

Для начала установим библиотеку:

pip install PySimpleGUI

Пример 1. Первое окно "Hello, world!"

Создадим базовое окно с кнопкой и текстом:

import PySimpleGUI as sg

layout = [
    [sg.Text("Hello, world!")],
    [sg.Button("OK")]
]

window = sg.Window("My First Window", layout)

while True:
    event, values = window.read()
    if event == sg.WINDOW_CLOSED or event == "OK":
        break

window.close()

Здесь layout — это список, описывающий содержимое окна построчно. Всё элементарно: текстовая метка и кнопка.

Пример 2. Простая форма ввода

Теперь создадим мини-приложение, которое спрашивает имя пользователя и приветствует его:

import PySimpleGUI as sg

layout = [
    [sg.Text("What's your name?")],
    [sg.Input(key="name")],
    [sg.Button("Submit")],
    [sg.Text("", size=(30, 1), key="output")]
]

window = sg.Window("Name App", layout)

while True:
    event, values = window.read()
    if event == sg.WINDOW_CLOSED:
        break
    if event == "Submit":
        name = values["name"]
        window["output"].update(f"Hello, {name}!")

window.close()

Обратите внимание: каждое поле можно идентифицировать по ключу (key), а затем обновлять или извлекать значение через values.

Пример 3. Сохранение файла

А теперь добавим диалог сохранения файла, который можно встроить в любое приложение:

import PySimpleGUI as sg

layout = [
    [sg.Text("Save your file:")],
    [sg.InputText(key="filepath"), sg.FileSaveAs()],
    [sg.Button("Save"), sg.Button("Exit")]
]

window = sg.Window("File Saver", layout)

while True:
    event, values = window.read()
    if event in (sg.WINDOW_CLOSED, "Exit"):
        break
    if event == "Save" and values["filepath"]:
        with open(values["filepath"], "w") as f:
            f.write("Some example content.")

window.close()

Это уже ближе к реальному приложению. PySimpleGUI позволяет ловко подключать файловые диалоги и другие "взрослые" функции без лишней боли.

Что мне особенно нравится — вы можете быстро собрать интерфейс, протестировать логику, и на лету вносить изменения. У PySimpleGUI отличный встроенный отладочный вывод — вы всегда видите, что возвращает read() и какие события происходят.

Заключение

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

Если вы только начинаете знакомство с GUI-разработкой — PySimpleGUI даст вам мягкий старт и хороший фундамент.

Введение в генеративные модели с использованием отличившихся нейронных сетей и Python.

# Введение в генеративные модели с использованием нейронных сетей и Python

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

В этом посте я покажу, как с помощью Python и фреймворка PyTorch можно построить базовую генеративную модель — автокодировщик (Autoencoder). Это не GAN и не Diffusion модель, но отличная стартовая точка для понимания принципов генерации.

## Что делает автокодировщик?

Автокодировщик состоит из двух частей:
1. Encoder — ужимает входные данные в компактное представление (вектор скрытого пространства).
2. Decoder — восстанавливает оригинальные данные из этого "сжатого" представления.

По сути, он учится восстанавливать вход с минимальными потерями — и, научившись этому, может "фантазировать" похожие данные в этом же пространстве.

## Простой пример: генерация изображений цифр MNIST

Установим зависимости:

pip install torch torchvision matplotlib

Импортируем нужное:

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

Определим архитектуру:

class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Flatten(),
            nn.Linear(28 * 28, 128),
            nn.ReLU(),
            nn.Linear(128, 32),
        )
        self.decoder = nn.Sequential(
            nn.Linear(32, 128),
            nn.ReLU(),
            nn.Linear(128, 28 * 28),
            nn.Sigmoid(),
            nn.Unflatten(1, (1, 28, 28))
        )

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

Подготовим данные MNIST:

transform = transforms.ToTensor()
dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
loader = DataLoader(dataset, batch_size=64, shuffle=True)

Обучим модель:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Autoencoder().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

for epoch in range(5):
    for batch in loader:
        imgs, _ = batch
        imgs = imgs.to(device)
        outputs = model(imgs)
        loss = criterion(outputs, imgs)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

Сгенерируем несколько новых изображений:

with torch.no_grad():
    latent_vectors = torch.randn(16, 32).to(device)
    generated_imgs = model.decoder(latent_vectors)
    grid = torchvision.utils.make_grid(generated_imgs.cpu(), nrow=4)
    plt.imshow(grid.permute(1, 2, 0))
    plt.axis('off')
    plt.show()

## Что дальше?

Автокодировщики — это только первая ступень в мире генеративных моделей. На их базе строятся Variational Autoencoders (VAE), GANs и даже новейшие Diffusion Models, которые уже рисуют как DALL·E и пишут как ChatGPT.

Понимание принципов автокодировщиков дает хорошую основу для освоения более сложных, но невероятно мощных моделей.

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

Как создать симулятор физических процессов с использованием Python и PhysX

Когда Python встречает физику: симулятор с помощью NVIDIA PhysX

Что объединяет гоночные симуляторы, реалистичную анимацию разрушений и эффектное поведение объектов на сцене? Конечно, физика. А если быть конкретнее — движок PhysX, изначально разработанный Ageia, а позже поглощённый NVIDIA. Он лежит в основе механики многих игр и симуляторов. Но что, если мы хотим использовать его вместе с Python?

Благодаря проекту physx-python от NVIDIA, теперь это возможно. Интуитивный интерфейс Python позволяет собирать полноценные трёхмерные сцены с телами, гравитацией и столкновениями — и всё это с минимальной настройкой.

Что потребуется?

- Установленный Python 3.8+
- Установленный модуль physx (доступен через PyPI или GitHub)
- Знание базовых концепций физики (масса, силы, импульсы)

Установка:

pip install physx

Сборка первой сцены

Создадим простую сцену: куб падает на плоскость под действием гравитации.

from physx import PxPhysics, PxSceneDesc, PxDefaultErrorCallback, PxDefaultAllocator, PxSimulationEventCallback
from physx import PxRigidStatic, PxRigidDynamic, PxShape, PxBoxGeometry, PxMaterial, PxTransform, PxVec3

physics = PxPhysics()
material = physics.create_material(0.5, 0.5, 0.6)

scene_desc = PxSceneDesc(gravity=PxVec3(0, -9.81, 0))
scene = physics.create_scene(scene_desc)

# Создаем землю (плоскость)
ground_shape = physics.create_shape(PxBoxGeometry(50, 1, 50), material)
ground_body = physics.create_rigid_static(transform=PxTransform(p=PxVec3(0, -1, 0)))
ground_body.attach_shape(ground_shape)
scene.add_actor(ground_body)

# Создаем динамический куб
box_shape = physics.create_shape(PxBoxGeometry(1, 1, 1), material)
box_body = physics.create_rigid_dynamic(transform=PxTransform(p=PxVec3(0, 5, 0)))
box_body.attach_shape(box_shape)
scene.add_actor(box_body)

Теперь запустим симуляцию:

time_step = 1.0 / 60.0  # 60 FPS
for step in range(120):
    scene.simulate(time_step)
    scene.fetch_results()
    pos = box_body.get_global_pose().p
    print(f"Step {step}: Box Y={pos.y:.2f}")

На выходе мы получим по кадрам, как куб падает и отскакивает — PhysX учитывает инерцию, массу, трение и отскок автоматически.

Почему PhysX и не, скажем, Pymunk или Box2D?

- PhysX — это полноценная 3D-физика. Большинство Python-движков оперируют 2D.
- Оптимизация. PhysX используется в AAA-проектах и оптимизирован под реальные нагрузки.
- Расширяемость. С PhysX можно моделировать не только твердые тела, но и жидкости, ткани, разрушения (через расширения).

Советы:

- Обрабатывайте столкновения через колбэки (наследуйте PxSimulationEventCallback)
- Используйте инерцию и силы, а не вручную перемещайте тела
- Не забывайте освобождать ресурсы (release())

PhysX с Python — это серьезный инструмент для тех, кто хочет симулировать реальные процессы: от гравитации и столкновений до сложного взаимодействия объектов. Создавайте симуляторы роботов, физические головоломки или тестируйте алгоритмы управления — теперь это возможно без написания ни строчки C++.

Следующий шаг? Визуализация. А значит, впереди ждёт интеграция с OpenGL, Pyglet или Panda3D. Физика оживает, а Python снова доказывает, что с ним возможны настоящие чудеса.

Разработка IoT решений с помощью платформы ThingsBoard и Python