Python Academy · Lekcja

Implementacja tabeli Q w Pythonie

Prosty przykład uczenia Q

Implementacja tabeli Q w Pythonie to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 3 z 5. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 5 lekcji w sumie.

Implementowanie Q-Learning w Pythonie

W tej lekcji zaimplementujemy w Pythonie prosty algorytm Q-Learning. Agent nauczy się poruszać po świecie reprezentowanym przez siatkę, aby maksymalizować uzyskiwane nagrody.

Implementacja tabeli Q w Pythonie — ilustracja 1

Definiowanie środowiska

Definiujemy prosty świat w postaci siatki 4×4, w którym agent rozpoczyna działanie w lewym górnym rogu i musi dotrzeć do prawego dolnego rogu, aby otrzymać nagrodę.

import numpy as np

# Define the environment
num_states = 16  # 4x4 grid
num_actions = 4  # Up, Down, Left, Right

# Define rewards (-1 for each step, +10 for the goal)
rewards = np.zeros(num_states)
rewards[-1] = 10

Inicjalizowanie tablicy Q

Tablica Q jest inicjalizowana zerami dla wszystkich par stan-akcja.

# Initialize the Q-Table
q_table = np.zeros((num_states, num_actions))

print("Initial Q-Table:")
print(q_table)

Implementowanie algorytmu Q-Learning

Używamy następujących parametrów:

α (współczynnik uczenia): Określa, w jakim stopniu nowe informacje zastępują stare.
γ (współczynnik dyskontowania): Określa znaczenie przyszłych nagród w porównaniu z nagrodami natychmiastowymi.
ε (współczynnik eksploracji): Równoważy eksplorację i wykorzystywanie zdobytej wiedzy.

# Parameters
alpha = 0.1  # Learning rate
gamma = 0.9  # Discount factor
epsilon = 0.1  # Exploration rate

# Q-Learning loop
num_episodes = 1000
for episode in range(num_episodes):
    state = 0  # Start at the first state
    done = False
    while not done:
        # Exploration or exploitation
        if np.random.rand() < epsilon:
            action = np.random.randint(num_actions)  # Explore
        else:
            action = np.argmax(q_table[state])  # Exploit

        # Transition to the next state
        next_state = (state + action) % num_states  # Simplified transition logic
        reward = rewards[next_state]

        # Update Q-value
        q_table[state, action] = q_table[state, action] + alpha * (
            reward + gamma * np.max(q_table[next_state]) - q_table[state, action]
        )

        # Move to the next state
        state = next_state
        done = state == num_states - 1

Ocena wyuczonej polityki

Po zakończeniu uczenia oceniamy politykę, wykonując optymalne akcje zapisane w tablicy Q:

# Evaluate the policy
state = 0
optimal_path = [state]
while state != num_states - 1:
    action = np.argmax(q_table[state])
    state = (state + action) % num_states  # Simplified transition logic
    optimal_path.append(state)

print("Optimal Path:", optimal_path)

Wizualizacja tablicy Q

Możemy zwizualizować tablicę Q, aby zrozumieć wyuczone wartości dla każdej pary stan-akcja:

import matplotlib.pyplot as plt
import seaborn as sns

# Visualize Q-Table
plt.figure(figsize=(10, 8))
sns.heatmap(q_table, annot=True, fmt=".2f", cmap="coolwarm")
plt.title("Q-Table Heatmap")
plt.xlabel("Actions")
plt.ylabel("States")
plt.show()

Zalety Q-Learning

Q-Learning oferuje kilka korzyści:

Jest prosty i łatwy do zaimplementowania.
Może obsługiwać środowiska stochastyczne.
Przy wystarczającej eksploracji zbiega do optymalnej polityki.

Ograniczenia Q-Learning

Q-Learning ma pewne ograniczenia:

Nie skaluje się dobrze w środowiskach z dużymi przestrzeniami stanów i akcji.
Uczenie może przebiegać powoli w złożonych środowiskach.
Wymaga dobrze zdefiniowanej reprezentacji stanów i akcji.

Podsumowanie i kolejne kroki

W tej lekcji:

Zaimplementowaliśmy w Pythonie prosty algorytm Q-Learning.
Wytrenowaliśmy agenta, aby poruszał się po świecie reprezentowanym przez siatkę, korzystając z tablicy Q.
Oceniliśmy wyuczoną politykę i zwizualizowaliśmy tablicę Q.

Następnie omówimy Deep Q-Learning, który wykorzystuje sieci neuronowe do obsługi środowisk z dużymi przestrzeniami stanów i akcji.

Implementacja tabeli Q w Pythonie — ilustracja 10

Często zadawane pytania

Czy lekcja „Implementacja tabeli Q w Pythonie” jest bezpłatna?

Tak — pełny tekst „Implementacja tabeli Q w Pythonie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 5 lekcji w sumie.

Co nauczysz się w „Implementacja tabeli Q w Pythonie”?

Prosty przykład uczenia Q Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 5.

Ile czasu zajmuje lekcja „Implementacja tabeli Q w Pythonie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Podstawowe koncepcje uczenia ze wzmocnieniem
Koncepcja tabeli Q
Implementacja tabeli Q w Pythonie
Głębokie uczenie Q
Poznajemy OpenAI Gym

← Powrót do Python Academy