Уроки ИИ для детей: создаем генератор изображений на Python

Сегодня нейросети умеют создавать удивительные изображения по текстовому описанию — например, Midjourney, Kandinsky или Шедеврум. Но чтобы понять, как они работают изнутри, полезно сначала освоить базовые операции с пикселями и цветом и изучить Python. Именно это мы и сделаем в этом уроке. А если ребенка заинтересует обучение ИИ и нейросетей для генерации изображений, мы расскажем, что делать дальше.

В этом уроке мы научимся создавать собственные изображения на Python — указывать каждый пиксель, рисовать фигуры, управлять цветом. Но есть и другой путь: обучить нейросеть делать это за вас. Искусственный интеллект способен анализировать миллионы картинок и создавать свои — от аватарок до реалистичных пейзажей. Знание того, как устроены пиксели и цвета, поможет ребенку быстрее освоить программирование ИИ и нейросетей для генерации изображений. Поэтому начнём с фундамента, а после этого урока вы сможете записаться на онлайн-курс по нейросетям для школьников и создать свою нейросеть-генератор.

Версия урока в видео-формате:

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

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

Установка библиотеки Pillow

Pillow не входит в стандартный набор Python, поэтому её нужно установить отдельно. Откройте терминал (командную строку) и выполните:
pip install pillow

Если вы работаете в среде, где уже есть Python, эта команда скачает и установит библиотеку. После установки её можно использовать в своих программах.

Импорт библиотеки

В Python библиотеки подключаются командой import. Для Pillow принято использовать сокращение PIL (это историческое название). Нам понадобятся два модуля: Image для работы с изображениями и ImageDraw для рисования фигур.

from PIL import Image, ImageDraw

Создаем первое изображение

Начнём с самого простого: создадим одноцветную картинку:
# Задаем размеры
width = 300
height = 300

# Задаем цвет в формате RGB (красный, зеленый, синий)
# Каждый цвет — число от 0 до 255
color = (255, 0, 0)  # ярко-красный

# Создаём изображение
image = Image.new("RGB", (width, height), color)

# Показываем картинку на экране
image.show()

# Сохраняем в файл
image.save("red_square.png")

Разберем каждую строчку:

• Image.new("RGB", (width, height), color) — создаёт новое изображение. Первый аргумент — режим цветов. "RGB" означает, что мы будем использовать три цветовых канала. Второй аргумент — размеры в пикселях (ширина, высота). Третий — цвет фона.
• image.show() — открывает картинку в стандартном просмотрщике (если он есть). Полезно для быстрой проверки.
• image.save("red_square.png") — сохраняет изображение в файл. Можно указывать разные расширения: .png, .jpg, .bmp и другие. Формат определяется по расширению.

Работа с каждым пикселем: создаём градиент

Теперь попробуем заполнить изображение градиентом, меняя цвет каждого пикселя. Для этого используем метод putpixel.
from PIL import Image

width = 300
height = 300

# Создаём черное изображение (цвет по умолчанию (0,0,0))
image = Image.new("RGB", (width, height))

# Двойной цикл: проходим по всем пикселям
for x in range(width):
    for y in range(height):
        # Красный компонент увеличивается с каждым столбцом
        r = int(x / width * 255)   # от 0 до 255 пропорционально x
        g = 0
        b = 0
        image.putpixel((x, y), (r, g, b))

image.show()
image.save("gradient.png")
Что здесь происходит:

• Мы создаем пустое изображение без указания цвета — по умолчанию фон чёрный.
• Вложенные циклы for перебирают все пиксели: внешний по x (столбцы), внутренний по y (строки).
• r = int(x / width * 255) вычисляет яркость красного так, чтобы в левом краю она была 0, а в правом — 255.
• putpixel((x, y), (r, g, b)) устанавливает цвет для конкретного пикселя. Координаты передаются в виде кортежа (x, y).

В результате получится горизонтальный градиент от черного к красному. Аналогично можно создать вертикальный или диагональный градиент, менять зелёный или синий каналы.

Когда мы писали код для градиента, мы сами определяли, как меняется цвет. В машинном обучении ИИ и нейросети учатся на примерах: ребенок будет показывать множество картинок, а искусственный интеллект находить закономерности.

Рисуем геометрические фигуры

Для рисования фигур нам понадобится класс ImageDraw. Сначала создадим изображение и объект Draw.
from PIL import Image, ImageDraw

# Создаём белую картинку (фон — белый)
image = Image.new("RGB", (400, 400), (255, 255, 255))
draw = ImageDraw.Draw(image)

Теперь можно рисовать.

Прямоугольник

# Рисуем прямоугольник от точки (50, 50) до (200, 150)
draw.rectangle([(50, 50), (200, 150)], fill=(255, 0, 0), outline=(0, 0, 0))

• fill — цвет заливки.
• outline — цвет контура (необязательно).

Круг (эллипс)

Круг или эллипс рисуются в прямоугольной области. Если область — квадрат, то получится круг.

# Рисуем круг в квадрате от (250, 50) до (350, 150)
draw.ellipse([(250, 50), (350, 150)], fill=(0, 255, 0))

Линия

# Линия от (50, 200) до (350, 200), толщина 3 пикселя
draw.line([(50, 200), (350, 200)], fill=(0, 0, 255), width=3)

Точка

Можно рисовать и отдельные точки (пиксели) с помощью point:

draw.point([(100, 100), (101, 100), (102, 100)], fill=(0, 0, 0))

После всех действий просмотрим и сохраним:

image.show()
image.save("shapes.png")

Случайный цвет

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

def random_color():
    r = random.randint(0, 255)
    g = random.randint(0, 255)
    b = random.randint(0, 255)
    return (r, g, b)

Эта функция каждый раз выдаёт новый кортеж из трёх случайных чисел.

Генерируем человечка (аватарку) случайного цвета

Теперь соберём всё вместе и создадим программу, которая рисует человечка со случайными цветами.
План:

• Создадим изображение 400×400 пикселей с белым фоном.
• Напишем функции для рисования головы, туловища, рук и ног.
• Каждая часть будет иметь свой случайный цвет.
• Координаты подберем так, чтобы человечек помещался на картинке.

import random
from PIL import Image, ImageDraw

def random_color():
    return (random.randint(0, 255),
            random.randint(0, 255),
            random.randint(0, 255))

def draw_head(draw, x, y, radius, color):
    # Верхний левый угол ограничивающего квадрата: (x-radius, y-radius)
    # Нижний правый: (x+radius, y+radius)
    left = x - radius
    top = y - radius
    right = x + radius
    bottom = y + radius
    draw.ellipse([(left, top), (right, bottom)], fill=color)

def draw_body(draw, x, y, width, height, color):
    # Туловище — прямоугольник, верхняя точка чуть ниже головы
    left = x - width//2
    top = y
    right = x + width//2
    bottom = y + height
    draw.rectangle([(left, top), (right, bottom)], fill=color)

def draw_arms(draw, x, y, length, width, color):
    # Левая рука
    left_shoulder = (x - width//2, y)
    left_hand = (x - length, y + length//2)
    draw.line([left_shoulder, left_hand], fill=color, width=width)
    # Правая рука
    right_shoulder = (x + width//2, y)
    right_hand = (x + length, y + length//2)
    draw.line([right_shoulder, right_hand], fill=color, width=width)

def draw_legs(draw, x, y, length, width, color):
    # Левая нога
    left_hip = (x - width//2, y)
    left_foot = (x - width//2, y + length)
    draw.line([left_hip, left_foot], fill=color, width=width)
    # Правая нога
    right_hip = (x + width//2, y)
    right_foot = (x + width//2, y + length)
    draw.line([right_hip, right_foot], fill=color, width=width)

# Создаём изображение
image = Image.new("RGB", (400, 400), (255, 255, 255))
draw = ImageDraw.Draw(image)

# Координаты центра головы
head_x = 200
head_y = 120
head_radius = 50
head_color = random_color()
draw_head(draw, head_x, head_y, head_radius, head_color)

# Туловище
body_width = 60
body_height = 100
body_y = head_y + head_radius   # сразу под головой
body_color = random_color()
draw_body(draw, head_x, body_y, body_width, body_height, body_color)

# Руки
arm_length = 80
arm_width = 12
arm_y = body_y + 30   # примерно на уровне плеч
arm_color = random_color()
draw_arms(draw, head_x, arm_y, arm_length, arm_width, arm_color)

# Ноги
leg_length = 80
leg_width = 12
leg_y = body_y + body_height   # низ туловища
leg_color = random_color()
draw_legs(draw, head_x, leg_y, leg_length, leg_width, leg_color)

# Сохраняем и показываем
image.save("random_avatar.png")
image.show()

Пояснения к функциям:

• draw_head рисует круг с центром в (x, y) и заданным радиусом. Для этого вычисляем координаты ограничивающего прямоугольника.
• draw_body рисует прямоугольник, верхняя граница которого совпадает с нижней границей головы.
• draw_arms рисует две линии от плеч в стороны. Плечи располагаются на ширину туловища.
• draw_legs рисует две линии от таза вниз.
• Каждая часть тела имеет свой случайный цвет, поэтому при каждом запуске получается уникальный человечек.

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

Ребенок только что научился создавать изображения «вручную»: задавать цвет каждого пикселя, рисовать фигуры, управлять градиентами. Но существует и другой подход — нейросети-генераторы. Именно они лежат в основе сервисов, которые по текстовому описанию создают реалистичные картинки, аватары и даже иллюстрации к книгам. Рассказываем, как это работает и что нужно знать, чтобы самому создавать такие нейросети.

Нейросеть-генератор — это программа, которая учится на огромном количестве примеров. Ей показывают миллионы изображений, и она постепенно выявляет закономерности: как сочетаются цвета, где обычно находятся глаза на лице, как устроена перспектива. После обучения нейросеть может сама генерировать новые картинки, которых раньше не видела. Например, если попросить её нарисовать «зеленого кота в космосе», она объединит знания о цветах, форме кота и космических пейзажах.

Что нужно знать, чтобы создавать нейросети-генераторы:

• Основы работы с пикселями и цветом. Как вы уже поняли, любое изображение — это просто набор чисел. Нейросети работают с теми же самыми числами, поэтому понимание формата RGB, координат и структуры картинки — обязательная база.
• Математику. Нейросети строятся на линейной алгебре, производных и теории вероятностей. Не пугайтесь — для первого знакомства достаточно школьного курса, а углубляться вы будете постепенно.
• Язык Python и специализированные библиотеки. Для создания нейросетей используют библиотеки TensorFlow, PyTorch или Keras. Они позволяют не писать сложные алгоритмы с нуля, а собирать готовые блоки.
• Навыки обучения и настройки моделей. Нейросеть не начинает работать сразу — её нужно «обучить». Это значит, что нужно подобрать примеры, запустить процесс, следить за ошибками и корректировать параметры. Этот этап требует терпения и понимания, как работает обучение.
• Понимание этики. Нейросети могут создавать очень реалистичные изображения, и важно использовать их ответственно, не нарушая авторские права и не вводя людей в заблуждение.

В школе «Пиксель» мы разработали курс по нейросетям для школьников, где ребята изучают эти принципы на практике. На нем они научатся создавать свои первые нейросети, которые распознают объекты на фото или генерируют простые изображения. Если ребенок интересуется программированием ИИ, этот курс станет отличным стартом.

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