எளிமையாப் புரிஞ்சுக்கலாம்

Reinforcement Learning-ல் agent ஒரு environment-க்குள் செயல் செய்யும். என்ன நிலை என்று observation கிடைக்கும்; என்ன செயல் செய்யணும்னு policy முடிவு செய்யும்; பிறகு reward கிடைக்கும். உடனே கிடைக்கும் reward மட்டும் இல்லாமல், தொடர்ந்து கிடைக்கும் மொத்த reward-ஐ மேம்படுத்த முயற்சி செய்யும். புதுசா முயற்சி செய்வதும், தெரிந்த நல்ல செயலைச் செய்வதும் balance ஆக வேண்டும். Reward-ஐ நாம்தான் வடிவமைக்கிறோம். அதனால் reward அதிகம் வந்தாலே நாம் நினைத்த நடத்தை கிடைத்துவிட்டது என்று சொல்ல முடியாது.

இந்த AI approach எப்படி வேலை செய்கிறது?

Reinforcement Learning-ல் தொடர்ச்சியான decisions முக்கியம். Agent தற்போதைய நிலையைப் பார்க்கும், action தேர்வு செய்யும், reward கிடைக்கும், அடுத்த நிலைக்குச் செல்லும். எந்த நிலையில் எந்த action எடுக்கலாம் என்று முடிவு செய்யும் முறையை policy என்போம். உடனே கிடைக்கும் reward மட்டும் இல்லாமல், எதிர்கால rewards சேர்த்த return-ஐ அதிகப்படுத்த முயற்சி செய்வோம். தூரத்தில் வரும் reward-க்கு குறைந்த weight கொடுக்க discount factor பயன்படுத்தலாம்.

இதைக் காட்ட Markov Decision Process என்ற model உதவும். States, actions, transitions, rewards, discount factor இதில் இருக்கும். அடுத்த state பற்றி கணிக்கத் தேவையான தகவல் தற்போதைய state-ல் இருக்கணும். Agent-க்கு முழுத் தகவல் தெரியவில்லை என்றால் memory அல்லது மறைந்த நிலையைப் பற்றிய belief தேவைப்படலாம். இது labels உள்ள spreadsheet-ஐ predict செய்வது மட்டும் இல்லை.

Value-based methods ஒரு state அல்லது state-action எவ்வளவு நல்லது என்று estimate செய்யும். Q-learning-ல் reward மற்றும் அடுத்த state-ஓட சிறந்த estimated value வைத்து Q-value update செய்வோம். Policy-gradient முறைகள் policy-ஐ நேரடியாக மாற்றும். Actor–critic-ல் policy, value இரண்டும் கற்றுக்கொள்ளும். Model-based முறைகள் environment transition model வைத்து planning செய்யும். ஒவ்வொன்றுக்கும் data efficiency, stability, compute trade-offs இருக்கும்.

இதுவரை போதுமான அளவு முயற்சி செய்யாத actions-ஐ முயன்று தகவல் பெறுவது exploration. இப்போது சிறந்ததாகத் தெரியும் action-ஐப் பயன்படுத்துவது exploitation. நிஜ உலகில் exploration பாதிப்பை ஏற்படுத்தலாம்; அதனால் பொருத்தமான simulator அல்லது controlled சூழலில் தொடங்கணும். Reward தவறாக இருந்தால், நாம விரும்பிய வேலையைச் செய்யாமல் points வாங்கும் shortcut-ஐ agent கற்றுக்கொள்ளலாம்.

ஒவ்வொரு படியாகப் பார்க்கலாம்

1. Actions, observations, rewards, எப்போது நிறுத்தணும்—முதலில் வரையறுக்கலாம்.
2. புதிய action-ஐ முயற்சி செய்வதும், ஏற்கனவே தெரிந்த action-ஐ செய்வதும் வேறு என்பதைப் புரிஞ்சுக்கலாம்.
3. Reward அதிகரிக்க ஒரு shortcut எடுத்தால் உண்மையான நோக்கம் தவறிப்போகுதா என்று சோதிக்கணும்.

உதாரணம்: task-உடன் approach-ஐ இணைக்கலாம்

ஒரு சின்ன grid-ல் robot charging station சென்றால் reward; ஒவ்வொரு step-க்கும் penalty என்று வைத்துக்கலாம். அருகில் கிடைக்கும் சின்ன reward-ஐவிட, சில steps எடுத்துப் பெரிய terminal reward அடைவது நல்லதாக இருக்கலாம். அனுபவித்த transitions வழியாக அந்த future benefit-ஐ Q-values முந்தைய states-க்கும் பரப்பும்.

கீழே சின்ன deterministic line world-ல் tabular Q-learning policy train செய்கிறோம். States தெரியும்; பாதுகாப்பாக reset செய்யலாம். நிஜ robot-ல் முழுமையற்ற observations, uncertainty, தவறுகளின் செலவு, simulation-லிருந்து real world-க்கு மாற்றம் போன்ற சிக்கல்கள் அதிகம்.

Algorithm பயிற்சி: கணிச்சு, மாற்றி, விளக்கலாம்

சின்ன line world-ல் Q-learning agent கற்றுக்கொள்ளும். Gamma-வை 0-ஆக மாற்றி greedy path பாருங்க. Immediate reward மட்டும் பார்த்தால் தூரத்தில் இருக்கும் goal benefit முந்தைய states-க்கு பரவாது. Step limit முடிவில்லாத loop-ஐத் தடுக்கும்.

import random
random.seed(7)

# States 0..4; 4 is terminal. Actions: -1 left, +1 right.
q = [[0.0, 0.0] for _ in range(5)]
actions = [-1, 1]
alpha, gamma, epsilon = 0.3, 0.9, 0.3
for episode in range(400):
    state = 0
    for step in range(50):
        action = (random.randrange(2) if random.random() < epsilon
                  else max(range(2), key=lambda a: q[state][a]))
        next_state = max(0, min(4, state + actions[action]))
        terminal = next_state == 4
        reward = 1.0 if terminal else -0.05
        target = reward + (0.0 if terminal else gamma * max(q[next_state]))
        q[state][action] += alpha * (target - q[state][action])
        state = next_state
        if terminal:
            break
state, path = 0, [0]
for _ in range(10):
    action = max(range(2), key=lambda a: q[state][a])
    state = max(0, min(4, state + actions[action]))
    path.append(state)
    if state == 4:
        break
print("greedy path:", path)
print("reached goal:", state == 4)

greedy path: [0, 1, 2, 3, 4]
reached goal: True

ஒரு விஷயத்தை மாற்றி இயக்கிப் பாருங்க.

இந்தப் பயிற்சிக்கு standard Python போதும். Package install அல்லது paid API தேவையில்லை. மேலே சொன்ன variable-ஐ மாற்றி, method-ல் என்ன விளைவு வருகிறது என்று விளக்கிப் பாருங்க. பிறகுதான் real data-க்கு எடுத்துச் செல்லலாம்.

Editor முழுவதும் load ஆனதும் code-ஐ ஏற்றி Run அழுத்துங்க.

இந்த இலவச editor, OneCompiler என்ற வெளிப்புறச் சேவையைப் பயன்படுத்தும். Run செய்யும் code அங்கு அனுப்பப்படும். Passwords, API keys, மாணவர்களின் private data போன்றவற்றைப் போடாதீங்க. Code வரவில்லை என்றால் editor தயாரானதும் மறுபடியும் ஏற்றுங்க.

கருத்தைப் பயன்படுத்தலாம்: உங்க புரிதலைச் சோதிங்க

அடுத்த பாடத்துக்கு முன்னாடி

• Technical பெயரை மட்டும் சொல்லாமல், கருத்தை உங்க வார்த்தைகளில் விளக்கிப் பாருங்க.
• Approach என்ன, அதன் assumptions என்ன, result-ஐ நம்ப என்ன evidence வேண்டும் என்று சொல்லிப் பாருங்க.
• பயிற்சியை முயற்சி செய்துவிட்டு, உங்க காரணத்தை விடையோடு ஒப்பிட்டுப் பாருங்க.

ஆதாரங்கள்: இன்னும் தெரிஞ்சுக்கலாம்

இந்தப் புதுப்பிப்பில் original research papers மற்றும் official documentation பயன்படுத்தப்பட்டுள்ளன. கீழே உள்ள கூடுதல் links ஆங்கிலத்தில் இருக்கும். அவற்றை முதலில் படிக்காமலேயே இந்தப் பாடத்தைப் புரிஞ்சுக்கலாம். Product versions, availability மாறலாம்.

• UC Berkeley CS 188: AI foundations ↗
• Spinning Up: reinforcement-learning concepts ↗