Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Автомати, що навчаються
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Не вказано
Факультет:
Не вказано
Кафедра:
Кафедра електронних обчислювальних машин
Інформація про роботу
Рік:
2005
Тип роботи:
Звіт про виконання лабораторної роботи
Предмет:
Теорія колективної поведінки інтелектуальних систем
Група:
КІ-44
Частина тексту файла (без зображень, графіків і формул):
Міністерство освіти і науки України
Національний університет „Львівська політехніка”
Кафедра електронних
обчислювальних машин
Звіт
про виконання лабораторної роботи № 3
з курсу „ Теорія колективної поведінки інтелектуальних систем ”
Тема:
Автомати, що навчаються
Львів – 2005
Мета: Реалізувати вказані типи автоматів, що навчаються, та дослідити їх поведінку.
Загальні відомості
Розглядаються три типи автоматів, що навчаються (цілеспрямованих автоматів). Для кожного з цих автоматі з кожною дією ai пов’язується лічильник сi. Крім цього для автомата визначається максимальне значення лічильників m (глибина пам’яті автомата), після досягнення якого значення лічильника не збільшується, а залишається незмінним.
1. Автомат з лінійною тактикою (автомат М.Л. Целтіна).
[1.0. Всі лічильники обнуляються. Перша дія обирається випадково.]
1.1. Реалізувати обрану дію.
1.2. Отримати відгук середовища (виграш/програш).
1.3. Якщо <виграш>, то збільшити значення лічильника на один, перейти на п.1.1.
1.4. Якщо <програш>, то
1.4.1. Якщо лічильник рівний нулю, то змінити дію, перейти на п.1.1.,
1.4.2. Інакше зменшити значення лічильника на один, перейти на п.1.1.
2. Автомат В.І. Крінського ("довірливий" автомат).
[1.0. Всі лічильники обнуляються. Перша дія обирається випадково. ]
1.1. Реалізувати обрану дію.
1.2. Отримати відгук середовища (виграш/програш).
1.3. Якщо <виграш>, то встановити значення лічильника рівним m, перейти на п.1.1.
1.4. Якщо <програш>, то
1.4.1. Якщо лічильник рівний нулю, то змінити дію, перейти на п.1.1.,
1.4.2. Інакше зменшити значення лічильника на один, перейти на п.1.1.
3. Автомат Г. Робінсона ("інерційний" автомат).
[1.0. Всі лічильники обнуляються. Перша дія обирається випадково. ]
1.1. Реалізувати обрану дію.
1.2. Отримати відгук середовища (виграш/програш).
1.3. Якщо <виграш>, то встановити значення лічильника рівним m, перейти на п.1.1.
1.4. Якщо <програш>, то
1.4.1. Якщо лічильник рівний нулю, то змінити дію, встановити значення відповідного лічильника рівним m, перейти на п.1.1.,
1.4.2. Інакше зменшити значення лічильника на один, перейти на п.1.1.
В процесі взаємодії цілеспрямованого автомата з середовищем визначаються три залежності:
Залежність біжучого виграшу від часу: R(t).
Залежність біжучого сумарного виграшу від часу: R((t) = (Rt.
Залежність біжучого проценту виграшних дій від часу (середнє значення виграшу, що припадає на одну дію): Ps(t) = (Rt / t.
Завдання
1. Скласти програму наступного змісту (алгоритм роботи програми):
Вибрати тип середовища (env_model)
Ініціалізувати середовище (випадкова ініціалізація)
Вибрати тип автомату, що навчається.
Відкрити файл для збереження результатів
Цикл від 1 до T (індекс t)
Отримати код дії, яку обрав автомат
Отримати відгук середовища на цю дію (біжучий виграш)
Модифікувати значення сумарного виграшу
Модифікувати значення проценту виграшних (правильних) дій
Запам’ятати отриманні значення у файлі результатів
Перейти на п.4
Закрити файл результатів.
2. Реалізувати три типи автоматів, що навчаються:
2.1. Автомат з лінійною тактикою (автомат М.Л. Целтіна).
2.2. Автомат В.І. Крінського ("довірливий" автомат).
2.3. Автомат Г. Робінсона ("інерційний" автомат).
3. Дослідити поведінку автоматів кожного типу в кожному з трьох середовищ (статичне детерміноване, динамічне детерміноване, стаціонарне випадкове), отримавши для кожного випадку вказані залежності від часу.
Текст програми
/* Copyright (c) 2005 alb. All Rights Reserved. * Multiagent systems Lab
* Computer Engineering Department * Lviv Polytechnic National University
* ===============================================
* Multiagent Systems. Lab work 03. Agent design I (Learning Automata)
* Here three types of learning automata are implemented:
* - learning automaton with linear tactics (Tsetlin's automaton),
* - trustful learning automaton (Krinsky's automaton),
* - inertial learning automaton (Robinson's automaton).
* With given
* set of available actions D={1,2} and
* set of possible responses R={0,1}
* 1 -> reward (win); 0 -> punishment (loss)
* you must investigate behaviour of automata
* over T interaction in specified environments. */
#include "stdafx.h"
int t; // current time step
int T = 100; // maximum number of time steps (interactions with environment)
int env_model; // environmetn code:
// 1 - envoronment with static response
// 2 - envoronment with predetermined dynamic response
// 3 - envoronment with stationary random response:
// binary bandit task (n-armed bandit, n=2)
// variables for environment's parameters
int env1; // winning action code (env_model = 1)
int env2_action1; // first winning action code (env_model = 2)
int env2_action2; // second winning action code (env_model = 2)
int max_period=6; // max period of action repetitions (env_model = 2)
int cd1 = 0; // counter for first action (env_model = 2)
int cd2 = 0; // counter for second action (env_model = 2)
int env2[2]; // periods of action repetitions (env_model = 2)
double env3[2]; // probabilities of rewards for each action (env_model = 3)
// file for saving results
char * res_file_name = "test.dat";
FILE * res_file;
int action; // automaton current action
int response; // current response of environment (can be 0 or 1)
double mr; // mean reward
// results
int R = 0; // current reward over time R(t)
int sumR = 0; // total reward over time sumR(t)
float prcR = 0; // success percent(rate) over time prcR(t)
int randomChoice3 (void) {
int tmp;
float rand_num;
rand_num = (float)rand() / (float)RAND_MAX;
rand_num = (float)rand() / (float)RAND_MAX;
if ((rand_num >= 0) && (rand_num <= 0.333)) {tmp = 1; return tmp;}
if ((rand_num > 0.333) && (rand_num <= 0.666)) {tmp = 2; return tmp;}
if ((rand_num > 0.666) && (rand_num <= 1)) {tmp = 3; return tmp;}
return -1;
}
// equiprobable choice (one from two)
int randomChoice2 (void) {
int _tmp;
float rand_num;
rand_num = (float)rand() / (float)RAND_MAX;
rand_num = (float)rand() / (float)RAND_MAX;
if ((rand_num >= 0) && (rand_num <= 0.5)) {_tmp = 1; return _tmp;}
if ((rand_num > 0.5) && (rand_num <= 1)) {_tmp = 2; return _tmp;}
return -1;
}
// automatic initialization of environment
void env_init (int env_id) {
int tmp;
switch (env_id) {
case 1: // envoronment with static response
env1 = randomChoice2(); break;
case 2: // envoronment with predetermined dynamic response
// random choice of first winning action (1 or 2)
env2_action1 = randomChoice2();
if (env2_action1 == 1) env2_action2 = 2; else env2_action2 = 1;
// random choice of repitition number for first action
tmp = (int) ((float)(max_period - 1) * (float)rand() / (float)RAND_MAX);
env2[0] = tmp + 1;
// random choice of repitition number for second action
tmp = (int) ((float)(max_period - 1) * (float)rand() / (float)RAND_MAX);
env2[1] = tmp + 1; break;
case 3: // envoronment with stationary random response
env3[0] = (float)rand() / (float)RAND_MAX;
env3[1] = (float)rand() / (float)RAND_MAX;
break;
default: printf("lab1 error: wrong env model code specified\n");
}
}
// response generation
int env_response (int env_id) {
int win_action, _response;
float ftmp;
switch (env_id) {
case 1: // envoronment with static response
if (action == env1) _response = 1;
else _response = 0;
break;
case 2: // envoronment with predetermined dynamic response
if (cd1 < env2[0]) {
cd1 ++; win_action = env2_action1;
}
else {
if (cd2 < (env2[1] - 1)) {
cd2 ++; win_action = env2_action2;
}
else {
cd1 = 0; cd2 = 0; win_action = env2_action2;
}
}
if (action == win_action) _response = 1;
else _response = 0;
break;
case 3: // envoronment with stationary random response
ftmp = (float)rand() / (float)RAND_MAX;
if (ftmp < env3[action-1]) _response = 1;
else _response = 0;
break;
default: printf("lab1 error: wrong env model code specified\n");
}
return _response;
}
// print environment parameters
void env_info (void) {
printf("\nenvironment = %d", env_model);
switch (env_model) {
case 1: // envoronment with static response
printf("\n (%d)\n",env1); break;
case 2: // envoronment with predetermined dynamic response
printf("\n(%d) -> %d, (%d) -> %d\n", env2_action1, env2[0], env2_action2, env2[1]);
break;
case 3: // envoronment with stationary random response
printf("\n(1) -> %f (2) -> %f\n", env3[0], env3[1]); break;
default: printf("lab1 error: wrong env model code specified\n");
}
}
void res_open_file (void) {
if ((res_file = fopen(res_file_name,"w")) == NULL) {
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", res_file_name);
}
}
void res_close_file (void) {
fclose(res_file);
}
void res_store_next_string (void) { fprintf(res_file,"%d,%d,%f\n",R,sumR,prcR); }
int casual_agent (void) { return randomChoice2(); }
int ag_type = 1;
int actNumber = 2; // action number of automaton
int memSize = 4; // memory size of automaton
int state = 1; // automaton current state
// learning automaton with linear tactics (Tsetlin's automaton)
int LA_decision (void) {
if (response > 0) { // 1 -> reward (win)
if (state < memSize) state++; // step up in current branch
}
else { // 0 -> punishment (loss)
if (state == 1) { // change action (change branch of automaton)
if (action == actNumber) action = 1;
else action++;
}
else state--; // step down in current branch
}
return action;
}
// trustful learning automaton (Krinsky's automaton)
int TLA_decision (void) {
if (response > 0) { // 1 -> reward (win)
if (state < memSize) state = memSize; // go to the deepest state in current branch
}
else { // 0 -> punishment (loss)
if (state == 1) { // change action (change branch of automaton)
if (action == actNumber) action = 1;
else action++;
}
else state--; // step down in current branch
}
return action;
}
// inertial learning automaton (Robinson's automaton)
int ILA_decision (void) {
if (response > 0) { // 1 -> reward (win)
if (state < memSize) state = memSize; // go to the deepest state in current branch
}
else { // 0 -> punishment (loss)
if (state == 1) { // change action (change branch of automaton)
if (action == actNumber) action = 1;
else action++;
state = memSize; // go to the deepest state in new branch
}
else state--; // step down in current branch
}
return action;
}
// print information about agent
void ag_info (void) {
printf("agent --> ");
switch (ag_type) {
case 1: printf("casual agent"); break;
case 2: printf("learning automaton with linear tactics (Tsetlin's automaton)"); break;
case 3: printf("trustful learning automaton (Krinsky's automaton)"); break;
case 4: printf("inertial learning automaton (Robinson's automaton)"); break;
default: printf("lab3 error: wrong <ag_type> value specified\n");
}
printf("\n\n");
}
int main(int argc, char* argv[])
{
// init random-number generator
srand((unsigned)time(NULL));
env_model = 1; // env_model = 2; env_model = 3;
ag_type = 4;
// set parameters of chosen environment
env_init(env_model);
env3[0] = 0.3; env3[1] = 0.8;
if (env_model == 3) mr = 0.5 * env3[0] + 0.5 * env3[1];
// open file for results
res_open_file();
printf("stating...\n\n");
// main cycle of program (over interactions with environment)
for (t=0; t < T; t++) {
// get learning automaton action
if (t==0) action = randomChoice2();
else {
switch (ag_type) {
case 1: action = casual_agent(); break; // casual
case 2: action = LA_decision(); break; // straightforward
case 3: action = TLA_decision(); break; // trustful
case 4: action = ILA_decision(); break; // inertial
default: printf("lab3 error: wrong <ag_type> value specified\n");
}
}
printf("agent action: %d | ", action);
// get response of environment
response = env_response(env_model);
// print response of environment
printf("env response: %d --> ",response);
// calculate results
R = response;
sumR = sumR + R;
prcR = (float)sumR / ((float)t + 1);
// save current results in file
res_store_next_string();
// print current results
printf("sum win: %d, rate win: %f\n", sumR, prcR);
}
printf("\n%d interactions performed\n", t);
env_info(); // print information about environment
if(env_model==3) printf("mean reward is %f\n\n",mr);
ag_info(); // print information about agent
res_close_file(); // close file with results
return 0;
}
Результати
Залежності біжучого проценту виграшних дій від часу (середнє значення виграшу, що припадає на одну дію): Ps(t) = (Rt / t для кожного типу автомата для кожного типу середовища у вигляді графіку та із зазначенням чисельних характеристик середовищ, для яких отримано результати:
Тип середовища
Статичне детерміноване
Динамічне детерміноване
Стаціонарне випадкове
Автомат з лінійною тактикою (М.Л. Целтіна)
environment = 1
-2
agent --> la
environment = 2
(1) -> 5, (2) -> 3
agent --> la
environment = 3
(1) -> 0.300000 (2) -> 0.800000
mean reward is 0.550000
agent --> la
Автомат В.І. Крінського ("довірливий")
environment = 1
-2
agent --> tla
environment = 2
(1) -> 5, (2) -> 1
agent --> tla
environment = 3
(1) -> 0.300000 (2) -> 0.800000
mean reward is 0.550000
agent --> tla
Автомат Г. Робінсона ("інерційний")
environment = 1
-1
agent --> ila
environment = 2
(2) -> 1, (1) -> 4
agent --> ila
environment = 3
(1) -> 0.300000 (2) -> 0.800000
mean reward is 0.550000
agent --> ila
Автомат з випадковим вибором (casual)
environment = 1
-2
agent --> casual agent
environment = 2
(2) -> 4, (1) -> 2
agent --> casual agent
environment = 3
(1) -> 0.300000 (2) -> 0.800000
mean reward is 0.550000
agent --> casual agent
Порівняння навчання автоматів з різними тактиками
На графіку подано порівняння чотирьох типів автоматів(трьох автоматів, що навчаються і одного, що діє випадково) при їх навчанні у стаціонарному випадковому середовищі:
environment --> envoronment with stationary random response, binary bandit task (n-armed bandit, n=2)
(1) -> 0.300000 (2) -> 0.800000
mean reward is 0.550000
Висновки: виконуючи дану лабораторну роботу я досліджував поведінку автоматів, що навчаються, в різних моделях середовищ. За даних умов найкраще себе показали автомат Робінсона ("інерційний") та автомат Крінського ("довірливий").
Найбільш помітним висновком є те, що автомати, які навчаються, після певного числа кроків починають давати кращі результати за випадковий автомат.
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора