History

leestott f915efe2b4 🌐 Update translations via Co-op Translator		2 weeks ago
..
solution	🌐 Update translations via Co-op Translator	3 weeks ago
README.md	🌐 Update translations via Co-op Translator	2 weeks ago
assignment.md	🌐 Update translations via Co-op Translator	3 weeks ago
notebook.ipynb	🌐 Update translations via Co-op Translator	3 weeks ago

README.md

ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ ਅਤੇ ਕਿਊ-ਲਰਨਿੰਗ ਦਾ ਪਰਚੇ

ਸਕੈਚਨੋਟ Tomomi Imura ਵੱਲੋਂ

ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ ਵਿੱਚ ਤਿੰਨ ਮਹੱਤਵਪੂਰਨ ਧਾਰਨਾਵਾਂ ਸ਼ਾਮਲ ਹਨ: ਏਜੰਟ, ਕੁਝ ਸਥਿਤੀਆਂ, ਅਤੇ ਹਰ ਸਥਿਤੀ ਲਈ ਕਾਰਵਾਈਆਂ ਦਾ ਸੈੱਟ। ਨਿਰਧਾਰਤ ਸਥਿਤੀ ਵਿੱਚ ਕਾਰਵਾਈ ਕਰਨ ਨਾਲ, ਏਜੰਟ ਨੂੰ ਇਨਾਮ ਮਿਲਦਾ ਹੈ। ਇੱਕ ਵਾਰ ਫਿਰ ਕੰਪਿਊਟਰ ਗੇਮ "ਸੁਪਰ ਮਾਰੀਓ" ਦੀ ਕਲਪਨਾ ਕਰੋ। ਤੁਸੀਂ ਮਾਰੀਓ ਹੋ, ਤੁਸੀਂ ਇੱਕ ਗੇਮ ਲੈਵਲ ਵਿੱਚ ਹੋ, ਇੱਕ ਚਟਾਨ ਦੇ ਕਿਨਾਰੇ ਦੇ ਕੋਲ ਖੜੇ ਹੋ। ਤੁਹਾਡੇ ਉੱਪਰ ਇੱਕ ਸਿੱਕਾ ਹੈ। ਤੁਸੀਂ ਮਾਰੀਓ ਹੋ, ਇੱਕ ਗੇਮ ਲੈਵਲ ਵਿੱਚ, ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸਥਿਤੀ ਵਿੱਚ ... ਇਹ ਤੁਹਾਡੀ ਸਥਿਤੀ ਹੈ। ਸੱਜੇ ਪਾਸੇ ਇੱਕ ਕਦਮ ਚਲਣਾ (ਇੱਕ ਕਾਰਵਾਈ) ਤੁਹਾਨੂੰ ਕਿਨਾਰੇ ਤੋਂ ਪਾਰ ਲੈ ਜਾਵੇਗਾ, ਅਤੇ ਇਹ ਤੁਹਾਨੂੰ ਘੱਟ ਅੰਕ ਦੇ ਸਕੋਰ ਦੇਵੇਗਾ। ਹਾਲਾਂਕਿ, ਜੰਪ ਬਟਨ ਦਬਾਉਣ ਨਾਲ ਤੁਹਾਨੂੰ ਇੱਕ ਅੰਕ ਮਿਲੇਗਾ ਅਤੇ ਤੁਸੀਂ ਜਿਊਂਦੇ ਰਹੋਗੇ। ਇਹ ਇੱਕ ਸਕਾਰਾਤਮਕ ਨਤੀਜਾ ਹੈ ਅਤੇ ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਇੱਕ ਸਕਾਰਾਤਮਕ ਅੰਕ ਦੇ ਸਕੋਰ ਮਿਲਣਾ ਚਾਹੀਦਾ ਹੈ।

ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ ਅਤੇ ਸਿਮੂਲੇਟਰ (ਗੇਮ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਗੇਮ ਖੇਡਣ ਦਾ ਤਰੀਕਾ ਸਿੱਖ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਇਨਾਮ ਵਧਾਇਆ ਜਾ ਸਕੇ, ਜੋ ਕਿ ਜਿਊਂਦੇ ਰਹਿਣਾ ਅਤੇ ਜਿੰਨੇ ਅੰਕ ਸੰਭਵ ਹੋ ਸਕਦੇ ਹਨ, ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ।

🎥 ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਤਾਂ ਜੋ ਦਿਮਿਤਰੀ ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ ਬਾਰੇ ਗੱਲ ਕਰ ਸਕੇ

ਪ੍ਰੀ-ਲੈਕਚਰ ਕਵਿਜ਼

ਪੂਰਵ ਸ਼ਰਤਾਂ ਅਤੇ ਸੈਟਅਪ

ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਪਾਇਥਨ ਵਿੱਚ ਕੁਝ ਕੋਡ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ। ਤੁਹਾਨੂੰ ਇਹ ਪਾਠ ਵਿੱਚ ਦਿੱਤੇ ਜੂਪਿਟਰ ਨੋਟਬੁੱਕ ਕੋਡ ਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ ਜਾਂ ਕਲਾਉਡ ਵਿੱਚ ਕਿਤੇ ਵੀ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਤੁਸੀਂ ਪਾਠ ਨੋਟਬੁੱਕ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਪਾਠ ਨੂੰ ਬਣਾਉਣ ਲਈ ਚਲ ਸਕਦੇ ਹੋ।

ਨੋਟ: ਜੇ ਤੁਸੀਂ ਇਹ ਕੋਡ ਕਲਾਉਡ ਤੋਂ ਖੋਲ੍ਹ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ rlboard.py ਫਾਈਲ ਵੀ ਲੈਣੀ ਪਵੇਗੀ, ਜੋ ਕਿ ਨੋਟਬੁੱਕ ਕੋਡ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇਸਨੂੰ ਨੋਟਬੁੱਕ ਵਾਲੇ ਹੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ।

ਪਰਚੇ

ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ Peter and the Wolf ਦੀ ਦੁਨੀਆ ਦੀ ਖੋਜ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਜੋ ਕਿ ਰੂਸੀ ਸੰਗੀਤਕਾਰ Sergei Prokofiev ਦੁਆਰਾ ਇੱਕ ਸੰਗੀਤਕ ਪਰੀਆਂ ਕਹਾਣੀ ਤੋਂ ਪ੍ਰੇਰਿਤ ਹੈ। ਅਸੀਂ ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੀਟਰ ਨੂੰ ਉਸਦੇ ਵਾਤਾਵਰਣ ਦੀ ਖੋਜ ਕਰਨ, ਸੁਆਦਿਸ਼ਟ ਸੇਬ ਇਕੱਠੇ ਕਰਨ ਅਤੇ ਭੇੜੇ ਨਾਲ ਮਿਲਣ ਤੋਂ ਬਚਾਉਣ ਦੇ ਯੋਗ ਬਣਾਉਣ ਜਾ ਰਹੇ ਹਾਂ।

ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ (RL) ਇੱਕ ਸਿੱਖਣ ਦੀ ਤਕਨੀਕ ਹੈ ਜੋ ਸਾਨੂੰ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰਯੋਗ ਚਲਾਉਣ ਦੁਆਰਾ ਕਿਸੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇੱਕ ਏਜੰਟ ਦੇ ਅਨੁਕੂਲ ਵਿਹਾਰ ਸਿੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇੱਕ ਏਜੰਟ ਦਾ ਕੁਝ ਲਕਸ਼ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਇਨਾਮ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਵਾਤਾਵਰਣ

ਸਰਲਤਾ ਲਈ, ਆਓ ਪੀਟਰ ਦੀ ਦੁਨੀਆ ਨੂੰ width x height ਦੇ ਆਕਾਰ ਦੇ ਇੱਕ ਵਰਗ ਬੋਰਡ ਵਜੋਂ ਮੰਨ ਲਵਾਂ, ਇਸ ਤਰ੍ਹਾਂ:

ਇਸ ਬੋਰਡ ਵਿੱਚ ਹਰ ਸੈੱਲ:

ਜ਼ਮੀਨ, ਜਿਸ 'ਤੇ ਪੀਟਰ ਅਤੇ ਹੋਰ ਜੀਵ ਚੱਲ ਸਕਦੇ ਹਨ।
ਪਾਣੀ, ਜਿਸ 'ਤੇ ਤੁਸੀਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਨਹੀਂ ਚੱਲ ਸਕਦੇ।
ਇੱਕ ਵ੍ਰਿਕਸ਼ ਜਾਂ ਘਾਹ, ਇੱਕ ਜਗ੍ਹਾ ਜਿੱਥੇ ਤੁਸੀਂ ਅਰਾਮ ਕਰ ਸਕਦੇ ਹੋ।
ਇੱਕ ਸੇਬ, ਜੋ ਕਿ ਪੀਟਰ ਨੂੰ ਆਪਣੇ ਆਪ ਨੂੰ ਖੁਸ਼ ਕਰਨ ਲਈ ਮਿਲਣ ਦੀ ਖੁਸ਼ੀ ਹੋਵੇਗੀ।
ਇੱਕ ਭੇੜਾ, ਜੋ ਕਿ ਖਤਰਨਾਕ ਹੈ ਅਤੇ ਇਸ ਤੋਂ ਬਚਣਾ ਚਾਹੀਦਾ ਹੈ।

ਇੱਕ ਵੱਖਰਾ ਪਾਇਥਨ ਮੋਡਿਊਲ, rlboard.py, ਇਸ ਵਾਤਾਵਰਣ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕੋਡ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ। ਕਿਉਂਕਿ ਇਹ ਕੋਡ ਸਾਡੇ ਧਾਰਨਾਵਾਂ ਨੂੰ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ, ਅਸੀਂ ਮੋਡਿਊਲ ਨੂੰ ਇੰਪੋਰਟ ਕਰਕੇ ਨਮੂਨਾ ਬੋਰਡ ਬਣਾਉਣ ਲਈ ਵਰਤਾਂਗੇ (ਕੋਡ ਬਲਾਕ 1):

from rlboard import *

width, height = 8,8
m = Board(width,height)
m.randomize(seed=13)
m.plot()

ਇਹ ਕੋਡ ਉੱਪਰ ਦਿੱਤੇ ਵਾਤਾਵਰਣ ਦੇ ਸਮਾਨ ਇੱਕ ਤਸਵੀਰ ਪ੍ਰਿੰਟ ਕਰੇਗਾ।

ਕਾਰਵਾਈਆਂ ਅਤੇ ਨੀਤੀ

ਸਾਡੇ ਉਦਾਹਰਨ ਵਿੱਚ, ਪੀਟਰ ਦਾ ਲਕਸ਼ ਸੇਬ ਲੱਭਣਾ ਹੋਵੇਗਾ, ਜਦੋਂ ਕਿ ਭੇੜੇ ਅਤੇ ਹੋਰ ਰੁਕਾਵਟਾਂ ਤੋਂ ਬਚਣਾ। ਇਹ ਕਰਨ ਲਈ, ਉਹ ਅਸਲ ਵਿੱਚ ਸੇਬ ਲੱਭਣ ਤੱਕ ਚੱਲ ਸਕਦਾ ਹੈ।

ਇਸ ਲਈ, ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਉਹ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਕਾਰਵਾਈਆਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣ ਸਕਦਾ ਹੈ: ਉੱਪਰ, ਹੇਠਾਂ, ਖੱਬੇ ਅਤੇ ਸੱਜੇ।

ਅਸੀਂ ਉਹਨਾਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸੰਬੰਧਿਤ ਕੋਆਰਡੀਨੇਟ ਬਦਲਾਅ ਦੇ ਜੋੜਿਆਂ ਨਾਲ ਨਕਸ਼ਾ ਕਰਾਂਗੇ। ਉਦਾਹਰਨ ਲਈ, ਸੱਜੇ ਵੱਲ ਚਲਣਾ (R) ਇੱਕ ਜੋੜੇ (1,0) ਦੇ ਅਨੁਸਾਰ ਹੋਵੇਗਾ। (ਕੋਡ ਬਲਾਕ 2):

actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
action_idx = { a : i for i,a in enumerate(actions.keys()) }

ਸਾਰ ਕਰਨ ਲਈ, ਇਸ ਸਥਿਤੀ ਦੀ ਰਣਨੀਤੀ ਅਤੇ ਲਕਸ਼ ਹੇਠਾਂ ਦਿੱਤੇ ਹਨ:

ਰਣਨੀਤੀ, ਸਾਡੇ ਏਜੰਟ (ਪੀਟਰ) ਦੀ ਨੀਤੀ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨੀਤੀ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਕਿਸੇ ਵੀ ਦਿੱਤੀ ਸਥਿਤੀ ਵਿੱਚ ਕਾਰਵਾਈ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਮੱਸਿਆ ਦੀ ਸਥਿਤੀ ਬੋਰਡ ਦੁਆਰਾ ਪ੍ਰਤੀਨਿਧੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਖਿਡਾਰੀ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਸ਼ਾਮਲ ਹੈ।
ਲਕਸ਼, ਰੀਇਨਫੋਰਸਮੈਂਟ ਲਰਨਿੰਗ ਦਾ ਅੰਤ ਵਿੱਚ ਇੱਕ ਚੰਗੀ ਨੀਤੀ ਸਿੱਖਣਾ ਹੈ ਜੋ ਸਾਨੂੰ ਸਮੱਸਿਆ ਨੂੰ ਕੁਸ਼ਲਤਾਪੂਰਵਕ ਹੱਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗੀ। ਹਾਲਾਂਕਿ, ਇੱਕ ਬੇਸਲਾਈਨ ਵਜੋਂ, ਆਓ ਸਭ ਤੋਂ ਸਧਾਰਨ ਨੀਤੀ ਰੈਂਡਮ ਵਾਕ ਨੂੰ ਮੰਨ ਲਵਾਂ।

ਰੈਂਡਮ ਵਾਕ

ਆਓ ਪਹਿਲਾਂ ਸਧਾਰਨ ਰੈਂਡਮ ਵਾਕ ਰਣਨੀਤੀ ਨੂੰ ਲਾਗੂ ਕਰਕੇ ਸਾਡੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਕਰੀਏ। ਰੈਂਡਮ ਵਾਕ ਨਾਲ, ਅਸੀਂ ਅਗਲੀ ਕਾਰਵਾਈ ਨੂੰ ਇਜਾਜ਼ਤ ਪ੍ਰਾਪਤ ਕਾਰਵਾਈਆਂ ਵਿੱਚੋਂ ਬੇਵਿਧੀ ਚੁਣਾਂਗੇ, ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਸੇਬ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦੇ (ਕੋਡ ਬਲਾਕ 3)।

ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨਾਲ ਰੈਂਡਮ ਵਾਕ ਲਾਗੂ ਕਰੋ:

def random_policy(m):
    return random.choice(list(actions))

def walk(m,policy,start_position=None):
    n = 0 # number of steps
    # set initial position
    if start_position:
        m.human = start_position 
    else:
        m.random_start()
    while True:
        if m.at() == Board.Cell.apple:
            return n # success!
        if m.at() in [Board.Cell.wolf, Board.Cell.water]:
            return -1 # eaten by wolf or drowned
        while True:
            a = actions[policy(m)]
            new_pos = m.move_pos(m.human,a)
            if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
                m.move(a) # do the actual move
                break
        n+=1

walk(m,random_policy)

walk ਨੂੰ ਕਾਲ ਕਰਨ ਨਾਲ ਸੰਬੰਧਿਤ ਪਾਥ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਆਉਣੀ ਚਾਹੀਦੀ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਚਾਲ ਤੋਂ ਦੂਜੇ ਚਾਲ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੀ ਹੈ।

ਵਾਕ ਪ੍ਰਯੋਗ ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਓ (ਕਹੋ, 100), ਅਤੇ ਨਤੀਜੇ ਦੇ ਅੰਕੜੇ ਪ੍ਰਿੰਟ ਕਰੋ (ਕੋਡ ਬਲਾਕ 4):
```
def print_statistics(policy):
    s,w,n = 0,0,0
    for _ in range(100):
        z = walk(m,policy)
        if z<0:
            w+=1
        else:
            s += z
            n += 1
    print(f"Average path length = {s/n}, eaten by wolf: {w} times")

print_statistics(random_policy)
```
ਧਿਆਨ ਦਿਓ ਕਿ ਪਾਥ ਦੀ ਔਸਤ ਲੰਬਾਈ ਲਗਭਗ 30-40 ਕਦਮ ਹੈ, ਜੋ ਕਿ ਕਾਫ਼ੀ ਹੈ, ਇਹ ਦੇਖਦੇ ਹੋਏ ਕਿ ਸਭ ਤੋਂ ਨੇੜੇ ਸੇਬ ਤੱਕ ਔਸਤ ਦੂਰੀ ਲਗਭਗ 5-6 ਕਦਮ ਹੈ।

ਤੁਸੀਂ ਇਹ ਵੀ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਰੈਂਡਮ ਵਾਕ ਦੌਰਾਨ ਪੀਟਰ ਦੀ ਚਾਲ ਕਿਵੇਂ ਲੱਗਦੀ ਹੈ:

ਇਨਾਮ ਫੰਕਸ਼ਨ

ਸਾਡੀ ਨੀਤੀ ਨੂੰ ਹੋਰ ਬੁੱਧੀਮਾਨ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸਮਝਣਾ ਪਵੇਗਾ ਕਿ ਕਿਹੜੀਆਂ ਚਾਲਾਂ "ਵਧੀਆ" ਹਨ। ਇਹ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਆਪਣਾ ਲਕਸ਼ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਲਕਸ਼ ਨੂੰ ਇਨਾਮ ਫੰਕਸ਼ਨ ਦੇ ਰੂਪ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਹਰ ਸਥਿਤੀ ਲਈ ਕੁਝ ਸਕੋਰ ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ। ਜਿੰਨਾ ਵੱਡਾ ਨੰਬਰ, ਉਨਾ ਵਧੀਆ ਇਨਾਮ ਫੰਕਸ਼ਨ। (ਕੋਡ ਬਲਾਕ 5)

move_reward = -0.1
goal_reward = 10
end_reward = -10

def reward(m,pos=None):
    pos = pos or m.human
    if not m.is_valid(pos):
        return end_reward
    x = m.at(pos)
    if x==Board.Cell.water or x == Board.Cell.wolf:
        return end_reward
    if x==Board.Cell.apple:
        return goal_reward
    return move_reward

ਇਨਾਮ ਫੰਕਸ਼ਨ ਬਾਰੇ ਇੱਕ ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਸਾਨੂੰ ਖੇਡ ਦੇ ਅੰਤ ਵਿੱਚ ਹੀ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਇਨਾਮ ਮਿਲਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਾਡਾ ਐਲਗੋਰਿਥਮ ਕਿਸੇ ਤਰੀਕੇ ਨਾਲ "ਵਧੀਆ" ਕਦਮਾਂ ਨੂੰ ਯਾਦ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਖੇਡ ਦੇ ਅੰਤ ਵਿੱਚ ਸਕਾਰਾਤਮਕ ਇਨਾਮ ਦੀ ਵਜ੍ਹਾ ਬਣਦੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਦੀ ਮਹੱਤਤਾ ਵਧਾਉਣੀ ਚਾਹੀਦੀ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਸਾਰੇ ਕਦਮ ਜੋ ਖਰਾਬ ਨਤੀਜਿਆਂ ਵੱਲ ਲੈ ਜਾਂਦੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਹੌਸਲਾ ਨਹੀਂ ਦੇਣਾ ਚਾਹੀਦਾ।

ਕਿਊ-ਲਰਨਿੰਗ

ਇੱਕ ਐਲਗੋਰਿਥਮ ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਇੱਥੇ ਚਰਚਾ ਕਰਾਂਗੇ, ਕਿਊ-ਲਰਨਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਐਲਗੋਰਿਥਮ ਵਿੱਚ, ਨੀਤੀ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ (ਜਾਂ ਡਾਟਾ ਸਟ੍ਰਕਚਰ) ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਸਨੂੰ ਕਿਊ-ਟੇਬਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਦਿੱਤੀ ਸਥਿਤੀ ਵਿੱਚ ਹਰ ਕਾਰਵਾਈ ਦੀ "ਵਧੀਆ"ਤਾ ਨੂੰ ਦਰਜ ਕਰਦਾ ਹੈ।

ਇਸਨੂੰ ਕਿਊ-ਟੇਬਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਸਨੂੰ ਇੱਕ ਟੇਬਲ ਜਾਂ ਬਹੁ-ਮਾਤਰੀ ਐਰੇ ਵਜੋਂ ਦਰਸਾਉਣਾ ਅਕਸਰ ਸੁਵਿਧਾਜਨਕ ਹੁੰਦਾ ਹੈ। ਕਿਉਂਕਿ ਸਾਡੇ ਬੋਰਡ ਦੇ ਮਾਪ width x height ਹਨ, ਅਸੀਂ ਕਿਊ-ਟੇਬਲ ਨੂੰ width x height x len(actions) ਦੇ ਆਕਾਰ ਦੇ numpy ਐਰੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਰਸਾ ਸਕਦੇ ਹਾਂ: (ਕੋਡ ਬਲਾਕ 6)

Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)

ਧਿਆਨ ਦਿਓ ਕਿ ਅਸੀਂ ਕਿਊ-ਟੇਬਲ ਦੇ ਸਾਰੇ ਮੁੱਲਾਂ ਨੂੰ ਇੱਕੋ ਜੇਹੇ ਮੁੱਲ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ, ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ - 0.25। ਇਹ "ਰੈਂਡਮ ਵਾਕ" ਨੀਤੀ ਦੇ ਅਨੁਸਾਰ ਹੈ, ਕਿਉਂਕਿ ਹਰ ਸਥਿਤੀ ਵਿੱਚ ਸਾਰੀਆਂ ਚਾਲਾਂ ਇੱਕੋ ਜੇਹੀਆਂ ਵਧੀਆ ਹਨ। ਅਸੀਂ ਕਿਊ-ਟੇਬਲ ਨੂੰ ਬੋਰਡ 'ਤੇ ਦਰਸਾਉਣ ਲਈ plot ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕਰ ਸਕਦੇ ਹਾਂ: m.plot(Q)।

ਹਰ ਸੈੱਲ ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਇੱਕ "ਤੀਰ" ਹੈ ਜੋ ਚਾਲ ਦੇ ਪਸੰਦੀਦਾ ਦਿਸ਼ਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਕਿਉਂਕਿ ਸਾਰੀਆਂ ਦਿਸ਼ਾਵਾਂ ਇੱਕੋ ਜੇਹੀਆਂ ਹਨ, ਇੱਕ ਬਿੰਦੂ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ।

ਹੁਣ ਸਾਨੂੰ ਸਿਮੂਲੇਸ਼ਨ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਆਪਣੇ ਵਾਤਾਵਰਣ ਦੀ ਖੋਜ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਕਿਊ-ਟੇਬਲ ਮੁੱਲਾਂ ਦੇ ਵਧੀਆ ਵੰਡਣ ਨੂੰ ਸਿੱਖਣ ਦੀ ਲੋੜ ਹੈ, ਜੋ ਸਾਨੂੰ ਸੇਬ ਤੱਕ ਪਹੁੰਚਣ ਦਾ ਰਾਹ ਕਾਫ਼ੀ ਤੇਜ਼ੀ ਨਾਲ ਲੱਭਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।

ਕਿਊ-ਲਰਨਿੰਗ ਦਾ ਸਾਰ: ਬੈਲਮੈਨ ਸਮੀਕਰਨ

ਜਦੋਂ ਅਸੀਂ ਚਲਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ, ਹਰ ਕਾਰਵਾਈ ਦਾ ਇੱਕ ਸੰਬੰਧਿਤ ਇਨਾਮ ਹੁੰਦਾ ਹੈ, ਜ਼ਿਆਦਾਤਰ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਚਾਲ ਸਾਡੇ ਲਕਸ਼ ਨੂੰ ਤੁਰੰਤ ਹਾਸਲ ਨਹੀਂ ਕਰਦੀ। ਇਸ ਲਈ ਅਸੀਂ ਤੁਰੰਤ ਫੈਸਲਾ ਨਹੀਂ ਕਰ ਸਕਦੇ ਕਿ ਕਿਹੜੀ ਦਿਸ਼ਾ ਵਧੀਆ ਹੈ।

ਯਾਦ ਰੱਖੋ ਕਿ ਤੁਰੰਤ ਨਤੀਜਾ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ, ਬਲਕਿ ਅੰਤਮ ਨਤੀਜਾ ਹੈ, ਜੋ ਸਾਨੂੰ ਸਿਮੂਲੇਸ਼ਨ ਦੇ ਅੰਤ ਵਿੱਚ ਮਿਲੇਗਾ।

ਇਸ ਦੇਰੀ ਨਾਲ ਇਨਾਮ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਲਈ, ਸਾਨੂੰ ਡਾਇਨਾਮਿਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਸਿਧਾਂਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜੋ ਸਾਨੂੰ ਆਪਣੀ ਸਮੱਸਿਆ ਬਾਰੇ ਦੁਹਰਾਅਵਾਦੀ ਤਰੀਕੇ ਨਾਲ ਸੋਚਣ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ।

ਮੰਨ ਲਵੋ ਕਿ ਅਸੀਂ ਹੁਣ ਸਥਿਤੀ s 'ਤੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਅਗਲੀ ਸਥਿਤੀ s' 'ਤੇ ਜਾਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇਹ ਕਰਨ ਨਾਲ, ਸਾਨੂੰ ਤੁਰੰਤ ਇਨਾਮ r(s,a) ਮਿਲੇਗਾ, ਜੋ ਇਨਾਮ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਲਸ ਕੁਝ ਭਵਿੱਖ ਦਾ ਇਨਾਮ। ਜੇਕਰ ਅਸੀਂ ਮੰਨ ਲਵਾਂ ਕਿ ਸਾਡਾ ਕਿਊ-ਟੇਬਲ ਹਰ ਕਾਰਵਾਈ ਦੀ "ਆਕਰਸ਼ਕਤਾ" ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਉਂਦਾ ਹੈ, ਤਾਂ ਸਥਿਤੀ s' 'ਤੇ ਅਸੀਂ ਇੱਕ ਕਾਰਵਾਈ a' ਚੁਣਾਂਗੇ ਜੋ Q(s',a') ਦੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਹੋਵੇਗੀ। ਇਸ ਤਰ੍ਹਾਂ, ਸਥਿਤੀ s 'ਤੇ ਸਾਨੂੰ ਮਿਲਣ ਵਾਲਾ ਸਭ ਤੋਂ ਵਧੀਆ ਸੰਭਵ ਭਵਿੱਖ ਦਾ ਇਨਾਮ max Q(s',a') ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ।

ਨੀਤੀ ਦੀ ਜਾਂਚ ਕਰਨਾ

ਕਿਉਂਕਿ Q-Table ਹਰ ਰਾਜ ਵਿੱਚ ਹਰ ਕ੍ਰਿਆ ਦੀ "ਆਕਰਸ਼ਣਸ਼ੀਲਤਾ" ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਇਸਨੂੰ ਵਰਤ ਕੇ ਸਾਡੇ ਸੰਸਾਰ ਵਿੱਚ ਕੁਸ਼ਲ ਨੈਵੀਗੇਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਕਾਫ਼ੀ ਆਸਾਨ ਹੈ। ਸਭ ਤੋਂ ਸਧਾਰਣ ਮਾਮਲੇ ਵਿੱਚ, ਅਸੀਂ ਉਸ ਕ੍ਰਿਆ ਨੂੰ ਚੁਣ ਸਕਦੇ ਹਾਂ ਜੋ ਸਭ ਤੋਂ ਉੱਚੇ Q-Table ਮੁੱਲ ਨਾਲ ਸਬੰਧਿਤ ਹੈ: (ਕੋਡ ਬਲਾਕ 9)

def qpolicy_strict(m):
        x,y = m.human
        v = probs(Q[x,y])
        a = list(actions)[np.argmax(v)]
        return a

walk(m,qpolicy_strict)

ਜੇ ਤੁਸੀਂ ਉਪਰੋਕਤ ਕੋਡ ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਧਿਆਨ ਦੇ ਸਕਦੇ ਹੋ ਕਿ ਕਈ ਵਾਰ ਇਹ "ਫਸ" ਜਾਂਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਰੋਕਣ ਲਈ ਨੋਟਬੁੱਕ ਵਿੱਚ STOP ਬਟਨ ਦਬਾਉਣਾ ਪੈਂਦਾ ਹੈ। ਇਹ ਇਸ ਲਈ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਕੁਝ ਹਾਲਾਤਾਂ ਵਿੱਚ ਦੋ ਰਾਜ "ਆਪਸੀ" ਤੌਰ 'ਤੇ ਇੱਕ ਦੂਜੇ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ, ਜਿਸ ਕਾਰਨ ਏਜੰਟ ਉਹਨਾਂ ਰਾਜਾਂ ਵਿੱਚ ਅਨੰਤ ਸਮੇਂ ਲਈ ਘੁੰਮਦਾ ਰਹਿੰਦਾ ਹੈ।

🚀ਚੁਣੌਤੀ

ਕੰਮ 1: walk ਫੰਕਸ਼ਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸੋਧੋ ਕਿ ਪਾਥ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਲੰਬਾਈ ਨੂੰ ਇੱਕ ਨਿਰਧਾਰਤ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ (ਜਿਵੇਂ ਕਿ 100) ਤੱਕ ਸੀਮਿਤ ਕੀਤਾ ਜਾ ਸਕੇ, ਅਤੇ ਉਪਰੋਕਤ ਕੋਡ ਇਸ ਮੁੱਲ ਨੂੰ ਵਾਰ-ਵਾਰ ਵਾਪਸ ਕਰੇ।

ਕੰਮ 2: walk ਫੰਕਸ਼ਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸੋਧੋ ਕਿ ਇਹ ਉਹਨਾਂ ਥਾਵਾਂ 'ਤੇ ਵਾਪਸ ਨਾ ਜਾਵੇ ਜਿੱਥੇ ਇਹ ਪਹਿਲਾਂ ਹੀ ਜਾ ਚੁੱਕਾ ਹੈ। ਇਹ walk ਨੂੰ ਲੂਪ ਕਰਨ ਤੋਂ ਰੋਕੇਗਾ, ਪਰ ਫਿਰ ਵੀ ਏਜੰਟ ਇੱਕ ਅਜਿਹੀ ਥਾਂ 'ਤੇ "ਫਸ" ਸਕਦਾ ਹੈ ਜਿੱਥੋਂ ਇਹ ਬਾਹਰ ਨਹੀਂ ਨਿਕਲ ਸਕਦਾ।

ਨੈਵੀਗੇਸ਼ਨ

ਇੱਕ ਵਧੀਆ ਨੈਵੀਗੇਸ਼ਨ ਨੀਤੀ ਉਹ ਹੋਵੇਗੀ ਜੋ ਅਸੀਂ ਟ੍ਰੇਨਿੰਗ ਦੌਰਾਨ ਵਰਤੀ ਸੀ, ਜੋ ਸ਼ੋਧ ਅਤੇ ਖੋਜ ਨੂੰ ਮਿਲਾਉਂਦੀ ਹੈ। ਇਸ ਨੀਤੀ ਵਿੱਚ, ਅਸੀਂ ਹਰ ਕ੍ਰਿਆ ਨੂੰ ਇੱਕ ਨਿਰਧਾਰਤ ਸੰਭਾਵਨਾ ਨਾਲ ਚੁਣਾਂਗੇ, ਜੋ Q-Table ਵਿੱਚ ਮੁੱਲਾਂ ਦੇ ਅਨੁਪਾਤ ਵਿੱਚ ਹੋਵੇਗੀ। ਇਹ ਰਣਨੀਤੀ ਫਿਰ ਵੀ ਏਜੰਟ ਨੂੰ ਵਾਪਸ ਉਸ ਸਥਿਤੀ 'ਤੇ ਲੈ ਜਾ ਸਕਦੀ ਹੈ ਜਿਸਨੂੰ ਇਹ ਪਹਿਲਾਂ ਹੀ ਖੋਜ ਚੁੱਕਾ ਹੈ, ਪਰ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਚਾਹੀਦੀ ਸਥਿਤੀ ਤੱਕ ਬਹੁਤ ਛੋਟੇ ਔਸਤ ਪਾਥ ਦਾ ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ (ਯਾਦ ਰੱਖੋ ਕਿ print_statistics ਸਿਮੂਲੇਸ਼ਨ ਨੂੰ 100 ਵਾਰ ਚਲਾਉਂਦਾ ਹੈ): (ਕੋਡ ਬਲਾਕ 10)

def qpolicy(m):
        x,y = m.human
        v = probs(Q[x,y])
        a = random.choices(list(actions),weights=v)[0]
        return a

print_statistics(qpolicy)

ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਨਾਲੋਂ ਕਾਫ਼ੀ ਛੋਟੀ ਔਸਤ ਪਾਥ ਲੰਬਾਈ ਮਿਲਣੀ ਚਾਹੀਦੀ ਹੈ, ਜੋ 3-6 ਦੇ ਰੇਂਜ ਵਿੱਚ ਹੋਵੇਗੀ।

ਸਿੱਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਜਾਂਚ

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੱਸਿਆ ਹੈ, ਸਿੱਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਖੋਜ ਅਤੇ ਸਮੱਸਿਆ ਦੇ ਖੇਤਰ ਦੀ ਬਣਤਰ ਬਾਰੇ ਪ੍ਰਾਪਤ ਗਿਆਨ ਦੀ ਖੋਜ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਸੰਤੁਲਨ ਹੈ। ਅਸੀਂ ਵੇਖਿਆ ਹੈ ਕਿ ਸਿੱਖਣ ਦੇ ਨਤੀਜੇ (ਏਜੰਟ ਨੂੰ ਲਕਸ਼ ਤੱਕ ਛੋਟਾ ਪਾਥ ਲੱਭਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਦੀ ਯੋਗਤਾ) ਵਿੱਚ ਸੁਧਾਰ ਹੋਇਆ ਹੈ, ਪਰ ਇਹ ਵੀ ਦਿਲਚਸਪ ਹੈ ਕਿ ਸਿੱਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਔਸਤ ਪਾਥ ਦੀ ਲੰਬਾਈ ਕਿਵੇਂ ਵਿਆਹਰ ਕਰਦੀ ਹੈ:

ਸਿੱਖਿਆਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

ਔਸਤ ਪਾਥ ਦੀ ਲੰਬਾਈ ਵਧਦੀ ਹੈ। ਸ਼ੁਰੂ ਵਿੱਚ, ਔਸਤ ਪਾਥ ਦੀ ਲੰਬਾਈ ਵਧਦੀ ਹੈ। ਇਹ ਸ਼ਾਇਦ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਜਦੋਂ ਸਾਨੂੰ ਵਾਤਾਵਰਣ ਬਾਰੇ ਕੁਝ ਨਹੀਂ ਪਤਾ ਹੁੰਦਾ, ਅਸੀਂ ਖਰਾਬ ਸਥਿਤੀਆਂ, ਜਿਵੇਂ ਕਿ ਪਾਣੀ ਜਾਂ ਭੇੜੀਆ ਵਿੱਚ ਫਸ ਸਕਦੇ ਹਾਂ। ਜਿਵੇਂ ਜਿਵੇਂ ਅਸੀਂ ਹੋਰ ਸਿੱਖਦੇ ਹਾਂ ਅਤੇ ਇਸ ਗਿਆਨ ਨੂੰ ਵਰਤਦੇ ਹਾਂ, ਅਸੀਂ ਵਾਤਾਵਰਣ ਨੂੰ ਹੋਰ ਲੰਬੇ ਸਮੇਂ ਲਈ ਖੋਜ ਸਕਦੇ ਹਾਂ, ਪਰ ਅਜੇ ਵੀ ਸੇਬਾਂ ਦੀ ਸਥਿਤੀ ਬਾਰੇ ਬਹੁਤ ਚੰਗੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਜਾਣਦੇ।
ਜਿਵੇਂ ਜਿਵੇਂ ਅਸੀਂ ਹੋਰ ਸਿੱਖਦੇ ਹਾਂ, ਪਾਥ ਦੀ ਲੰਬਾਈ ਘਟਦੀ ਹੈ। ਜਦੋਂ ਅਸੀਂ ਕਾਫ਼ੀ ਸਿੱਖ ਲੈਂਦੇ ਹਾਂ, ਤਾਂ ਏਜੰਟ ਲਈ ਲਕਸ਼ ਹਾਸਲ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਪਾਥ ਦੀ ਲੰਬਾਈ ਘਟਣ ਲੱਗਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਅਸੀਂ ਅਜੇ ਵੀ ਖੋਜ ਲਈ ਖੁੱਲੇ ਹਾਂ, ਇਸ ਲਈ ਅਸੀਂ ਅਕਸਰ ਸਭ ਤੋਂ ਵਧੀਆ ਪਾਥ ਤੋਂ ਹਟ ਜਾਂਦੇ ਹਾਂ ਅਤੇ ਨਵੀਆਂ ਵਿਕਲਪਾਂ ਦੀ ਖੋਜ ਕਰਦੇ ਹਾਂ, ਜਿਸ ਨਾਲ ਪਾਥ ਲੰਬਾ ਹੋ ਜਾਂਦਾ ਹੈ।
ਲੰਬਾਈ ਅਚਾਨਕ ਵਧਦੀ ਹੈ। ਜੋ ਅਸੀਂ ਇਸ ਗ੍ਰਾਫ 'ਤੇ ਵੇਖਦੇ ਹਾਂ, ਉਹ ਇਹ ਹੈ ਕਿ ਕਿਸੇ ਸਮੇਂ, ਲੰਬਾਈ ਅਚਾਨਕ ਵਧ ਗਈ। ਇਹ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਟੋਕੈਸਟਿਕ ਪ੍ਰਕਿਰਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਕਿ ਅਸੀਂ ਕਿਸੇ ਸਮੇਂ Q-Table ਦੇ ਗੁਣਾਂ ਨੂੰ ਨਵੀਆਂ ਮੁੱਲਾਂ ਨਾਲ ਓਵਰਰਾਈਟ ਕਰਕੇ "ਖਰਾਬ" ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸਨੂੰ ਆਦਰਸ਼ ਤੌਰ 'ਤੇ ਸਿੱਖਣ ਦੀ ਦਰ ਨੂੰ ਘਟਾ ਕੇ ਘਟਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਸਿੱਖਣ ਦੇ ਅੰਤ ਵਿੱਚ, ਅਸੀਂ Q-Table ਮੁੱਲਾਂ ਨੂੰ ਇੱਕ ਛੋਟੇ ਮੁੱਲ ਨਾਲ ਹੀ ਠੀਕ ਕਰਦੇ ਹਾਂ)।

ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਹ ਯਾਦ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਸਿੱਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਫਲਤਾ ਅਤੇ ਗੁਣਵੱਤਾ ਪੈਰਾਮੀਟਰਾਂ 'ਤੇ ਕਾਫ਼ੀ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਿੱਖਣ ਦੀ ਦਰ, ਸਿੱਖਣ ਦਰ ਦਾ ਘਟਾਅ, ਅਤੇ ਡਿਸਕਾਊਂਟ ਫੈਕਟਰ। ਇਹਨਾਂ ਨੂੰ ਅਕਸਰ ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਪੈਰਾਮੀਟਰਾਂ ਤੋਂ ਵੱਖਰਾ ਕੀਤਾ ਜਾ ਸਕੇ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਅਸੀਂ ਸਿੱਖਣ ਦੌਰਾਨ ਠੀਕ ਕਰਦੇ ਹਾਂ (ਉਦਾਹਰਨ ਲਈ, Q-Table ਦੇ ਗੁਣਾਂ)। ਸਭ ਤੋਂ ਵਧੀਆ ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਮੁੱਲਾਂ ਨੂੰ ਲੱਭਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਅਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਵੱਖਰੇ ਵਿਸ਼ੇ ਨੂੰ ਯੋਗ ਹੈ।

ਪੋਸਟ-ਲੈਕਚਰ ਕਵਿਜ਼

ਅਸਾਈਨਮੈਂਟ

ਇੱਕ ਹੋਰ ਹਕੀਕਤੀ ਸੰਸਾਰ

ਅਸਵੀਕਾਰਨਾ:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚਨਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।