Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
DevioLab
CRYPTO TRADING AUTOMATION
LIVE
AUTOMATED CRYPTO TRADING • BINANCE
Автоматизуйте свій
криптопортфель
Торгові боти DevioLab аналізують крипторинок,
автоматично відкривають і закривають позиції
та керують вашим портфелем на Binance 24/7.
CRYPTO
80 Bots
BINANCE
Spot Trading
TRADING
24 / 7
deviolab.com
Лабораторна робота №2
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
О
Факультет:
Не вказано
Кафедра:
Не вказано
Інформація про роботу
Рік:
2014
Тип роботи:
Лабораторна робота
Предмет:
Інтелектуальні системи
Частина тексту файла (без зображень, графіків і формул):
‘МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ УНІВЕРСИТЕТ „ЛЬВІВСЬКА ПОЛІТЕХНІКА”
Лабораторна робота №2
з дисципліни " Теорія інтелектуальних систем"
Львів – 2014
Назва: Моделювання простих форм цілеспрямованої поведінки. Дослідження роботи цілеспрямованих автоматів (Learning Automata) у стаціонарному випадковому середовищі.
МЕТА: Змоделювати та дослідити роботу цілеспрямованого автомату у стаціонарному випадковому середовищі.
N
Модель оптимальної поведінки
Конструкція ЦА
Кількість доступних агенту дій
8
W1
AL
3
AL -> Автомат з лінійною тактикою (автомат М.Л.Цетліна)
// environment
int environment (int _en)
{
int _r = 0;
switch (_en)
{
case 0: _r = seResponse(); break;
case 1: _r = ceResponse(); break;
default: printf("lab2 error: wrong env code specified\n");
}
return _r;
}
// ----------------------------------------------------------------------------
// save results of random agent
void saveResultsRA (void)
{
int i;
if ((RA_res_file = fopen(RA_res_file_name,"w")) == NULL)
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", RA_res_file_name);
for (i=0; i < T; i++)
fprintf(RA_res_file,"%f,%f,%f,%f\n", sumRm[i], sumRv[i], avrRm[i], avrRv[i]);
fclose(RA_res_file);
}
// ----------------------------------------------------------------------------
// save results of perfect agent
void saveResultsPA (void)
{
int i;
if ((PA_res_file = fopen(PA_res_file_name,"w")) == NULL)
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", PA_res_file_name);
for (i=0; i < T; i++)
fprintf(PA_res_file,"%f,%f,%f,%f\n", sumRm[i], sumRv[i], avrRm[i], avrRv[i]);
fclose(PA_res_file);
}
// ----------------------------------------------------------------------------
// save results of learning automaton
void saveResultsLA (void)
{
int i;
if ((LA_res_file = fopen(LA_res_file_name,"w")) == NULL)
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", LA_res_file_name);
for (i=0; i < T; i++)
fprintf(LA_res_file,"%f,%f,%f,%f\n", sumRm[i], sumRv[i], avrRm[i], avrRv[i]);
fclose(LA_res_file);
}
// ----------------------------------------------------------------------------
// return index of maximal value in <_array>
int argmax(float* _array, int size)
{
int _arg = uRand(size);
float _max = _array[_arg];
for (int i=0; i < size; i++)
if (_array[i] > _max) {_max = _array[i]; _arg = i;}
return _arg;
}
// ----------------------------------------------------------------------------
// init agent
void initAgent (int _ag)
{
switch (_ag)
{
case 0: break;
case 1: break;
case 2: state = 1; action = uRand(nA); break;
case 3: state = 1; action = uRand(nA); break;
case 4: state = 1; action = uRand(nA); break;
default: printf("lab2 error: wrong agent code specified\n");
}
}
// ----------------------------------------------------------------------------
// random agent
int randomAgent (void)
{
return uRand(nA);
}
// ----------------------------------------------------------------------------
// perfect agent
int perfectAgent (void)
{
if (env) paction = argmax(cePa[ceState],nA);
else paction = argmax(sePa,nA);
return paction;
}
// ----------------------------------------------------------------------------
// learning automaton with linear tactics (Tsetlin's automaton)
int LLA (void)
{
int _action = action;
if (response > 0) // 1 -> reward
{
if (state < memSize) state++; // step up in current branch
}
else // 0 -> penalty
{
if (state == 1)
{
// change action (change branch of automaton)
if (action == (nA-1)) _action = 0;
else _action = action + 1;
}
else state--; // step down in current branch
}
/*
// compact version
(response>0)?
((state<memSize)?state++:state):
((state==1)?
((action==(nA-1))?
(_action=0):
(_action++)):
(state--));
// one line version
int r=response, s=state, m=memSize, a=action;
(r>0)?((s<m)?s++:s):((s==1)?((a==(nA-1))?(a=0):(a++)):(s--)); state=s; return a;
*/
return _action;
}
// ----------------------------------------------------------------------------
// trustful learning automaton (Krinsky's automaton)
int TLA (void)
{
int _action = action;
if (response > 0) // 1 -> reward
{
if (state < memSize) state = memSize; // go to the deepest state in current branch
}
else // 0 -> penalty
{
if (state == 1)
{
// change action (change branch of automaton)
if (action == (nA-1)) _action = 0;
else _action = action + 1;
}
else state--; // step down in current branch
}
/*
// compact version
(response>0)?
((state<memSize)?state=memSize:state):
((state==1)?
((action==(nA-1))?
(_action=0):
(_action++)):
(state--));
// one line version (int r=response, s=state, m=memSize, a=action;)
int r=response, s=state, m=memSize, a=action;
(r>0)?((s<m)?s=m:s):((s==1)?((a==(nA-1))?(a=0):(a++)):(s--)); state=s; return a;
*/
return _action;
}
// ----------------------------------------------------------------------------
// inertial learning automaton (Robinson's automaton)
int ILA (void)
{
int _action = action;
if (response > 0) // 1 -> reward
{
if (state < memSize) state = memSize; // go to the deepest state in current branch
}
else // 0 -> penalty
{
if (state == 1)
{
// change action (change branch of automaton)
if (action == (nA-1)) _action = 0;
else _action = action + 1;
// go to the deepest state in new branch
state = memSize;
}
else state--; // step down in current branch
}
/*
// compact version
(response>0)?
((state<memSize)?state=memSize:state):
((state==1)?
((action==(nA-1))?
(_action=0):
(state=memSize+_action++-_action)):
(state--));
// one line version (int r=response, s=state, m=memSize, a=action;)
int r=response, s=state, m=memSize, a=action;
(r>0)?((s<m)?s=m:s):((s==1)?((a==(nA-1))?(a=0):(s=m+a++-a):(s--)); state=s; return a;
*/
return _action;
}
// ----------------------------------------------------------------------------
// agent
int agent (int _ag)
{
int _a = 0;
switch (_ag)
{
case 0: _a = randomAgent(); break;
case 1: _a = perfectAgent(); break;
case 2: _a = LLA(); break;
case 3: _a = TLA(); break;
case 4: _a = ILA(); break;
default: printf("lab2 error: wrong agent code specified\n");
}
return _a;
}
// ----------------------------------------------------------------------------
// simulation
void simulation (int _i)
{
initAgent(agt);
sumR = 0.0f;
avrR = 0.0f;
for (t=0; t < T; t++) {
// get action of agent
action = agent(agt);
// get response of environment
response = environment(env);
// calculate cumulative results
sumR = sumR + (float)response;
avrR = sumR / ((float)t + 1);
// save results
_sumR[t][_i] = sumR;
_avrR[t][_i] = avrR;
}
}
// ----------------------------------------------------------------------------
// get mean values of simulation results
void getMeanValues (void)
{
for (t=0; t < T; t++)
{
float tmps1 = 0.0f;
float tmps2 = 0.0f;
for (int i=0; i < n; i++)
{
tmps1 += _sumR[t][i];
tmps2 += _avrR[t][i];
}
sumRm[t] = (float)tmps1 / (float)n;
avrRm[t] = (float)tmps2 / (float)n;
}
}
// ----------------------------------------------------------------------------
// get variances of simulation results
void getVarianceValues (void)
{
for (t=0; t < T; t++)
{
float tmps1 = 0.0f;
float tmps2 = 0.0f;
for (int i=0; i < n; i++)
{
tmps1 += (sumRm[t] - _sumR[t][i]) * (sumRm[t] - _sumR[t][i]);
tmps2 += (avrRm[t] - _avrR[t][i]) * (avrRm[t] - _avrR[t][i]);
}
sumRv[t] = (float)tmps1 / (float)(n-1);
avrRv[t] = (float)tmps2 / (float)(n-1);
//sumRv[t] = (float)tmps1 / (float)n;
//avrRv[t] = (float)tmps2 / (float)n;
}
}
// ----------------------------------------------------------------------------
// main
int main(int argc, char* argv[])
{
int i;
// init random-number generator
srand((unsigned)time(NULL));
// init environment
if (env == 0) seInit();
else ceInit();
// save parameters of experiment
saveParameters();
// run experiment for random agent
agt = 0;
for (i=0; i < n; i++) simulation(i);
getMeanValues();
getVarianceValues();
saveResultsRA();
// run experiment for perfect agent
agt = 1;
for (i=0; i < n; i++) simulation(i);
getMeanValues();
getVarianceValues();
saveResultsPA();
// run experiment for learning automaton
agt = LATYPE;
for (i=0; i < n; i++) simulation(i);
getMeanValues();
getVarianceValues();
saveResultsLA();
return 0
Рис.1 Діаграма для LA, PA, RA
Кількість доступних агенту дій
p(a0) = 0.445540
p(a1) = 0.252510
p(a2) = 0.188360
Висновок: на цій лабораторній роботі я змоделював та дослідив роботу цілеспрямованого автомату у стаціонарному випадковому середовищі.
06.12.2014 16:38
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора