Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Лабораторна 4
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
О
Факультет:
СІ
Кафедра:
Кафедра ЕОМ
Інформація про роботу
Рік:
2024
Тип роботи:
Звіт до лабораторної роботи
Предмет:
теорія інтелектуальних систем
Частина тексту файла (без зображень, графіків і формул):
Міністерство освіти і науки України
Національний університет “Львівська політехніка”
Кафедра ЕОМ
Звіт
до лабораторної роботи №4
з дисципліни: «Теорія інтелектуальних систем»
на тему: «Дослідження та моделювання марківського процесу прийняття рішень (Markov Decision Process, MDP)»
Львів 2017
Мета: Дослідити модель марківського процесу прийняття рішень (Markov Decision Process, MDP).
Порядок виконання роботи
1. Реалізувати модель марківського процесу прийняття рішень (Markov Decision Process, MDP) (кількість станів обрати згідно варіанту).
2. Реалізувати модель взаємодії агента з середовищем у вигляді марківського процесу прийняття рішень (кількість доступних агенту дій обрати згідно варіанту). Модель оптимальної поведінки (цільова функція): сумарний виграш з відступаючим горизонтом (receding-horizon model).
3. Реалізувати алгоритм роботи "ідеального" агента (агента, який володіє повною інформацією про характеристики середовища) для випадку марківського процесу прийняття рішень.
4. Реалізувати програму обчислювального експерименту по дослідженню моделі взаємодії агента з стаціонарним випадковим середовищем.
5. Провести обчислювальний експеримент. Отримати усереднені залежності значень цільової функції від часу для 1) випадкового агента та 2) "ідеального" агента.
6. Порівняти отримані залежності та зробити висновки.
Варіант
N
Кількість станів MDP
Кількість доступних агенту дій
6
3
4
Текст програми обчислювального експерименту
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <tchar.h>
#include <math.h>
#define ENVTYPE 1
#define NACTIONS 4
#define NSTATES 3
#define NSTEPS 500
#define NREPLICAS 1000
#define REWARD 10//+1
#define PENALTY 0//-1
#define RLTYPE 5 //3 //4
#define RLEPSILON 0.1f
#define RLTAU 0.12f
}
.
.
.
int uRand(int x)
{
int _rnum = (int)((float)x * (float)rand() / (float)RAND_MAX);
return _rnum;
}
// ----------------------------------------------------------------------------
// discrete probability distribution specified by probabilities from <_array>
int dRand(float* _array, int size)
{
int _rnum = size - 1;
float _left = 0;
float _right = _array[0];
float ftmp = (float)rand() / (float)RAND_MAX;
for (int i = 0; i < size - 1; i++)
{
if ((ftmp >= _left) && (ftmp < _right)) { _rnum = i; break; }
_left = _right;
_right += _array[i + 1];
}
return _rnum;
}
// ----------------------------------------------------------------------------
// initialization of stationary environment
void seInit(void)
{
for (int i = 0; i < nA; i++)
sePa[i] = (float)rand() / (float)RAND_MAX;
//sePa[0] = 0.2f;
//sePa[1] = 0.8f;
}
// ----------------------------------------------------------------------------
// response of stationary environment
int seResponse(void)
{
int _r;
float rnum = (float)rand() / (float)RAND_MAX;
if (rnum < sePa[action]) _r = REWARD;
else _r = PENALTY;
return _r;
}
// ----------------------------------------------------------------------------
// initialization of mdp
void mdpInit(void)
{
int i, j, v;
int maxReward = REWARD;
float _sum1, _sum2;
// probabilities of rewards
for (i = 0; i < nS; i++)
for (j = 0; j < nA; j++)
mdpR[i][j] = uRand(maxReward);
// probabilities of state transition
for (i = 0; i < nS; i++)
for (j = 0; j < nA; j++)
{
_sum1 = 0;
_sum2 = 0;
for (v = 0; v < nS; v++)
{
mdpT[i][j][v] = (float)rand() / (float)RAND_MAX;
_sum1 += mdpT[i][j][v];
}
for (v = 0; v < nS - 1; v++)
{
mdpT[i][j][v] = mdpT[i][j][v] / _sum1;
_sum2 += mdpT[i][j][v];
}
mdpT[i][j][nS - 1] = 1.0f - _sum2;
}
// initial state
mdpState = uRand(nS);
}
// ----------------------------------------------------------------------------
// response of mdp & state transition
int mdpResponse(void)
{
int _r;
// get response in current state
_r = mdpR[mdpState][action];
// commutate states
mdpState = dRand(mdpT[ceState][action], nS);
return _r;
}
// ----------------------------------------------------------------------------
// environment
int environment(int _en)
{
int _r = 0;
switch (_en)
{
case 0: _r = seResponse(); break;
case 1: _r = mdpResponse(); break;
default: printf("lab4 error: wrong env code specified\n");
}
return _r;
}
// ----------------------------------------------------------------------------
// save parameters in file
void saveParameters(void)
{
int i, j, v;
if ((par_file = fopen(par_file_name, "w")) == NULL) {
fprintf(stderr, "Cannot open file <%s> for parameters of experiment.\n", par_file_name);
}
fprintf(par_file, "T = %d\n", T);
fprintf(par_file, "n = %d\n", n);
fprintf(par_file, "env = %d\n", env);
fprintf(par_file, "nA = %d\n", nA);
if (env) fprintf(par_file, "nS = %d\n", nS);
fprintf(par_file, "====================\n");
switch (env)
{
case 0: // se (stationary environment)
for (i = 0; i < nA; i++)
fprintf(par_file, "p(a%d) = %f\n", i, sePa[i]);
break;
case 1: // mdp
// values of reward function
for (i = 0; i < nS; i++)
{
for (j = 0; j < nA; j++)
fprintf(par_file, "R(s%d,a%d) = %d\n", i, j, mdpR[i][j]);
if (i < nS - 1) fprintf(par_file, "--------------------\n");
}
fprintf(par_file, "\n====================\n");
// probabilities of state transition (values of the state transition function)
for (i = 0; i < nS; i++)
{
for (j = 0; j < nA; j++)
{
for (v = 0; v < nS; v++)
fprintf(par_file, "T(s%d,a%d,s%d) = %f\n", i, j, v, mdpT[i][j][v]);
fprintf(par_file, "--------------------\n");
}
}
break;
default: printf("lab3 error: wrong env model code specified\n");
}
fclose(par_file);
}
// ----------------------------------------------------------------------------
// 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 \t %f\n", 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 \t %f\n", avrRm[i], avrRv[i]);
fclose(PA_res_file);
}
// ----------------------------------------------------------------------------
// return maximum value from <_array> of <size> elements
float max(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];
return _max;
}
// ----------------------------------------------------------------------------
// return index of maximum value in <_array> of <size> elements
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 perfect agent (for MDP)
void initPerfectAgent(void)
{
int i, j, z;
float sum = 0.0f;
int V[3];
float **Qsa = new float*[3];
for (int count = 0; count < 3; count++)
Qsa[count] = new float[4]; // perform value iteration --> optimal value function V*(s)
for (z = 0; z < nS; z++) V[z] = 1.0f;
for (t = 0; t < T * 30; t++)
{
for (i = 0; i < nS; i++)
{
for (j = 0; j < nA; j++)
{
sum = 0.0f;
for (z = 0; z < nS; z++) sum = sum + mdpT[i][j][z] * V[z];
Qsa[i][j] = mdpR[i][j] + gammaVI * sum;
}
V[i] = max(Qsa[i], nA);
}
}
// determine the optimal policy given the optimal value function
for (i = 0; i < nS; i++)
{
for (j = 0; j < nA; j++)
{
sum = 0.0f;
for (z = 0; z < nS; z++) sum = sum + mdpT[i][j][z] * V[z];
Qsa[i][j] = mdpR[i][j] + gammaVI * sum;
}
paction[i] = argmax(Qsa[i], nA);
}
}
// ----------------------------------------------------------------------------
// init agent
Графічні залежності отриманих результатів
Графіки середнього «виграшу» ідеального та випадкового агентів
/
/
Результати обчислення :
R(s0,a0) = 0 R(s1,a0) = 9 R(s2,a0) = 1
R(s0,a1) = 9 R(s1,a1) = 9 R(s2,a1) = 7
R(s0,a2) = 3 R(s1,a2) = 7 R(s2,a2) = 3
R(s0,a3) = 5 R(s1,a3) = 3 R(s2,a3) = 0
====================
T(s0,a0,s0) = 0.549673
T(s0,a0,s1) = 0.402138
T(s0,a0,s2) = 0.048189
--------------------
T(s0,a1,s0) = 0.289416
T(s0,a1,s1) = 0.646818
T(s0,a1,s2) = 0.063766
--------------------
T(s0,a2,s0) = 0.131180
T(s0,a2,s1) = 0.262834
T(s0,a2,s2) = 0.605986
--------------------
T(s0,a3,s0) = 0.615021
T(s0,a3,s1) = 0.154061
T(s0,a3,s2) = 0.230917
--------------------
T(s1,a0,s0) = 0.392330
T(s1,a0,s1) = 0.597326
T(s1,a0,s2) = 0.010344
--------------------
T(s1,a1,s0) = 0.421940
T(s1,a1,s1) = 0.303268
T(s1,a1,s2) = 0.274793
--------------------
T(s1,a2,s0) = 0.462384
T(s1,a2,s1) = 0.055400
T(s1,a2,s2) = 0.482216
--------------------
T(s1,a3,s0) = 0.007732
T(s1,a3,s1) = 0.437572
T(s1,a3,s2) = 0.554697
--------------------
T(s2,a0,s0) = 0.469515
T(s2,a0,s1) = 0.180127
T(s2,a0,s2) = 0.350358
--------------------
T(s2,a1,s0) = 0.466550
T(s2,a1,s1) = 0.002682
T(s2,a1,s2) = 0.530768
--------------------
T(s2,a2,s0) = 0.348973
T(s2,a2,s1) = 0.320864
T(s2,a2,s2) = 0.330163
--------------------
T(s2,a3,s0) = 0.050834
T(s2,a3,s1) = 0.431931
T(s2,a3,s2) = 0.517235
Висновок: на цій лабораторній роботі було досліджено методи та алгоритми навчання з підкріпленням (Reinforcement Learning) в стаціонарному випадковому середовищі та набуто навички їх реалізації.
02.05.2018 21:05-
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора