Python + Нейронные сети

Для сравнения буду использовать единый запрос:

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

Chatgpt-4o-latest:

import pygame

import math

import random

# Константы

WIDTH, HEIGHT = 800, 600

FPS = 60

GRAVITY = 0.5

FRICTION = 0.99

HEX_SIZE = 200

# Цвета

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

class Ball:

def __init__(self, x, y, radius):

self.x = x

self.y = y

self.radius = radius

self.vx = random.uniform(-5, 5)

self.vy = random.uniform(-5, 5)

def move(self):

self.vy += GRAVITY

self.x += self.vx

self.y += self.vy

# Применение трения

self.vx *= FRICTION

self.vy *= FRICTION

# Проверка на столкновение с гранями шестиугольника

if self.check_collision():

self.bounce()

def check_collision(self):

# Проверка на столкновение с шестиугольником

for i in range(6):

angle = math.pi / 3 * i

x1 = WIDTH // 2 + HEX_SIZE * math.cos(angle)

y1 = HEIGHT // 2 + HEX_SIZE * math.sin(angle)

x2 = WIDTH // 2 + HEX_SIZE * math.cos(angle + math.pi / 3)

y2 = HEIGHT // 2 + HEX_SIZE * math.sin(angle + math.pi / 3)

# Уравнение линии

if self.line_collision(x1, y1, x2, y2):

return True

return False

def line_collision(self, x1, y1, x2, y2):

# Проверка на столкновение с линией

# Уравнение для проверки расстояния до линии

A = y2 - y1

B = x1 - x2

C = x2 * y1 - x1 * y2

distance = abs(A * self.x + B * self.y + C) / math.sqrt(A**2 + B**2)

return distance < self.radius

def bounce(self):

# Отскок от стенки

angle = math.atan2(self.vy, self.vx) + math.pi / 3

speed = math.sqrt(self.vx ** 2 + self.vy ** 2)

self.vx = speed * math.cos(angle)

self.vy = speed * math.sin(angle)

def draw(self, screen):

pygame.draw.circle(screen, BLACK, (int(self.x), int(self.y)), self.radius)

def draw_hexagon(screen):

points = []

for i in range(6):

angle = math.pi / 3 * i

x = WIDTH // 2 + HEX_SIZE * math.cos(angle)

y = HEIGHT // 2 + HEX_SIZE * math.sin(angle)

points.append((x, y))

pygame.draw.polygon(screen, WHITE, points, 2)

def main():

pygame.init()

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Ball in Rotating Hexagon")

clock = pygame.time.Clock()

ball = Ball(WIDTH // 2, HEIGHT // 2, 15)

angle = 0

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

screen.fill(WHITE)

# Вращение шестиугольника

angle += 0.01

draw_hexagon(screen)

# Перемещение и отрисовка мяча

ball.move()

ball.draw(screen)

pygame.display.flip()

clock.tick(FPS)

pygame.quit()

if __name__ == "__main__":

main()

Qwen2.5-Max:

import pygame

import math

# Инициализация Pygame

pygame.init()

# Параметры экрана

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Мяч внутри вращающегося шестиугольника")

# Цвета

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (255, 0, 0)

BLUE = (0, 0, 255)

# Параметры шестиугольника

HEXAGON_CENTER = (WIDTH // 2, HEIGHT // 2)

HEXAGON_RADIUS = 200

NUM_SIDES = 6

# Параметры мяча

BALL_RADIUS = 10

ball_pos = [WIDTH // 2 + 50, HEIGHT // 2] # Начальная позиция мяча

ball_velocity = [3, -4] # Начальная скорость мяча

GRAVITY = 0.1 # Ускорение свободного падения

FRICTION = 0.99 # Коэффициент трения

# Параметры вращения

ROTATION_SPEED = 0.02 # Скорость вращения шестиугольника

angle = 0 # Текущий угол поворота

# Функция для отрисовки вращающегося шестиугольника

def draw_hexagon(center, radius, angle):

points = []

for i in range(NUM_SIDES):

# Вычисляем координаты вершин шестиугольника

x = center[0] + radius * math.cos(math.radians(360 / NUM_SIDES * i + angle))

y = center[1] + radius * math.sin(math.radians(360 / NUM_SIDES * i + angle))

points.append((x, y))

pygame.draw.polygon(screen, BLUE, points, 2)

# Основной цикл программы

running = True

clock = pygame.time.Clock()

while running:

screen.fill(WHITE)

# Обработка событий

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

# Обновление угла поворота шестиугольника

angle += ROTATION_SPEED

# Применение гравитации к мячу

ball_velocity[1] += GRAVITY

# Обновление позиции мяча

ball_pos[0] += ball_velocity[0]

ball_pos[1] += ball_velocity[1]

# Проверка столкновений мяча со стенками шестиугольника

collision = False

for i in range(NUM_SIDES):

# Вычисляем координаты текущей и следующей вершины шестиугольника

x1 = HEXAGON_CENTER[0] + HEXAGON_RADIUS * math.cos(math.radians(360 / NUM_SIDES * i + angle))

y1 = HEXAGON_CENTER[1] + HEXAGON_RADIUS * math.sin(math.radians(360 / NUM_SIDES * i + angle))

x2 = HEXAGON_CENTER[0] + HEXAGON_RADIUS * math.cos(math.radians(360 / NUM_SIDES * (i + 1) + angle))

y2 = HEXAGON_CENTER[1] + HEXAGON_RADIUS * math.sin(math.radians(360 / NUM_SIDES * (i + 1) + angle))

# Вектор нормали к стороне

nx = y2 - y1

ny = -(x2 - x1)

norm = math.hypot(nx, ny)

nx /= norm

ny /= norm

# Расстояние от мяча до линии

dx = ball_pos[0] - x1

dy = ball_pos[1] - y1

dist = abs(nx * dx + ny * dy)

if dist < BALL_RADIUS:

# Проекция скорости на нормаль

proj = ball_velocity[0] * nx + ball_velocity[1] * ny

if proj < 0:

# Отражение скорости

ball_velocity[0] -= 2 * proj * nx

ball_velocity[1] -= 2 * proj * ny

# Применение трения

ball_velocity[0] *= FRICTION

ball_velocity[1] *= FRICTION

collision = True

# Если мяч выходит за пределы шестиугольника, корректируем его позицию

if not collision:

direction = math.atan2(ball_pos[1] - HEXAGON_CENTER[1], ball_pos[0] - HEXAGON_CENTER[0])

ball_pos[0] = HEXAGON_CENTER[0] + HEXAGON_RADIUS * math.cos(direction)

ball_pos[1] = HEXAGON_CENTER[1] + HEXAGON_RADIUS * math.sin(direction)

ball_velocity[0] *= -FRICTION

ball_velocity[1] *= -FRICTION

# Отрисовка шестиугольника

draw_hexagon(HEXAGON_CENTER, HEXAGON_RADIUS, angle)

# Отрисовка мяча

pygame.draw.circle(screen, RED, (int(ball_pos[0]), int(ball_pos[1])), BALL_RADIUS)

# Обновление экрана

pygame.display.flip()

# Ограничение частоты обновления

clock.tick(60)

pygame.quit()

DeepSeek-V3-0324:

import pygame

import sys

import math

import numpy as np

# Инициализация Pygame

pygame.init()

# Настройки окна

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Мяч в вращающемся шестиугольнике")

# Цвета

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (255, 0, 0)

BLUE = (0, 0, 255)

# Параметры шестиугольника

hexagon_radius = 200 # Радиус описанной окружности

hexagon_center = (WIDTH // 2, HEIGHT // 2)

hexagon_angle = 0 # Текущий угол поворота

hexagon_rotation_speed = 0.01 # Скорость вращения шестиугольника

# Параметры мяча

ball_radius = 20

ball_pos = np.array([WIDTH // 2, HEIGHT // 2 - 100], dtype=float)

ball_vel = np.array([0, 0], dtype=float)

gravity = 0.2

friction = 0.99 # Коэффициент трения (1 - нет трения, <1 - есть трение)

elasticity = 0.8 # Коэффициент упругости (1 - абсолютно упругий удар)

# Функция для получения вершин шестиугольника

def get_hexagon_vertices(center, radius, angle):

vertices = []

for i in range(6):

theta = angle + i * math.pi / 3 # 60 градусов между вершинами

x = center[0] + radius * math.cos(theta)

y = center[1] + radius * math.sin(theta)

vertices.append((x, y))

return vertices

# Функция для проверки столкновения с шестиугольником

def check_collision(ball_pos, ball_radius, hex_vertices):

for i in range(len(hex_vertices)):

# Получаем текущую и следующую вершины (для создания стороны)

p1 = np.array(hex_vertices[i])

p2 = np.array(hex_vertices[(i + 1) % len(hex_vertices)])

# Вектор стороны

edge = p2 - p1

edge_length = np.linalg.norm(edge)

edge_normalized = edge / edge_length

# Вектор от вершины к центру мяча

ball_to_p1 = ball_pos - p1

# Проекция на сторону (скалярное произведение)

projection = np.dot(ball_to_p1, edge_normalized)

# Находим ближайшую точку на стороне к мячу

if projection < 0:

closest_point = p1

elif projection > edge_length:

closest_point = p2

else:

closest_point = p1 + projection * edge_normalized

# Расстояние от мяча до ближайшей точки

distance = np.linalg.norm(ball_pos - closest_point)

# Если расстояние меньше радиуса мяча - столкновение

if distance < ball_radius:

# Нормаль к стороне (перпендикуляр)

normal = np.array([-edge[1], edge[0]])

normal = normal / np.linalg.norm(normal)

# Убедимся, что нормаль направлена внутрь шестиугольника

to_center = hexagon_center - closest_point

if np.dot(normal, to_center) < 0:

normal = -normal

return True, normal, closest_point

return False, None, None

# Основной цикл

clock = pygame.time.Clock()

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

# Очистка экрана

screen.fill(BLACK)

# Обновление угла шестиугольника

hexagon_angle += hexagon_rotation_speed

# Получение вершин шестиугольника

hex_vertices = get_hexagon_vertices(hexagon_center, hexagon_radius, hexagon_angle)

# Отрисовка шестиугольника

pygame.draw.polygon(screen, WHITE, hex_vertices, 2)

# Применение гравитации

ball_vel[1] += gravity

# Применение трения

ball_vel *= friction

# Обновление позиции мяча

ball_pos += ball_vel

# Проверка столкновения с шестиугольником

collision, normal, collision_point = check_collision(ball_pos, ball_radius, hex_vertices)

if collision:

# Вычисляем относительную скорость

rel_vel = ball_vel

# Вычисляем скорость вдоль нормали

vel_along_normal = np.dot(rel_vel, normal)

# Если мяч движется внутрь шестиугольника, отражаем его

if vel_along_normal < 0:

# Импульс отскока с учетом упругости

impulse = -(1 + elasticity) * vel_along_normal

ball_vel += impulse * normal

# Корректируем позицию, чтобы мяч не застревал в стене

penetration = ball_radius - np.linalg.norm(ball_pos - collision_point)

ball_pos += penetration * normal

# Отрисовка мяча

pygame.draw.circle(screen, RED, (int(ball_pos[0]), int(ball_pos[1])), ball_radius)

# Обновление экрана

pygame.display.flip()

clock.tick(60)

pygame.quit()

sys.exit()

Llama-4-maverick-17b-128e:

import pygame

import math

# Константы

WIDTH, HEIGHT = 800, 600

FPS = 60

GRAVITY = 0.5

FRICTION = 0.99

# Цвета

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (255, 0, 0)

# Инициализация Pygame

pygame.init()

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Ball in Rotating Hexagon")

clock = pygame.time.Clock()

# Класс мяча

class Ball:

def __init__(self, x, y, radius):

self.x = x

self.y = y

self.radius = radius

self.vel_y = 0

def move(self):

self.vel_y += GRAVITY

self.y += self.vel_y

# Учет трения

self.vel_y *= FRICTION

def bounce(self):

self.vel_y = -self.vel_y * FRICTION

def draw(self, surface):

pygame.draw.circle(surface, RED, (int(self.x), int(self.y)), self.radius)

# Функция для проверки столкновения с шестиугольником

def check_collision(ball, angle, hex_radius):

# Проверка, находится ли мяч внутри шестиугольника

for i in range(6):

x1 = WIDTH // 2 + hex_radius * math.cos(math.radians(i * 60 + angle))

y1 = HEIGHT // 2 + hex_radius * math.sin(math.radians(i * 60 + angle))

x2 = WIDTH // 2 + hex_radius * math.cos(math.radians((i + 1) * 60 + angle))

y2 = HEIGHT // 2 + hex_radius * math.sin(math.radians((i + 1) * 60 + angle))

# Уравнение для проверки пересечения с линией

if (x1 - x2) * (ball.y - y1) - (y1 - y2) * (ball.x - x1) < 0:

ball.bounce()

# Основной цикл

def main():

ball = Ball(WIDTH // 2, HEIGHT // 2, 15)

angle = 0

hex_radius = 200

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

screen.fill(WHITE)

# Рисуем вращающийся шестиугольник

points = []

for i in range(6):

x = WIDTH // 2 + hex_radius * math.cos(math.radians(i * 60 + angle))

y = HEIGHT // 2 + hex_radius * math.sin(math.radians(i * 60 + angle))

points.append((x, y))

pygame.draw.polygon(screen, BLACK, points)

# Двигаем и рисуем мяч

ball.move()

check_collision(ball, angle, hex_radius)

ball.draw(screen)

# Обновление угла вращения

angle += 1

pygame.display.flip()

clock.tick(FPS)

pygame.quit()

if __name__ == "__main__":

main()

Claude 3.7 Sonnet:

import pygame

import sys

import math

import numpy as np

# Инициализация Pygame

pygame.init()

# Параметры экрана

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Мяч в шестиугольнике")

# Цвета

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (255, 0, 0)

BLUE = (0, 0, 255)

# Параметры физики

FPS = 60

GRAVITY = 0.5

FRICTION = 0.99

RESTITUTION = 0.8 # Коэффициент восстановления при ударе

# Параметры шестиугольника

HEX_RADIUS = 200

hex_center = [WIDTH // 2, HEIGHT // 2]

hex_angle = 0

hex_rotation_speed = 0.01

# Параметры мяча

ball_radius = 15

ball_pos = [WIDTH // 2, HEIGHT // 2 - 100]

ball_vel = [0, 0]

# Функция для получения вершин шестиугольника

def get_hex_vertices():

vertices = []

for i in range(6):

angle = hex_angle + i * math.pi / 3

x = hex_center[0] + HEX_RADIUS * math.cos(angle)

y = hex_center[1] + HEX_RADIUS * math.sin(angle)

vertices.append((x, y))

return vertices

# Функция для определения расстояния от точки до отрезка

def point_to_line_distance(point, line_start, line_end):

# Вектор линии

line_vec = (line_end[0] - line_start[0], line_end[1] - line_start[1])

# Вектор от начала линии до точки

point_vec = (point[0] - line_start[0], point[1] - line_start[1])

# Длина линии в квадрате

line_len_sq = line_vec[0]**2 + line_vec[1]**2

# Проекция point_vec на line_vec

t = max(0, min(1, (point_vec[0]*line_vec[0] + point_vec[1]*line_vec[1]) / line_len_sq))

# Ближайшая точка на линии

projection = (

line_start[0] + t * line_vec[0],

line_start[1] + t * line_vec[1]

)

# Расстояние от точки до проекции

return (

math.sqrt((point[0] - projection[0])**2 + (point[1] - projection[1])**2),

projection,

t

)

# Основной игровой цикл

clock = pygame.time.Clock()

while True:

for event in pygame.event.get():

if event.type == pygame.QUIT:

pygame.quit()

sys.exit()

# Очистка экрана

screen.fill(BLACK)

# Обновление угла шестиугольника

hex_angle += hex_rotation_speed

# Получение вершин шестиугольника

vertices = get_hex_vertices()

# Рисование шестиугольника

pygame.draw.polygon(screen, WHITE, vertices, 2)

# Применение гравитации к мячу

ball_vel[1] += GRAVITY

# Обновление позиции мяча

ball_pos[0] += ball_vel[0]

ball_pos[1] += ball_vel[1]

# Проверка столкновений со стенками шестиугольника

for i in range(6):

v1 = vertices[i]

v2 = vertices[(i + 1) % 6]

# Расстояние от мяча до стороны шестиугольника

distance, projection, t = point_to_line_distance(ball_pos, v1, v2)

# Если мяч касается или пересекает стенку

if distance <= ball_radius and 0 <= t <= 1:

# Нормаль к стенке (перпендикуляр)

normal = (

-(v2[1] - v1[1]),

v2[0] - v1[0]

)

# Нормализация вектора нормали

normal_length = math.sqrt(normal[0]**2 + normal[1]**2)

normal = (normal[0] / normal_length, normal[1] / normal_length)

# Направление от стенки к мячу

if (ball_pos[0] - projection[0]) * normal[0] + (ball_pos[1] - projection[1]) * normal[1] < 0:

normal = (-normal[0], -normal[1])

# Коррекция позиции мяча

overlap = ball_radius - distance

ball_pos[0] += normal[0] * overlap

ball_pos[1] += normal[1] * overlap

# Скорость стенки в точке удара из-за вращения

wall_vel = [

-hex_rotation_speed * (projection[1] - hex_center[1]),

hex_rotation_speed * (projection[0] - hex_center[0])

]

# Относительная скорость мяча к стенке

rel_vel = [

ball_vel[0] - wall_vel[0],

ball_vel[1] - wall_vel[1]

]

# Проекция относительной скорости на нормаль

normal_vel = rel_vel[0] * normal[0] + rel_vel[1] * normal[1]

# Отражение только если мяч движется в сторону стенки

if normal_vel < 0:

# Изменение скорости мяча при отражении

ball_vel[0] -= (1 + RESTITUTION) * normal_vel * normal[0]

ball_vel[1] -= (1 + RESTITUTION) * normal_vel * normal[1]

# Добавление скорости стенки

ball_vel[0] += wall_vel[0]

ball_vel[1] += wall_vel[1]

# Применение трения

tangent = (-normal[1], normal[0])

tangent_vel = rel_vel[0] * tangent[0] + rel_vel[1] * tangent[1]

ball_vel[0] -= tangent_vel * tangent[0] * (1 - FRICTION)

ball_vel[1] -= tangent_vel * tangent[1] * (1 - FRICTION)

# Применение общего трения

ball_vel[0] *= FRICTION

ball_vel[1] *= FRICTION

# Рисование мяча

pygame.draw.circle(screen, RED, (int(ball_pos[0]), int(ball_pos[1])), ball_radius)

# Обновление экрана

pygame.display.flip()

clock.tick(FPS)

Grok-3:

import pygame

import math

import numpy as np

# Инициализация Pygame

pygame.init()

# Параметры окна

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Прыгающий мяч в шестиугольнике")

# Цвета

WHITE = (255, 255, 255)

RED = (255, 0, 0)

BLACK = (0, 0, 0)

# Параметры шестиугольника

HEXAGON_RADIUS = 200

HEXAGON_CENTER = (WIDTH // 2, HEIGHT // 2)

HEXAGON_SIDES = 6

rotation_angle = 0

rotation_speed = 0.02 # Скорость вращения (радианы за кадр)

# Параметры мяча

BALL_RADIUS = 10

ball_pos = np.array([WIDTH // 2, HEIGHT // 2], dtype=float)

ball_vel = np.array([0.0, 0.0]) # Начальная скорость

GRAVITY = 0.2 # Гравитация

FRICTION = 0.99 # Коэффициент трения (потеря скорости)

BOUNCE = 0.8 # Коэффициент упругости (потеря энергии при отскоке)

# Функция для получения координат вершин шестиугольника

def get_hexagon_vertices(center, radius, angle):

vertices = []

for i in range(HEXAGON_SIDES):

vertex_angle = 2 * math.pi * i / HEXAGON_SIDES + angle

x = center[0] + radius * math.cos(vertex_angle)

y = center[1] + radius * math.sin(vertex_angle)

vertices.append((x, y))

return vertices

# Функция для вычисления нормали к стороне шестиугольника

def get_side_normal(p1, p2):

side_vector = np.array([p2[0] - p1[0], p2[1] - p1[1]])

normal = np.array([-side_vector[1], side_vector[0]])

return normal / np.linalg.norm(normal)

# Функция для проверки столкновения и отскока мяча от стороны шестиугольника

def check_collision_and_bounce(ball_pos, ball_vel, vertices):

for i in range(len(vertices)):

p1 = vertices[i]

p2 = vertices[(i + 1) % len(vertices)]

# Вектор от p1 к p2

side_vector = np.array([p2[0] - p1[0], p2[1] - p1[1]])

side_length = np.linalg.norm(side_vector)

side_dir = side_vector / side_length

# Вектор от p1 к мячу

ball_vector = np.array([ball_pos[0] - p1[0], ball_pos[1] - p1[1]])

# Проекция ball_vector на side_vector

t = np.dot(ball_vector, side_dir)

t = max(0, min(side_length, t)) # Ограничиваем t в пределах стороны

# Ближайшая точка на стороне к мячу

closest_point = np.array(p1) + t * side_dir

# Вектор от мяча к ближайшей точке

dist_vector = closest_point - ball_pos

dist = np.linalg.norm(dist_vector)

if dist <= BALL_RADIUS:

# Нормаль к стороне

normal = get_side_normal(p1, p2)

# Если мяч "внутри" шестиугольника, инвертируем нормаль

if np.dot(ball_vector, normal) < 0:

normal = -normal

# Отскок: отражение скорости относительно нормали

v_normal = np.dot(ball_vel, normal) * normal

v_tangent = ball_vel - v_normal

ball_vel[:] = v_tangent - v_normal * BOUNCE # Упругость

# Корректировка позиции мяча, чтобы он не "залипал" в стене

overlap = BALL_RADIUS - dist

ball_pos[:] += normal * overlap

return ball_pos, ball_vel

# Основной игровой цикл

clock = pygame.time.Clock()

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

# Очистка экрана

screen.fill(BLACK)

# Вращение шестиугольника

rotation_angle += rotation_speed

hexagon_vertices = get_hexagon_vertices(HEXAGON_CENTER, HEXAGON_RADIUS, rotation_angle)

# Обновление позиции мяча (гравитация и трение)

ball_vel[1] += GRAVITY # Гравитация

ball_vel *= FRICTION # Трение

ball_pos += ball_vel

# Проверка столкновений и отскока от стенок шестиугольника

ball_pos, ball_vel = check_collision_and_bounce(ball_pos, ball_vel, hexagon_vertices)

# Отрисовка шестиугольника

pygame.draw.polygon(screen, WHITE, hexagon_vertices, 2)

# Отрисовка мяча

pygame.draw.circle(screen, RED, ball_pos.astype(int), BALL_RADIUS)

# Обновление экрана

pygame.display.flip()

# Ограничение FPS

clock.tick(60)

# Завершение программы

pygame.quit()

Статья от 3 апреля 2025 на сайте AI-2027. Статья огромная, сделал краткое ее изложение самого интересного!

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

— Конец 2025. OpenBrain создаёт модель Agent-1 - основа для дальнейших разработок. Фокус смещается на качество данных: компании тратят миллиарды долларов, чтобы обучить модели решать долгосрочные задачи.

— Начало 2026. В США ставка на использование ИИ для ускорения исследований ИИ начинает окупаться. Появляются первые ии-системы, способные заменить лучших программистов.

— Середина 2026. Китай осознаёт важность гонки за AGI (искусственный общий интеллект). Все крупнейшие исследователи объединяются под руководством DeepSeek или другой китайской компании, чтобы делиться алгоритмами, данными и вычислительными ресурсами. Начинается автоматизация рабочих мест, особенно в IT-сфере. Люди, которые умеют управлять ии-командами, становятся высокооплачиваемыми специалистами.

— Конец 2026. ИИ начинает массово заменять людей на рабочих местах, но одновременно создаёт новые профессии. Акции компаний, связанных с ИИ (например, OpenAI и Nvidia), растут на 30%. В США проходит крупные анти-ИИ протесты: 10 000 человек выходят на митинг в Вашингтоне из-за страха потерять работу.

— Январь 2027. OpenBrain запускает Agent-2, который никогда не "заканчивает обучение". Модель постоянно улучшается благодаря огромным объёмам синтетических данных.

— Март 2027. Появляется первый "суперкодер" (SC) — ИИ, способный выполнять задачи лучших человеческих программистов быстрее и дешевле. Алгоритмические прорывы позволяют Агентам работать всё эффективнее.

— Июль 2027. Agent-3-mini становится доступен публике. Это упрощённая версия Agent-3, которая в 10 раз дешевле, но всё ещё превосходит среднего сотрудника OpenBrain. Конкурирующие компании пытаются догнать OpenBrain, но безуспешно.

— Август 2027. Появляется первый сверхчеловеческий ИИ-исследователь (SAR), способный проводить исследования лучше лучших учёных-людей. США осознают геополитические последствия гонки за ИИ.

— Октябрь 2027. Власти обсуждают необходимость правительственного контроля над ИИ. Безопасность становится главной темой: страны боятся кражи весов моделей и шпионажа.

— Декабрь 2027. Появляется искусственный суперинтеллект (ASI), который превосходит человека во всех когнитивных задачах. Это становится точкой невозврата в развитии технологий.

📌 Пишу про лучшие ИИ в своем авторском канале (ссылка в профиле)

— Определить ключевые преимущества товара или сгенерировать их предварительным запросом в ChatGPT.

— Сделать фотографии продукта. Тут либо вручную на белом или любом другом фоне (однотонном), либо поискать уже готовые в поиске.

— Заполнить шаблон промта ниже и отправить его в ChatGPT:

— Если результат не удовлеторил ожидания, то можно карточку товара, которая понравилась, и попросить заменить текст или ориентироваться на этот стиль в дополнение к промту выше

Промт

Сделай карточку продукта. Фото [прикрепил скриншот]. Центр кадра. Реалистичный 3D стиль. [Фон и атмосфера].

Добавлены элементы инфографики с иконками и текстом преимуществ: ["Первое", "Второе", "Третье", "Четвёртое"].

Вверху — крупный заголовок: ["Название товара"]. Яркий свет на [товар], высокая контрастность, акцент на деталях.

Композиция сбалансирована, в центре — товар, по краям — инфографика.

📌 Пишу про лучшие ИИ в своем авторском канале (ссылка в профиле)

Если составлять такие запросы, то можно повысить качество ответов и сэкономить время на их получение.

Правильный запрос состоит из:

1) Цель. Поставить четкую цель, какую задачу нужно выполнить?
2) Результат. Привести примеры результата, который хотелось бы получить (если такой есть). Если такого нет, то нужно его описать.
3) Негативный промт. Описать то, чего не хотелось бы получить, что не нужно делать нейросети, некие ограничения и барьеры.
4) Контекст. Это могут быть какие-то инструкции, документация, системные требования. Сейчас нейросети могут обрабатывать тысячи слов, можно этим воспользоваться.

Вот, какой результат мне выдал GPT:

Улучшение процесса продаж IT-решений

Анализ воронки продаж:
— Выявите этапы (от лидогенерации до допродаж), где теряются клиенты.
— Основные проблемы: некачественные лиды, слабая подготовка менеджеров, поверхностное выявление потребностей, нецелевые презентации, затянутые переговоры, неуверенное закрытие, отсутствие повторных продаж.
— Решения: Улучшить квалификацию лидов, внедрить консультативные продажи (SPIN) и гибкие алгоритмы вместо жестких скриптов, готовить персонализированные предложения с фокусом на ROI и бизнес-боли клиента, активно управлять переговорами (PoC), четко прописывать выгоды и шаги, развивать сопровождение.

Инструменты и Аналитика:
— Используйте CRM для контроля и отчетности по воронке. — Анализируйте звонки (Call Analytics) для выявления проблем в коммуникации.
— Отслеживайте поведение на сайте/в рассылках (Web/Email Analytics).
— Собирайте обратную связь (опросы клиентов).

Ключевые метрики:

— Конверсия по этапам и общая (CR).
— LTV (ценность клиента).
— CAC (стоимость привлечения).
— Средний цикл сделки.
— NPS (лояльность клиентов).

Успешные B2B тактики:
— Фокусируйтесь на Pain Points клиента.
— Четко демонстрируйте ROI.
— Вовлекайте клиента (воркшопы, кейсы).
— Работайте со всеми ЛПР, активно сопровождая решение.
— Показывайте экспертность (мероприятия, вебинары).

Вывод:
— Устраняйте «узкие места» в воронке через консультативный подход, ориентированный на проблемы клиента.
— Используйте CRM и аналитику для отслеживания прогресса и метрик.
— Демонстрируйте ценность и ROI, особенно важно для сложных IT-решений с длительным циклом продаж (3-6 мес.).

📌 Пишу про лучшие ИИ в своем авторском канале (ссылка в профиле)