Explorați Cărți electronice
Categorii
Explorați Cărți audio
Categorii
Explorați Reviste
Categorii
Explorați Documente
Categorii
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 3. Compunerea funcțiilor și evaluarea pasivă
1. Obiective ........................................................................................................... 37
2. Înlănțuirea funcțiilor .................................................................................... 37
3. Compunerea funcțiilor ................................................................................ 39
4. Evaluarea pasivă ............................................................................................ 40
5. Aplicații ............................................................................................................. 41
Capitolul 6. Algoritmul A*
1. Obiective ........................................................................................................... 77
2. Algoritmul A* .................................................................................................. 77
3. Aplicații ............................................................................................................. 80
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 7. Jocuri. Algoritmul minimax
1. Obiective ........................................................................................................... 95
2. Jocuri .................................................................................................................. 95
3. Algoritmul minimax...................................................................................... 96
4. Retezarea alfa-beta ....................................................................................... 99
5. Aplicație ......................................................................................................... 103
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
6. Aplicații .......................................................................................................... 146
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 13. Rețele neuronale: algoritmul de retro-propagare
(backpropagation)
1. Obiective ........................................................................................................ 213
2. Descrierea algoritmului ........................................................................... 213
3. Considerente practice ............................................................................... 217
4. Aplicație ......................................................................................................... 220
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 1
Noțiuni fundamentale de
programare funcțională
1. Obiective
2. Programarea funcțională
Imperativ Funcțional
private int Square(int x) public static int SumOfSquares(int n)
{ {
return x * x; int Square(int x) => x * x;
} int SumSq(int m) => Range(1, m).Select(x =>
Square(x)).Sum();
public int SumOfSquares(int n) return SumSq(n);
{ }
int sum = 0;
for (int i = 1; i <= n; i++)
sum += Square(i);
return sum;
}
10
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3. Imutabilitate
11
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public Ellipse ModifyWith(double newRx = 0, double newRy = 0)
{
if (newRx == 0) newRx = Rx;
if (newRy == 0) newRy = Ry;
return new Ellipse(newRx, newRy);
}
4. Recursivitate
12
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
funcție-recursivă(parametri, variabile)
if(not condiție)
return rezultat
cod-buclă
return funcție-recursivă(parametri, variabile-
modificate)
13
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Atunci când se folosesc funcții recursive, parametrii sunt memorați
pe stivă, iar dacă nivelul de recursivitate este foarte mare, acesta poate
produce o excepție de memorie insuficientă. Pentru a evita acest lucru, în
unele limbaje funcționale se folosește metoda tail recursion. Mai jos este
rescrisă funcția de calcul al factorialului în acest mod. Rezultatul este
calculat în acumulatorul acc și transmis ca parametru în funcția recursivă.
5. Funcții ca obiecte
Obiectele de tip Func pot fi folosite ca orice alt obiect, adică pot fi
atribuite cu diferite valori, trimise ca parametru și apelate când este nevoie:
15
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
private static int Add(int x, int y)
{
return x + y;
}
16
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static void Test4()
{
int result = PerformOperation((x, y) => x + y, 5, 5);
Console.WriteLine(result);
result = PerformOperation((x, y) => x * y, 5, 5);
Console.WriteLine(result);
}
17
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static void Test5()
{
// Add și Mul sunt funcții locale definite în interiorul funcției Test5
Console.WriteLine(Add(3, 4));
Console.WriteLine(Mul(3, 4));
}
6. Alte aspecte
18
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Începând cu versiunea 6, limbajul C# a introdus directiva using
static, care permite accesarea membrilor statici ai unui tip fără specificarea
numelui tipului. De exemplu:
7. Închideri (closures)
19
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
WriteLine(uc()); // 2
WriteLine(uc()); // 3
}
int IncrementCounter()
{
return ++counter;
}
20
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
8. Aplicații
Exemple:
Introduceti latura 1: 2
Introduceti latura 2: 3
Introduceti latura 3: 4
Reprezinta un triunghi valid
Introduceti latura 1: 1
Introduceti latura 2: -1
Introduceti latura 3: 1
Nu reprezinta un triunghi valid
Introduceti latura 1: 1
Introduceti latura 2: 2
Introduceti latura 3: 3
Nu reprezinta un triunghi valid
procedure SqrtIterative(x)
if x < 0.0 then
return nan // not a number
else
b←x
while abs (b * b - x) > 1e-12 do
b ← ((x / b) + b) / 2.0
return b
21
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
8.3. Realizați un joc simplu de ghicire a unui număr de către
utilizator. Mai întâi, programul va alege în mod aleatoriu un număr natural
de la 1 la 10, după care utilizatorul va introduce succesiv diferite valori,
până la ghicirea numărului.
Numărul aleatoriu se generează cu ajutorul clasei .NET Random.
Implementați funcția Guess în manieră recursivă.
Exemplu:
Introduceti numarul: 5
Numarul corect este mai mare
Introduceti numarul: 7
Numarul corect este mai mare
Introduceti numarul: 9
Numarul corect este mai mic
Introduceti numarul: 8
Corect!
f (x ) f (x )
f ' ( x)
2
Exemplu de apel:
22
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
y = Derivative(x => x * x, 3);
WriteLine($"x^2(3) = 9\t(x^2)'(3) = {y:F0}"); // x^2(3) = 9 (x^2)'(3) = 6
}
Exemplu de apel:
23
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
24
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 2
1. Obiective
2. Crearea listelor
25
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
int[] array = new int[] { 1, 2 };
IEnumerable<int> intList1 = array.AsEnumerable();
WriteLine(intList1.ToStringF()); // [ 1 2 ]
WriteLine(intList2.ToStringF()); // [ 1 2 3 ]
WriteLine(intList3.ToStringF()); // [ 1 2 3 4 ]
26
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
prime = false;
break;
}
if (prime)
yield return i;
}
}
LINQ FunCs
Select Map
Aggregate Reduce
SelectMany Bind
Where Filter
27
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3.1. Funcții de transformare
string Nume(int n)
{
if (n == 1) return "unu";
else if (n == 2) return "doi";
else if (n == 3) return "trei";
else return "";
}
class Country
{
public readonly string Name;
public readonly int Population;
28
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Name = name;
Population = population;
}
}
cu rezultatul:
1. Russia: 17098242
2. Ukraine: 603628
3. France: 551695
4. Spain: 498511
5. Sweden: 450295
6. Norway: 385178
7. Germany: 357386
8. Finland: 338145
9. Poland: 312685
10. Italy: 301338
29
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Mai exact, în acest caz funcția lucrează astfel:
Dacă lista are un singur element, atunci acesta este rezultatul. Dacă
lista primită este vidă, funcția aruncă o excepție:
System.InvalidOperationException: Sequence contains no elements.
Să considerăm un alt exemplu, în care dorim să concatenăm
elementele unei liste într-un șir de caractere, în care elementele să fie
despărțite prin spațiu:
30
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
int Factorial(int x) => Range(1, x).Reduce(1, (a, i) => a * i);
int f = Factorial(5); // 120
int[][] lists = {
new[] {1, 2, 3},
new[] {4},
new[] {5, 6, 7, 8},
new[] {9, 10}};
var result = lists.Bind(x => x); // [ 1 2 3 4 5 6 7 8 9 10 ]
32
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3.5. Funcții de căutare și adăugare
4. Tuple
33
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
var first = pair.Item1; // "unu"
var second = pair.Item2; // "doi"
var third = mixedTuple.Item3; // "abc"
5. Aplicații
Exemple:
Exemplu:
34
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Lista cu elemente duplicate este: [ 1 1 2 2 3 3 ]
Exemplu:
private static double Argmin(Func<double, double> f, double min, double max, double step)
{
var range = DoubleRange(min, max, step);
// se returnează x-ul pentru care f(x) este minimă
// nu se poate folosi o buclă de tip imperativ: for, while etc.
35
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
// se poate folosi funcția Reduce sau altă abordare funcțională (o funcție recursivă etc.)
}
private static double Argmax(Func<double, double> f, double min, double max, double step)
{
var range = DoubleRange(min, max, step);
// se returnează x-ul pentru care f(x) este maximă
}
36
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 3
1. Obiective
2. Înlănțuirea funcțiilor
37
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
În această funcție, fiecare rezultat intermediar este pasat funcției
următoare, astfel încât avem nevoie de mai multe instrucțiuni distincte. În
LINQ, metodele sunt fluente (fluent), adică pot fi înlănțuite. Acestea se
aplică unor obiecte IEnumerable și returnează tot obiecte IEnumerable.
Folosind această facilitate, funcția de mai sus poate fi rescrisă astfel:
38
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
3. Compunerea funcțiilor
double x = 5.1;
var l3 = CubeLength(x);
39
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
În acest caz, CubeLength este o funcție compusă, care primește
argumentul primit de Cube și întoarce rezultatul calculat de Length.
Apelarea succesivă a funcțiilor poate fi realizată împreună cu
funcțiile de transformare ale listelor. În exemplul următor, aplicăm în ordine
trei funcții simple asupra elementelor unei liste de numere reale:
4. Evaluarea pasivă
Obiectele de tip vector (array) sau listă sunt evaluate în mod activ
(eager). Când se definește, de exemplu, o listă, ea se creează efectiv în
memorie, chiar dacă nu este folosită ulterior. Există însă situații în care
dorim să evaluăm o expresie doar atunci când este nevoie. De exemplu,
putem să definim o secvență foarte mare de date, dar dorim să se calculeze
aceste valori doar în momentul în care le folosim efectiv. Acest mod de
evaluare se numește pasiv sau întârziat (lazy) și poate conduce la o scădere
foarte mare a necesarului de memorie a unui program.
Colecțiile IEnumerable sunt evaluate pasiv. Prin urmare, pe lângă
modurile de definire pe care le-am considerat până acum, se pot defini
colecții infinite. Biblioteca FunCs include funcția InfiniteF.Define care
definește o secvență infinită. În exemplul următor, se definește șirul
numerelor naturale.
5. Aplicații
41
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Definiți funcția DiscountedSum ca o extension method pentru
IEnumerable, apelabilă la fel ca funcția standard Sum.
Exemplu:
[ ]
unde și , .
Exemplu:
42
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
WriteLine($"Valoarea lui pi este:\t{Math.PI}");
43
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static BigInteger Factorial(int n) => (n <= 1) ? 1 : (n * Factorial(n - 1));
Exemplu:
var e2 = Math.Exp(x);
WriteLine($"Exact:\t{e2:F6}"); // 7.389056
5.4. Date fiind toate tipurile de bancnote ale unei țări și o valoare,
determinați numărul minim de bancnote necesar pentru plata acelei valori.
Nu folosiți construcții imperative (de exemplu, bucle for sau while).
Folosiți secvențe IEnumerable, recursivitatea și/sau funcția Reduce. Alte
funcții utile din IEnumerable pot fi First și Append.
Algoritmul de descompunere este greedy: se sortează descrescător
tipurile de bancnote, se calculează numărul maxim de bancnote de tipul cel
mai mare care pot fi utilizate la un moment dat, după care se scade suma
identificată din suma inițială și se trece la următorul tip de bancnotă.
44
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
var amount = 2778;
var money = "[ 500 200 100 50 10 5 1 ]".ToIntEnumF();
var result = Decompose(amount, money); // [ 5 1 0 1 2 1 3 ]
45
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
46
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 4
1. Obiective
2. Tipul Option
47
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
if (ok && result >= 0)
return result;
else
throw new Exception($"Argument {s} is not a valid natural number");
}
48
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Se poate observa că tipul OptionF este un container (sau wrapper)
care poate conține orice alt tip de obiect. De asemenea, se poate testa în mod
explicit dacă un obiect de tip opțiune conține sau nu un obiect „valoare”.
În metoda următoare, se prezintă mai multe operații cu obiecte
IEnumerable și OptionF:
OptionF<int> o1 = ToNatural("1");
WriteLine(o1); // Some(1)
OptionF<int> o2 = ToNatural("abc");
WriteLine(o2); // None
49
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
private static OptionF<string> StringNotNumber(string s)
{
if (!double.TryParse(s, out double d)) // s nu reprezintă un număr
return OptionF<string>.Some(s);
else
return OptionF<string>.None();
}
optStr = StringNotNumber("123");
optLen = optStr.Map(x => x.Length);
WriteLine($"{optStr} -> {optLen}"); // None -> None
}
3. Functori
50
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3.1. Legile functorilor
4. Monade
51
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Să notăm cu M<T> tipul unui astfel de obiect-container care conține
elemente de tip T. Bind folosește o funcție de transformare de tip T → M(R).
Tipul obiectului-container rezultat după aplicarea funcției Bind va fi M<R>.
Să mai considerăm o funcție simplă numită Return, care
încapsulează o valoare T într-un obiect-container M<T>. Ca exemple de
funcții Return putem menționa orice funcție care creează o enumerare
populată de obiecte de un anumit tip, precum:
52
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
4.1. Legile monadelor
1. Identitate la stânga
// Return(t).Bind(f) == f(t)
int t = 3;
Func<int, OptionF<int>> Return = x => OptionF<int>.Some(x);
Func<int, OptionF<int>> f = x => OptionF<int>.Some(x * x);
var r1 = Return(t).Bind(f); // Some(9)
var r2 = f(t); // Some(9)
2. Identitate la dreapta
// m == m.Bind(Return)
3. Asociativitate
OptionF<int> m = OptionF<int>.Some(3);
Func<int, OptionF<int>> f = x => OptionF<int>.Some(x * x);
Func<int, OptionF<int>> g = x => OptionF<int>.Some(x + 1);
OptionF<int> r1 = m.Bind(f).Bind(g); // Some(10)
OptionF<int> r2 = m.Bind(x => f(x).Bind(g)); // Some(10)
53
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5. Aplicații
Exemplu:
54
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static void Problem2()
{
var students = new List<Student>
{
new Student("Alex Neagoe", "10"),
new Student("Carla Stoenescu", "3.50"),
new Student("Flavius Predoiu", "absent"),
new Student("Doina Vasiliu", "9.75"),
new Student("Dan Draghicescu", "5"),
new Student("Maria Raducanu", "7.25")
};
}
Alex Neagoe - 10
Doina Vasiliu - 10
Dan Draghicescu - 5
Maria Raducanu - 7
namespace OptionAccountI
{
public class Bank
{
private Dictionary<int, Account> _accounts;
55
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public Bank()
{
_accounts = new Dictionary<int, Account>();
}
return _accounts[accountNumber];
}
}
return _balance;
}
56
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public Balance(double value)
{
_value = value;
}
bool ok = false;
if (account != null)
{
var balance = account.GetBalance();
if (balance != null)
{
double a = balance.GetValue();
WriteLine($"Soldul este pozitiv: {a}");
ok = true;
}
}
if (!ok)
WriteLine("Soldul este negativ sau nu poate fi interogat");
}
}
}
57
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Refactorizați programul într-o manieră funcțională:
58
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 5
Potrivirea modelelor
1. Obiective
59
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static string Judet1(string cod)
{
switch (cod)
{
case "IS": return "Iasi";
case "SV": return "Suceava";
case "B": return "Bucuresti";
default: return "Alt judet";
}
}
switch (cod)
{
case string c when d.ContainsKey(c): // c ia valoarea lui cod
return d[c];
default:
return "Alt judet";
}
}
WriteLine(Judet2("IS")); // Iasi
WriteLine(Judet2("VS")); // Alt judet
WriteLine(Judet2("Arad")); // Cod invalid
}
60
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3. Potrivirea modelelor cu algoritmul Rete
Faptele cu care vom lucra sunt constituite din zero sau mai multe
câmpuri separate de spații, de exemplu: "1 2 3", "abc efg", "a 1.4 15 -6
alte cuvinte".
Elementele a căror valoare dorim să o determinăm prin potrivirea
modelelor sunt echivalente variabilelor și se notează cu un semn de
întrebare pus înaintea numelui, de exemplu: ?varsta, ?loc_nastere, ?specie.
Aceste variabile lor lua valoarea unui singur câmp dintr-un fapt.
Dacă dorim ca o variabilă să poată conține orice număr de câmpuri
(zero, unu sau mai multe), numele acesteia trebuie precedat și de simbolul
dolar, de exemplu: $?text.
Uneori, dorim să identificăm unul sau mai multe câmpuri dintr-un
fapt, dar nu ne interesează valorile lor specifice. În această situație se
folosesc variabile libere, notate cu ? sau $? și fără un nume de variabilă.
61
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Să presupunem că avem un fapt care reprezintă numele unei
persoane, compus din numele de familie, inițiala tatălui și unul sau mai
multe prenume și că dorim să aflăm numele de familie. Faptele pot fi de
tipul: "Ionescu T. George" sau "Popescu S. Andrei Sebastian". Potrivirea se
face cu modelul "?nume $?", unde variabila nume va lua valorile Ionescu,
respectiv Popescu.
Dacă dorim să identificăm primul prenume al unei persoane, vom
folosi modelul "? ? ?prenume $?", unde variabila prenume va lua valorile
George, respectiv Andrei.
Dacă se folosesc în același timp două variabile libere multi-câmp,
rezultatele pot fi multiple. De exemplu, cu faptul "1 2 3" și modelul
"$? ?x $?", variabila x va lua trei valori: 1, 2, respectiv 3, deoarece prima
variabilă liberă poate înlocui zero sau mai multe câmpuri, iar a doua poate și
ea înlocui zero sau mai multe câmpuri. În acest caz, numărul de soluții va fi
egal cu numărul de câmpuri din fapt.
list.MatchF("?x ?y $?w ?z", out var x, out var y, out var w, out var z);
WriteLine($"{x} - {y} - {w} - {z}"); // 1 - 2 - 3 4 5 6 7 8 9 - 10
}
62
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
iar rezultatele multiple sunt disponibile într-o listă de dicționare, câte un
dicționar pentru fiecare soluție. Valoarea fiecărei variabile dintr-un dicționar
se poate regăsi folosind numele acesteia:
// Rezultat:
// 1 - 2
// 1 - 3
// 1 - 4
// 1 - 5
// 2 - 3
// 2 - 4
// 2 - 5
// 3 - 4
// 3 - 5
// 4 - 5
}
Întrucât listele sunt unele dintre cele mai folosite structuri de date în
programarea funcțională, potrivirea modelor pentru liste este de asemenea
foarte des întâlnită, mai ales în contextul funcțiilor recursive. De obicei, se
identifică primul element din listă (head) și lista de elemente următoare (tail).
În FunCs, această facilitate este implementată pentru tipul
IEnumerable generic. Celelalte tipuri de potrivire de modele se pot utiliza
doar pentru colecții de tip string.
Exemplul următor prezintă o funcție care calculează recursiv suma
elementelor dintr-o listă:
63
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static void MySumTest()
{
var list = "[ 1 2 3 4 5 ]".ToIntEnumF();
int sum = MySum(list); // 15
}
64
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Kinship.csv
65
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public static void Parents()
{
// încărcarea faptelor din fișier
var sr = new StreamReader("kinship.csv");
var lines = sr.ReadToEnd().Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
sr.Close();
// Rezultat:
// Father Marco, mother Lucia, child Sophia
// Father Marco, mother Lucia, child Alfonso
// Father Pierro, mother Francesca, child Angela
// Father Pierro, mother Francesca, child Marco
// Father Roberto, mother Maria, child Lucia
// Father Roberto, mother Maria, child Emilio
// Father James, mother Victoria, child Charlotte
// Father James, mother Victoria, child Colin
// Father Andrew, mother Christine, child Jennifer
// Father Andrew, mother Christine, child James
// Father Christopher, mother Penelope, child Victoria
// Father Christopher, mother Penelope, child Arthur
}
66
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5.2. Constrângeri
// Rezultat:
// Grandfather Roberto, mother Lucia, child Sophia
// Grandfather Roberto, mother Lucia, child Alfonso
// Grandfather Christopher, mother Victoria, child Charlotte
// Grandfather Christopher, mother Victoria, child Colin
// Grandfather Pierro, father Marco, child Sophia
// Grandfather Pierro, father Marco, child Alfonso
// Grandfather Andrew, father James, child Charlotte
// Grandfather Andrew, father James, child Colin
}
67
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Tot un mecanism de constrângeri poate fi folosit împreună cu
soluțiile multiple pentru a determina permutările elementelor unei liste:
// Rezultat:
// 3 - 2 - 1
// 3 - 1 - 2
// 1 - 3 - 2
// 2 - 3 - 1
// 1 - 2 - 3
// 2 - 1 - 3
}
linie1 linie 2
coloana1 coloana 2
linie linie coloana coloana
1 2 1 2
68
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
var patterns = new List<string>
{
"n $? ?row $?",
"n $? ?col $?"
};
em = new ExpertMatchF(queens);
// Rezultat:
// 2 4 1 3
// 3 1 4 2
}
69
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
După cum se poate vedea urmărind rezultatele programului de mai
sus, presupunând că prima damă se află pe linia 1, a doua pe linia 2 ș.a.m.d.,
există două soluții:
6. Sisteme expert
70
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
7. Aplicații
Exemplu:
1 Fizz 11 16
2 7 Fizz 17
Fizz 8 13 Fizz
4 Fizz 14 19
Buzz Buzz FizzBuzz Buzz
71
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Indicații: Urmărind arborele, putem vedea că verii lui x au același
bunic ca și x, dar părinți diferiți. Se dă următoarea funcție, care trebuie
completată:
Exemplu:
72
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
7.3. Realizați un sistem expert bazat pe un arbore de decizie generic,
reprezentând raționamentul pentru rezolvarea unei anumite probleme.
Problema va fi rezolvată interactiv, prin întrebări adresate utilizatorului. Se
pleacă din rădăcina arborelui și apoi, în funcție de răspunsurile date, se
coboară în arbore până se atinge o frunză, corespunzătoare unei concluzii
(soluții).
Pentru fiecare nod neterminal, se definesc următoarele caracteristici:
Viteza.kbf
root n11
question n11 Viteza isi pastreaza directia?
answers n11 da nu nu_stiu
rule when n11 if nu then n21
rule when n11 if da then n22
rule when n11 if nu_stiu then n23
conclusion n23 Informatii insuficiente.
question n21 Modulul vectorului viteza este constant?
answers n21 da nu
rule when n21 if nu then n31
rule when n21 if da then n32
conclusion n31 Miscare curbilinie neuniforma.
conclusion n32 Miscare curbilinie uniforma.
question n22 Vectorul acceleratie este nul?
73
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
answers n22 da nu
rule when n22 if nu then n33
rule when n22 if da then n34
conclusion n34 Miscare rectilinie uniforma.
question n33 Acceleratie constanta?
answers n33 da nu
rule when n33 if nu then n41
rule when n33 if da then n42
conclusion n41 Miscare rectilinie neuniforma.
question n42 Acceleratie pozitiva?
answers n42 da nu
rule when n42 if nu then n51
rule when n42 if da then n52
conclusion n51 Miscare rectilinie uniform incetinita.
conclusion n52 Miscare rectilinie uniform accelerata.
Exemplu:
74
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
var em = new ExpertMatchF(facts);
// root n11
em.MatchVar("root ?r", out string currentNode);
if (conclusion != "")
{
WriteLine(conclusion);
break; // se afișează concluzia și se părăsește bucla while
}
75
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
76
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 6
Algoritmul A*
1. Obiective
2. Algoritmul A*
f(n) este un cost estimat. Cu cât este mai mic f(n), cu atât este mai
bun nodul n;
g(n) este costul căii de la nodul inițial la n. Este cunoscută;
h(n) este estimarea costului căii de la n la un nod scop. Este o
estimare euristică.
Tipuri de căutare:
77
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Căutarea A*: f(n) = g(n) + h(n). Reunește ideile căutărilor de cost
uniform și greedy.
PROBLEMĂ =
{
Stare-inițială : STARE
» starea inițială a problemei
Acțiuni(s : STARE) : ACȚIUNE*
» o funcție care întoarce lista de acțiuni care se pot efectua în starea s
Stare-succesoare(s : STARE, a : ACȚIUNE) : STARE
» o funcție care întoarce starea în care se ajunge aplicând acțiunea a în starea s
78
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Cost(s1 : STARE, s2 : STARE) : NUMĂR-REAL-POZITIV
» o funcție care întoarce costul/distanța dintre 2 stări vecine s1 și s2
Euristică(s : STARE) : NUMĂR-REAL-POZITIV
» o funcție care întoarce estimarea euristică a costului/distanței din starea s în starea scop
Este-scop(s : STARE) : BOOLEAN
» o funcție care verifică dacă starea s este starea scop
}
NOD =
{
Stare » starea problemei corespunzătoare nodului
Părinte » părintele nodului
Acțiune » acțiunea prin care a rezultat nodul
G » distanța cunoscută parcursă din starea inițială până la starea curentă
H » estimarea euristică a distanței din starea curentă până la starea scop
F » suma G + H
}
CĂUTARE-A-STEA
intrări: problemă : PROBLEMĂ
ieșiri: soluție : NOD » nod care conține starea scop
------------------------------------------------------------------------------------------------------------------------
soluție ← Nul
rădăcină ← NOD(Stare ← problemă.Stare-inițială, Nul, Nul, G ← 0, H ← problemă.Euristică(Stare),
F ← G + H)
lista-deschisă ← [ rădăcină ] » nodurile care vor fi expandate
lista-închisă ← [ ] » nodurile deja vizitate
» dacă în aceeași stare s-a ajuns deja pe o cale mai scurtă, nod-fiu este ignorat
dacă lista-deschisă nu conține un nod cu starea nod-fiu.Stare și G mai mic decât nod-fiu.G și
lista-închisă nu conține un nod cu starea nod-fiu.Stare și G mai mic decât nod-fiu.G
atunci
lista-deschisă.Adaugă(nod-fiu)
79
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
lista-închisă.Înlocuiește(nli, nod-curent)
altfel
lista-închisă.Adaugă(nod-curent)
Variante:
3. Aplicații
80
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Problema 1
Problema 2
81
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Problema 3
Problema 4
82
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
4.1. Rezolvați pe hârtie problema 2 sau problema 3, la alegere.
Arătați cum evoluează lista deschisă, ce noduri sunt scoase din listă, ce
noduri sunt expandate, ce valori f au fiii etc.
Program.cs
using System;
namespace Astar
{
public class Program
{
83
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
private static void Main(string[] args)
{
Console.WriteLine("Problema 1");
Console.WriteLine(AstarAlgorithm.Solve(new Problem1()));
Console.WriteLine("\r\nProblema 2");
Console.WriteLine(AstarAlgorithm.Solve(new Problem2()));
Console.WriteLine("\r\nProblema 3");
Console.WriteLine(AstarAlgorithm.Solve(new Problem3()));
Console.WriteLine("\r\nProblema 4");
Console.WriteLine(AstarAlgorithm.Solve(new Problem4()));
Console.WriteLine();
Console.ReadLine();
}
}
}
IProblem.cs
namespace Astar
{
public interface IProblem
{
double GetEdgeCost(string state1, string state2);
string GetRoot();
Problem1.cs
using System;
namespace Astar
{
84
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public class Problem1 : IProblem
{
public string GetRoot()
{
return "A";
}
return double.PositiveInfinity;
}
return double.PositiveInfinity;
}
85
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public string[] GetSuccessors(string state)
{
switch (state)
{
case "A": return new string[] { "B", "C" };
case "B": return new string[] { "A", "D" };
case "C": return new string[] { "A", "D" };
case "D": return new string[] { "B", "C", "E" };
case "E": return new string[] { "D" };
}
return null;
}
}
}
Problem2.cs
using System;
namespace Astar
{
public class Problem2 : IProblem
{
public string GetRoot()
{
return "Buzau";
}
if (state1 == "Bacau")
{
if (state2 == "Iasi")
86
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
return 128;
if (state2 == "Focsani")
return 106;
if (state2 == "Galati")
return 188;
}
else if (state1 == "Buzau")
{
if (state2 == "Focsani")
return 77;
if (state2 == "Galati")
return 133;
if (state2 == "Constanta")
return 231;
}
else if (state1 == "Constanta")
{
if (state2 == "Tulcea")
return 123;
}
else if (state1 == "Focsani")
{
if (state2 == "Vaslui")
return 138;
}
else if (state1 == "Galati")
{
if (state2 == "Vaslui")
return 155;
}
else if (state1 == "Iasi")
{
if (state2 == "Vaslui")
return 72;
}
return double.PositiveInfinity;
}
87
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
case "Galati": return 195;
case "Buzau": return 231;
case "Constanta": return 342;
case "Tulcea": return 239;
}
return double.PositiveInfinity;
}
return null;
}
}
}
Problem3.cs
using System;
namespace Astar
{
public class Problem3 : IProblem
{
public string GetRoot()
{
return "1";
}
88
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
return double.PositiveInfinity;
}
return double.PositiveInfinity;
}
89
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
case "4": return new string[] { "1", "6" };
case "5": return new string[] { "2", "3", "6" };
case "6": return new string[] { "3", "4", "5" };
}
return null;
}
}
}
Problem4.cs
using System;
namespace Astar
{
public class Problem4 : IProblem
{
public string GetRoot()
{
return "1";
}
90
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
if (state1 == "4" && state2 == "6") return 5;
return double.PositiveInfinity;
}
return double.PositiveInfinity;
}
return null;
}
}
}
Node.cs
namespace Astar
{
public class Node
{
91
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public string State { get; set; }
SortedNodeList.cs
using System.Collections.Generic;
namespace Astar
{
public class SortedNodeList
{
private List<Node> _list;
92
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public SortedNodeList()
{
_list = new List<Node>();
}
AstarAlgorithm.cs
using System;
using System.Collections.Generic;
namespace Astar
{
public class AstarAlgorithm
{
public static string Solve(IProblem problem)
{
var openList = new SortedNodeList();
var closedList = new Dictionary<string, Node>();
93
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
root.H = problem.GetHeuristic(root.State);
root.F = root.G + root.H;
openList.Add(root);
94
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 7
1. Obiective
2. Jocuri
Numărul de jucători: 1, 2, n ;
Natura mutărilor: există jocuri cu mutări libere (mutarea este aleasă
conștient, dintr-o mulțime de acțiuni posibile, de exemplu, șahul) și
jocuri cu mutări aleatorii (mutarea este dictată de un factor aleatoriu:
zaruri, cărți de joc, monede etc.). Pot exista jocuri cu ambele tipuri
de mutări;
Cantitatea de informație de care dispune un jucător (un jucător de
șah vede configurația completă a pieselor adversarului, pe când un
jucător de cărți nu are acces la configurațiile celorlalți jucători).
95
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Nu necesită cantități mari de cunoștințe inițiale. Multe jocuri sunt
concepute astfel încât să poată fi rezolvate prin metode de căutare
din starea inițială până în poziția câștigătoare. Bineînțeles, acest
lucru este adevărat numai pentru jocurile simple. Un contraexemplu
este jocul de șah, care presupune un arbore de căutare cu factorul de
ramificare 35, adică în fiecare moment există (în medie) 35 de
mutări disponibile. Având în vedere că un jucător face (tot în medie)
aproximativ 50 de mutări, putem trage concluzia că pentru un joc
trebuie examinate 35250 2,55 10154 variante.
3. Algoritmul minimax
96
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Pentru aplicarea algoritmului, se selectează o limită de adâncime și o
funcție de evaluare. Se construiește arborele până la limita de adâncime. Se
calculează funcția de evaluare pentru frunze și se propagă evaluarea în sus,
selectând minimele pe nivelul minimizant (decizia omului) și maximele pe
nivelul maximizant (decizia calculatorului).
Să considerăm mai întâi căutarea pe un singur nivel (engl. ply, pliu,
cută, strat; în teoria jocurilor, această denumire sugerează numărul de
niveluri în arbore care se studiază):
B C D
8 3 -1
-2 A MAX
-6 B -2 C -4 D MIN
E F G H I J
9 -6 0 -2 -4 -3
97
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
În nodul B, vom avea valoarea minimă a fiilor săi (–6). La fel în C și
D. În A, vom prelua valoarea maximă dintre B, C și D, adică –2.
Aceste valori numerice sunt date de funcția de evaluare statică.
Deoarece această estimare poate fi imprecisă, e importantă căutarea pe cât
mai multe niveluri, pentru a crește numărul de posibilități avute în vedere, și
deci și șansele de a determina mutarea optimă.
Pseudocodul algoritmului minimax este următorul:
JOC =
{
Stare-curentă : STARE
» starea în care trebuie să mute jucătorul care utilizează algoritmul
Acțiuni(s : STARE) : ACȚIUNE*
» o funcție care întoarce lista de acțiuni (mutări) care se pot efectua în starea s
Stare-succesoare(s : STARE, a : ACȚIUNE) : STARE
» o funcție care întoarce starea în care se ajunge aplicând acțiunea a în starea s
Este-terminală(s : STARE) : BOOLEAN
» o funcție care verifică dacă starea s este o stare terminală (câștig, pierdere sau
» remiză)
Evaluare(s : STARE) : NUMĂR-REAL
» funcția de evaluare statică, care calculează valoarea poziției s
» joc de sumă nulă cu doi jucători: cu cât valoarea funcției este mai mare,
» cu atât poziția este mai bună pentru jucătorul care utilizează algoritmul
» și mai rea pentru adversar
}
MINIMAX
intrări: joc : JOC
stare : STARE » în apelul inițial: joc.Stare-curentă
este-nivel-maximizant : BOOLEAN » în apelul inițial: Adevărat
adâncime-curentă : NUMĂR-NATURAL » în apelul inițial: 0
adâncime-maximă : NUMĂR-NATURAL
ieșiri: acțiune : ACȚIUNE
valoare : NUMĂR-REAL
------------------------------------------------------------------------------------------------------------------------
dacă adâncime-curentă ≥ adâncime-maximă sau joc.Este-terminală(stare) atunci
întoarce (Nul, joc.Evaluare(stare))
98
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
dacă este-nivel-maximizant atunci
întoarce (joc.Acțiuni(stare)[valori.Argmax()], valori.Max()) » acțiunea cu valoare maximă
altfel
întoarce (joc.Acțiuni(stare)[valori.Argmin()], valori.Min()) » acțiunea cu valoare minimă
4. Retezarea alfa-beta
MINIMAX-CU-ALFA-BETA
intrări: joc : JOC
adâncime-maximă : NUMĂR-NATURAL
ieșiri: acțiune : ACȚIUNE
------------------------------------------------------------------------------------------------------------------------
(acțiune, _) ← VALOARE-MAXIMĂ(joc, joc. Stare-curentă, alfa ← –∞, beta ← ∞, adâncime-curentă ← 0,
adâncime-maximă)
întoarce acțiune
VALOARE-MAXIMĂ
intrări: joc : JOC
stare : STARE
alfa : NUMĂR-REAL
beta : NUMĂR-REAL
99
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
adâncime-curentă : NUMĂR-NATURAL
adâncime-maximă : NUMĂR-NATURAL
ieșiri: acțiune : ACȚIUNE
valoare : NUMĂR-REAL
------------------------------------------------------------------------------------------------------------------------
dacă adâncime-curentă ≥ adâncime-maximă sau joc.Este-terminală(stare) atunci
întoarce joc.Evaluare(stare)
VALOARE-MINIMĂ
intrări: joc : JOC
stare : STARE
alfa : NUMĂR-REAL
beta : NUMĂR-REAL
adâncime-curentă : NUMĂR-NATURAL
adâncime-maximă : NUMĂR-NATURAL
ieșiri: acțiune : ACȚIUNE
valoare : NUMĂR-REAL
------------------------------------------------------------------------------------------------------------------------
dacă adâncime-curentă ≥ adâncime-maximă sau joc.Este-terminală(stare) atunci
întoarce joc.Evaluare(stare)
3 A MAX
3 B -5 C MIN
D E F G
3 5 -5
101
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3 A MAX
3 B 2 C MIN
D E F G H MAX
3 5 (4)
0 I J M N MIN
2 (7) (8)
K L
0 (7)
102
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5. Aplicație
103
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
mutări posibile: fiecare piesă poate fi mutată în orice direcție, într-un
careu liber adiacent.
104
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Trebuie implementate doar următoarele metode:
105
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3
2
1
0
0 1 2 3
F dyc dyo ,
c o
unde dyc reprezintă avansul pieselor calculatorului, iar dyo, ale omului.
Funcția va fi 0 când niciun jucător nu are vreun avantaj, de exemplu:
3
2 C C O O
1 O O C C
0
0 1 2 3
F = (1+1+2+2) – (1+1+2+2) = 0.
3
2
1 O O O O
0 C C C C
0 1 2 3
F = (3+3+3+3) – (1+1+1+1) = 8.
106
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Funcția va fi mică când omul are un avantaj, de exemplu:
3 O O O O
2 C C C C
1
0
0 1 2 3
F 12 y c y o ,
c o
MainForm.cs
using System;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
namespace SimpleCheckers
{
public partial class MainForm : Form
{
private Board _board;
private int _selected; // indexul piesei selectate
private PlayerType _currentPlayer; // om sau calculator
private Bitmap _boardImage;
public MainForm()
{
InitializeComponent();
try
{
_boardImage = (Bitmap)Image.FromFile("board.png");
}
catch
{
MessageBox.Show("Nu se poate incarca board.png");
Environment.Exit(1);
108
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
pictureBoxBoard.Refresh();
}
if (_board == null)
return;
109
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
if (_selected == -1)
{
foreach (Piece p in _board.Pieces.Where(a => a.Player == PlayerType.Human))
{
if (p.X == mouseX && p.Y == mouseY)
{
_selected = p.Id;
pictureBoxBoard.Refresh();
break;
}
}
}
else
{
Piece selectedPiece = _board.Pieces[_selected];
CheckFinish();
110
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
pictureBoxBoard.Refresh();
_currentPlayer = PlayerType.Human;
CheckFinish();
}
if (end)
{
if (winner == PlayerType.Computer)
{
MessageBox.Show("Calculatorul a castigat!");
_currentPlayer = PlayerType.None;
}
else if (winner == PlayerType.Human)
{
MessageBox.Show("Ai castigat!");
_currentPlayer = PlayerType.None;
}
}
}
111
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
SolidBrush brush = transparentRed;
if (b1.Pieces[i].Player == PlayerType.Human)
brush = transparentGreen;
Minimax.cs
using System;
namespace SimpleCheckers
{
/// <summary>
112
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// Implementeaza algoritmul de cautare a mutarii optime
/// </summary>
public class Minimax
{
private static Random _rand = new Random();
/// <summary>
/// Primeste o configuratie ca parametru, cauta mutarea optima si returneaza configuratia
/// care rezulta prin aplicarea acestei mutari optime
/// </summary>
public static Board FindNextBoard(Board currentBoard)
{
throw new Exception("Aceasta metoda trebuie implementata");
}
}
}
Board.cs
using System;
using System.Collections.Generic;
using System.Linq;
namespace SimpleCheckers
{
/// <summary>
/// Reprezinta o configuratie a jocului (o tabla de joc) la un moment dat
/// </summary>
public class Board
{
public int Size { get; set; } // dimensiunea tablei de joc
public List<Piece> Pieces { get; set; } // lista de piese, atat ale omului cat si ale calculatorului
public Board()
{
Size = 4;
Pieces = new List<Piece>(Size * 2);
113
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public Board(Board b)
{
Size = b.Size;
Pieces = new List<Piece>(Size * 2);
/// <summary>
/// Calculeaza functia de evaluare statica pentru configuratia (tabla) curenta
/// </summary>
public double EvaluationFunction()
{
throw new Exception("Aceasta metoda trebuie implementata");
}
/// <summary>
/// Creeaza o noua configuratie aplicand mutarea primita ca parametru in configuratia curenta
/// </summary>
public Board MakeMove(Move move)
{
Board nextBoard = new Board(this); // copy
nextBoard.Pieces[move.PieceId].X = move.NewX;
nextBoard.Pieces[move.PieceId].Y = move.NewY;
return nextBoard;
}
/// <summary>
/// Verifica daca configuratia curenta este castigatoare
/// </summary>
/// <param name="finished">Este true daca cineva a castigat si false altfel</param>
/// <param name="winner">Cine a castigat: omul sau calculatorul</param>
public void CheckFinish(out bool finished, out PlayerType winner)
{
if (Pieces.Where(p => p.Player == PlayerType.Human && p.Y == Size - 1).Count() == Size)
{
finished = true;
winner = PlayerType.Human;
return;
}
114
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
finished = false;
winner = PlayerType.None;
}
}
}
Piece.cs
using System;
using System.Collections.Generic;
namespace SimpleCheckers
{
public enum PlayerType { None, Computer, Human };
/// <summary>
/// Reprezinta o piesa de joc
/// </summary>
public class Piece
{
public int Id { get; set; } // identificatorul piesei
public int X { get; set; } // pozitia X pe tabla de joc
public int Y { get; set; } // pozitia Y pe tabla de joc
public PlayerType Player { get; set; } // carui tip de jucator apartine piesa (om sau calculator)
/// <summary>
/// Returneaza lista tuturor mutarilor permise pentru piesa curenta (this)
/// in configuratia (tabla de joc) primita ca parametru
/// </summary>
public List<Move> ValidMoves(Board currentBoard)
{
throw new Exception("Aceasta metoda trebuie implementata");
}
115
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Testeaza daca o mutare este valida intr-o anumita configuratie
/// </summary>
public bool IsValidMove(Board currentBoard, Move move)
{
throw new Exception("Aceasta metoda trebuie implementata");
}
}
}
Move.cs
namespace SimpleCheckers
{
/// <summary>
/// Reprezinta mutarea unei singure piese
/// </summary>
public class Move
{
public int PieceId { get; set; } // id-ul piesei mutate
public int NewX { get; set; } // noua pozitie X
public int NewY { get; set; } // noua pozitie Y
116
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 8
Algoritmi evolutivi
1. Obiective
117
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
permițând apariția unor trăsături care nu ar fi apărut în cadrul
populației doar prin selecție și încrucișare.
Structura generală a unui astfel de algoritm este cea din figura 8.1.
Codificarea diferă de la problemă la problemă, cele mai des folosite
metode fiind codificările binară și reală. Condiția de stop se poate referi la
evoluția pentru un anumit număr de generații sau la proprietățile populației
curente, de exemplu convergența populației către o anumită valoare,
pierderea diversității indivizilor din populație etc.
Dimensiunea populației poate fi în jur de 50. Pentru probleme
simple poate fi mai mic (30), iar pentru probleme dificile poate fi mai mare
(100). Dacă sunt prea puțini cromozomi, algoritmul nu are diversitatea
necesară găsirii soluției. Dacă sunt prea mulți, algoritmul va fi mai lent, fără
a se îmbunătăți însă calitatea soluției.
Numărul maxim de generații variază de obicei între 100-1000, în
funcție de dificultatea problemei.
118
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3. Tipuri de codificare
i 1 2 3 4 5
wi 70 55 40 15 5
vi 40 15 5 30 10
119
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Exemplul 3.1.2. Problema împachetării
Se consideră un set de n obiecte caracterizate prin dimensiunile
d1, d2, ..., dn și o mulțime de m cutii având capacitățile c1, c2, ..., cm . Se pune
problema plasării obiectelor în cutii astfel încât capacitatea acestora să nu
fie depășită, iar numărul de cutii utilizate să fie cât mai mic. O posibilă
reprezentarea binară pentru această problemă este următoarea: se utilizează
o matrice cu n linii și m coloane iar elementul Mij are valoarea 1 dacă
obiectul i este plasat în cutia j și 0 în caz contrar. Prin liniarizarea matricii se
ajunge ca fiecare soluție potențială să fie reprezentată printr-un cromozom
cu m · n gene.
n
f (x) n A xi2 A cos( xi )
i 1
120
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Orice problemă de minimizare poate fi transformată într-una de
maximizare prin schimbarea semnului funcției obiectiv. Pentru o problemă
de minimizare în care dorim minimizarea unei funcții g(x), funcția de
adaptare va fi F(x) = –g(x).
4. Pseudocodul general
PROBLEMĂ =
{
Funcție-de-adaptare(x : NUMĂR-REAL*) : NUMĂR-REAL
» funcția care definește problema de optimizare (funcția de fitness)
Număr-gene : NUMĂR-NATURAL
» dimeniunea problemei, numărul de parametri de intrare ai funcției de adaptare
Domeniu(i : NUMĂR-NATURAL) : NUMĂR-REAL*
» această definiție este pentru codare reală, pentru codare binară domeniul este {0,1}
» întoarce o listă cu 2 elemente: domeniul genei cu indexul i,
» adică al parametrului de intrare xi al funcției de adaptare: [xi;min, xi;max]
}
PARAMETRI =
{
Număr-cromozomi : NUMĂR-NATURAL
» dimensiunea populației
Probabilitate-încrucișare : NUMĂR-REAL([0, 1])
» probabilitatea (rata) de încrucișare (crossover)
Probabilitate-mutație : NUMĂR-REAL([0, 1])
» probabilitatea (rata) de mutație
Număr-maxim-generații : NUMĂR-NATURAL
» criteriu de terminare
}
CROMOZOM =
{
Valori : NUMĂR-REAL*
» o listă de intrări pentru funcția de adaptare de dimensiune Număr-gene
Adaptare : NUMĂR-REAL
» valoarea funcției de adaptare pentru cromozomul curent
}
ALGORITM-EVOLUTIV
intrări: problemă : PROBLEMĂ
parametri : PARAMETRI
ieșiri: soluție : CROMOZOM » individul care maximizează funcția de adaptare
------------------------------------------------------------------------------------------------------------------------
populație ← INIȚIALIZARE(problemă, parametri) » listă de cromozomi
populație ← CALCUL-ADAPTARE(populație, problemă)
121
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
repetă de parametri.Număr-maxim-generații ori
populație-nouă ← [ ]
părinți ← SELECȚIE(populație, problemă) » listă de dimensiune 2 * parametri.Număr-cromozomi
soluție ← CEL-MAI-ADAPTAT(populație)
întoarce soluție
INIȚIALIZARE
intrări: problemă : PROBLEMĂ
parametri : PARAMETRI
ieșiri: populație : CROMOZOM*
------------------------------------------------------------------------------------------------------------------------
pentru-fiecare cromozom din [0 .. parametri.Număr-cromozomi]
pentru-fiecare genă din [0 .. problemă.Număr-gene]
(xmin, xmax) ← problemă.Domeniu(genă)
populație[cromozom].Valori[genă] ← Număr-aleatoriu-uniform(xmin, xmax)
întoarce populație
CALCUL-ADAPTARE
intrări: populație : CROMOZOM*
problemă : PROBLEMĂ
ieșiri: populație : CROMOZOM*
------------------------------------------------------------------------------------------------------------------------
pentru-fiecare cromozom din populație
cromozom.Adaptare ← problemă.Funcție-de-adaptare(cromozom.Valori)
întoarce populație
CEL-MAI-ADAPTAT
intrări: populație : CROMOZOM*
ieșiri: soluție : CROMOZOM
------------------------------------------------------------------------------------------------------------------------
întoarce populație[populație.Argmax(cr : cr.Adaptare)]
» cromozomul cu funcția de adaptare maximă
122
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5. Operatori genetici
5.1. Selecția
SELECȚIE-RULETĂ
intrări: populație : CROMOZOM*
ieșiri: părinți : CROMOZOM*
------------------------------------------------------------------------------------------------------------------------
valori-adaptare ← populație.Transformă(cr : cr.Adaptare)
» lista de valori ale funcțiilor de adaptare ale tuturor cromozomilor din populație
opțiuni ← EȘANTIONARE-PROPORȚIONALĂ(valori-adaptare, 2 * populație.Dimensiune)
părinți ← [ ]
pentru-fiecare o din opțiuni
părinți.Adaugă (populație[o])
întoarce părinți
EȘANTIONARE-PROPORȚIONALĂ
intrări: valori : NUMĂR-REAL-POZITIV*
n : NUMĂR-NATURAL » numărul de opțiuni dorite
123
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
ieșiri: opțiuni : NUMĂR-NATURAL* » indecșii opțiunilor selectate
------------------------------------------------------------------------------------------------------------------------
sumă ← valori.Sumă()
opțiuni ← [ ]
repetă de n ori
na ← Număr-aleatoriu-uniform(0, sumă)
is ← indexul primului element s ≥ na din sume-parțiale
opțiuni.Adaugă(is)
întoarce opțiuni
SELECȚIE-RANGURI
intrări: populație : CROMOZOM*
ieșiri: părinți : CROMOZOM*
------------------------------------------------------------------------------------------------------------------------
populație-sortată ← populație.Sortează-după(cr : cr.Adaptare, Crescător)
ranguri ← populație.Transformă(cr : populație-sortată.Index(cr))
» cromozomul cel mai adaptat va avea rangul (populație.Dimensiune – 1), iar
» cromozomul cel mai slab adaptat va avea rangul 0
124
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5.1.3. Selecția de tip competiție
SELECȚIE-COMPETIȚIE
intrări: populație : CROMOZOM*
problemă : PROBLEMĂ
dimensiune-competiție : NUMĂR-ÎNTREG
ieșiri: părinți : CROMOZOM*
------------------------------------------------------------------------------------------------------------------------
părinți ← [ ]
repetă de (2 * populație.Dimensiune) ori
competiție ← [ ]
repetă de dimensiune-competiție ori
competiție.Adaugă(un element aleatoriu din populație care nu există în competiție)
» competiție conține doar cromozomi diferiți
părinți.Adaugă(CEL-MAI-ADAPTAT(competiție))
întoarce părinți
5.1.4. Elitismul
Cel mai adaptat individ este copiat direct în noua populație. Asigură
faptul că niciodată nu se pierde soluția cea mai bună.
populație-nouă ← [ CEL-MAI-ADAPTAT(populație) ]
repetă de (parametri.Număr-cromozomi – 1) ori
aplică SELECȚIE, ÎNCRUCIȘARE și MUTAȚIE pentru a genera restul cromozomilor din populație-nouă
5.2. Încrucișarea
125
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5.2.1. Încrucișarea binară
ÎNCRUCIȘARE-BINARĂ
intrări: p1 : CROMOZOM » primul părinte
p2 : CROMOZOM » al doilea părinte
probabilitate : NUMĂR-REAL([0, 1]) » probabilitatea de încrucișare
ieșiri: c1 : CROMOZOM » primul copil
c2 : CROMOZOM » al doilea copil
------------------------------------------------------------------------------------------------------------------------
dacă probabilitate < Număr-aleatoriu-uniform(0, 1) atunci
» nu se face încrucișare, se copiază părinții
dacă Număr-aleatoriu-uniform(0, 1) < 0.5 atunci
întoarce (p1, p2)
altfel
întoarce (p2, p1)
126
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5.2.2. Încrucișarea reală
xi' = ai · xi + (1 – ai) · yi
yi' = (1 – ai) · xi + ai · yi
xi' = a · xi + (1 – a) · yi
yi' = (1 – a) · xi + a · yi
În acest caz, a este un scalar ales aleatoriu din intervalul (0, 1) sau
(–0,25, 1,25). Astfel, copiii vor fi plasați pe un segment de dreaptă
determinat de genele părinților.
127
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
ÎNCRUCIȘARE-REALĂ
intrări: p1 : CROMOZOM » primul părinte
p2 : CROMOZOM » al doilea părinte
probabilitate : NUMĂR-REAL([0, 1]) » probabilitatea de încrucișare
ieșiri: c1 : CROMOZOM » primul copil
c2 : CROMOZOM » al doilea copil
------------------------------------------------------------------------------------------------------------------------
dacă probabilitate < Număr-aleatoriu-uniform(0, 1) atunci
» nu se face încrucișare, se copiază părinții
dacă (Număr-aleatoriu-uniform(0, 1) < 0.5) atunci
întoarce (p1, p2)
altfel
întoarce (p2, p1)
a ← Număr-aleatoriu-uniform(0, 1)
c1.Valori ← a * p1.Valori + (1 – a) * p2.Valori
c2.Valori ← (1 – a) * p1.Valori + a * p2.Valori
» formulele de mai sus sunt vectoriale: calculele se realizează pentru fiecare dimensiune/genă
» în parte; se aplică încrucișarea aritmetică, valorile genelor sunt numere reale
5.3. Mutația
Cel mai simplu și des utilizat tip de mutație binară este cel în care se
selectează o genă iar valoarea acesteia este negată (0 devine 1 iar 1 devine
0) cu o anumită probabilitate, numită probabilitate de mutație și notată cu
pm. Aceasta trebuie să fie în general mică, de exemplu 0,02.
128
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
MUTAȚIE-BINARĂ
intrări: c : CROMOZOM » cromozomul (copilul) înainte de mutație
probabilitate : NUMĂR-REAL([0, 1]) » probabilitatea de mutație
ieșiri: c : CROMOZOM » cromozomul (copilul) după mutație
------------------------------------------------------------------------------------------------------------------------
pentru-fiecare genă din c.Valori.Dimensiune
dacă probabilitate ≥ Număr-aleatoriu-uniform(0, 1) atunci
c.Valori[genă] ← 1 – c.Valori[genă] » 0 devine 1 și 1 devine 0
întoarce c
MUTAȚIE-REALĂ
intrări: c : CROMOZOM » cromozomul (copilul) înainte de mutație
probabilitate : NUMĂR-REAL([0, 1]) » probabilitatea de mutație
problemă : PROBLEMĂ » parametru suplimentar față de varianta binară
ieșiri: c : CROMOZOM » cromozomul (copilul) după mutație
------------------------------------------------------------------------------------------------------------------------
pentru-fiecare genă din c.Valori.Dimensiune
dacă probabilitate ≥ Număr-aleatoriu-uniform(0, 1) atunci
(xmin, xmax) ← problemă.Domeniu(genă)
c.Valori[genă] ← Număr-aleatoriu-uniform(xmin, xmax)
întoarce c
6. Aplicații
r = 100 / (2x + y)
x' = x · r
y' = y · r
130
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Astfel, 2x' + y' va fi întotdeauna 100 (constrângerea va fi satisfăcută
de toți indivizii), iar optimizarea se va face după funcția de adaptare
F(x', y') = x' · y'.
131
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Metoda Solve(...) din clasa EvolutionaryAlgorithm
Trebuie completată bucla principală, cu apelul operatorilor genetici.
Program.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Programul principal care apeleaza algoritmul
/// </summary>
public class Program
{
private static void Main(string[] args)
{
throw new Exception("Aceasta metoda trebuie completata");
132
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
// Console.WriteLine("{0:F2} {1:F2} -> {2:F4}", solution.Genes[0], solution.Genes[1],
// solution.Fitness);
}
}
}
EvolutionaryAlgorithm.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Clasa care implementeaza algoritmul evolutiv pentru optimizare
/// </summary>
public class EvolutionaryAlgorithm
{
/// <summary>
/// Metoda de optimizare care gaseste solutia problemei
/// </summary>
public Chromosome Solve(IOptimizationProblem p, int populationSize,
int maxGenerations, double crossoverRate, double mutationRate)
{
throw new Exception("Aceasta metoda trebuie completata");
133
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
for (int i = 0; i < populationSize; i++)
population[i] = newPopulation[i];
}
return Selection.GetBest(population);
}
}
}
Selection.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Clasa care reprezinta operatia de selectie
/// </summary>
public class Selection
{
private static Random _rand = new Random();
Crossover.cs
using System;
namespace EvolutionaryAlgorithm
{
134
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Clasa care reprezinta operatia de incrucisare
/// </summary>
public class Crossover
{
private static Random _rand = new Random();
Mutation.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Clasa care reprezinta operatia de mutatie
/// </summary>
public class Mutation
{
private static Random _rand = new Random();
Chromosome.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Clasa care reprezinta un individ din populatie
/// </summary>
135
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public class Chromosome
{
public int NoGenes { get; set; } // numarul de gene ale individului
public double[] MinValues { get; set; } // valorile minime posibile ale genelor
public double[] MaxValues { get; set; } // valorile maxime posibile ale genelor
136
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
}
IOptimizationProblem.cs
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Interfata pentru problemele de optimizare
/// </summary>
public interface IOptimizationProblem
{
void ComputeFitness(Chromosome c);
Chromosome MakeChromosome();
}
}
Equation.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Clasa care reprezinta problema din prima aplicatie: rezolvarea ecuatiei
/// </summary>
public class Equation : IOptimizationProblem
{
public Chromosome MakeChromosome()
{
// un cromozom are o gena (x) care poate lua valori in intervalul (-5, 5)
return new Chromosome(1, new double[] { -5 }, new double[] { 5 });
}
double x = c.Genes[0];
// c.Fitness = functia care va fi maximizata
}
}
}
137
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Fence.cs
using System;
namespace EvolutionaryAlgorithm
{
/// <summary>
/// Clasa care reprezinta problema din a doua aplicatie: maximizarea ariei terenului
/// </summary>
public class Fence : IOptimizationProblem
{
public Chromosome MakeChromosome()
{
// un cromozom are doua gene (x si y) care pot lua valori in intervalul (0, 100)
return new Chromosome(2, new double[] { 0, 0 }, new double[] { 100, 100 });
}
double x = c.Genes[0];
double y = c.Genes[1];
138
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 9
Rezoluția propozițională
1. Obiective
139
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
ȘI de SAU-uri). Regulile de conversie sunt prezentate mai jos și trebuie
aplicate în ordine.
1. Implicațiile (I):
φ ⇒ ψ → ¬φ ∨ ψ
φ ⇐ ψ → φ ∨ ¬ψ
φ ⇔ ψ → (¬φ ∨ ψ) ∧ (φ ∨ ¬ψ)
2. Negațiile (N):
¬¬φ → φ
¬(φ ∧ ψ) → ¬φ ∨ ¬ψ
¬(φ ∨ ψ) → ¬φ ∧ ¬ψ
3. Distribuția (D):
φ ∨ (ψ ∧ χ) → (φ ∨ ψ) ∧ (φ ∨ χ)
(φ ∧ ψ) ∨ χ → (φ ∨ χ) ∧ (ψ ∨ χ)
φ ∨ (φ1 ∨ ... ∨ φn) → φ ∨ φ1 ∨ ... ∨ φn
(φ1 ∨ ... ∨ φn) ∨ φ → φ1 ∨ ... ∨ φn ∨ φ
φ ∧ (φ1 ∧ ... ∧ φn) → φ ∧ φ1 ∧ ... ∧ φn
(φ1 ∧ ... ∧ φn) ∧ φ → φ1 ∧ ... ∧ φn ∧ φ
¬(g ∧ (r ⇒ f))
I ¬(g ∧ (¬r ∨ f))
N ¬g ∨ ¬(¬r ∨ f)
¬g ∨ (¬¬r ∧ ¬f)
¬g ∨ (r ∧ ¬f)
D (¬g ∨ r) ∧ (¬g ∨ ¬f)
140
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3. Algoritmul de rezoluție propozițională
Afirmații:
Afară plouă sau este soare.
Dacă este soare, atunci este cald.
Reprezentări:
ploaie ∨ soare
soare ⇒ cald
Cu alte cuvinte, din două clauze în care una conține un literal iar
cealaltă negația acelui literal, putem deduce o clauză care conține reuniunea
literalilor celor două clauze-premisă, fără perechea complementară.
Într-o formulare mai generală, rezoluția propozițională se bazează pe
următoarea regulă de inferență:
141
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
φ1 ∨ ... ∨ φi–1 ∨ χ ∨ φi+1 ∨... ∨ φn
ψ1 ∨ ... ∨ ψj–1 ∨ ¬χ ∨ ψj+1 ∨... ∨ ψm
---------------------------------------------------------------------------
φ1 ∨ ... ∨ φi–1 ∨ φi+1 ∨... ∨ φn ∨ ψ1 ∨ ... ∨ ψj–1 ∨ ψj+1 ∨... ∨ ψm
sau echivalent:
C1 = {..., χ, ...}
C2 = {..., ¬χ, ...}
-------------------------------
C1 ∖ { χ } ⋃ C2 ∖ { ¬χ }
p∨q
¬p ∨ r
----------
q∨r
¬p ∨ q
p∨q
----------
q
142
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
p∨q∨r
¬p
-------------
q∨r
p
¬p
------
{}
p∨q
¬p ∨ ¬q
-----------
p ∨ ¬p
q ∨ ¬q
p∨q
¬p ∨ ¬q
------------ Greșit!
{}
143
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
4. Demonstrarea automată a propozițiilor
1. ¬p ∨ r Premisă
2. ¬q ∨ r Premisă
3. p∨q Premisă
4. q∨r 1, 3
5. r 2, 4
1. p∨q Premise
2. p ∨ ¬q Premise
3. ¬p ∨ q Premise
4. ¬p ∨ ¬q Premise
5. p 1, 2
6. ¬p 3, 4
7. {} 5, 6
144
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Această relație dintre nerealizabilitate și implicația logică poate fi
folosită pentru determinarea implicațiilor logice, adică pentru demonstrarea
generală a teoremelor. Pentru aceasta, se neagă concluzia, se adaugă la
mulțimea de premise și se folosește rezoluția pentru a determina dacă
mulțimea de clauze rezultată este nerealizabilă.
O propoziție φ este demonstrabilă dintr-o mulțime Δ de propoziții
dacă și numai dacă procesul de rezoluție propozițională generează clauza
vidă din mulțimea Δ ∪ {¬φ}.
Ca exemplu, fie următoarea problemă. Se dau trei premise: p, p ⇒ q,
(p ⇒ q) ⇒ (q ⇒ r) și trebuie demonstrat r. Procesul de rezoluție este descris
mai jos. Clauzele 3 și 4 rezultă din aducerea premisei 3 în forma normal
conjunctivă: (p ∨ ¬q ∨ r) ∧ (¬q ∨ r).
1. p Premisa 1
2. ¬p ∨ q Premisa 2
3. p ∨ ¬q ∨ r Premisa 3 FNC
4. ¬q ∨ r Premisa 3 FNC
5. ¬r Concluzia negată
6. q 1, 2
7. r 4, 6
8. {} 5, 7
5. Decidabilitatea
6. Aplicații
p
p q
(q r ) s
p
p p q
p q
(q r ) s q s
r s
146
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
6.1b. Pentru aceleași premise ca la problema 1, încercați să
demonstrați adevărul propoziției r.
147
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
p
NOT p OR q
NOT q OR s
NOT r OR s
NOT s
148
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Metoda TryResolve(Clause c1, Clause c2) din clasa Resolution
Metoda care încearcă să găsească literali complementari în cele două
clauze primite ca parametri. Întoarce o listă de rezolvenți, posibil vidă.
ex1a.proof
0. p
1. NOT p OR q
2. NOT q OR s
3. NOT r OR s
4. NOT s
5. q <- 0+1
6. NOT p OR s <- 1+2
7. NOT q <- 2+4
8. s <- 2+5
9. NOT r <- 3+4
10. NOT p <- 4+6
11. {} <- 4+8
Demonstratie:
0. p
1. NOT p OR q
2. NOT q OR s
4. NOT s
5. q <- 0+1
8. s <- 2+5
11. {} <- 4+8
ex1b.proof
0. p
1. NOT p OR q
2. NOT q OR s
3. NOT r OR s
4. NOT r
5. q <- 0+1
149
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
6. NOT p OR s <- 1+2
7. s <- 2+5
Program.cs
using System;
namespace Resolution
{
public class Program
{
private static void Main(string[] args)
{
Resolution res = new Resolution();
res.Prove(new FactBase("ex1a.facts"));
Console.WriteLine("\r\n");
res.Prove(new FactBase("ex1b.facts"));
Console.WriteLine("\r\n");
Resolution.cs
using System;
using System.Collections.Generic;
namespace Resolution
{
/// <summary>
/// Clasa care ajuta verificarea procesului de rezolutie, in care din doua clauze rezulta
una noua. S1 si S2 reprezinta indecsii clauzelor sursa.
/// O pereche de clauze trebuie tratata o singura data.
/// </summary>
public class Pair
{
public int S1 { get; set; }
public int S2 { get; set; }
150
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public Pair(int s1, int s2)
{
S1 = s1;
S2 = s2;
}
}
/// <summary>
/// Clasa corespunzatoare algoritmului de rezolutie
/// </summary>
public class Resolution
{
/// <summary>
/// Metoda care implementeaza algoritmul. Primeste o baza de fapte si incearca sa
ajunga la o contradictie
/// </summary>
public void Prove(FactBase fb)
{
List<Pair> matchedPairs = new List<Pair>();
while (fbHasChanged)
{
// pentru toate perechile de clauze care nu au mai fost prelucrate, apeleaza TryResolve
// daca o clauza-rezolvent c este vida (lista sa de literali este vida), atunci se adauga clauza
// c in baza de fapte si se afiseaza demonstratia: fb.WriteProof(c)
// daca nu, se adauga clauza c in baza de fapte si continua procesul
// la adaugarea unei clauze c in baza de fapte, trebuie setate c.Source1 si c.Source1
// (indecsii clauzelor din care a rezultat c)
// adaugati clauza in baza de fapte cu metoda fb.AddClause(c), care face si afisarea si
// salvarea in fisierul de demonstratie
}
/// <summary>
/// Metoda care incearca sa gaseasca literali complementari in cele doua clauze sursa.
Intoarce o lista (posibil vida) de rezolventi
/// </summary>
private List<Clause> TryResolve(Clause c1, Clause c2)
{
List<Clause> resolvents = new List<Clause>();
151
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
return resolvents;
}
/// <summary>
/// Elimina literalii duplicati din clauza
/// </summary>
private Clause RemoveDuplicates(Clause clause)
{
Clause c = new Clause();
return c;
}
/// <summary>
/// Testeaza daca o baza de fapte contine o clauza
/// </summary>
private bool Contains(List<Clause> fbClauses, Clause clause)
{
foreach (Clause fbc in fbClauses)
{
if (AreEqual(fbc, clause))
return true;
}
return false;
}
/// <summary>
/// Testeaza daca doua clauze sunt egale, adica au aceiasi literali, indiferent de
ordinea in care apar acestia
/// </summary>
private bool AreEqual(Clause c1, Clause c2)
{
foreach (Literal lit in c1.Literals)
{
if (!(Contains(c2, lit)))
return false;
}
return true;
152
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
/// <summary>
/// Testeaza daca o clauza contine un literal
/// </summary>
private bool Contains(Clause clause, Literal literal)
{
foreach (Literal lit in clause.Literals)
{
if (lit.Atom == literal.Atom && lit.IsNegative == literal.IsNegative)
return true;
}
return false;
}
/// <summary>
/// Testeaza daca o lista de obiecte "Pair" contine o anumita pereche
/// </summary>
private bool Contains(List<Pair> list, Pair pair)
{
foreach (Pair p in list)
{
if (p.S1 == pair.S1 && p.S2 == pair.S2)
return true;
}
return false;
}
}
}
FactBase.cs
using System;
using System.Collections.Generic;
using System.IO;
namespace Resolution
{
/// <summary>
/// Clasa care corespunde intregii multimi de clauze asupra careia se desfasoara
procesul de inferenta
/// </summary>
public class FactBase
{
153
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Numele bazei de fapte; corespunde numelui fisierului din care se citesc premisele
/// </summary>
public string Name { get; set; }
/// <summary>
/// Lista de clauze care compun baza de fapte
/// </summary>
public List<Clause> Clauses { get; set; }
/// <summary>
/// Constructorul care initializeaza baza de fapte cu clauzele din fisierul .facts
/// </summary>
public FactBase(string fileName)
{
Name = Path.GetFileNameWithoutExtension(fileName);
AddClause(new Clause(line));
}
sr.Close();
}
/// <summary>
/// Adauga o clauza in baza de fapte
/// </summary>
public void AddClause(Clause clause)
{
StreamWriter sw = new StreamWriter(Name + ".proof", true);
if (clause.Source1 == -1) // premisele initiale, citite din fisier
{
Console.WriteLine("{0}. {1}", Clauses.Count, clause.ToString());
sw.WriteLine("{0}. {1}", Clauses.Count, clause.ToString());
}
154
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
else // clauzele rezultate din procesul de rezolutie
{
Console.WriteLine("{0}. {1} <- {2}+{3}", Clauses.Count, clause.ToString(),
clause.Source1, clause.Source2);
sw.WriteLine("{0}. {1} <- {2}+{3}", Clauses.Count, clause.ToString(),
clause.Source1, clause.Source2);
}
sw.Close();
Clauses.Add(clause);
}
/// <summary>
/// Afiseaza intreaga demonstratie, urmarind indecsii Source1 si Source2 pana la
premise. Include doar clauzele care contribuie efectiv la demonstratie.
/// </summary>
public void WriteProof(Clause contradiction)
{
StreamWriter sw = new StreamWriter(Name + ".proof", true);
sw.WriteLine("\r\nDemonstratie:\r\n");
inProof.Sort();
Console.WriteLine("\r\nDemonstratie:\r\n");
for (int i = 0; i < inProof.Count; i++)
{
Clause clause = Clauses[inProof[i]];
if (clause.Source1 != -1)
{
155
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Console.WriteLine("{0}. {1} <- {2}+{3}", Clauses.IndexOf(clause),
clause.ToString(), clause.Source1, clause.Source2);
sw.WriteLine("{0}. {1} <- {2}+{3}", Clauses.IndexOf(clause), clause.ToString(),
clause.Source1, clause.Source2);
}
else
{
Console.WriteLine("{0}. {1} ", Clauses.IndexOf(clause), clause.ToString());
sw.WriteLine("{0}. {1} ", Clauses.IndexOf(clause), clause.ToString());
}
}
sw.Close();
}
}
}
Clause.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace Resolution
{
/// <summary>
/// Reprezinta o disjunctie de literali, de exemplu: "p OR NOT q OR r"
/// </summary>
public class Clause
{
/// <summary>
/// Literalii din disjunctie
/// </summary>
public List<Literal> Literals { get; set; }
/// <summary>
/// In baza de fapte, fiecare clauza are un index. In procesul de rezolutie, din doua
clauze se deduce una noua. Source1 este indexul primei clauze din care s-a dedus clauza
curenta (this).
/// </summary>
public int Source1 { get; set; }
/// <summary>
/// In baza de fapte, fiecare clauza are un index. In procesul de rezolutie, din doua
clauze se deduce una noua. Source2 este indexul celei de a doua clauze din care s-a dedus
clauza curenta (this).
156
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// </summary>
public int Source2 { get; set; }
public Clause()
{
Literals = new List<Literal>();
Source1 = Source2 = -1;
}
/// <summary>
/// Constructorul care primeste o linie din fisierul .facts si o imparte in literali
/// </summary>
public Clause(string clause)
{
Literals = new List<Literal>();
/// <summary>
/// Metoda care formateaza literalii clauzei pentru afisare si salvare in fisier
/// </summary>
public override string ToString()
{
if (Literals.Count == 0)
return "{}";
StringBuilder sb = new StringBuilder();
Literal lit;
157
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
return sb.ToString();
}
}
}
Literal.cs
namespace Resolution
{
/// <summary>
/// Reprezinta un literal, de exemplu "p" sau "NOT p"
/// </summary>
public class Literal
{
/// <summary>
/// Formula atomica a literalului, fara "NOT" daca literalul este negat. De exemplu:
pentru "p" este "p", pentru "NOT q" este "q"
/// </summary>
public string Atom { get; set; }
/// <summary>
/// Este adevarat daca literalul este negat ("NOT")
/// </summary>
public bool IsNegative { get; set; }
158
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 10
1. Obiective
2. Mulțimi fuzzy
A ( x) : X [0,1]
159
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Pentru a reprezenta o mulțime fuzzy, trebuie să-i definim mai întâi
funcția de apartenență. În acest caz, o mulțime fuzzy A este complet definită
de mulțimea tuplelor:
A {( x, A ( x)) | x X }
A 1 / x1 ... n / xn
supp(A) = {x X | A ( x) 0} .
n(A) = {x X | A ( x) 1} .
161
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
2.2. Numere fuzzy
cx
1 , c x c
x c
A ( x) 1 ,c x c
0, altfel
162
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
cx
1 , c x c
1, c x d
A ( x) x d
1 ,d x d
0, altfel
163
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
În logica fuzzy, regula de inferență corespunzătoare este următoarea:
3.2. Defuzzificarea
x (x )
i A i
xCG i
(x )
i
A i
164
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
În figura 10.6, programul folosește drept universuri de discurs
intervalele (0,100). În figura din dreapta, mulțimea delimitată cu albastru
este B, cea delimitată cu roz este B' iar valoarea pe axa X indicată cu roșu
este centrul de greutate.
165
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Figura 10.7. Sistem de inferență fuzzy de tip Mamdani
cu două reguli și două intrări stricte
166
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
DACĂ finanțarea-proiectului este adecvată
ȘI numărul de angajați este redus
ATUNCI riscul-proiectului este mic.
4.2. Fuzzificarea
167
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
4.4. Calcularea consecvenților
4.6. Defuzzificarea
168
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Figura 10.8. Defuzzificarea utilizând metoda centrului de greutate
5. Aplicații
169
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Figura 10.9. Diagrama UML de clase a aplicației complete
170
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Metoda ComputeOutput(double distanceLeft) din clasa
FuzzyInference
Metoda care implementează procesul efectiv de inferență Mamdani
cu reguli multiple. Metoda primește ca parametru distanța rămasă și
folosește informațiile date de regulile și mulțimile fuzzy pentru a calcula
accelerația metroului.
0.75
0.5
0.25
0
0 1 2 3 4 5 6 7 8 9
v[0] → μ(xmin)
v[n – 1] → μ(xmax).
171
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
i
xi xmin xmax xmin .
n 1
MainForm.cs
using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;
namespace SubwayControl
{
public partial class MainForm : Form
{
/// <summary>
/// Pozitia metroului, unde 0 este pozitia in prima statie si 1 este pozitia in a doua
statie
/// </summary>
private double _position;
public MainForm()
{
InitializeComponent();
_position = 0;
}
/// <summary>
/// Evenimentul de refresh al pictureBoxRoute, care deseneaza "metroul" conform
pozitiei sale curente _position
/// </summary>
private void pictureBoxRoute_Paint(object sender, PaintEventArgs e)
{
double p = _position;
if (p < -0.01)
172
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
p = -0.01;
if (p > 1.01)
p = 1.01;
e.Graphics.DrawImage(b, 0, 0);
}
/// <summary>
/// Evenimentul de click al butonului "Porneste", in care se desfasoara deplasarea
animata a metroului.
/// Aici se apeleaza metoda ComputeOutput din FuzzyInference.
/// </summary>
private void buttonStart_Click(object sender, EventArgs e)
{
FuzzyInference fuzzy = new FuzzyInference();
_position = 0;
double speed = 0;
double distanceLeft = 1000;
while (changed)
{
double acc = fuzzy.ComputeOutput(distanceLeft);
if (double.IsNaN(acc))
throw new Exception("Nu se aplica nicio regula fuzzy!");
173
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
previousDistance = distanceLeft;
distanceLeft -= speed;
_position = (1000 - distanceLeft) / 1000.0;
pictureBoxRoute.Refresh();
}
174
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
MessageBox.Show(copyright, "Despre Metroul fuzzy");
}
}
}
FuzzyInference.cs
using System;
using System.Collections.Generic;
namespace SubwayControl
{
/// <summary>
/// Clasa care contine procesul de inferenta fuzzy
/// </summary>
public class FuzzyInference
{
private UniverseOfDiscourse _distance, _acceleration;
private FuzzySet _lowDistance, _mediumDistance, _highDistance;
private FuzzySet _negativeAcceleration, _zeroAcceleration, _positiveAcceleration;
private List<FuzzyRule> _rules;
public FuzzyInference()
{
CreateUniverses();
CreateSets();
CreateRules();
}
/// <summary>
/// Defineste universurile de discurs ale problemei.
/// </summary>
private void CreateUniverses()
{
_distance = new UniverseOfDiscourse("Distanta ramasa", 0, 1000, "m");
_acceleration = new UniverseOfDiscourse("Acceleratia", -1, 1, "m/s^2");
}
/// <summary>
/// Defineste multimile fuzzy, aici doar numere fuzzy triunghiulare sau trapezoidale.
/// </summary>
private void CreateSets()
{
175
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
_lowDistance = new FuzzySet("Distanta mica", new
TrapezoidalMembershipFunction(-0.01, 0, 200, 300));
_mediumDistance = new FuzzySet("Distanta medie", new
TriangularMembershipFunction(200, 500, 800));
_highDistance = new FuzzySet("Distanta mare", new
TrapezoidalMembershipFunction(700, 800, 1000, 1000.01));
/// <summary>
/// Defineste regulile fuzzy care vor fi folosite in procesul de inferenta.
/// </summary>
private void CreateRules()
{
_rules = new List<FuzzyRule>();
/// <summary>
/// Metoda apelata din exterior, care pentru o intrare stricta trebuie sa returneze o
iesire stricta.
/// In cazul metroului, intrarea este distanta ramasa pana la urmatoarea statie, iar
iesirea este noua valoare pentru acceleratie.
/// </summary>
public double ComputeOutput(double distanceLeft)
{
// fuzzificarea pentru antecedentul fiecarei reguli fuzzy
// reprezentarea multimilor induse in consecventi prin esantionare, de exemplu cu
100 de valori discrete
// agregarea multimilor induse prin reuniune
// defuzzificarea cu metoda centrului de greutate - aceasta este valoarea returnata
de metoda
176
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
throw new Exception("Aceasta metoda trebuie implementata.");
}
}
}
UniverseOfDiscourse.cs
namespace SubwayControl
{
/// <summary>
/// Clasa care defineste un univers de discurs, cu nume, unitate de masura (de exemplu
metri pentru distanta, m/s^2 pentru acceleratie)
/// si valorile minime si maxime ale intervalului de definitie
/// </summary>
public class UniverseOfDiscourse
{
public string Name { get; set; }
177
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
FuzzySet.cs
namespace SubwayControl
{
/// <summary>
/// Defineste o multime fuzzy, cu un nume (de exemplu "distanta mica") si o functie de
apartenenta
/// </summary>
public class FuzzySet
{
public string Name { get; set; }
FuzzyRule.cs
namespace SubwayControl
{
/// <summary>
/// Clasa care defineste o regula fuzzy, de forma: daca x este A, atunci y este B.
/// Antecedentul este multimea fuzzy A iar consecventul este multimea fuzzy B.
/// </summary>
public class FuzzyRule
{
/// <summary>
/// Antecedentul regulei (daca/if). Daca sunt mai multi antecedenti, trebuie o lista sau
un vector.
/// </summary>
public FuzzySet Antecedent { get; set; }
/// <summary>
/// Consecventul regulei (atunci/then)
/// </summary>
public FuzzySet Consequent { get; set; }
178
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public FuzzyRule(FuzzySet antecedent, FuzzySet consequent)
{
Antecedent = antecedent;
Consequent = consequent;
}
}
}
MembershipFunction.cs
using System;
namespace SubwayControl
{
public interface IMembershipFunction
{
double ComputeMembership(double x);
}
/// <summary>
/// Functia de apartenenta a unui numar fuzzy triunghiular
/// </summary>
public class TriangularMembershipFunction : IMembershipFunction
{
private double _center;
private double _leftWidth;
private double _rightWidth;
/// <summary>
/// Spre deosebire de definitia din text, cu centru, latime la stanga si latime la
dreapta,
/// aici constructorul primeste punctul minim al suportului, centrul si punctul maxim
al suportului.
/// S-a considerat ca aceasta definitie este mai intuitiva atunci cand se definesc
multimile efective pe universul de discurs.
/// </summary>
public TriangularMembershipFunction(double supportMin, double center, double
supportMax)
{
_center = center;
_leftWidth = center - supportMin;
_rightWidth = supportMax - center;
179
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Calculul efectiv al functiei de apartenenta pentru un x din universul de discurs
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public double ComputeMembership(double x)
{
throw new Exception("Aceasta metoda trebuie implementata.");
}
}
/// <summary>
/// Functia de apartenenta a unui numar fuzzy trapezoidal
/// </summary>
public class TrapezoidalMembershipFunction : IMembershipFunction
{
private double _coreMin;
private double _coreMax;
private double _leftWidth;
private double _rightWidth;
/// <summary>
/// Spre deosebire de definitia din text, cu valorile minime si maxime ale nucleului,
latime la stanga si latime la dreapta,
/// aici constructorul primeste punctele minime ale suportului si nucleului, respectiv
punctele maxime ale nucleului si suportului.
/// S-a considerat ca aceasta definitie este mai intuitiva atunci cand se definesc
multimile efective pe universul de discurs.
/// </summary>
public TrapezoidalMembershipFunction(double supportMin, double coreMin, double
coreMax, double supportMax)
{
_coreMin = coreMin;
_coreMax = coreMax;
_leftWidth = coreMin - supportMin;
_rightWidth = supportMax - coreMax;
180
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
public double ComputeMembership(double x)
{
if (x >= _coreMin - _leftWidth && x <= _coreMin)
return 1.0 - (_coreMin - x) / _leftWidth;
if (x > _coreMin && x <= _coreMax)
return 1;
if (x > _coreMax && x <= _coreMax + _rightWidth)
return 1.0 - (x - _coreMax) / _rightWidth;
return 0;
}
}
}
181
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
182
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 11
Rețele bayesiene
1. Obiective
183
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Pe baza acestei relații rezultă teorema lui Bayes, care este importantă
pentru toate raționamentele probabilistice pe care le vom studia.
Considerăm formula probabilităților condiționate:
( )
( | )
( )
( ) ( | ) ( )
( ) ( | ) ( )
( | ) ( )
( | )
( )
( | ) ( )
( | )
( )
unde I este ipoteza, E este evidența (provenind din datele observate), ( )
este probabilitatea a-priori a ipotezei, adică gradul inițial de încredere în
ipoteză, ( | ) este verosimilitatea datelor observate (likelihood), adică
măsura în care s-a observat evidența în condițiile îndeplinirii ipotezei, iar
( | ) este probabilitatea a-posteriori a ipotezei, dată fiind evidența.
Relația este importantă deoarece putem calcula astfel probabilitățile
cauzelor, date fiind efectele. Este mai simplu de cunoscut când o cauză
determină un efect, dar invers, când cunoaștem un efect, probabilitățile
cauzelor nu pot fi cunoscute imediat. Teorema ne ajută să diagnosticăm o
anumită situație sau să testăm o ipoteză.
Să considerăm următorul exemplu de diagnosticare. Știm că
probabilitatea de apariție a meningitei în populația generală este ( )
. De asemenea, probabilitatea ca o persoană să aibă gâtul înțepenit
184
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
este ( ) . Mai știm că meningita cauzează gât înțepenit în jumătate
din cazuri: ( | ) .
Dorim să aflăm următorul lucru: dacă un pacient are gâtul înțepenit,
care este probabilitatea să aibă meningită?
Aplicând teorema lui Bayes, vom avea:
( | ) ( )
( | )
( )
3. Rețele bayesiene
( ) ( | ) ( )
( ) ( | ) ( | ) ( | ) ( )
( ) ∏ ( | )
185
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
O rețea bayesiană arată ca în figura 11.2: este un graf orientat aciclic
(directed acyclic graph), în care evenimentele sau variabilele se reprezintă ca
noduri, iar relațiile de corelație sau cauzalitate se reprezintă sub forma
arcelor dintre noduri.
Gripă Abces
Febră
Oboseală Anorexie
186
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
În acest exemplu, se consideră că atât gripa cât și abcesul pot
determina febra. De asemenea, febra poate cauza o stare de oboseală sau
lipsa poftei de mâncare (anorexie).
Sensul săgeților arcelor sunt dinspre părinți, cum ar fi gripa și
abcesul, înspre fii, precum febra. Deși în acest exemplu relațiile sunt
cauzale, în general o rețea bayesiană reflectă relații de corelație, adică
măsura în care aflarea unor informații despre o variabilă-părinte aduce noi
informații despre o variabilă-fiu.
Fiecare variabilă are o mulțime de valori. În cazul cel mai simplu,
variabilele au valori binare, de exemplu Da și Nu. În general însă, o
variabilă poate avea oricâte valori.
Asociate cu variabilele, o rețea bayesiană conține o serie de tabele de
probabilități, precum cele din tabelul 11.1. Pentru nodurile fără părinți se
indică probabilitățile marginale ale fiecărei valori (adică fără a lua în
considerare valorile celorlalte variabile). Pentru celelalte noduri, se indică
probabilitățile condiționate pentru fiecare valoare, ținând cont de fiecare
combinație de valori ale variabilelor părinte.
În general, o variabilă binară fără părinți va avea un singur
parametru independent, o variabilă cu 1 părinte va avea 2 parametri
independenți iar o variabilă cu n părinți va avea parametri independenți
în tabela de probabilități corespunzătoare.
Presupunerea modelului bazat pe rețele bayesiene este că o variabilă
nu depinde decât de părinții săi și deci ecuația anterioară devine:
( ) ∏ ( | ( ))
187
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
4. Inferența prin enumerare
( | )
∑ ∑ ( )
* + * +
∑∑ ( ) ( ) ( | ) ( | ) ( | )
( ) ∑ ( ) ∑ ( | ) ( | ) ( | )
188
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
( ) ∑ ( ) , ( | ) ( | ) ( | )
( | ) ( | ) ( | )-
( ) * ( ) , ( | ) ( | ) ( | )
( | ) ( | ) ( | )-
( ) , ( | ) ( | ) ( | )
( | ) ( | ) ( | )-+
* , -
, -+
( | )
∑ ∑ ( )
* + * +
∑∑ ( ) ( ) ( | ) ( | ) ( | )
( ) ∑ ( ) ∑ ( | ) ( | ) ( | )
( ) * ( ) , ( | ) ( | ) ( | )
( | ) ( | ) ( | )-
( ) , ( | ) ( | ) ( | )
( | ) ( | ) ( | )-+
189
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
* , -
, -+
( | )
( | )
5. Aplicații
190
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5.3. Tot cu ajutorul programului, răspundeți la următoarele întrebări:
191
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Figura 11.3. Model de intersecție
192
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 12
1. Obiective
194
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
n
y f wi xi .
i1
wi ( p 1) wi ( p) e( p) xi ( p) ,
195
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Cu ajutorul perceptronului pot fi învățate de exemplu funcții binare
elementare, precum ȘI, SAU etc. (figura 12.2). Pe abscisă și ordonată sunt
reprezentate valorile celor două intrări, iar culoarea cercurilor reprezintă
rezultatul operației (alb = 0, negru = 1). Perceptronul împarte planul în două
regiuni de decizie (datorită pragului funcției de activare). În cazul
n-dimensional, spațiul soluțiilor va fi divizat tot în două regiuni de un
hiperplan. Acestea sunt probleme liniar separabile. Aici poate fi observată
și utilitatea pragului: în lipsa acestuia, hiperplanul separator ar trece
întotdeauna prin origine, ceea ce nu este de dorit în orice situație.
se inițializează toate ponderile wi cu 0 sau cu valori aleatorii din intervalul [–0.5, 0.5]
se inițializează rata de învățare eta cu o valoare din intervalul (0, 1], de exemplu 0.1
se inițializează numărul maxim de epoci P, de exemplu 100
p = 0 // numărul epocii curente
erori = true // un flag care indică existența erorilor de antrenare
196
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
yi = F(sum(xij * wj)) cu j = 1..n+1
dacă (yi != ydi)
{
e = ydi – yi
erori = true
pentru fiecare intrare j = 1..n+1
wj = wj + eta * xij * e
}
}
p=p+1
}
197
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
4. Perceptronul multi-strat
198
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Introducerea mai multor straturi a fost determinată de necesitatea
creșterii complexității regiunilor de decizie. După cum am arătat în
secțiunea 3, un perceptron cu un singur strat și o ieșire generează regiuni de
decizie de forma unor semiplane. Adăugând încă un strat, fiecare neuron se
comportă ca un perceptron standard asupra ieșirii neuronilor din stratul
anterior și astfel ieșirea rețelei poate aproxima regiuni de decizie convexe,
rezultate din intersecția semiplanelor generate de neuroni. La rândul său, un
perceptron cu trei straturi poate genera zone de decizie arbitrare (figura
12.5).
199
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Din punct de vedere al funcției de activare a neuronilor, rețelele
multi-strat nu asigură o creștere a puterii de calcul în raport cu rețelele cu un
singur strat dacă funcțiile de activare sunt liniare, deoarece o funcție liniară
de funcții liniare este tot o funcție liniară. Puterea perceptronului multi-strat
provine tocmai din funcțiile de activare neliniare. Aproape orice funcție
neliniară poate fi folosită în acest scop, cu excepția funcțiilor polinomiale.
Însă funcțiile cele mai des utilizate pentru rețele MLP clasice sunt sigmoida
unipolară (sau logistică), afișată în figura 12.6:
1
f ( s)
1 e s
1 e 2 s
f ( s) .
1 e 2 s
0.5
0
-8 0 8
-1
-8 0 8
200
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Se poate constata că funcțiile sigmoide se comportă aproximativ
liniar pentru valori absolute mici ale argumentului și se saturează, preluând
oarecum rolul de prag, pentru valori absolute mari ale argumentului.
O aproximare mai simplă a sigmoidei este funcția semiliniară,
definită astfel:
1, s 1
f ( s) s, s (1, 1) .
1, s 1
5. Aplicații
201
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Întrucât aici se presupune că ieșirile neuronilor aparțin intervalului
[0,1], se folosesc următoarele expresii pentru funcțiile de activare:
funcția prag:
0, s 0
f ( s)
1, s 0
funcția semiliniară:
0, s 0
f ( s ) s, s (0, 1)
1, s 1
1
f ( s)
1 e s
202
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Scopul aplicațiilor este determinarea ponderilor conexiunilor dintre
neuroni și a valorilor prag astfel încât rețeaua să aproximeze câteva funcții
binare elementare. De exemplu:
203
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
5.1. Completați metodele care calculează cele trei funcții de activare
și metodele care calculează ieșirile perceptronilor: StepActivation,
SemiliniarActivation, SigmoidActivation, respectiv SLP și MLP.
MainForm.cs
using System;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
namespace DecisionRegions
{
public partial class MainForm : Form
{
/// <summary>
/// Functie care calculeaza iesirea retelei in functie de tipul ei: perceptron cu un singur
strat sau perceptron multistrat
/// </summary>
private Func<double, double, double> NetworkFunction;
204
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Functie care reprezinta functia de activare a retelei: prag, semiliniara sau sigmoida
unipolara
/// </summary>
private Func<double, double> ActivationFunction;
private double w13, w23, w14, w24, t3, t4, w35, w45, t5; // ponderile si pragurile
public MainForm()
{
InitializeComponent();
comboBoxType.SelectedIndex = 0;
comboBoxActivation.SelectedIndex = 0;
/// <summary>
/// Functia de activare prag
/// </summary>
private double StepActivation(double x)
{
throw new Exception("Aceasta metoda trebuie implementata.");
}
/// <summary>
/// Functia de activare semiliniara
/// </summary>
private double SemiliniarActivation(double x)
{
throw new Exception("Aceasta metoda trebuie implementata.");
}
/// <summary>
/// Functia de activare sigmoida unipolara
/// </summary>
private double SigmoidActivation(double x)
{
throw new Exception("Aceasta metoda trebuie implementata.");
}
/// <summary>
/// Citeste valorile ponderilor si pragurilor din interfata grafica
/// </summary>
private void ReadParametersFromGUI()
205
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
{
if (comboBoxType.SelectedIndex == 0) // SLP
{
w13 = ConvertToDouble(textBoxSw13.Text);
w23 = ConvertToDouble(textBoxSw23.Text);
t3 = ConvertToDouble(textBoxSt3.Text);
}
else if (comboBoxType.SelectedIndex == 1) // MLP
{
w13 = ConvertToDouble(textBoxMw13.Text);
w23 = ConvertToDouble(textBoxMw23.Text);
w14 = ConvertToDouble(textBoxMw14.Text);
w24 = ConvertToDouble(textBoxMw24.Text);
t3 = ConvertToDouble(textBoxMt3.Text);
t4 = ConvertToDouble(textBoxMt4.Text);
w35 = ConvertToDouble(textBoxMw35.Text);
w45 = ConvertToDouble(textBoxMw45.Text);
t5 = ConvertToDouble(textBoxMt5.Text);
}
}
/// <summary>
/// Converteste numerele citite ca text din interfata in valori reale
/// </summary>
private double ConvertToDouble(string s)
{
if (s.Contains(","))
MessageBox.Show("Folositi punctul ca separator! (" + s + ")");
try
{
CultureInfo ci = (CultureInfo)(CultureInfo.CurrentCulture.Clone());
ci.NumberFormat.NumberDecimalSeparator = ".";
return Convert.ToDouble(s, ci);
}
catch
{
MessageBox.Show("Numar invalid: " + s);
return 0;
}
}
206
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Metoda care calculeaza iesirea perceptronului cu un singur strat pentru intrarile x si y
/// </summary>
private double SLP(double x1, double x2)
{
// double s = suma ponderata a intrarilor cu scaderea pragului, conform primei
ecuatii din text
// se folosesc ponderile w13, w23 si pragul t3
// in functie de alegerea utilizatorului, ActivationFunction poate fi: StepActivation, S
emiliniarActivation sau SigmoidActivation
// functia de activare este setata in evenimentul comboBoxActivation_SelectedInde
xChanged
// in metoda curenta se lucreaza in mod generic doar cu "ActivationFunction": retur
n ActivationFunction(s);
/// <summary>
/// Antreneaza perceptronul cu un singur strat si seteaza ponderile in interfata
/// </summary>
private void buttonTrainSLP_Click(object sender, EventArgs e)
{
comboBoxType.SelectedIndex = 0;
comboBoxActivation.SelectedIndex = 0;
int trainingSetSize = 4;
int noInputs = 2;
double alpha = 0.1; // rata de invatare
outputs[0] = Convert.ToInt32(textBox00.Text);
outputs[1] = Convert.ToInt32(textBox01.Text);
outputs[2] = Convert.ToInt32(textBox10.Text);
outputs[3] = Convert.ToInt32(textBox11.Text);
207
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
weights[0] = rand.Next(10) / 10.0 - 0.5;
weights[1] = rand.Next(10) / 10.0 - 0.5;
weights[2] = rand.Next(10) / 10.0 - 0.5;
textBoxSw13.Text = weights[0].ToString("F1");
textBoxSw23.Text = weights[1].ToString("F1");
textBoxSt3.Text = weights[2].ToString("F1");
/// <summary>
/// Metoda care calculeaza iesirea perceptronului cu doi neuroni in stratul ascuns pen
tru intrarile x si y
/// </summary>
private double MLP(double x1, double x2)
{
// pentru fiecare neuron, se calculeaza suma intrarilor ponderate, se scade pragul si
se aplica functia de activare
// neuronul 5 are ca intrari iesirile neuronilor 3 si 4
// iesirea neuronului 5 este iesirea retelei
208
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Antreneaza perceptronul multistrat si seteaza ponderile in interfata
/// </summary>
private void buttontrainMLP_Click(object sender, EventArgs e)
{
comboBoxType.SelectedIndex = 1;
comboBoxActivation.SelectedIndex = 2;
textBoxMw13.Text = w[0].ToString("F6");
textBoxMw23.Text = w[1].ToString("F6");
textBoxMt3.Text = w[2].ToString("F6");
textBoxMw14.Text = w[3].ToString("F6");
textBoxMw24.Text = w[4].ToString("F6");
textBoxMt4.Text = w[5].ToString("F6");
textBoxMw35.Text = w[6].ToString("F6");
textBoxMw45.Text = w[7].ToString("F6");
textBoxMt5.Text = w[8].ToString("F6");
}
/// <summary>
/// Selecteaza tipul de perceptron atunci cand utilizatorul il alege din combobox
/// </summary>
private void comboBoxType_SelectedIndexChanged(object sender, EventArgs e)
{
if (comboBoxType.SelectedIndex == 0)
{
groupBoxSLP.Enabled = true;
groupBoxMLP.Enabled = false;
NetworkFunction = SLP;
}
else if (comboBoxType.SelectedIndex == 1)
{
groupBoxSLP.Enabled = false;
groupBoxMLP.Enabled = true;
NetworkFunction = MLP;
}
}
209
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Selecteaza functia de activare atunci cand utilizatorul o alege din combobox
/// </summary>
private void comboBoxActivation_SelectedIndexChanged(object sender, EventArgs e)
{
if (comboBoxActivation.SelectedIndex == 0)
ActivationFunction = StepActivation;
else if (comboBoxActivation.SelectedIndex == 1)
ActivationFunction = SemiliniarActivation;
else if (comboBoxActivation.SelectedIndex == 2)
ActivationFunction = SigmoidActivation;
}
/// <summary>
/// Calculeaza si afiseaza iesirile retelei pentru combinatiile de intrari (0,0), (0,1), (1,0)
si (1,1)
/// </summary>
private void ComputeResults()
{
textBoxResults.Clear();
for (int x1 = 0; x1 <= 1; x1++)
for (int x2 = 0; x2 <= 1; x2++)
{
double y = NetworkFunction(x1, x2);
textBoxResults.AppendText(string.Format("{0} {1} {2:F3}\r\n", x1, x2, y));
}
}
/// <summary>
/// Evenimentul de click al butonului "Calculeaza"
/// </summary>
private void buttonCompute_Click(object sender, EventArgs e)
{
ReadParametersFromGUI();
ComputeResults();
pictureBoxRegions.Refresh();
}
210
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Desenarea regiunilor de decizie pentru retea in picturebox. Intrarile retelei sunt aic
i numere reale din intervalul [-0.5, 1.5]
/// </summary>
private void pictureBoxRegions_Paint(object sender, PaintEventArgs e)
{
int size = pictureBoxRegions.Width; // patrat
Bitmap b = new Bitmap(size, size);
Graphics g = Graphics.FromImage(b);
g.Clear(Color.White);
e.Graphics.DrawImage(b, 0, 0);
}
/// <summary>
/// Testeaza daca doua numere reale sunt egale (in reprezentarea double pot aparea
erori mici care fac ca testarea normala a egalitatii sa esueze)
/// </summary>
/// <returns></returns>
private bool AreEqual(double x, double y)
{
if (Math.Abs(x - y) < 1e-8)
return true;
else
return false;
}
211
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Informatii despre program si autor
/// </summary>
private void buttonAbout_Click(object sender, EventArgs e)
{
const string copyright =
"Retele neuronale - Regiuni de decizie\r\n" +
"Inteligenta artificiala, Laboratorul 12\r\n" +
"(c)2016-2020 Florin Leon\r\n" +
"http://florinleon.byethost24.com/lab_ia.htm";
/// <summary>
/// Inchiderea programului
/// </summary>
private void buttonExit_Click(object sender, EventArgs e)
{
Environment.Exit(0);
}
}
}
212
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 13
Algoritmul de retro-propagare
(backpropagation)
1. Obiective
2. Descrierea algoritmului
213
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
F F F
F i j k ...
x y z
1 1
ekn2 yknd ykn ,
2
MSE
KN k n KN k n
d
unde ykn este valoarea dorită la ieșirea n a rețelei pentru vectorul k, iar ykn
este ieșirea efectivă a rețelei.
Algoritmul pentru un perceptron multi-strat cu un singur strat ascuns
este următorul.
Pasul 1: Inițializarea
214
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Pasul 2: O nouă epocă de antrenare
n
y j f xi wij j ,
i 1
unde n este numărul de intrări ale neuronului j din stratul ascuns, iar f este
funcția de activare sigmoidă.
Pentru simplitate, pragul este considerat ca fiind ponderea unei
conexiuni suplimentare a cărei intrare este întotdeauna egală cu 1. Expresia
de mai sus devine acum:
n 1
y j f xi wij .
i 1
215
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
3.3. Se calculează ieșirile reale ale rețelei:
m1
yk f y j w jk ,
j 1
1 1
ekn2 yknd ykn .
2
MSE
KN k n KN k n
k f ' ek ,
ex
f ' ( x) f ( x) 1 f ( x) .
1 e
x 2
Vom avea:
k yk 1 yk ek .
w jk w jk y j k ,
216
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
unde α este rata de învățare.
l
j y j 1 y j k w jk ,
k 1
wij wij xi j .
3. Considerente practice
218
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
trebuie să fie în jur sau sub o zecime din produsul dintre numărul de vectori
de antrenare și numărul de ieșiri. În unele situații însă (de exemplu, dacă
datele de antrenare sunt relativ puține), numărul de ponderi poate fi chiar
jumătate din produs.
Pentru un perceptron multi-strat se consideră că numărul de neuroni
dintr-un strat trebuie să fie suficient de mare pentru ca acest strat să
furnizeze trei sau mai multe laturi pentru fiecare regiune convexă
identificată de stratul următor. Deci numărul de neuroni dintr-un strat ar
trebui să fie aproximativ de trei ori mai mare decât cel din stratul următor.
După cum am menționat, un număr insuficient de ponderi conduce la
„sub-potrivire” (underfitting), în timp ce un număr prea mare de ponderi
conduce la „supra-potrivire” (overfitting), fenomene prezentate în figura de
mai jos. Același lucru apare dacă numărul de epoci de antrenare este prea
mic sau prea mare.
4. Aplicație
Segments.data
7 10 10
1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0
1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0
1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0
0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0
1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0
1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0
1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0
1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
220
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Studiați structura prototipului de aplicație. Diagrama UML de clase
a programului complet este următoarea:
221
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Implementați următoarele metode, corespunzătoare algoritmului
backpropagation:
222
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Metoda BackwardPass(double[] inputVector, double[]
desiredOutputs) din clasa BackPropAlgorithm
Pasul de propagare înapoi al algoritmului.
MainForm.cs
using System;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
namespace Backpropagation
{
public partial class MainForm : Form
{
private Dataset _dataset;
private NeuralNetwork _nn;
private BackPropAlgorithm _backProp;
public MainForm()
{
InitializeComponent();
223
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
{
checkBox2.BackColor = checkBox2.Checked ? Color.Red : SystemColors.Control;
}
/// <summary>
/// Verifica starea checkbox-urilor care simuleaza display-
ul si returneaza vectorul corespunzator.
/// </summary>
/// <returns></returns>
private double[] GenerateTestVector()
{
double[] testVector = new double[_dataset.NoInputs]; // 7 led-uri
if (checkBox0.Checked)
testVector[0] = 1;
if (checkBox1.Checked)
testVector[1] = 1;
if (checkBox2.Checked)
testVector[2] = 1;
if (checkBox3.Checked)
testVector[3] = 1;
224
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
if (checkBox4.Checked)
testVector[4] = 1;
if (checkBox5.Checked)
testVector[5] = 1;
if (checkBox6.Checked)
testVector[6] = 1;
return testVector;
}
/// <summary>
/// Antreneaza reteaua si afiseaza rezultatele.
/// </summary>
private void buttonTrain_Click(object sender, System.EventArgs e)
{
CultureInfo ci = (CultureInfo)(CultureInfo.CurrentCulture.Clone());
ci.NumberFormat.NumberDecimalSeparator = ".";
225
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
richTextBoxTraining.Focus();
}
/// <summary>
/// Returneaza vectorul cu indexul i din multimea de antrenare.
/// </summary>
private double[] GetVectorFromDataset(int i)
{
double[] v = new double[_dataset.NoInputs];
for (int k = 0; k < _dataset.NoInputs; k++)
v[k] = _dataset.Data[i, k];
return v;
}
/// <summary>
/// Foloseste reteaua pentru a recunoaste o cifra formata de utilizator pe display.
/// </summary>
private void buttonPropagate_Click(object sender, EventArgs e)
{
richTextBoxTesting.Clear();
_dataset.ScaleVector(testVector);
double[] outputs = _nn.Propagate(testVector);
_dataset.RescaleVector(outputs);
s = "Iesirea retelei:\r\n";
for (int i = 0; i < _dataset.NoOutputs; i++)
{
s += string.Format("{0:F2} ", outputs[i]);
if (outputs[i] > max)
{
max = outputs[i];
maxIndex = i;
}
}
richTextBoxTesting.Text += s + "\r\n\r\n";
226
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
richTextBoxTesting.Text += string.Format("Cifra recunoscuta: {0}", maxIndex);
richTextBoxTesting.Focus();
}
NeuralNetwork.cs
using System;
namespace Backpropagation
{
/// <summary>
/// Clasa corespunzatoare unei retele neuronale de tip perceptron multistrat cu un sing
ur strat ascuns.
/// </summary>
public class NeuralNetwork
{
/// <summary>
/// Numarul de intrari
/// </summary>
public int NoInputs { get; private set; }
/// <summary>
/// Numarul de neuroni din stratul ascuns
/// </summary>
public int NoHidden { get; private set; }
227
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Numarul de iesiri
/// </summary>
public int NoOutputs { get; private set; }
/// <summary>
/// Neuronii din stratul ascuns
/// </summary>
public Neuron[] HiddenLayer { get; private set; }
/// <summary>
/// Neuronii din stratul de iesire
/// </summary>
public Neuron[] OutputLayer { get; private set; }
/// <summary>
/// Constructorul clasei.
/// </summary>
/// <param name="noHidden">Numarul de neuroni din stratul ascuns</param>
public NeuralNetwork(int noInputs, int noHidden, int noOutputs)
{
NoInputs = noInputs;
NoHidden = noHidden;
NoOutputs = noOutputs;
/// <summary>
/// Metoda care calculeaza iesirile retelei pentru un vector primit ca parametru.
/// </summary>
public double[] Propagate(double[] vector)
{
ForwardPass(vector);
return y;
}
228
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <summary>
/// Pasul de propagare inainte al algoritmului.
/// </summary>
private void ForwardPass(double[] inputVector)
{
// se calculeaza activarile neuronilor din stratul ascuns si apoi din stratul de iesire
Neuron.cs
using System;
namespace Backpropagation
{
/// <summary>
/// Clasa corespunzatoare unui neuron din retea.
/// </summary>
public class Neuron
{
/// <summary>
/// Ponderile conexiunilor de intrare ale neuronului.
/// </summary>
public double[] Weights { get; set; }
/// <summary>
/// Valoarea functiei de activare. Valoarea se calculeaza cu metoda ComputeActivatio
n, dar este pastrata
/// in proprietatea Activation. In algoritmul backpropagation, functiile de activare se c
alculeaza
/// doar in pasul "inainte", iar in pasul "inapoi" se folosesc valorile de activare calculat
e deja.
/// </summary>
public double Activation { get; private set; }
/// <summary>
/// Constructorul clasei.
/// </summary>
229
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// <param name="noWeightsIncludingBias">Numarul de ponderi (egal cu numarul d
e intrari) + 1. Valoarea 1 corespunde termenului "bias" (prag), o conexiune conectata mer
eu la o intrare egala cu 1</param>
public Neuron(int noWeightsIncludingBias)
{
_noWeights = noWeightsIncludingBias;
/// <summary>
/// Initializeaza ponderea cu un numar aleatoriu din intervalul [-0.1, 0.1), diferit de 0.
/// </summary>
private double InitWeight()
{
double w = 0;
while (Math.Abs(w) < 1e-6)
w = _r.NextDouble() / 5.0 - 0.1;
return w;
}
/// <summary>
/// Calculeaza functia de activare pentru un vector de intrare si memoreaza valoarea i
n proprietatea Activation.
/// </summary>
/// <param name="x">Vectorul de intrare</param>
public void Activate(double[] x)
{
double s = 0;
Activation = SigmoidFunction(s);
}
/// <summary>
/// Functia sigmoida unipolara.
/// </summary>
private double SigmoidFunction(double x)
{
return 1.0 / (1.0 + Math.Exp(-x));
}
230
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
}
Dataset.cs
using System;
using System.IO;
namespace Backpropagation
{
/// <summary>
/// Clasa corespunzatoare unei multimi de date de antrenare.
/// </summary>
public class Dataset
{
/// <summary>
/// Datele propriu-
zise memorate in forma unei matrice, in care numarul de linii este numarul de vectori de a
ntrenare,
/// iar numarul de coloane este suma dintre numarul de intrari si numarul de iesiri.
/// De exemplu, pentru problema binara XOR, multimea de antrenare are 4 vectori, 2 i
ntrari si 1 iesire si este de forma:
/// 0 0 0 / 0 1 1 / 1 0 1 / 0 0 0
/// </summary>
public double[,] Data { get; private set; }
/// <summary>
/// Multimea de antrenare este citita dintr-un fisier.
/// </summary>
public Dataset(string fileName)
{
StreamReader sr = new StreamReader(fileName);
NoInputs = Convert.ToInt32(toks[0]);
NoOutputs = Convert.ToInt32(toks[1]);
NoVectors = Convert.ToInt32(toks[2]);
231
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Data = new double[NoVectors, NoInputs + NoOutputs];
sr.Close();
}
/// <summary>
/// Pentru a putea fi invatate mai usor de reteaua neuronala, datele pot fi scalate.
/// In cazul de fata, datele de antrenare sunt intre 0 si 1, iar scalarea se face automat
/// intre 0.1 si 0.9, pentru a aplica sigmoida unipolara.
/// Atentie! Metoda aceasta nu este generala si nu poate fi aplicata pentru orice date
de antrenare.
/// </summary>
public void ScaleData()
{
for (int i = 0; i < NoVectors; i++)
for (int j = 0; j < NoInputs + NoOutputs; j++)
Data[i, j] = Data[i, j] * 0.8 + 0.1;
}
/// <summary>
/// Scaleaza elementele unui vector din domeniul [0, 1] in domeniul [0.1, 0.9].
/// </summary>
public void ScaleVector(double[] vector)
{
for (int i = 0; i < vector.Length; i++)
vector[i] = vector[i] * 0.8 + 0.1;
}
/// <summary>
/// Rescaleaza elementele unui vector de intrare din domeniul modificat [0.1, 0.9] in d
omeniul initial [0, 1].
/// </summary>
public void RescaleVector(double[] vector)
{
for (int i = 0; i < vector.Length; i++)
{
vector[i] = (vector[i] - 0.1) / 0.8;
if (vector[i] > 1)
232
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
vector[i] = 1;
if (vector[i] < 0)
vector[i] = 0;
}
}
}
}
BackPropAlgorithm.cs
using System;
namespace Backpropagation
{
/// <summary>
/// Algoritmul backpropagation pentru antrenarea unei retele neuronale.
/// </summary>
public class BackPropAlgorithm
{
private NeuralNetwork _nn; // reteaua neuronala care este antrenata
private Dataset _dataset; // multimea de antrenare
private double _learningRate; // rata de invatare
private double[] _errors; // erorile dintre iesirile dorite si iesirile reale ale retelei
private double[,] _dwij, _dwjk; // corectiile ponderilor delta-w
/// <summary>
/// Eroarea medie patratica din epoca de antrenare curenta.
/// </summary>
public double MeanSquareError { get; private set; }
// stratul de intrare are indicele i, stratul ascuns are indicele j, stratul de iesire are in
dicele k
_dwij = new double[_nn.NoInputs + 1, _nn.NoHidden]; // inclusiv "bias"-ul
_dwjk = new double[_nn.NoHidden + 1, _nn.NoOutputs]; // inclusiv "bias"-ul
}
/// <summary>
/// Metoda de antrenare a retelei folosind algoritmul backpropagation. Antrenarea se
realizeaza
/// pana la atingerea unui numar maxim de epoci sau pana la atingerea unei erori acc
eptabile.
233
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
/// </summary>
public void Train(double learningRate, int maxEpochs, double maxError)
{
_learningRate = learningRate;
MeanSquareError = double.MaxValue;
int currentEpoch = 1;
/// <summary>
/// Metoda care implementeaza o epoca de antrenare si seteaza eroarea medie patra
tica.
/// </summary>
private void TrainOneEpoch()
{
// se reseteaza corectiile ponderilor (metoda este deja implementata si trebuie doa
r apelata)
double totalSquareError = 0;
_errors = new double[_dataset.NoOutputs];
_nn.Propagate(inputVector);
BackwardPass(inputVector, outputVector);
234
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
// se seteaza eroarea medie patratica pentru aceasta epoca de antrenare
// se folosesc: totalSquareError, _dataset.NoVectors, _dataset.NoOutputs
/// <summary>
/// Pasul de propagare inapoi al algoritmului.
/// </summary>
private void BackwardPass(double[] inputVector, double[] desiredOutputs)
{
// se calculeaza erorile pentru neuronii din stratul de iesire
// eroarea este diferenta dintre iesirea dorita si iesirea retelei (din reteaua _nn)
235
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
}
}
236
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Referințe
Capitolele 1-4
Capitolul 5
Capitolul 6
Hart, P. E., Nilsson, N. J., Raphael, B. (1968). A Formal Basis for the Heuristic
Determination of Minimum Cost Paths, IEEE Transactions on Systems Science and
Cybernetics, vol. 4, no. 2, pp. 100-107
Leon, F. (2020). Inteligență artificială. Note de curs: Metode de căutare,
http://florinleon.byethost24.com/curs_ia.htm
237
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Leon, F. (2020). Sinteze de inteligență artificială, Ed. Tehnopress, Iași
Russell, S. J., Norvig, P. (2002). Artificial Intelligence: A Modern Approach, Prentice Hall,
2nd Edition
Capitolul 7
Edwards, D. J., Hart, T. P. (1961). The Alpha-beta Heuristic, Report no. AIM-030,
Massachusetts Institute of Technology, https://dspace.mit.edu/handle/1721.1/6098
Leon, F. (2020). Inteligență artificială. Note de curs: Jocuri. Satisfacerea constrângerilor,
http://florinleon.byethost24.com/curs_ia.htm
Leon, F. (2020). Sinteze de inteligență artificială, Ed. Tehnopress, Iași
Rich, E. (1983). Artificial Intelligence, Mc Graw-Hill Book Company, New York
Russell, S. J., Norvig, P. (2002). Artificial Intelligence: A Modern Approach, Prentice Hall,
2nd Edition
Capitolul 8
Baeck, T., Fogel, D. B., Michalewicz, Z., eds. (1997). Handbook of Evolutionary
Computation, Institute of Physics Publishing Publishing and Oxford University Press
Dolan, R. (2016). Optimization (Solutions), https://robert-dolan.grad.uconn.edu/wp-content/
uploads/sites/1419/2016/06/Lecture-4.7-Solutions.pdf
Holland, J. H. (1975). Adaptation in Natural and Artificial Systems, University of Michigan
Press, Ann Arbor, Michigan, USA.
Leon, F. (2020). Inteligență artificială. Note de curs: Metode de optimizare (I),
http://florinleon.byethost24.com/curs_ia.htm
Leon, F. (2020). Sinteze de inteligență artificială, Ed. Tehnopress, Iași
Capitolul 9
238
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Capitolul 10
Capitolul 11
Capitolele 12-13
Caudill, M. (1987). Neural Network Primer: Part I, AI Expert, vol. 2, no. 12, pp. 46-52
Cybenko, G. (1989). Approximation by Superpositions of a Sigmoidal Function,
Mathematics of Control, Signals and Systems, vol. 2, pp. 303-314
Leon, F. (2006). Agenți inteligenți cu capacități cognitive, Ed. Tehnopress, Iași
Leon, F. (2014). Inteligență artificială: mașini cu vectori suport, Ed. Tehnopress, Iași
Leon, F. (2020). Inteligență artificială. Note de curs: Rețele neuronale (I),
http://florinleon.byethost24.com/curs_ia.htm
Leon, F. (2020). Sinteze de inteligență artificială, Ed. Tehnopress, Iași
Minsky, M., Papert, S. (1969). Perceptrons, The MIT Press, Cambridge, Massachusetts,
USA
Negnevitsky, M. (2004). Artificial Intelligence: A Guide to Intelligent Systems, 2nd Edition,
Addison Wesley
239
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com
Rosenblatt, F. (1958) The Perceptron: A Probabilistic Model for Information Storage and
Organization in the Brain, Psychological Review, vol. 65, no. 6, pp. 386-408
Rumelhart, D. E., Hinton, G. E., Williams, R. J. (1986). Learning Internal Representations
by Error Propagation, în D. E. Rumelhart, J. L. McClelland (eds.): Parallel Distributed
Processing: Explorations in the Microstructure of Cognition, vol. 1, pp. 318-362, The MIT
Press, Cambridge, Massachusetts, USA
Vijeth, D. (2015). NeuronDotNet, https://sourceforge.net/projects/neurondotnet
240
Florin Leon (2020). Aplicatii de inteligenta artificiala in C#, Tehnopress, Iasi, ISBN 978-606-687-428-1
http://florinleon.byethost24.com