Mesterséges intelligenciával kapcsolatos kérdés?
2009-08-19T13:05:27+02:00
2011-05-13T22:22:31+02:00
2022-07-19T04:52:48+02:00
  • a dolgok ennél egyszerűbbek.

    Mert az elménél hiába a legnagyobb számú történés memorizálása, mégis az agy a pillanatnyi állapotában dönt.

    Tehát 100 százalékosra semmi sem vehető az emberi elménél.
    Mutasd a teljes hozzászólást!
  • Hi!

    Olvasgattam a hozzászólásaitokat (és bár süket vagyok hozzá) lene egy pár kérdésem.

    Van egy adathalmaz (adatbázis) amely múltbéli eseményeket tartalmaz. Ebből ugyan nem számolható ki egy jövőbeli állapot, de egy plussz paraméterrel kiegészítve (amely az eredeti adatbázis egyik "részhalmaza", azaz kiszámolom) és egy véletlenszám (inkább egy poker nyerési esély latolgatás színtű) felhasználásával kb 10%-25%-os eredményt érek el (belefutottam már 59%-os értékbe is). Lehet ezt tovább fokozni?

    Van egy project, sok objektum van, (egyetlen kiinduló 3D szerkezet mindegyik). Ebből sokfajta matematikai okossággal 1-1 paraméter lehet számolni. Összeségébe több ezer félét is. A kérdés, milyen előszűrőt lenne érdemes használni? Molekula modellezéssel kapcsoltatos (gyógyszerfejlesztés).
    Mutasd a teljes hozzászólást!
  • Heh hát ezt nem értem miért kéne kevesebbet számolnia mint a sima CG-nek de mindegy.


    Nincs benne lineáris keresés, azért. Az NN CG lineáris keresés egy iterációja az egy teljes tréning iteráció, NN újraszámolással meg mindennel. Az nagyon sok. Kb. 4x-5x gyorsabb a konvergencia ugyanannyi algo lépés mellett, így kilóra kevesebb számítás kell hasonló eredményhez.
    Mutasd a teljes hozzászólást!
  • Nincs mit, nagyon szivesen :).
    Semmi gond, ráérnek azok az algok .

    SCG: Heh hát ezt nem értem miért kéne kevesebbet számolnia mint a sima CG-nek de mindegy. Amúgy érthetően le van írva tényleg, ki is nyomtattam .
    Mutasd a teljes hozzászólást!
  • Bocs, hogy még nem válaszoltam a Tudástárban. Nagyon be vagyok havazva, még vasárnap is tolom neki a melót. Az a két kérdés meg legalább egy óra, mire leírom, mit kell csinálni. Főleg az RTLR bonyolult.

    SCG? Itt a Moller doksi.

    Teljesen jól le van írva, mit kell csinálni. Az elején leírja, hogy jutott el az algoritmusig, aminek pontos leírása a 11. oldalon kezdődik. Én egy hétvége alatt összedobtam a PDF alapján az algot C#-ban. Viszont ebben az eredeti formában nem elég hatékony, és hajlamos "beragadni", ezért jó egy havi tökölődésbe került, mire gatyába ráztam. Ez olyan jól sikerült, hogy u.n. kvázi online-ként is tud futni (nem a teljes tréninghalmaz a batch, hanem annak egy kis, 50-100 elemű része, amit egy külön optimalizálódó filter algó választ).
    Mutasd a teljes hozzászólást!
  • Jó könyvnek tűnik, és még nem olvastam. Megrendeltem. Kösz!
    Mutasd a teljes hozzászólást!
  • Viccelsz? Komolyra fordítva a szót, nem. Az ajánlott irodalomban bennevan aki akarja elolvassa.
    Neurális Hálók c. tantárgyból is csak ezek voltak:
    Multi Layer Perceptron => Gradiens módszer/Error Backpropagation (az alap backprop semmi extra)

    Radial Basis Function => Konjugált Gradiens (ez is csak az alap nem az SCG, de SCG-ről nem is sok mindent találtam van egy algoritmusom SCG címen de az sima CG)

    Support Vector Machine => Csak annak az elmélete ment, hogy milyen módon szeparál semmi más.

    A mestint meg jelen pillanatban kb ennyi:
    Félév első felében állapottér reprezentáció (hiányos állapottér reprezentációt kell kiegészíteni ami kb annyit jelent, hogy a magyarul megfogalmazott mondatokat formalizáljuk)
    A második felében meg a tanár kivetít java/C# nyelven megírt állapottér reprezentációkat amilyeneket majd nekünk is írni kell. Aztán adva lesz egy előre megírt kereső rendszer ami majd adja a megoldást. <= ez a gyakorlat.

    Az elmélet meg úgy néz ki, hogy az első pár órán átvesszük az állapottér reprezentációval kapcsolatos alapfogalmakat. Aztán jönnek a keresőrendszerek, majd egy-két útkereső példa. Backtrack algoritmus-ból pl vettünk kettőt. Ez teszi ki a félévnek kb 3/4 -edét. A maradék részben pedig probléma reprodukcióval foglalkozunk.

    Van ez a szép 1000+ oldalas kék könyv: Stuart Russel - A mesterséges intelligencia modern megközelítésben -> ami ajánlott irodalom. Nos ebből kb kb 1fejezet az ami nekünk egy egész félév. Átvettem a könyvet eddig kb a 600. oldalig és azt vettem észre, hogy ami jelenleg megy elméleten azt én már 300 oldallal elhagytam .

    Ahol meg mondom optimalizáció megy az meg a Numerikus Matematika. Ott először Lebegőpontos számábrázolás/Mátrix aritmetika/LU felbontás-PLU-LDU-Cholesky/Lineáris egyenletrendszerek megoldása Cholesky-LU felbontással/Sajátérték-Sajátvektor feladatok/Nem-lineáris egyenletrendszerek megoldása iterációs-gaussNewton módszerrel/Numerikus integrálás

    Na kb ezek az érdekes részek amik kapcsolódnak a témához .
    Mutasd a teljes hozzászólást!
  • Viccelsz? Komolyra fordítva a szót, nem. Az ajánlott irodalomban bennevan aki akarja elolvassa.
    Neurális Hálók c. tantárgyból is csak ezek voltak:
    Multi Layer Perceptron => Gradiens módszer/Error Backpropagation (az alap backprop semmi extra)

    Radial Basis Function => Konjugált Gradiens (ez is csak az alap nem az SCG, de SCG-ről nem is sok mindent találtam van egy algoritmusom SCG címen de az sima CG)

    Support Vector Machine => Csak annak az elmélete ment, hogy milyen módon szeparál semmi más.

    A mestint meg jelen pillanatban kb ennyi:
    Félév első felében állapottér reprezentáció (hiányos állapottér reprezentációt kell kiegészíteni ami kb annyit jelent, hogy a magyarul megfogalmazott mondatokat formalizáljuk)
    A második felében meg a tanár kivetít java/C# nyelven megírt állapottér reprezentációkat amilyeneket majd nekünk is írni kell. Aztán adva lesz egy előre megírt kereső rendszer ami majd adja a megoldást. <= ez a gyakorlat.

    Az elmélet meg úgy néz ki, hogy az első pár órán átvesszük az állapottér reprezentációval kapcsolatos alapfogalmakat. Aztán jönnek a keresőrendszerek, majd egy-két útkereső példa. Backtrack algoritmus-ból pl vettünk kettőt. Ez teszi ki a félévnek kb 3/4 -edét. A maradék részben pedig probléma reprodukcióval foglalkozunk.

    Van ez a szép 1000+ oldalas kék könyv: Stuart Russel - A mesterséges intelligencia modern megközelítésben -> ami ajánlott irodalom. Nos ebből kb kb 1fejezet az ami nekünk egy egész félév. Átvettem a könyvet eddig kb a 600. oldalig és azt vettem észre, hogy ami jelenleg megy elméleten azt én már 300 oldallal elhagytam .

    Ahol meg mondom optimalizáció megy
    Mutasd a teljes hozzászólást!
  • Markov? Bayes?
    Mutasd a teljes hozzászólást!
  • Mestint-en hmmm
    Állapottér-reprezentáció (elsőrendű logikai formulák százait) a félév feléig.
    Második felében KÉSZ előre megírt programokat nézünk. Szóval van egy full állapottér reprezentáció + egy előre megírt keresőrendszer.
    Elméleten még van problémaredukció és ennyi. Gépet nem is látunk gyakorlaton :p. Optimalizációt (szigorú értelemben) nem is veszünk/vettünk. Numerikus Matematikából volt a Legkisebb négyzetek feladata ami ugye egy lokális optimalizáció meg volt a gauss-newton módszer és adios amigos.
    Kb ez most az egyetem, csoda, hogy google-n csüngök és próbálgatom megírni magamnak ezeket ? Egyetemen még csak szó sincs ilyenekről...
    Mutasd a teljes hozzászólást!
  • Mondjuk, ezek után nagyon érdekelne, mit tanítanak prog. mat. - on mest. int. néven (pontosabban ahelyett). Láttam a tematikát, van benne érdekes dolog bőven, de gyakorlaton nem próbáltok ki semmit? Hogy a búbánatban lehet így tanítani??? Ez olyan, mintha a jogsit csak a KRESZ vizsgára adnák ki. El lehet képzelni.

    Szerintem az tök alap, hogy az összes létező optimalizációt meg kell tanulni. Nem csak elméletben, gyakorlatban is.

    Én addig nem adnék mest. int. kollokviumot senkinek, amíg meg nem tud írni egy SCG-t vagy egy LM-et. Fejből, papírra. Alap, mint a levegő.
    Mutasd a teljes hozzászólást!
  • Jogos, de ezt volt a legegyszerűbb beleírni.




    // population : IEnumerable<Chromosome> // best Chromosome: var bestCh = population.OrderBy(c => c.Fitness).First(); // best fitness: double bestFit = population.Select(c => c.Fitness).OrderBy(f => f).First();
    Mutasd a teljes hozzászólást!
  • Jogos, de ezt volt a legegyszerűbb beleírni. A többi terminálási feltétel annyival bonyolultabb amennyivel ez az eljárás egyszerűbb mint mondjuk egy Szimulált Hűtés. Mindazonáltal valami mást is benézhettem mert pl az ackley függvényre nem esik be a (0,0)-nál lévő "lyukba :D". Megáll 1.71... -es fitnessen, normál esetben meg 1.0e-25 -ös fitness-ig megy a ciklus. Ha ez alá esik akkor terminál, csak ugye most szépen minden egyed beáll 1.71-es fitnessre. Valahol még mindíg elbambultam...
    Mutasd a teljes hozzászólást!
  • Szerintem nincs semmi értelme, hogy az overall fitness-t nézed!
    Az egyedeket meg nem feltétlenül húzza egy pontba, nem próbáltam, de pl ha egy olyan függvényt nézel, amiben van 2db szimmetrikus minimum, csak az egyik kicsit mélyebb, és mind a 2 'gödörbe' kb az egyedek fele bele esett már... Ilyenkor elég sok iteráció kell, hogy az összes egyed átkerüljön 1 gödörbe, és még az sem biztos hogy a mélyebb lesz az! (persze sok egyed esetén fordulhat elő ilyesmi)
    Mutasd a teljes hozzászólást!
  • Nem nem tanították, hogy a globális optimalizáció mi fán terem .
    De tottál igazad van úgy elqrtam a mutációs operátort ahogy illik . Leírtam itt az egyik hozzászólásomban jól, erre a koordinátát abszolútértékben vizsgáltam .

    szerk.:
    Javítva, működik! Mosmár egy pöppet lassabban terminál. A terminálási feltételem egyébként azért az OverAllFitness mert úgyis összerántja a populáció egyedeit az algo a legjobb fitness-el rendelkező egyedhez.

    Szóval mostmár szépen konvergál .
    Solution Found in overall: 314(Generations) Elsaped Time: 15ms Best solution: x:0,999999997609146 y:9,50000000132567 Fit:5,84752473213031E-17 A folytatáshoz nyomjon meg egy billentyűt . . . =============================================================== private static double lowerBound = -15000000.0; private static double upperBound = +15000000.0; private static int populationSize = 5; =============================================================== private static double Function(double x, double y) { return Math.Pow(3*x-32, 2) + Math.Pow(2*y-190, 2); }
    Azthiszem, hogy most akkor nekiállok tesztelni az ackley függvény és társaira. Az eredeti mutációval 1400 generációnál állt meg, de ugye én itt overallfitness-el terminálok.
    Mutasd a teljes hozzászólást!
  • 1: population = random NP hosszúságú vektorok


    Helyett: NP darab random vektor
    Mutasd a teljes hozzászólást!
  • Ja, és ne az OverallFitness termináljon, hanem a BestFitness. Mindegy, hogy a többi egyed milyen "okos", ha van köztük egy "legokosabb", aki megoldásként szerepel.
    Mutasd a teljes hozzászólást!
  • Nem értem, hogy ez a Wiki-s leírás miért okoz ekkora gondot? Ennél jobban egyszerűen nem lehet elmagyarázni!

    NP = pop. méret F = szabad paraméter 0..2 közt CR = szabad paraméter 0..1 közt f = optimalizálandő függvény Ezeket az elején kiszólod. 1: population = random NP hosszúságú vektorok 2: ciklus amíg nem f4sza 3: idx = rnd.Next(population.Length), x = population[idx] 4: set = new HashSet<int>() 5: set.Add(idx) 6: a = PickRandom(population, set) 7: b = PickRandom(population, set) 8: c = PickRandom(population, set) 9: R = rnd.Next(population.Lenght) 10: y = üres vektor 11: ciklus i = 0 population.Length - ig 12: ri = rnd.NextDouble() 13: ha i = R vagy ri < CR 14: akkor y[i] = a[i] + F * (b[i] - c[i]) 15: különben y[i] = x[i] 16: ciklus i vége 17: ha f(y) < f(x) akkor population[idx] = y 18: ciklus amíg nem f4sza vége

    A PickRandom függvény azt csinálja, hogy olyan elemet választ a populációból, aminek az indexe nincs benne a set halmazban. Ha kiválasztotta, akkor beleteszi az indexet, majd visszatér vele.

    Ez csak ennyi.

    SZERK: Csak aztán próbáld meg adaptálni a szabad paramétereket, miután az alap algód működik!
    Mutasd a teljes hozzászólást!
  • Amit nem értek mostmár, hogy ez miért globális optimalizáció?


    Há' nem tanították az egyetemen?

    A globális opt. olyan optimalizáció, ami a megoldás keresése során a megoldásvektor (pl: kromoszóma) által elért teljesítményt használja heurisztikára (pl: fittness). A lokális opt. pedig valami ismert számítási módszer alapján közelíti megoldást (pl: gradient descent, 2 opt).

    G.opt: keresés, l.opt: számolás.

    A pontos megfogalmazást nem tudom, de ez a lényege.

    (x-3)^2+(y-3)^2 függvénynél beragad 18-as fitness körül és sehova tovább.


    Jóhogy, baze! Nézted már az algodat? A vektor a futás után csak csökkenni tud! Tehát szépen eléri a [0,0]-t, és ott beáll. Tehát nem optmializálsz, csak elszámolsz 0-ig, oszt szevasz. Ez persze a x^2+y^2 -nek a megoldása, de attól még hibás.
    Mutasd a teljes hozzászólást!
  • Akkor megmutatom, hogy oldottam meg, max kiveszem belőle a mutációt (Saját megoldás).
    static void Main(string[] args) { #region FillUpPopulation for (int i = 0; i < populationSize; i++) { double x = lowerBound + rand.NextDouble() * (upperBound - lowerBound); double y = lowerBound + rand.NextDouble() * (upperBound - lowerBound); population.Add(new Chromosome(x, y, Function(x,y) )); //Console.WriteLine(population[i]); } #endregion //Console.WriteLine("====================="); #region MainLoop do { GetBest(population); if (OverallFitness(population) < 1.0e-15) break; Console.WriteLine("===IT: {0}===", iterationCounter); #region F Fmax = rand.NextDouble(); Fmin = rand.NextDouble(); F = (Fmax-Fmin)*((maxIteration-iterationCounter)/maxIteration); #endregion for (int i = 0; i < population.Count; i++) { trial = population[i] + lambda * (bestEntity - population[i]) + F * (population[rand.Next(0, population.Count - 1)] - population[rand.Next(0, population.Count - 1)]); trial.Fitness = Function(trial.X, trial.Y); //Console.WriteLine("T:{0}", trial); Chromosome u = population[i] ^ trial; u.Fitness = Function(population[i].X, population[i].Y); population[i] = (u.Fitness <= population[i].Fitness) ? u : population[i]; //Console.WriteLine("V:{0}", population[i]); } ++iterationCounter; } while (true); Console.WriteLine("Solution Found: {0}",iterationCounter); Console.WriteLine(bestEntity); #endregion } private static void GetBest(List<Chromosome> c) { int best = 0; for (int i = 0; i < c.Count; i++) { if (i > 0 && c[i].Fitness <= c[i - 1].Fitness) best = i; } bestEntity = c[best]; } private static double OverallFitness(List<Chromosome> c) { double fit = 0.0; foreach (Chromosome chr in c) { fit += chr.Fitness; } return fit; } //TESZTFÜGGVÉNY: private static double Function(double x, double y) { //return Math.Pow(x, 2) + Math.Pow(y, 2); //return Math.Pow(3*x, 2) + Math.Pow(5*y, 2); return Math.Pow(x-2, 2) + Math.Pow(y-2, 2); }
    Az operátorokat a kromoszómákra saját magam definiáltam felül ha már sajátot nem lehet. A ^ operátor a mutáció lett mert vektort a vektoradik hatványra minek emelne az ember . Az első két tesztre a saját mutációs operátorommal min: 124 generáció után van megoldás; a dokumentációban megadottakkal 150+. A gond azzal van, hogy nem megy minimuma, akkor hol basszintottam el?
    Mutasd a teljes hozzászólást!
  • Kicsit utánanaolvastam én is, mert érdekes téma. Te most a Differential evolution-nal csináltad?
    lsd wikin

    Ha igen, akkor valamit elrontottál, mivel az 'ügynökök' csak akkor vesznek fel új értéket (esetlegesen közeledhetnek egymáshoz), ha F(y) < F(x), tehát az új pozícióban kisebb a "potenciálja" függvény értéke, véletlenül előfordulhat, hogy pont arrafelé keverednek a nem 0 minimumú függvény esetén is, de nagyon nem szabadna, főleg nem az összesnek... próbálgasd más paraméterekkel

    Természetesen megtörténhet hogy nem találja meg a globális minimumot, képzelj el egy kúpot, aminek a közepén van egy nagyon mély lyuk (glob min.), "radásul a fala magas is a függvény többi értékéhez képset" ahoz hogy ezt megtaláljuk, ahoz pont belekéne esnie az ügynöknek a kúp közepébe, amúgy valószínűleg simán kikerüli, hiszen a kúp falán f(X) értéke 'potenciálja' nagy, tehát a falról nagy valószínűséggel hamar le is pattan az ügynök ( valószínű hogy amikor pont őt változtatnánk, a kiszámolt új Y-ra F(Y) < F(X), hiszen a kúp fala meredek -> magasan van X, így csak jobban elcsúszik a kúp közepétől... )

    Valamilyen minimális, lightosabb matekot nem tud valaki az algoritmus működéséről, hogy most hogyan meg miért is, mondjuk biztos nagyon nem egyszerű, de azért belelesnék

    ui: találtam olvasnivalót, hátha segít
    Mutasd a teljes hozzászólást!
  • Szóval megírtam a kezdetleges változatot és észrevettem egy gubancot ezzel az algo-val. Ha a globális minimum nem a (0,0)-ban van akkor órákon át is futhat nem találja meg.
    Pl.: (x-3)^2+(y-3)^2 függvénynél beragad 18-as fitness körül és sehova tovább. Ha viszont az origóban van a globális minimum aka:
    x^2+y^2 akkor simán elkapja. A populáció mérete 5 a vizsgált tartomány pedig: [-370000.8501;+370000.8501]
    148 iterációból összehúzza az 5 egyedet.
    Amit nem értek mostmár, hogy ez miért globális optimalizáció? Az algo a (0,0)-ba rántja össze a populáció egyedeit de mi van ha a függvény globális minimuma nem ott van? Ugye arra számítottam, hogy azon egyedhez húzza a többi egyedet amelyik a legjobb fitness értékkel rendelkezik, de még cak nem is azt csinálni . Az más kérdés, hogy akkor sem garantált a globális minimum mert ha 1 egyed sem kerül a közelébe (Miért ne történhetne meg?) akkor a globális minimum amit talál valójában csak lokális...

    Valamit vagy nagyon benéztem vagy csak olyan függvényekre működik ahol a géobális minimum (0,0) -nál van.
    Mutasd a teljes hozzászólást!
  • Csináltam egy kis tesztet, hogy lássam milyen gyorsan konvergál a saját DE variánsom. A függvény egy tök egyszerű f(x,y)=x^2+y^2 függvény volt a [-15;+15] intervallumon.
    A populáció mérete 5 és a hozzájuk tartozó kezdeti vektorok és a hozzájuk tartozó fitness értékek:
    x0(t)=[-3,8] Fit=75 x1(t)=[-7,-9] Fit=130 x2(t)=[13,2] Fit=173 x3(t)=[3,-9] Fit=90 x4(t)=[-2,-15] Fit=229
    2 iteráció után a helyzet:
    x0(t)=[1.75, 6.93825] Fit=51.20181306 x1(t)=[-3.8585, -0.2] Fit=14.92802225 x2(t)=[-0.853, 2] Fit=4.727609 x3(t)=[-2.065, -0.71] Fit=4.768325 x4(t)=[-2, -0.80875] Fit=4.654076563
    Alias 2 iteráció után a fitness értékek az alábbi vektor megfelelő értékei szerint csökkentek:
    [23.79, 115.0719775, 168.272391, 85.231675, 224.3459234]
    Nekem ez elég jónak tünik . Az F paraméter iterációszámtól függően önmagát változtatja, és a konvergencia sokkal gyorsabb mint iterációszámtól függetlenített esetben. Szabadon választható paraméternek egyedül a populáció mérete és a lambda paraméter maradt. A tesztet NP=5 és L=0.35-el számoltam egyébként.
    Bonyolultabb függvényhez már nem vállalkozok erre a lapon számolásra, inkább megírom és kiderül mi lesz belőle .
    Mutasd a teljes hozzászólást!
  • Na egye fene nyitok 2 témát akkor .
    Mutasd a teljes hozzászólást!
  • Te, Evo! Ha megkérded a Tudástárban, hogyan kell a gyarkorlatban RTRL BP-t vagy hatékony Adaptive Annealinget csinálni, akkor elmagyarázom, csak szólj!

    Nekem ezek mind megvannak C#-ban, működnek szépen, le tudom írni pszeudokódban, mit kell csinálni.

    SZERK.: Nekem olyanom is van, hogy RTLR Scaled Conjugate Gradient. Na, ilyet aztán nem találsz a Neten. A legjobb Recurrent Algo a NeuroSolutions-ban van, az egy BPTT Conjugate Gradient, aminél az előbbi messze gyorsabb és pontosabb. Fél évembe került mire kitököltem, annyira bonyolult ... de megérte.
    Mutasd a teljes hozzászólást!
  • Adaptive Annealing != Adaptive Simulated Annealing.
    Mutasd a teljes hozzászólást!
  • Látom erről is sokat írnak a neten...
    Adaptive Simulated Annealing is a variant of Simulated Annealing.
    Baze most aztán okosabb lettem :O.
    Mutasd a teljes hozzászólást!
  • Messze nem ugyanaz a kettő!
    Mutasd a teljes hozzászólást!
  • adaptív annealing-et nem ismerem de a simulated annealing-től meg jócskán gyorsabban konvergál a DE.
    Mutasd a teljes hozzászólást!
  • Csak tudd, hogy feed-forward hálónál a BP-k sokkal gyorsabbak és pontosabbak, mint bármelyik globális opt. RNN-nél fordul csak a helyzet.

    Ez a DE meg NN-hez nem válik be. Sem semmi olyan g. opt. ami populáció alapú, mert isszonyú lassú a konvergencia az adaptív annealinghez képest.
    Mutasd a teljes hozzászólást!
abcd