AI agenti v Pythonu — jak začít

Umělá inteligence (AI) a agentní systémy se stávají stále důležitějšími nástroji v programování, a Python je jedním z nejpopulárnějších jazyků pro jejich vývoj. V tomto článku se podíváme na to, jak začít s AI agenty v Pythonu, jaké knihovny a nástroje použít a vytvoříme jednoduchého agenta, který provádí konkrétní úkol.

Co je AI agent?

AI agent je program, který může autonomně jednat a reagovat na prostředí kolem sebe. Může to být například chatovací bot, který odpovídá na otázky uživatelů, nebo systém, který automatizuje obchodování na burze. Klíčovým prvkem agentů je schopnost učit se z dat a přizpůsobovat se změnám v prostředí.

Proč použít Python?

Python je skvělým jazykem pro vývoj AI agentů z několika důvodů:

• Jednoduchost a čitelnost: Python má jednoduchou syntaxi, která usnadňuje psaní a čtení kódu.
• Bohatá ekosystém knihoven: Existuje mnoho knihoven pro strojové učení a AI, jako jsou TensorFlow, PyTorch, a scikit-learn.
• Komunita a podpora: Python má velkou komunitu, což znamená, že najdete spoustu příkladů a zdrojů.

Základní komponenty AI agenta

Než se ponoříme do kódu, je třeba pochopit několik základních komponentů AI agenta:

1. Senzory: Senzory jsou vstupy, které agentovi umožňují vnímat své prostředí.
2. Akční mechanismy: Tyto mechanismy určují, jak agent reaguje na podněty z prostředí.
3. Učení: Agent by měl mít schopnost se učit z předchozích zkušeností a upravovat své chování.

Instalace potřebných knihoven

Nejprve si nainstalujeme potřebné knihovny. V našem příkladu použijeme numpy pro matematické operace a random pro generování náhodných čísel. Pokud ještě nemáte numpy, můžete ho nainstalovat pomocí pip:

pip install numpy

Vytvoření jednoduchého AI agenta

Nyní si vytvoříme jednoduchého AI agenta, který se bude učit, jak se vyhýbat překážkám v prostředí. Agent bude mít schopnost se pohybovat nahoru, dolů, vlevo a vpravo. Naší úlohou bude naprogramovat agenta, který se vyhýbá náhodně umístěným překážkám.

Kód agenta

Zde je jednoduchý příklad agenta:

import numpy as np
import random

class Agent:
    def __init__(self, size):
        self.size = size
        self.position = [random.randint(0, size - 1), random.randint(0, size - 1)]
        self.environment = np.zeros((size, size))

    def sense_environment(self):
        return self.environment

    def move(self, direction):
        if direction == 'up' and self.position[0] > 0:
            self.position[0] -= 1
        elif direction == 'down' and self.position[0] < self.size - 1:
            self.position[0] += 1
        elif direction == 'left' and self.position[1] > 0:
            self.position[1] -= 1
        elif direction == 'right' and self.position[1] < self.size - 1:
            self.position[1] += 1

    def update_environment(self, obstacles):
        for obs in obstacles:
            self.environment[obs[0]][obs[1]] = 1  # označíme překážku

    def choose_action(self):
        actions = ['up', 'down', 'left', 'right']
        return random.choice(actions)

    def step(self, obstacles):
        self.update_environment(obstacles)
        action = self.choose_action()
        self.move(action)

# Vytvoření agenta s prostředím 5x5
agent = Agent(size=5)

# Umístění překážek
obstacles = [(1, 1), (2, 2), (3, 3)]

# Simulace několika kroků agenta
for _ in range(10):
    agent.step(obstacles)
    print(f"Aktuální pozice agenta: {agent.position}")

Vysvětlení kódu

1. Inicializace: V konstruktoru třídy Agent inicializujeme velikost prostředí a náhodně umístíme agenta.
2. Senzory: Metoda sense_environment vrací aktuální stav prostředí. V tomto jednoduchém příkladu však agent nevyužívá senzorické informace.
3. Pohyb: Metoda move umožňuje agentovi se pohybovat v těchto čtyřech směrech, přičemž kontroluje, zda se agent nachází uvnitř hranic prostředí.
4. Aktualizace prostředí: Metoda update_environment aktualizuje prostředí podle umístění překážek.
5. Výběr akce: Metoda choose_action náhodně vybírá akci pro agenta.
6. Krok: Metoda step kombinuje aktualizaci prostředí a pohyb agenta.

Zlepšení agenta

V současné podobě agent jedná náhodně a nemá žádnou strategii, jak se vyhnout překážkám. Můžeme implementovat jednoduchou logiku, která mu pomůže vyhnout se překážkám. Například, pokud agent zjistí, že se blíží k překážce, může se pokusit změnit směr.

Příklad logiky pro vyhýbání se překážkám

Můžeme upravit metodu choose_action, aby agent vybíral akce na základě aktuální pozice a okolí:

def choose_action(self, obstacles):
    # Získání pozice agenta
    x, y = self.position
    possible_actions = []

    # Kontrola dostupných pohybů
    if x > 0 and (x-1, y) not in obstacles:  # nahoru
        possible_actions.append('up')
    if x < self.size - 1 and (x+1, y) not in obstacles:  # dolů
        possible_actions.append('down')
    if y > 0 and (x, y-1) not in obstacles:  # vlevo
        possible_actions.append('left')
    if y < self.size - 1 and (x, y+1) not in obstacles:  # vpravo
        possible_actions.append('right')

    return random.choice(possible_actions) if possible_actions else None

Závěr

V tomto článku jsme se podívali na základy tvorby AI agentů v Pythonu. Vytvořili jsme jednoduchého agenta, který se učil vyhýbat překážkám v prostředí. Tato ukázka je jen začátkem – agenti mohou být mnohem složitější a mohou využívat pokročilé algoritmy strojového učení.

Pokud se chcete dozvědět více, doporučuji prozkoumat knihovny jako TensorFlow nebo PyTorch, které vám umožní implementovat složitější modely. V budoucnu se podíváme na to, jak využívat tyto knihovny k vytváření sofistikovanějších AI agentů.