Ugrás a fő tartalomra

AI / MI alapok : technikák, technológiák

AI / MI alapok : technikák, technológiák



Az MI alapjai és főbb területei

Az MI célja, hogy gépek emberi intelligenciához hasonló képességeket mutassanak, például tanuljanak, problémát oldjanak meg, vagy döntéseket hozzanak. Az MI-t három fő kategóriára oszthatjuk:

  • Narrow AI (Keskeny MI): Specifikus feladatokra specializált rendszerek, pl. képfelismerés, beszédfelismerés.
  • General AI (Általános MI): Emberi szintű intelligencia, amely bármilyen feladatot képes ellátni (még nem valósult meg).
  • Superintelligent AI (Szuperintelligens MI): Az emberi intelligenciát meghaladó képességek (jelenleg elméleti koncepció).

A modern MI leginkább a keskeny MI-re fókuszál, és ehhez számos technika és technológia társul.


Technológiai alapok

Az MI működéséhez szükséges technológiai infrastruktúra elemek:

a) Hardver

  • GPU-k (Graphics Processing Units): A mélytanulási modellek párhuzamos számításaihoz elengedhetetlenek (pl. NVIDIA CUDA).
  • TPU-k (Tensor Processing Units): A Google által fejlesztett, kifejezetten MI feladatokra optimalizált chipek.
  • Quantum Computing: A jövőben az MI-t gyorsíthatja kvantumszámítógépek használata.

b) Adatok

  • Az MI modellek hatékonysága nagymértékben függ a nagy mennyiségű, jó minőségű adattól (Big Data).
  • Adattisztítás, előfeldolgozás és annotáció kulcsfontosságú.

c) Szoftveres keretrendszerek

  • TensorFlow: Google által fejlesztett, mélytanulásra optimalizált keretrendszer.
  • PyTorch: Rugalmas és kutatóbarát, a Facebook támogatásával.
  • Scikit-learn: Gépi tanulási algoritmusokhoz.
  • Hugging Face: NLP modellek és transzformerekhez.

d) Felhőszolgáltatások

  • Az MI modellek képzése és futtatása gyakran felhőben történik (pl. AWS, Google Cloud, Azure).



Az AI technikák közé tartozik például:

  1. Döntési fák (Decision Trees)

  2. Neurális hálózatok és mélytanulás (Neural Networks & Deep Learning)

  3. Bayes-i hálózatok (Bayesian Networks)

  4. Támogatóvektor-gépek (Support Vector Machines, SVM)

  5. Klaszterezési algoritmusok (Clustering Algorithms)

  6. Reinforcement Learning (Megerősítéses tanulás)

  7. Genetikus algoritmusok (Genetic Algorithms)

  8. Markov modellek és rejtett Markov modellek (HMM, Hidden Markov Models)

  9. Autoencoder hálózatok

  10. Adatdimenzió-csökkentési módszerek (PCA, t-SNE, UMAP)





1. Döntési fák (Decision Trees)

1.1 Mi az a döntési fa?

A döntési fa egy fa-alapú osztályozó vagy regressziós modell, amelyet döntések meghozatalára használnak egy sor feltételes szabály alapján. Minden egyes csomópont egy döntést képvisel, a levelek pedig a végső kimeneteket tartalmazzák.

📌 Használati területek:
✔️ Osztályozási problémák (pl. egy email SPAM vagy nem SPAM?)
✔️ Regressziós problémák (pl. ingatlanárak előrejelzése)
✔️ Üzleti döntéshozatal (pl. ügyfelek hitelképességének elemzése)

1.2 Hogyan működik?

A döntési fa az adatokat iteratívan osztja fel a leginformatívabb jellemzők (feature-ök) alapján.

Lépések:

1️⃣ Gyökércsomópont (Root Node): Az adatok teljes halmaza.
2️⃣ Elágazások (Branches): A különböző lehetséges döntések.
3️⃣ Belső csomópontok: További elágazások az adatok szétválasztására.
4️⃣ Levelek (Leaves): A végső döntések vagy kategóriák.

📌 Példa egy egyszerű döntési fára:
Kérdés: Elmegyünk ma szabadtéri programra?

  • Ha esik az eső, akkor nem megyünk.

  • Ha nem esik az eső, de hideg van, akkor szintén nem megyünk.

  • Ha napos idő van, és meleg is van, akkor elmegyünk.

🔽 Grafikus ábrázolás:

--- java

          (Kinti program?)
             /      \
       (Esik?)     (Nem esik?)
        /   \          /      \
     Igen   Nem   (Hideg?)   (Meleg?)
      |      |      /    \     /    \
   Nem megy Nem megy Nem megy Megyünk

1.3 Milyen módszerekkel építhető fel egy döntési fa?

A fa növekedése során mindig azt a változót (feature-t) választjuk ki, amely a legjobban megkülönbözteti az adatokat. Ehhez többféle kritériumot használhatunk:

a) Gini-index

Megmutatja az egyes csomópontok tisztaságát. Ha egy csomópontban minden elem ugyanabba a kategóriába tartozik, akkor a Gini-index 0. Ha az elemek fele-fele arányban oszlanak meg, akkor közel 0,5.

📌 Képlet:

Gini=1−∑pi2Gini = 1 - \sum p_i^2

🔹 Minél alacsonyabb a Gini-index, annál jobb a felosztás.

b) Entropia és információs nyereség (Information Gain)

Az entropia azt mutatja meg, hogy mennyire rendezetlenek az adatok. Az információs nyereség azt méri, hogy mennyire csökkenti az entrópiát egy adott változó alapján történő osztás.

📌 Képlet:

H(S)=−∑pilog⁡2piH(S) = - \sum p_i \log_2 p_i

🔹 Minél nagyobb az információs nyereség, annál informatívabb a szétválasztás.

1.4 Előnyök és hátrányok

✅ Előnyök:
✔️ Könnyen értelmezhető és vizualizálható.
✔️ Nem igényel előzetes adatnormalizálást.
✔️ Képes kezelni numerikus és kategóriális adatokat is.

❌ Hátrányok:
❌ Könnyen túlilleszkedhet (overfitting), ha túl mély a fa.
❌ Nem mindig a legpontosabb modell más ML-algoritmusokhoz képest.

1.5 Gyakorlati példa (Pythonban)

📌 Példa: Döntési fa segítségével határozzuk meg, hogy valaki felvesz-e egy hitelt (igen/nem) bizonyos jellemzők alapján.

---python

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn import datasets

# Adatok betöltése (példa-adat: iris dataset)
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Adatok felosztása teszt- és tanulóhalmazra
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Döntési fa modell létrehozása
model = DecisionTreeClassifier(criterion='gini', max_depth=3)
model.fit(X_train, y_train)

# Pontosság kiértékelése
accuracy = model.score(X_test, y_test)
print(f"Modell pontossága: {accuracy:.2f}")

🔹 A modell egy virágfajtát jósol meg a bemeneti adatok alapján (pl. szirmok hossza és szélessége alapján).

1.6 Döntési fák alkalmazási területei

✔️ Egészségügy: Diagnosztikai döntések segítése (pl. rákbetegség kockázatának elemzése).
✔️ Pénzügy: Hitelfelvételi döntések.
✔️ Marketing: Vásárlói szegmensek azonosítása.
✔️ HR és toborzás: Munkavállalók kiválasztása.

Összegzés

🔹 A döntési fák az egyik legkönnyebben érthető és alkalmazható ML-algoritmusok. Egyszerű szabályok alapján hoznak döntéseket, és sok iparágban használják őket.

🔹 Legnagyobb kihívásuk az, hogy túl nagy méretűvé válhatnak, ami túlilleszkedéshez vezethet. Ezt pruning (metszés) technikákkal lehet kezelni.


2. Neurális hálózatok és mélytanulás (Neural Networks & Deep Learning)

A neurális hálózatok a mesterséges intelligencia egyik legfejlettebb területét képviselik. Ezek az emberi agy inspirálta számítási modellek képesek összetett mintázatok felismerésére, például arcfelismerésre, beszédfelismerésre vagy önvezető autók irányítására.

🔹 Kapcsolódás más technikákhoz:
A neurális hálózatokat használják gépi tanulásban, természetes nyelvfeldolgozásban (NLP), számítógépes látásban (CV), megerősítéses tanulásban (RL) és még sok más területen.

2.1 A neurális hálózatok alapjai

1️⃣ Mesterséges neuron (Perceptron)

A mesterséges neuron egy matematikai modell, amely több bemenetet fogad, ezekből egyetlen kimenetet számol ki súlyok és egy aktivációs függvény segítségével.

📌 Matematikai modell:

y=f(∑wixi+b)y = f \left( \sum w_i x_i + b \right)

🔹 Magyarázat:

  • xix_i → bemenetek

  • wiw_i → súlyok (a bemenetek fontosságát határozzák meg)

  • bb → bias (eltolás)

  • ff → aktivációs függvény

  • yy → kimenet

2️⃣ Rétegek és architektúra

A neurális hálózatok több rétegből épülnek fel:

📌 Rétegek típusai:
1️⃣ Bemeneti réteg – az adatok fogadása (pl. képpontok egy képből)
2️⃣ Rejtett rétegek – a mintázatok megtanulása
3️⃣ Kimeneti réteg – az előrejelzés vagy osztályozás

🔹 Példa egy egyszerű háromrétegű hálózatra:

--- scss

Bemeneti réteg → Rejtett réteg → Kimeneti réteg
   (x1, x2)    →   (h1, h2)   →    (y1, y2)

2.2 Aktivációs függvények

Az aktivációs függvények határozzák meg, hogy egy neuron milyen mértékben aktiválódjon.

📌 Leggyakoribb típusok:

🔹 ReLU (Rectified Linear Unit)

f(x)=max⁡(0,x)f(x) = \max(0, x)

👉 Előny: Gyors, jól működik mély hálózatokban.

🔹 Sigmoid

f(x)=11+e−xf(x) = \frac{1}{1 + e^{-x}}

👉 Előny: Valószínűségi kimenetekhez használják.

🔹 Tanh (Tangens hiperbolikus)

f(x)=ex−e−xex+e−xf(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}

👉 Előny: Értékei -1 és 1 között mozognak, jobb normalizáció.

2.3 Tanulási folyamat (Backpropagation és gradiens módszerek)

A neurális hálózatok a visszaterjesztéses tanulási algoritmust (Backpropagation) és a gradiens módszereket használják a súlyok frissítésére.

🔹 Lépések:
1️⃣ Előrehaladás (Forward Propagation) – a bemenet végighalad a hálózaton, és kiszámítja a kimenetet.
2️⃣ Hibaszámítás (Loss Calculation) – összehasonlítja a kimenetet a valós eredménnyel.
3️⃣ Visszaterjesztés (Backpropagation) – kiszámolja a hibát, és visszaterjeszti azt a hálózatba.
4️⃣ Súlyfrissítés (Gradient Descent) – a hálózat finomhangolja a súlyokat, hogy minimalizálja a hibát.

📌 Költségfüggvény (Loss function)
A tanulás során a hálózat a hibát próbálja minimalizálni, amit egy költségfüggvény mér.

Példa:

L=12∑(yvaloˊs−ypred)2L = \frac{1}{2} \sum (y_{valós} - y_{pred})^2

🔹 Minél kisebb az L értéke, annál pontosabb a modell.

2.4 Mélytanulás és mély neurális hálózatok

A mélytanulás (Deep Learning, DL) az a gépi tanulási módszer, amely mély, többrétegű neurális hálózatokat használ.

📌 Miért „mély” tanulás?
✔️ Nagyon mély, sok rétegből álló hálózatokat használ (pl. 10-100 réteg is lehet).
✔️ Képes összetett mintázatok felismerésére (pl. képfelismerés, beszédfelismerés).
✔️ Nagy adathalmazokon is jól működik.

2.5 Gyakorlati példa egy neurális hálózatra (Pythonban, TensorFlow/Keras)

📌 Egyszerű neurális hálózat a Keras könyvtárral, amely kézzel írott számokat ismer fel (MNIST dataset)

--- python

import tensorflow as tf
from tensorflow import keras
import numpy as np

# MNIST adatbázis betöltése
mnist = keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Adatok normalizálása (0-1 tartományba)
x_train, x_test = x_train / 255.0, x_test / 255.0

# Neurális hálózat létrehozása
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),  # Bemeneti réteg
    keras.layers.Dense(128, activation='relu'),  # Rejtett réteg
    keras.layers.Dense(10, activation='softmax') # Kimeneti réteg (10 osztály)
])

# Modell fordítása és tanítása
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)

# Modell értékelése
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Teszt pontosság: {test_acc:.2f}')

🔹 Ez egy egyszerű neurális hálózat, amely képes felismerni kézzel írott számokat egy képből.

2.6 Neurális hálózatok alkalmazási területei

✔️ Számítógépes látás: Arcfelismerés, objektumfelismerés (pl. önvezető autók).
✔️ Természetes nyelvfeldolgozás (NLP): Automatikus fordítás, chatbotok.
✔️ Hangfelismerés: Siri, Google Assistant.
✔️ Egészségügy: MRI és CT képek diagnosztikája.
✔️ Pénzügy: Csalásfelderítés, tőzsdei előrejelzések.

Összegzés

🔹 A neurális hálózatok az AI egyik legfontosabb és legfejlettebb technikái.
🔹 A mélytanulás az utóbbi években hatalmas előrelépést hozott az AI fejlődésében.
🔹 Hátrány: Nagy adat- és számítási kapacitás-igénye van.



3. Bayes-i hálózatok (Bayesian Networks)

A Bayes-i hálózatok (más néven irányított valószínűségi gráfok) olyan modellek, amelyek a valószínűségi kapcsolatok hálózatát reprezentálják. Ezek a modellek bizonytalansággal terhelt rendszerekben segítenek következtetéseket levonni, például orvosi diagnózisokban, kockázatelemzésben és nyelvfeldolgozásban.

🔹 Kapcsolódás más technikákhoz:
✔️ Gyakran használják gépi tanulásban és mesterséges intelligenciában valószínűségi következtetésekhez.
✔️ Kapcsolódik a Markov-modellekhez, amelyeket például beszédfelismerésben használnak.

3.1 Alapfogalmak

A Bayes-i hálózat egy gráfelméleti modell, amely a véletlen változók közötti függőségeket ábrázolja.

📌 Elemei:
1️⃣ Csomópontok (Nodok): Véletlen változókat jelölnek.
2️⃣ Élek (Edges): Irányított kapcsolatok a változók között.
3️⃣ Valószínűségi táblázatok (Conditional Probability Table, CPT): Minden csomóponthoz tartozik egy táblázat, amely az adott változó feltételes valószínűségeit tartalmazza.

3.2 Példa: Betegség diagnosztizálása

Tegyük fel, hogy egy influenza észlelésére építünk Bayes-i hálózatot. Az alábbi változókat vesszük figyelembe:

  • Influenza (Igen/Nem)

  • Láz (Igen/Nem)

  • Torokfájás (Igen/Nem)

🔹 Hálózat szerkezete:

--- markdown

       Influenza
        /     \
      Láz    Torokfájás

Ez azt jelenti, hogy az Influenza befolyásolja a Láz és Torokfájás valószínűségét.

📌 Példa valószínűségi táblázatokra (CPT):

| Influenza | P(Láz | Influenza) | P(Torokfájás | Influenza) | |-----------|------------------|------------------| | Igen | 0.8 | 0.7 | | Nem | 0.2 | 0.1 |

🔹 Kérdés: Ha egy páciens lázas, mennyi az esélye annak, hogy influenzás?
👉 Ezt a Bayes-tétellel számoljuk ki!

3.3 Bayes-tétel és következtetés

A Bayes-tétel a feltételes valószínűségek számítására szolgál:

P(A∣B)=P(B∣A)P(A)P(B)P(A | B) = \frac{P(B | A) P(A)}{P(B)}

🔹 Példa:
Ha tudjuk, hogy valaki lázas (B = Láz), milyen valószínűséggel van influenzája (A = Influenza)?

P(Igen∣Laˊz)=P(Laˊz∣Igen)P(Igen)P(Laˊz)P(Igen | Láz) = \frac{P(Láz | Igen) P(Igen)}{P(Láz)}

👉 Ez az inverz következtetés azt mutatja meg, hogy egy megfigyelt tünet (láz) alapján hogyan következtethetünk az okra (influenza).

3.4 Bayes-i hálózatok előnyei és hátrányai

✅ Előnyök:
✔️ Jól kezelik a bizonytalanságot.
✔️ Képesek következtetéseket levonni hiányos adatok alapján.
✔️ Könnyen frissíthetők új adatokkal.

❌ Hátrányok:
❌ Nehéz felépíteni, mert a valószínűségi táblázatokat előre meg kell adni vagy ki kell számítani.
❌ Nagy méretű hálózatok esetén a számítási költség magas lehet.

3.5 Gyakorlati példa Pythonban

📌 Használjuk a pgmpy könyvtárat egy egyszerű Bayes-i hálózat létrehozására!

---python

from pgmpy.models import BayesianNetwork
from pgmpy.factors.discrete import TabularCPD
from pgmpy.inference import VariableElimination

# Bayes-i hálózat létrehozása
model = BayesianNetwork([('Influenza', 'Láz'), ('Influenza', 'Torokfájás')])

# Feltételes valószínűségek (CPT-k) definiálása
cpd_influenza = TabularCPD(variable='Influenza', variable_card=2, values=[[0.1], [0.9]])  # 10% eséllyel influenza
cpd_laz = TabularCPD(variable='Láz', variable_card=2, 
                      values=[[0.2, 0.8], [0.8, 0.2]], 
                      evidence=['Influenza'], evidence_card=[2])
cpd_torok = TabularCPD(variable='Torokfájás', variable_card=2, 
                        values=[[0.3, 0.7], [0.7, 0.3]], 
                        evidence=['Influenza'], evidence_card=[2])

# Hálózatba illesztés
model.add_cpds(cpd_influenza, cpd_laz, cpd_torok)

# Valószínűségi következtetés
inference = VariableElimination(model)
result = inference.query(variables=['Influenza'], evidence={'Láz': 1})
print(result)

🔹 Ez a modell kiszámolja, hogy ha valaki lázas, mennyi esélye van influenzára.

3.6 Alkalmazási területek

✔️ Orvosi diagnózisok – betegségek előrejelzése tünetek alapján.
✔️ Pénzügyi kockázatelemzés – hitelezési kockázatok felmérése.
✔️ Robotika – bizonytalanság kezelése autonóm rendszerekben.
✔️ Beszédfelismerés – szavak felismerése zajos környezetben.

Összegzés

🔹 A Bayes-i hálózatok bizonytalansággal terhelt rendszerek modellezésére alkalmasak.
🔹 Matematikai alapja a Bayes-tétel, amely lehetővé teszi a következtetések levonását.
🔹 Legfőbb hátránya, hogy a teljes valószínűségi modell meghatározása nehéz és számításigényes lehet.




4. Támogatóvektor-gépek (Support Vector Machines, SVM)

A támogatóvektor-gépek (SVM-ek) a felügyelt tanulás egyik leghatékonyabb algoritmusai, amelyeket osztályozási és regressziós problémákra használnak. Az SVM-ek célja egy optimális választóvonal (hipersík) megtalálása, amely a legjobban szétválasztja az adatokat.

🔹 Kapcsolódás más technikákhoz:
✔️ Gyakran használják gépi tanulásban és mintázatfelismerésben.
✔️ Hasonlóságot mutat a neurális hálózatokkal, de más matematikai alapokon működik.

4.1 Alapötlet: Hipersík és Maximális Margó

📌 Az SVM működésének alapja:

  • Az algoritmus egy választóvonalat keres az adatok között.

  • Célja, hogy maximalizálja a margót, azaz a választóvonal és a legközelebbi adatok (támogató vektorok) távolságát.

🔹 Egydimenziós példa:
Ha van egy osztályozási feladatunk, ahol két csoport van (piros és kék pontok), az SVM megkeresi azt a lehetőségek közül a legjobb választóvonalat, amely a lehető legnagyobb távolságot tartja a két osztály legközelebbi pontjaitól.

🔹 Többdimenziós esetben az SVM nem vonalat, hanem egy hipersíkot keres, amely elválasztja az osztályokat.

4.2 Támogató vektorok és a margin

📌 Kulcsfogalmak:

  • Támogató vektorok: azok az adatpontok, amelyek a margin határán helyezkednek el és meghatározzák a választóvonalat.

  • Margin (rés): a választóvonal és a legközelebbi adatok közötti távolság. Minél nagyobb a margin, annál jobb a generalizáció (tehát az SVM jobban működik új adatokkal).

🔹 Matematikai modell:
Az SVM egy hipersíkot keres a következő egyenlet szerint:

wTx+b=0w^T x + b = 0

✔️ Cél: Az ww és bb értékek olyan meghatározása, hogy a választóvonal optimális legyen.
✔️ Optimalizálás: A cél a margin maximalizálása, amit egy konvex optimalizálási probléma segítségével oldunk meg.

4.3 Lineáris vs. Nemlineáris osztályozás

📌 Lineáris osztályozás
Ha az adatok egyenes vonallal (vagy hipersíkkal) elválaszthatók, az SVM könnyen alkalmazható.

📌 Nemlineáris osztályozás
Ha az adatok nem választhatók el egy egyszerű egyenessel, az SVM kernel trükköt alkalmaz.

🔹 Példa egy nemlineáris adathalmazra:

---mathematica

   O   O      X   X
    O O        X X
     O         X

Ezt az adatot egy egyenessel nem lehet elválasztani, ezért kell kernel trükköt használni.

4.4 Kernel trükk: Az SVM bővítése

Az SVM kerneleket használ, hogy az adatokat egy magasabb dimenziójú térbe transzformálja, ahol már elválaszthatók egy hipersíkkal.

📌 Gyakori kernelek:
✔️ Lineáris kernel: Ha az adatokat egy egyenes el tudja választani.
✔️ Polinomiális kernel: Ha az adatok nemlineárisan elválaszthatók.
✔️ RBF (Radial Basis Function) kernel: A leggyakoribb, jól működik bármilyen nemlineáris mintázatnál.

🔹 Kernel trükk elve:

  • Az adatok átalakítása magasabb dimenzióba, ahol már egyenes vonallal elválaszthatók.

  • Pl. egy kör alakú elrendezés 2D-ben egy 3D térben egy síkkal elválasztható!

4.5 SVM megvalósítása Pythonban (sklearn használatával)

📌 Egyszerű példa lineáris osztályozásra:

---python

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
import matplotlib.pyplot as plt

# Adathalmaz betöltése (pl. virágok osztályozása)
iris = datasets.load_iris()
X = iris.data[:, :2]  # Csak két jellemzőt használunk a vizualizáció miatt
y = iris.target

# Adathalmaz felosztása
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# SVM modell létrehozása és tanítása
model = SVC(kernel='linear')
model.fit(X_train, y_train)

# Modell kiértékelése
accuracy = model.score(X_test, y_test)
print(f"Pontosság: {accuracy:.2f}")

📌 Nemlineáris osztályozás RBF kernellel:

---python

model = SVC(kernel='rbf', gamma='scale')
model.fit(X_train, y_train)

🔹 Az RBF kernel segít megoldani azokat a problémákat, ahol a pontok bonyolultan oszlanak el.

4.6 Alkalmazási területek

✔️ Arcfelismerés – Az SVM-ek jól működnek képfelismerési problémákban.
✔️ Bioinformatika – Génexpressziós adatok osztályozása.
✔️ Szövegosztályozás – Spam és nem spam e-mailek elkülönítése.
✔️ Pénzügy – Csalások és anomáliák észlelése.

4.7 Összegzés

✅ Előnyök:
✔️ Hatékony kis és közepes méretű adathalmazokon.
✔️ Jól működik bonyolult osztályozási problémákban.
✔️ Robusztus a zajos adatokkal szemben.

❌ Hátrányok:
❌ Nagy adathalmazoknál lassú lehet.
❌ Nehezen skálázható nagy méretű adatok esetén.
❌ A megfelelő kernel kiválasztása nem mindig egyszerű.



5. Döntési fák és Random Forest 🌳🌲

A döntési fák és a Random Forest algoritmusok az egyik leggyakrabban használt technikák a gépi tanulásban. Ezek intuitívak, könnyen értelmezhetők és hatékonyan alkalmazhatók osztályozási és regressziós problémákban.

🔹 Kapcsolódás más technikákhoz:
✔️ Gyakran használják felügyelt tanulásban adatok osztályozására.
✔️ A Random Forest az egyedi döntési fákat egyesíti, így egy ensemble (együttes) tanulási módszer.
✔️ Kapcsolódik a Boosting algoritmusokhoz, amelyek szintén több modellt kombinálnak.

5.1 Döntési fák (Decision Trees) alapjai

📌 Hogyan működnek?
A döntési fa egy fa-struktúrájú modell, ahol:
✔️ Minden csomópont (node) egy döntési szabályt tartalmaz.
✔️ Az ágak (edges) a lehetséges kimeneteket jelölik.
✔️ A levelek (leaves) tartalmazzák a végső osztályokat vagy értékeket.

🔹 Egyszerű példa: Egy döntési fa a „Veszek-e esernyőt?” kérdésre

--- markdown

          Esik az eső?
          /       \
        Igen       Nem
        /           \
    Viszek      Nem viszek
   esernyőt       esernyőt

🔹 Matematikai alapja
A döntési fák olyan feltételek sorozatát követik, amelyek egy adott célváltozóhoz vezetnek. A döntési kritériumokat általában az alábbi módszerek alapján határozzák meg:

✔️ Gini-index (Gini impurity) – a heterogenitás mérésére.
✔️ Információs entrópia – mennyire tiszta egy elágazás.

📌 A cél az, hogy a lehető legjobban szétválasszuk az adatokat, vagyis csökkentsük a bizonytalanságot minden lépésben.

5.2 Döntési fa osztályozás példában (Pythonban)

📌 Egyszerű osztályozási példa egy döntési fával:

--- python

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
from sklearn import tree

# Adathalmaz betöltése
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Adathalmaz felosztása
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Döntési fa modell létrehozása és tanítása
model = DecisionTreeClassifier(criterion='gini', max_depth=3)
model.fit(X_train, y_train)

# Modell pontosságának kiértékelése
accuracy = model.score(X_test, y_test)
print(f"Pontosság: {accuracy:.2f}")

# Döntési fa vizualizálása
plt.figure(figsize=(10,6))
tree.plot_tree(model, feature_names=iris.feature_names, class_names=iris.target_names, filled=True)
plt.show()

🔹 Eredmény: A döntési fa struktúrája láthatóvá válik, amely segít az adatok értelmezésében.

5.3 Döntési fák hátrányai és megoldásuk: Random Forest

📌 Probléma: A döntési fák könnyen túlilleszkedhetnek az adatokra (overfitting).
📌 Megoldás: Használjunk Random Forest-et, amely több döntési fát kombinál!

🔹 Mi az a Random Forest?
✔️ Több döntési fát hoz létre, és azok átlagolt eredményét veszi figyelembe.
✔️ Az egyes döntési fák véletlenszerűen választott jellemzőkkel épülnek fel.
✔️ Robusztusabb és pontosabb eredményt ad, mint egyetlen döntési fa.

5.4 Random Forest osztályozás Pythonban

📌 Példa egy Random Forest modellre:

--- python

from sklearn.ensemble import RandomForestClassifier

# Random Forest modell létrehozása és tanítása
rf_model = RandomForestClassifier(n_estimators=100, max_depth=3, random_state=42)
rf_model.fit(X_train, y_train)

# Modell kiértékelése
accuracy = rf_model.score(X_test, y_test)
print(f"Random Forest pontosság: {accuracy:.2f}")

🔹 Miért jobb a Random Forest?
✔️ Kevésbé hajlamos a túlilleszkedésre, mert több modell együttes eredményét használja.
✔️ Jobb általánosítási képesség új adatokra.
✔️ Párhuzamosan futtatható, így hatékony nagy adathalmazok esetén is.

5.5 Alkalmazási területek

✔️ Orvosi diagnózis – Különböző egészségügyi mutatók alapján betegségek előrejelzése.
✔️ Pénzügyi előrejelzések – Csalások és kockázatok észlelése.
✔️ Szövegosztályozás – Spam e-mailek azonosítása.
✔️ Képfelismerés – Objektumok osztályozása.

5.6 Összegzés

Döntési fa:

✅ Előnyök:
✔️ Könnyen értelmezhető és vizualizálható.
✔️ Gyorsan fut kis adathalmazokon.

❌ Hátrányok:
❌ Hajlamos a túlilleszkedésre.
❌ Nem mindig működik jól, ha sok zaj van az adatokban.

Random Forest:

✅ Előnyök:
✔️ Jobb általánosítási képesség új adatokra.
✔️ Csökkenti a túlilleszkedést azáltal, hogy több modellt kombinál.

❌ Hátrányok:
❌ Lassabb, mint egy egyszerű döntési fa.
❌ Nehezebb értelmezni az eredményeket (mert sok fa kombinációja).


6. K legközelebbi szomszéd (K-Nearest Neighbors, KNN) algoritmus 🔍👥

A K legközelebbi szomszéd (KNN) egy egyszerű, de hatékony algoritmus, amely osztályozási és regressziós problémákra egyaránt alkalmazható. Nem tanulási fázison alapul, hanem az új adatpontok osztályozásához a legközelebbi k szomszédot veszi figyelembe.

🔹 Kapcsolódás más technikákhoz:
✔️ Az SVM-hez hasonlóan példa-alapú tanulás, azaz nincs explicit tanulási lépése.
✔️ A döntési fákkal ellentétben nincs szabály-alapú döntés, csak a távolságokat vizsgálja.

6.1 KNN működési elve

📌 Alapötlet:
Egy új adatpont osztályát vagy értékét úgy határozzuk meg, hogy megnézzük a legközelebbi k adatpontot, és a többségi osztály alapján döntünk.

🔹 Példa: Új adat besorolása két csoport közé

Ha van két csoport (🔵 kék és 🔴 piros pontok), és egy új adatpont (❓) érkezik:


🔵  🔵  🔵  ❓  🔴  🔴  🔴

  • Ha k = 3, akkor a három legközelebbi szomszédot nézzük: lehet, hogy 2 🔵 és 1 🔴 → Az új adatot kéknek soroljuk be.

  • Ha k = 5, akkor a többség lehet 🔴 → Az új adatot pirosnak soroljuk be.

🔹 KNN algoritmus lépései:
1️⃣ Válasszuk ki a k értéket (pl. 3, 5 vagy 7).
2️⃣ Számítsuk ki a távolságokat az új adat és az összes meglévő adat között.
3️⃣ Válasszuk ki a legközelebbi k szomszédot.
4️⃣ Többségi szavazás alapján döntsük el az osztályt.

📌 Távolságmérési módszerek:
✔️ Euklideszi távolság (a legismertebb):

d(x,y)=∑(xi−yi)2d(x, y) = \sqrt{\sum (x_i - y_i)^2}

✔️ Manhattan-távolság (abszolút különbségek összege).
✔️ Koszinusz hasonlóság (szög az adatvektorok között, szöveganalízisben gyakori).

6.2 KNN osztályozás Pythonban

📌 Példa az Iris adathalmazon KNN algoritmussal:

--- python

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import numpy as np

# Adathalmaz betöltése
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Adathalmaz felosztása (70% tanító, 30% teszt)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# KNN modell létrehozása és tanítása (k = 5)
model = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
model.fit(X_train, y_train)

# Modell pontosságának mérése
accuracy = model.score(X_test, y_test)
print(f"KNN pontosság: {accuracy:.2f}")

🔹 Fontos megjegyzések:
✔️ A k értéket jól kell megválasztani: túl kicsi k zajérzékeny lehet, túl nagy k pedig elmossa a mintázatokat.
✔️ Nagy adathalmazoknál lassú lehet, mert minden új adatpontnál újra kell számolni az összes távolságot.

6.3 Hogyan válasszuk meg a K értéket?

📌 K túl kicsi (pl. 1 vagy 3):
✔️ Hajlamos a túlilleszkedésre (overfitting).
✔️ Zajra érzékeny, mert egyetlen vagy nagyon kevés adatpont dönt az osztályról.

📌 K túl nagy (pl. 15 vagy 20):
✔️ Általánosabb, de elmossa az osztályokat, mert távolabbi pontokat is figyelembe vesz.

📌 Megoldás:
🔹 Általában 5 és 11 közötti K értékek működnek jól.
🔹 K-t optimalizálhatjuk kereséssel:

--- python

from sklearn.model_selection import cross_val_score

# K érték optimalizálása
for k in range(1, 21):
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, X_train, y_train, cv=5)
    print(f"K={k}, Átlagos pontosság: {scores.mean():.2f}")

Ez segít megtalálni a legjobb K értéket az adott adathalmazra!

6.4 KNN regresszió

A KNN nemcsak osztályozásra, hanem regresszióra is használható!

🔹 Példa KNN regresszióra (házárak előrejelzése)

--- python

from sklearn.neighbors import KNeighborsRegressor

# KNN regresszor modell
knn_regressor = KNeighborsRegressor(n_neighbors=5)
knn_regressor.fit(X_train, y_train)

# Előrejelzés
y_pred = knn_regressor.predict(X_test)

✔️ KNN regresszió esetén az új értéket a legközelebbi szomszédok átlagaként számítjuk ki.

6.5 KNN előnyei és hátrányai

✅ Előnyök:
✔️ Egyszerű és könnyen érthető.
✔️ Nincs szükség hosszú tanítási időre.
✔️ Jó teljesítmény kis adathalmazokon.

❌ Hátrányok:
❌ Nagy adathalmazoknál lassú, mert minden új adatnál újra kell számolni a távolságokat.
❌ Érzékeny lehet a nem megfelelően normalizált adatokra.
❌ Dimenziórobbanás: magas dimenziókban rosszabbul működik.

📌 Megoldás:
✔️ Hatékony adatstruktúrák (KD-tree, Ball-tree) használata gyorsabb kereséshez.
✔️ Adatok normalizálása, hogy a különböző jellemzők azonos skálán legyenek.

6.6 KNN alkalmazási területek

✔️ Orvosi diagnosztika – Betegségek előrejelzése.
✔️ Ajánlórendszerek – Hasonló felhasználók viselkedése alapján ajánlásokat ad.
✔️ Képfelismerés – Képek osztályozása hasonlóság alapján.
✔️ Pénzügyi előrejelzések – Hitelképesség értékelése múltbeli adatok alapján.

Összegzés

✅ KNN egy egyszerű, de erős algoritmus, amely jól működik kis adathalmazoknál.
✅ Nem tanul előre, hanem csak a szomszédokat vizsgálja, így könnyen implementálható.
❌ Nagy adathalmazoknál lassú, és figyelni kell a k érték optimális beállítására.




7. Naiv Bayes-osztályozó 🤖📊

A Naiv Bayes-osztályozó egy valószínűségi modell, amely a Bayes-tételen alapul. Egyszerű, mégis nagyon hatékony algoritmus, főként szövegosztályozásra, spam szűrésre és orvosi diagnosztikára használják.

🔹 Kapcsolódás más technikákhoz:
✔️ KNN-hez hasonlóan gyors, de statisztikai alapú.
✔️ Döntési fákkal szemben nem keres szabályokat, hanem valószínűségi modelleket használ.

7.1 A Bayes-tétel és az alapelvek

📌 Bayes-tétel képlete:

P(A∣B)=P(B∣A)⋅P(A)P(B)P(A | B) = \frac{P(B | A) \cdot P(A)}{P(B)}

ahol:

  • P(A | B) = A valószínűsége, ha B megtörtént (feltételes valószínűség).

  • P(B | A) = B valószínűsége, ha A megtörtént.

  • P(A) = A önálló valószínűsége.

  • P(B) = B önálló valószínűsége.

📌 Naiv feltételezés:
A Naiv Bayes-osztályozó feltételezi, hogy az egyes jellemzők függetlenek egymástól. Bár ez a való világban ritkán igaz, a modell ennek ellenére meglepően jól működik.

7.2 Példa: Spam e-mailek osztályozása

Ha egy e-mailben az alábbi szavak szerepelnek:
✅ "ajánlat"
✅ "ingyenes"
✅ "nyeremény"

akkor megvizsgáljuk, hogy ezek a szavak milyen gyakran fordulnak elő spam vs. nem spam e-mailekben, és ennek alapján számítjuk ki a valószínűséget.

7.3 Naiv Bayes osztályozók típusai

📌 Multinomiális Naiv Bayes – Szöveganalízishez (pl. spam szűrés).
📌 Gaussi Naiv Bayes – Folytonos adatokat (pl. szenzoradatok) modellez.
📌 Bernoulli Naiv Bayes – Igen/Nem típusú adatokra (pl. jelen van-e egy szó vagy sem).

7.4 Naiv Bayes osztályozó Pythonban

📌 Példa: SMS spam szűrés

---python

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score

# Példa adatok (spam és nem spam SMS-ek)
messages = [
    ("Ingyenes nyeremény! Kattints ide most!", "spam"),
    ("Találkozunk este a moziban?", "ham"),
    ("Ajánlat! Vásárolj most és spórolj!", "spam"),
    ("Holnap munka után találkozunk?", "ham")
]

# Szöveg és címke különválasztása
texts, labels = zip(*messages)

# Szöveg átalakítása számokká (bag-of-words modell)
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)
y = [1 if label == "spam" else 0 for label in labels]

# Tanító és teszt adatok szétválasztása
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Naiv Bayes modell létrehozása és tanítása
model = MultinomialNB()
model.fit(X_train, y_train)

# Előrejelzés és pontosság mérése
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Pontosság: {accuracy:.2f}")

🔹 Mi történik itt?
✔️ Az SMS-eket szavak számosságává alakítjuk (bag-of-words modell).
✔️ A Naiv Bayes valószínűségi alapú döntést hoz arról, hogy spam vagy nem spam az üzenet.

7.5 Előnyök és hátrányok

✅ Előnyök:
✔️ Gyors és skálázható nagy adathalmazokra.
✔️ Jól működik szövegosztályozásra.
✔️ Kis adathalmazokkal is megbízható.

❌ Hátrányok:
❌ A függetlenségi feltételezés gyakran nem teljesül.
❌ Rosszul teljesít, ha a jellemzők egymással erősen korrelálnak.

📌 Megoldás:
✔️ Használjunk TF-IDF transzformációt, hogy a szavak fontosságát figyelembe vegyük!

----python

from sklearn.feature_extraction.text import TfidfVectorizer
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(texts)

7.6 Alkalmazási területek

✔️ Spam szűrés – Gmail, Yahoo, Outlook spamdetektorok.
✔️ Orvosi diagnosztika – Betegségek előrejelzése tünetek alapján.
✔️ Sentiment analízis – Vélemények osztályozása (pozitív/negatív).
✔️ Dokumentumosztályozás – Hírek, cikkek kategorizálása.

Összegzés

✅ Naiv Bayes egy gyors és hatékony algoritmus, különösen szöveganalízisben.
✅ Alapja a Bayes-tétel, amely a valószínűségekre épít.
❌ Hátránya a függetlenségi feltételezés, de még így is jól teljesít!



8. Logisztikus regresszió 📊🔢

A logisztikus regresszió (LR) egy statisztikai és gépi tanulási modell, amelyet leginkább bináris osztályozási problémákra (pl. beteg vagy egészséges, spam vagy nem spam) alkalmaznak. Bár "regresszió" a neve, valójában osztályozási modell, mert az eredmény egy valószínűség, amelyet aztán osztályokba sorolunk.

🔹 Kapcsolódás más technikákhoz:
✔️ KNN-nel ellentétben ez egy paraméteres modell, amelyet előre betanítunk.
✔️ Naiv Bayes-szel szemben nincsenek függetlenségi feltételezések.
✔️ Hasonló az SVM-hez, mert hipersíkot próbál találni az osztályok elválasztására.

8.1 A logisztikus regresszió alapelve

📌 Alapgondolat:
A lineáris regresszióhoz hasonlóan az adatokból egy egyenes vonalat illesztünk, de az eredményt egy 0 és 1 közötti valószínűséggé alakítjuk a logisztikus (sigmoid) függvény segítségével.

Logisztikus (sigmoid) függvény:

A logisztikus regresszió a sigmoid függvényt használja, amely így néz ki:

σ(z)=11+e−z\sigma(z) = \frac{1}{1 + e^{-z}}

ahol z egy lineáris egyenlet:

z=w0+w1x1+w2x2+...+wnxnz = w_0 + w_1x_1 + w_2x_2 + ... + w_nx_n

📌 Sigmoid függvény tulajdonságai:
✔️ Kimenete 0 és 1 között van → alkalmas valószínűségi értékek modellezésére.
✔️ Ha σ(z)>0.5\sigma(z) > 0.5, akkor az egyik osztályba, ha kisebb, akkor a másikba soroljuk az adatot.

📌 Döntési szabály:

  • Ha P(y=1∣x)>0.5P(y=1 | x) > 0.5 → osztály 1

  • Ha P(y=1∣x)≤0.5P(y=1 | x) \leq 0.5 → osztály 0

8.2 Példa: Beteg-e valaki egy tünet alapján?

Ha a X változó azt mutatja, hogy egy betegnek van-e láza (1 = van, 0 = nincs), akkor a logisztikus regresszió a valószínűséget becsli:

P(beteg∣X)=11+e−(w0+w1X)P(\text{beteg} | X) = \frac{1}{1 + e^{-(w_0 + w_1X)}}

Ha az eredmény pl. 0.8, akkor a modell azt mondja, hogy 80% valószínűséggel beteg az illető.

8.3 Logisztikus regresszió Pythonban

📌 Példa: Diabétesz előrejelzése

--- python

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Példa adathalmaz (cukorbetegség előrejelzése)
data = {
    "Glucose": [80, 85, 90, 150, 160, 170],
    "Diabetes": [0, 0, 0, 1, 1, 1]  # 1 = cukorbeteg, 0 = egészséges
}

df = pd.DataFrame(data)

# Adatok szétválasztása
X = df[["Glucose"]]
y = df["Diabetes"]

# Tanító és teszt adatok felosztása
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Modell betanítása
model = LogisticRegression()
model.fit(X_train, y_train)

# Előrejelzés és pontosság kiértékelése
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Modell pontossága: {accuracy:.2f}")

🔹 Mi történik itt?
✔️ A glükózszint alapján megtanítjuk a modellt arra, hogy cukorbeteg-e valaki.
✔️ A sigmoid függvény valószínűségi értékeket ad, majd ezeket 0 vagy 1 osztályokba sorolja.

8.4 Hogyan tanulja meg a súlyokat? (Optimalizálás)

A modell a súlyokat (w0, w1, ...) gradiens módszerrel tanulja meg.

📌 Költségfüggvény (log loss):
A lineáris regresszió MSE (négyzetes hiba) helyett a log loss (logaritmikus veszteség) függvényt használja:

J(w)=−1m∑i=1m[yilog⁡pi+(1−yi)log⁡(1−pi)]J(w) = -\frac{1}{m} \sum_{i=1}^{m} \left[ y_i \log p_i + (1 - y_i) \log (1 - p_i) \right]

📌 Optimalizálás:

  • Gradiens csökkenés (Gradient Descent) – iteratív módszer, amely fokozatosan javítja a súlyokat.

  • Newton-módszer – gyorsabb, de számításigényesebb módszer.

8.5 Logisztikus regresszió vs. más osztályozók

AlgoritmusElőnyökHátrányok
KNNEgyszerű, könnyen érthetőLassú nagy adathalmazoknál
Naiv BayesGyors, jól működik szövegekenFeltételezi a függetlenséget
SVMErős, jól működik kis adathalmazonLassú nagy adathalmazoknál
Logisztikus Regr.Jó magyarázhatóság, gyorsCsak lineáris elválasztás esetén működik jól

8.6 Többosztályos logisztikus regresszió

📌 One-vs-Rest (OvR) stratégia:
Ha több osztály van (pl. piros-zöld-kék kategóriák), akkor a logisztikus regressziót úgy használjuk, hogy minden osztály ellen a többi osztályt teszteljük.

🔹 Python példakód többosztályos problémára:

--- python

from sklearn.datasets import load_iris

# Adathalmaz betöltése (Iris virágok 3 osztálya)
iris = load_iris()
X = iris.data
y = iris.target

# Modell betanítása többosztályos osztályozásra
model = LogisticRegression(multi_class="ovr")
model.fit(X, y)

# Osztályok előrejelzése
y_pred = model.predict(X)

8.7 Logisztikus regresszió alkalmazási területei

✔️ Orvosi diagnosztika – Pl. cukorbetegség, rák előrejelzése.
✔️ Pénzügyi előrejelzések – Pl. hitelképesség becslése.
✔️ Marketing kampányok – Pl. vásárlók elkötelezettségének becslése.
✔️ Kiberbiztonság – Pl. jogosult-e egy felhasználó egy műveletre.

Összegzés

✅ Egyszerű és hatékony modell, amely jól alkalmazható bináris osztályozásra.
✅ Probabilitás alapú megközelítés, amelyet könnyű értelmezni.
❌ Csak lineárisan elválasztható adatokon működik jól.



9. Megerősítéses tanulás (Reinforcement Learning, RL) 🎮🤖

A Megerősítéses Tanulás (Reinforcement Learning, RL) egy gépi tanulási módszer, amelyben egy ügynök (agent) próbálja maximalizálni a hosszú távú jutalmat egy dinamikusan változó környezetben. Az RL algoritmusok a próbálkozás és hibázás (trial and error) módszerével tanulnak, és folyamatosan javítják a döntéseiket.

🔹 Kapcsolódás más technikákhoz:
✔️ Hasonló a felügyelt tanuláshoz, de itt nincs címkézett adat, csak a jutalmak.
✔️ Különbözik a nem felügyelt tanulástól, mert a cél nem az adatok szerkezetének megértése, hanem optimális döntéshozatal.

9.1 Hogyan működik az RL?

📌 Az RL egy interaktív folyamat, amelyben az ügynök döntéseket hoz, jutalmat kap, és folyamatosan tanul.

🔹 Alapkomponensek:

1️⃣ Ügynök (Agent) – A tanuló rendszer (pl. egy robot, önvezető autó, AI játékos).
2️⃣ Környezet (Environment) – A világ, amelyben az ügynök működik (pl. sakk, egy valódi város az önvezető autónak).
3️⃣ Állapot (State, s) – A környezet aktuális állapota (pl. a sakk tábla állása).
4️⃣ Akció (Action, a) – Az ügynök döntése (pl. lépés egy sakkjátszmában).
5️⃣ Jutalom (Reward, r) – Az ügynök visszacsatolást kap az akciójáért (pl. egy jó lépés +1 pont).
6️⃣ Politika (Policy, π(s)) – Az ügynök stratégiája, amely alapján kiválasztja az akciókat.

📌 Cél:
Az ügynöknek azt kell megtanulnia, hogy milyen akciókat kell végrehajtania, hogy hosszú távon a lehető legnagyobb összegzett jutalmat kapja.

9.2 RL folyamat lépésről lépésre

1️⃣ Az ügynök észleli az aktuális állapotot (sts_t).
2️⃣ Az ügynök választ egy akciót (ata_t), egy adott politika (π\pi) szerint.
3️⃣ Az akció hatására a környezet új állapotba kerül (st+1s_{t+1}).
4️⃣ Az ügynök jutalmat kap (rtr_t), amely megmondja, hogy az akció jó vagy rossz volt.
5️⃣ Az ügynök frissíti a stratégiáját, hogy a jövőben jobb döntéseket hozzon.

🔹 RL tanulás ciklus:

---nginx
 
Kezdeti állapot → Akció → Új állapot → Jutalom → Frissítés → Ismétlés

9.3 Példa: RL egy önvezető autónál 🚗

📌 Cél: Az autónak meg kell tanulnia, hogyan közlekedjen a városban.

✔️ Állapotok (s): Az autó sebessége, közlekedési lámpák, távolság a többi autótól.
✔️ Akciók (a): Gyorsítás, fékezés, kanyarodás.
✔️ Jutalom (r): Ha az autó biztonságosan halad, jutalmat kap (+1). Ha nekiütközik valaminek, büntetést kap (-10).

🔹 A tanulási folyamat során az autó megtanulja, hogyan haladjon biztonságosan és hatékonyan.

9.4 RL algoritmusok típusai

📌 1. Dinamikus programozási módszerek (Dynamic Programming, DP)

  • Alapelve: Ha ismerjük a környezet teljes modelljét (pl. sakk esetén az összes lehetséges lépést), akkor iteratív módszerekkel optimalizálhatjuk a döntéseket.

  • Pl.: Bellman-egyenlet, Value Iteration, Policy Iteration.

📌 2. Monte Carlo módszerek

  • Alapelve: Az ügynök próbálkozásokkal szimulációkat futtat, és az eredmények alapján javítja a döntéseit.

  • Pl.: Monte Carlo Policy Evaluation, Monte Carlo Control.

📌 3. Temporal Difference Learning (TD-learning)

  • Alapelve: A tanulás során az ügynök részben azonnali visszajelzésekből tanul, és nem kell megvárnia egy teljes epizód végét.

  • Pl.: Q-learning, SARSA (State-Action-Reward-State-Action).

9.5 Q-learning – Az egyik legnépszerűbb RL algoritmus

📌 Alapötlet:
A Q-learning egy off-policy algoritmus, amely az egyes állapot-akció párokhoz Q-értéket rendel, amely az adott akció hosszú távú várható jutalmát mutatja.

📌 Q-érték frissítési képlete:

Q(s,a)=Q(s,a)+α[r+γmax⁡Q(s′,a′)−Q(s,a)]Q(s, a) = Q(s, a) + \alpha \left[ r + \gamma \max Q(s', a') - Q(s, a) \right]

ahol:
✔️ Q(s,a)Q(s, a) – az adott állapotban végrehajtott akció várható értéke.
✔️ rr – az akcióért kapott azonnali jutalom.
✔️ γ\gamma – a diszkontálási faktor (0 és 1 között), amely azt mutatja, hogy a távoli jutalmak mennyire fontosak.
✔️ α\alpha – a tanulási ráta (learning rate).

📌 Q-learning RL példaprogram Pythonban (OpenAI Gym)

---python

import gym
import numpy as np

# OpenAI Gym egyszerű fagyasztott tó (FrozenLake) környezete
env = gym.make("FrozenLake-v1", is_slippery=False)
Q = np.zeros([env.observation_space.n, env.action_space.n])  # Q-tábla inicializálás

alpha = 0.1  # Tanulási ráta
gamma = 0.9  # Diszkontálási tényező
episodes = 1000  # Iterációk száma

for episode in range(episodes):
    state = env.reset()[0]  # Kezdőállapot
    done = False

    while not done:
        action = np.argmax(Q[state, :] + np.random.randn(1, env.action_space.n) * 0.01)  # Felfedezés és kiaknázás
        new_state, reward, done, _, _ = env.step(action)  # Lépés
        Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[new_state, :]) - Q[state, action])
        state = new_state

print("Kész a tanulás!")

🔹 Mit csinál ez a kód?
✔️ Egy egyszerű játékot játszik, ahol az ügynök megpróbál eljutni a célba.
✔️ Az algoritmus Q-értékeket tanul, és egyre jobb döntéseket hoz.

9.6 RL alkalmazási területek

✔️ Önvezető autók – Az autók tanulnak a közlekedési szabályokból.
✔️ Játékok (AI gaming) – Az AlphaGo és az AlphaZero RL-t használt a sakk és a Go játékok megnyeréséhez.
✔️ Robotika – Robotkarok megtanulják, hogyan fogjanak meg tárgyakat.
✔️ Pénzügyi modellezés – RL alapú algoritmusok kereskedési stratégiákat optimalizálnak.

9.7 Összegzés

✅ Az RL olyan problémákra jó, ahol a döntések hosszú távú következményekkel járnak.
✅ Nem kell előre címkézett adatokkal tanítani, mert az ügynök maga fedezi fel a világot.
❌ Hátrány: Nagyon idő- és számításigényes, mert sok iteráció kell a tanuláshoz.




11. Genetikus Algoritmusok (GA) – Evolúciós tanulás 🧬🤖

A genetikus algoritmus (GA) egy optimalizációs módszer, amely a természetes szelekció és az evolúció elvein alapul. Ez az algoritmus populációt hoz létre, amelyet mutációval és keresztezéssel fejleszt, hogy megtalálja az optimális megoldást egy adott problémára.

11.1 Hogyan működik a genetikus algoritmus?

📌 A GA alapelve:
✅ Populációval dolgozik (lehetséges megoldások halmaza).
✅ Genetikai műveleteket végez rajtuk (keresztezés, mutáció).
✅ A legjobb egyedeket tartja meg (természetes szelekció).
✅ Több generáción keresztül javítja a megoldásokat.

11.2 A genetikus algoritmus fő lépései

1️⃣ Inicializálás (Kezdő populáció létrehozása)

A genetikus algoritmus véletlenszerű egyedekkel (megoldásokkal) indul.

Példa: Egy optimalizációs probléma esetén minden egyed egy bináris kromoszóma lehet:
📌 0110101011 (10 bites megoldás)

2️⃣ Fitness függvény (Kiértékelés)

A fitness függvény megmondja, hogy egy egyed mennyire jó a probléma megoldásában.

Példa: Ha egy robot mozgását optimalizáljuk, akkor a fitness függvény lehet:
✅ Megteszi a legrövidebb utat?
✅ Energiatakarékosan mozog?

🔹 A cél mindig a legjobb fitness érték elérése!

3️⃣ Szelekció (A legjobbak kiválasztása)

A szelekció során a legjobb egyedek kerülnek kiválasztásra, hogy tovább örökítsék génjeiket.

📌 Gyakori szelekciós módszerek:
✔️ Rulettkerék szelekció – Valószínűség alapján választ.
✔️ Torna szelekció – A legjobb egyedeket veszi figyelembe.

4️⃣ Keresztezés (Crossover) – Új egyedek létrehozása

A keresztezés során két szülő géneket cserél, hogy új megoldásokat hozzon létre.

🔹 Példa – Egy pontos keresztezés:

Szülő 1: 10110 | 11001
Szülő 2: 01001 | 00111
Utód: 10110 | 00111

📌 Ez segít új megoldások létrehozásában!

5️⃣ Mutáció (Mutation) – Változatosság fenntartása

A mutáció során véletlenszerűen megváltoztatunk egy gént, hogy elkerüljük a helyi optimumokat.

🔹 Példa – Egy gén megváltoztatása:

Eredeti egyed: 1011010100
Mutáció után: 1011011100

📌 Ez segít elkerülni a korai konvergenciát!

6️⃣ Generációváltás és ismétlés

Az új egyedek bekerülnek a populációba, és az eljárás ismétlődik több generáción keresztül.

✅ Végső cél: A legjobb egyed megtalálása.

11.3 Genetikus algoritmus implementációja Pythonban

📌 Példa: Egy matematikai függvény optimalizálása genetikus algoritmussal

---python

import numpy as np

# Fitness függvény: Az x^2 minimalizálása
def fitness(x):
    return -x**2  # Negatív, mert maximalizálni akarunk

# Inicializálás: 10 véletlen egyed a [-10, 10] intervallumban
pop_size = 10
population = np.random.uniform(-10, 10, pop_size)

# Evolúciós ciklus
for generation in range(100):
    fitness_values = np.array([fitness(x) for x in population])
    
    # Szelekció (legjobb 2 egyed kiválasztása)
    parents = population[np.argsort(fitness_values)[-2:]]
    
    # Keresztezés (átlagolás)
    offspring = (parents[0] + parents[1]) / 2
    
    # Mutáció (kis véletlen változtatás)
    offspring += np.random.uniform(-0.5, 0.5)
    
    # Új generáció létrehozása
    population = np.concatenate((parents, [offspring] * (pop_size - 2)))

# Legjobb megoldás kiírása
print("Legjobb megoldás:", population[np.argmax([fitness(x) for x in population])])

11.4 Genetikus algoritmus alkalmazásai

✔️ Optimalizálás 📈 – Bármilyen matematikai probléma megoldása.
✔️ Robotika 🤖 – Robotkarok mozgásának optimalizálása.
✔️ Játékipar 🎮 – AI ellenfelek fejlesztése játékokban.
✔️ Hálózatok tervezése 🖧 – Internet- és közlekedési hálózatok optimalizálása.
✔️ DNS és bioinformatika 🧬 – Fehérjeszerkezetek előrejelzése.

11.5 Genetikus algoritmus vs. más módszerek

MódszerElőnyökHátrányok
Genetikus Algoritmus (GA)Nem kell differenciálható függvény, gyors globális keresésLassabb, sok iteráció kell
Gradiens alapú módszerekGyors konvergenciaLokális minimumok csapdája
Monte Carlo módszerekSztochasztikus optimalizációNagy számítási igény

📌 A GA akkor hasznos, ha a keresési tér nagy és komplex!

Összegzés

✅ Genetikus algoritmus az evolúció elveit utánozza 🧬
✅ Használható optimalizálásra, AI fejlesztésre és biológiában
❌ Sok iteráció kell, és nem mindig konvergál gyorsan



12. Klaszterezési algoritmusok – Adatok csoportosítása 📊🔍

A klaszterezés egy felügyelet nélküli tanulási módszer, amely célja hasonló objektumok csoportosítása egy adathalmazban. A klaszterezési algoritmusok az adatok közötti mintázatok és struktúrák felismerésére szolgálnak anélkül, hogy előre definiált címkékkel rendelkeznének.

📌 Hol hasznos?
✔️ Adatbázisok szegmentálása (pl. ügyfelek csoportosítása marketing célokra).
✔️ Anomália detekció (pl. csalások felderítése pénzügyi tranzakciókban).
✔️ Kép- és mintafelismerés (pl. arcfelismerés, orvosi diagnosztika).
✔️ Hálózatok elemzése (pl. közösségek azonosítása a közösségi médiában).

12.1 Klaszterezés főbb típusai

🔹 1️⃣ Középpont alapú klaszterezés (Partitioning-based)

Az adathalmazt előre meghatározott számú klaszterre osztja, és a középpontokat optimalizálja.
📌 Példa: K-means, K-medoids

🔹 2️⃣ Hierarchikus klaszterezés (Hierarchical Clustering)

A klaszterek egymásba ágyazott hierarchikus szerkezetet alkotnak.
📌 Példa: Agglomeratív (összevonó) és Divizív (felosztó) módszerek

🔹 3️⃣ Sűrűség alapú klaszterezés (Density-based)

Az adatpontokat a sűrűségük alapján klaszterekbe rendezi, és képes zajos adatokat és anomáliákat kezelni.
📌 Példa: DBSCAN, OPTICS

🔹 4️⃣ Rács alapú klaszterezés (Grid-based)

Az adatteret egy rácsra osztja, és az egyes cellák sűrűsége alapján hoz létre klasztereket.
📌 Példa: STING (Statistical Information Grid)

🔹 5️⃣ Modell alapú klaszterezés (Model-based)

Az adatokat valószínűségi modellek alapján klaszterekre osztja.
📌 Példa: Gaussian Mixture Models (GMM), Hidden Markov Model (HMM)

12.2 Klaszterezési algoritmusok részletesen

1️⃣ K-means klaszterezés

Lényege:
✔️ K számú klasztert keres az adatokban.
✔️ Centroidok segítségével iteratívan frissíti a klasztereket.

📌 Működése:

  1. Válassz ki K klaszterközéppontot (centroidot) véletlenszerűen.

  2. Minden pontot rendelj hozzá a legközelebbi klaszterhez.

  3. Számítsd újra a centroidokat.

  4. Ismételd a 2-3. lépést, amíg a klaszterek stabilizálódnak.

🔹 Előnyök: Gyors, könnyen érthető.
❌ Hátrányok: Előre meg kell adni K-t, érzékeny a kiugró értékekre.

📌 Python implementáció:

---python

from sklearn.cluster import KMeans
import numpy as np

# Véletlen 2D pontok létrehozása
X = np.random.rand(100, 2)

# K-means klaszterezés 3 klaszterrel
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# Klaszterek kiírása
print("Klaszterközéppontok:", kmeans.cluster_centers_)
print("Pontok hozzárendelése:", kmeans.labels_)

2️⃣ Hierarchikus klaszterezés

📌 Lényege:
✔️ Klasztereket hierarchikus fastruktúrába szervez.
✔️ Dendrogram segítségével ábrázolható.

🔹 Típusok:

  1. Agglomeratív (összevonó) – Minden adatpont külön klaszterként indul, majd összevonja őket.

  2. Divizív (felosztó) – Egy nagy klaszterrel indul, majd felosztja kisebb klaszterekre.

🔹 Előnyök: Nem kell előre megadni a klaszterek számát.
❌ Hátrányok: Nagy adathalmazoknál lassú.

📌 Python implementáció:

---python

from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt

# Véletlen 2D adatok létrehozása
X = np.random.rand(20, 2)

# Hierarchikus klaszterezés
Z = linkage(X, method='ward')

# Dendrogram rajzolása
plt.figure(figsize=(10, 5))
dendrogram(Z)
plt.show()

3️⃣ DBSCAN (Density-Based Spatial Clustering of Applications with Noise)

📌 Lényege:
✔️ Sűrűségen alapuló klaszterezés, amely automatizáltan találja meg a klaszterek számát.
✔️ Képes anomáliákat és zajokat kezelni.

🔹 Előnyök:
✔️ Nem kell előre megadni a klaszterek számát.
✔️ Jól kezeli a különböző méretű és alakú klasztereket.

🔹 Hátrányok:
❌ Az optimális paraméterek kiválasztása nehéz lehet.

📌 Python implementáció:

---python

from sklearn.cluster import DBSCAN

# DBSCAN klaszterezés
dbscan = DBSCAN(eps=0.2, min_samples=5)
labels = dbscan.fit_predict(X)

# Klaszterek kiírása
print("Klaszterek:", np.unique(labels))

4️⃣ Gaussian Mixture Model (GMM)

📌 Lényege:
✔️ A klasztereket valószínűségi eloszlásokként modellezi.
✔️ GMM rugalmasabb, mint a K-means, mert átfedő klasztereket is kezel.

🔹 Előnyök:
✔️ Kevésbé érzékeny az adatpontok elhelyezkedésére.
✔️ Rugalmasabb, mint a K-means.

🔹 Hátrányok:
❌ Lassabb, mint a K-means.

📌 Python implementáció:

---python

from sklearn.mixture import GaussianMixture

# GMM klaszterezés
gmm = GaussianMixture(n_components=3, random_state=42)
gmm.fit(X)
labels = gmm.predict(X)

print("GMM klaszterek:", np.unique(labels))

12.3 Klaszterezés kiértékelése

📌 Hogyan tudjuk megállapítani, hogy egy klaszterezés jó-e?

✔️ Silhouette Score – Az egyedek közelségét méri a saját klaszterükhöz képest.
✔️ Dunn Index – A klaszterek közötti távolságot méri.
✔️ Elbow Method (K-means esetén) – A klaszterszám kiválasztására szolgál.

📌 Python implementáció Silhouette Score-ral:

---- python

from sklearn.metrics import silhouette_score

score = silhouette_score(X, kmeans.labels_)
print("Silhouette Score:", score)

Összegzés

✅ Klaszterezési algoritmusok segítenek adatok csoportosításában 📊
✅ K-means gyors, de érzékeny az inicializációra
✅ Hierarchikus klaszterezés jól vizualizálható
✅ DBSCAN jól kezeli az anomáliákat
✅ GMM rugalmasabb, mint a K-means




13. Markov modellek és rejtett Markov modellek (HMM) 🔄🤖

A Markov modellek (Markov Models, MM) és a rejtett Markov modellek (Hidden Markov Models, HMM) olyan matematikai modellek, amelyek idősorok és szekvenciális adatok elemzésére szolgálnak. Alkalmazásuk gyakori a beszédfelismerésben, pénzügyi előrejelzésben, génszekvencia-elemzésben és robotikában.

13.1 Markov modellek (MM) alapelvei

A Markov-modell egy diszkrét állapotokból álló rendszer, amely Markov-tulajdonsággal rendelkezik:
✅ A jövő állapotát csak a jelen állapot határozza meg, a múlt nem befolyásolja közvetlenül.

📌 Matematikailag:

P(Xt+1∣Xt,Xt−1,...,X0)=P(Xt+1∣Xt)P(X_{t+1} | X_t, X_{t-1}, ..., X_0) = P(X_{t+1} | X_t)

Ez azt jelenti, hogy a jövő csak a jelenlegi állapottól függ – nincs memória a múltbeli állapotokról.

🔹 Példa: Egy robot mozog egy 3 szobás házban. Ha egy szobában van, akkor csak az ottani pozíciója határozza meg, hova mehet tovább – nem számít, honnan jött.

📌 Átmeneti valószínűségi mátrix (Transition Probability Matrix, TPM):

Egy Markov-modell az állapotok közötti átmenetek valószínűségeit egy mátrixban tárolja.

ÁllapotSzoba 1Szoba 2Szoba 3
Szoba 10.10.60.3
Szoba 20.40.20.4
Szoba 30.30.50.2

Ez azt jelenti, hogy ha a robot Szoba 1-ben van, 60% az esélye, hogy Szoba 2-be megy, és 30% hogy Szoba 3-ba.

13.2 Rejtett Markov modellek (HMM) 📡

A rejtett Markov-modell (HMM) egy olyan Markov-modell, ahol:
✔️ A valódi állapotokat nem figyelhetjük meg közvetlenül (rejtettek).
✔️ Csak megfigyelhető jelekből következtethetünk az állapotokra.

📌 Hogyan működik?

🔹 Példa: Beszédfelismerés 🎙️

Tegyük fel, hogy egy rendszer egy emberi hang alapján próbálja felismerni, milyen szavakat mondunk ki.

  • A beszéd akusztikai jelei (megfigyelések) érzékelhetők.

  • De a valódi kimondott szó (állapot) rejtett, mert azt nem tudjuk közvetlenül mérni.

13.3 A rejtett Markov-modell 5 fő eleme

1️⃣ Állapotok (SS)

  • A rendszer lehetséges állapotai (pl. „csend”, „magánhangzó”, „mássalhangzó”).

2️⃣ Megfigyelések (OO)

  • Azt látjuk/halljuk, amit az érzékelők mérnek (pl. frekvenciák, hangerő).

3️⃣ Átmeneti valószínűségek (AA)

  • Az állapotok közötti valószínűségi mátrix.

4️⃣ Megfigyelési valószínűségek (BB)

  • Az állapotokból származó megfigyelések valószínűségei.

5️⃣ Kezdeti állapoteloszlás (π\pi)

  • Annak valószínűsége, hogy a rendszer egy adott állapotból indul.

📌 Matematikai reprezentáció:
A HMM egy λ=(A,B,π)\lambda = (A, B, \pi) tripletből áll, ahol:

  • AA: Átmeneti mátrix (állapotok közötti átmenetek).

  • BB: Megfigyelési mátrix (állapotból milyen jelek várhatók).

  • π\pi: Kezdeti valószínűségek.

13.4 A HMM három fő problémája

📌 1️⃣ Valószínűség kiszámítása – Forward algoritmus
Cél: Mekkora a valószínűsége egy adott megfigyeléssorozatnak?

📌 2️⃣ Legvalószínűbb állapotok – Viterbi algoritmus
Cél: Mi a legvalószínűbb állapotok sorozata egy megfigyeléssorozat alapján?

📌 3️⃣ Paraméterek tanulása – Baum-Welch algoritmus
Cél: Ha nem ismerjük az átmeneti vagy megfigyelési valószínűségeket, hogyan lehet őket megtanulni?

13.5 HMM implementáció Pythonban – Beszédfelismerés

---- python

import numpy as np
from hmmlearn import hmm

# Modell létrehozása (3 állapot, 2 megfigyelési érték)
model = hmm.MultinomialHMM(n_components=3, n_iter=100)

# Példa megfigyelések (szimbólumok sorozata)
observations = np.array([[0,1,1,2,2,0,1,2]]).T

# Modell betanítása
model.fit(observations)

# Legvalószínűbb állapotok kiszámítása (Viterbi algoritmus)
logprob, state_sequence = model.decode(observations, algorithm="viterbi")

print("Legvalószínűbb állapotok:", state_sequence)

13.6 Alkalmazási területek

✔️ Beszédfelismerés 🎙️ (Google Assistant, Siri, Alexa).
✔️ Pénzügyi előrejelzés 📈 (Részvényárfolyamok modellezése).
✔️ Genetikai szekvenálás 🧬 (DNS szekvenciák elemzése).
✔️ Robotika 🤖 (Mozgások tervezése).
✔️ Szövegfeldolgozás 📜 (Automatikus szövegértés).

13.7 Markov modellek vs. Rejtett Markov modellek

TípusJellemzőkPélda
Markov-modell (MM)Az állapotok megfigyelhetők.Robot mozgás modellezése
Rejtett Markov-modell (HMM)Az állapotok rejtettek, csak megfigyelések állnak rendelkezésre.Beszédfelismerés

Összegzés

✅ Markov modellek az állapotok közötti átmeneteket modellezik
✅ Rejtett Markov modellek olyan rendszereket írnak le, ahol az állapotokat nem látjuk közvetlenül
✅ Alkalmazásuk széles körű: beszédfelismerés, pénzügy, genomika, robotika





14. Autoencoder hálózatok (AE) 🤖🎭

Az Autoencoder (AE) egy speciális neurális hálózat, amelyet adatok tömörítésére és rekonstrukciójára terveztek. A célja, hogy a bemeneti adatokat egy alacsonyabb dimenziós reprezentációba (kód) sűrítse, majd ebből az információból visszaállítsa az eredetit.

📌 Fő alkalmazási területek:
✔️ Adattömörítés (dimenziócsökkentés).
✔️ Zajszűrés (Denoising Autoencoder).
✔️ Kép- és adatgenerálás (Variational Autoencoder – VAE).
✔️ Anomália detekció (ritka események felismerése).

1️⃣ Az Autoencoder működése

Egy Autoencoder két fő komponensből áll:

🔹 1. Encoder (Kódoló)

  • A bemeneti adatokat egy kisebb dimenziós térbe transzformálja.

  • Ez a tömörített rejtett reprezentáció (latens tér, kód).

🔹 2. Decoder (Dekódoló)

  • Az Encoder kimenetéből visszaállítja az eredeti adatot.

  • Célja, hogy a bemenethez minél hasonlóbb kimenetet hozzon létre.

📌 Matematikailag:
Legyen az Autoencoder egy függvény f(x)f(x), amely egy bemeneti xx adatot képez le önmagára:

x′=Decoder(Encoder(x))x' = Decoder(Encoder(x))

A hálózatot úgy tanítjuk, hogy minimalizálja a rekonstrukciós hibát:

L(x,x′)=∣∣x−x′∣∣2L(x, x') = ||x - x'||^2

Ez a Mean Squared Error (MSE) vagy Binary Cross-Entropy (BCE) lehet.

2️⃣ Típusai és alkalmazásaik

2.1 Hagyományos Autoencoder (Basic AE)

📌 Célja: Dimenziócsökkentés, adattömörítés.
✅ A tanult latens tér sűrítve tartalmazza a bemeneti adatok legfontosabb jellemzőit.
🎯 Alkalmazás: PCA helyett (pl. képfeldolgozás).

🔹 Példa: Képek tömörítése:

  • Bemenet: 28×28 képek.

  • Kimenet: Ugyanaz a kép, de tömörítve és rekonstruálva.

2.2 Denoising Autoencoder (Zajszűrő AE)

📌 Célja: A zajos bemenetek tisztítása.
✅ Az Autoencoder megtanulja, hogy a zajos bemenetből visszaállítsa a tiszta verziót.
🎯 Alkalmazás: Képek és adatok zajszűrése.

🔹 Példa:

  • Bemenet: Egy homályos vagy zajos kép.

  • Kimenet: Egy zajmentes, éles kép.

2.3 Variational Autoencoder (VAE)

📌 Célja: Generatív modell, amely képes új adatokat előállítani.
✅ Nemcsak egyetlen kódot tanul meg, hanem eloszlásokat modellez a latens térben.
🎯 Alkalmazás: Képgenerálás, adattömörítés.

🔹 Példa:

  • Bemenet: Képek (pl. arcok).

  • Kimenet: Új, eddig nem látott, de hasonló arcok generálása.

📌 Matematikailag:
A VAE az információvesztés szabályozására KL-divergenciát is minimalizálja:

L=∣∣x−x′∣∣2+DKL(q(z∣x)∣∣p(z))L = ||x - x'||^2 + D_{KL}(q(z|x) || p(z))

ahol

  • DKLD_{KL} – Kullback-Leibler divergencia, ami a latens tér szerkezetét szabályozza.

2.4 Sparse Autoencoder (Ritka AE)

📌 Célja: A latens tér ritka reprezentációjának tanulása.
✅ A hálózatot úgy kényszerítjük, hogy csak néhány neuront aktiváljon.
🎯 Alkalmazás: Főbb jellemzők kinyerése (pl. arcok detektálása).

2.5 Convolutional Autoencoder (CAE)

📌 Célja: Képfeldolgozásra optimalizált AE.
✅ Konvolúciós rétegekkel dolgozik a teljesen összekapcsolt rétegek helyett.
🎯 Alkalmazás: Képek tömörítése, anomália detekció.

🔹 Példa:

  • Bemenet: Homályos kép.

  • Kimenet: Élesített, tiszta kép.

3️⃣ Autoencoder implementáció Pythonban (Keras)

📌 Egyszerű Autoencoder képfeldolgozáshoz (MNIST adatokkal)

---python

import tensorflow as tf
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model

# Bemeneti méret
input_dim = 784  # 28x28 képek

# Encoder
input_layer = Input(shape=(input_dim,))
encoded = Dense(128, activation='relu')(input_layer)
encoded = Dense(64, activation='relu')(encoded)
encoded = Dense(32, activation='relu')(encoded)  # Latens tér

# Decoder
decoded = Dense(64, activation='relu')(encoded)
decoded = Dense(128, activation='relu')(decoded)
decoded = Dense(input_dim, activation='sigmoid')(decoded)

# Modell összeállítása
autoencoder = Model(input_layer, decoded)
autoencoder.compile(optimizer='adam', loss='mse')

# Betanítás MNIST adatokkal
from tensorflow.keras.datasets import mnist
import numpy as np

(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))

autoencoder.fit(x_train, x_train, epochs=50, batch_size=256, validation_data=(x_test, x_test))

# Rekonstrukció vizualizálása
import matplotlib.pyplot as plt

decoded_imgs = autoencoder.predict(x_test[:10])

plt.figure(figsize=(10, 4))
for i in range(10):
    # Eredeti
    plt.subplot(2, 10, i+1)
    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')
    
    # Rekonstruált
    plt.subplot(2, 10, i+11)
    plt.imshow(decoded_imgs[i].reshape(28, 28), cmap='gray')

plt.show()

4️⃣ Összegzés

✅ Autoencoderek képesek az adatok tömörítésére és rekonstrukciójára.
✅ Sokféle típus létezik: egyszerű AE, denoising AE, VAE, sparse AE, CAE.
✅ Alkalmazásai széleskörűek: képfeldolgozás, zajszűrés, adatgenerálás, anomália detekció.



Adatdimenzió-csökkentési módszerek 📉🧠

Az adatdimenzió-csökkentés célja a nagy dimenziójú adatok egyszerűsítése úgy, hogy a legfontosabb információkat megőrizzük.

✅ Fő előnyei:

  • Vizualizáció: Többdimenziós adatok 2D/3D térbe vetítése.

  • Adatfeldolgozás gyorsítása: Kevesebb változó -> kisebb számítási költség.

  • Túlilleszkedés csökkentése: Felesleges zaj eltávolítása.

🔹 Legfontosabb technikák

1️⃣ PCA (Principal Component Analysis) – Főkomponens-analízis
2️⃣ t-SNE (t-Distributed Stochastic Neighbor Embedding)
3️⃣ UMAP (Uniform Manifold Approximation and Projection)

1️⃣ PCA – Főkomponens-analízis (Principal Component Analysis)

📌 Cél: Az adatok ortogonális tengelyek mentén való transzformálása, hogy a legtöbb varianciát megőrizze.

📌 Hogyan működik?

  1. Kovariancia-mátrix kiszámítása 📊

  2. Sajátértékek és sajátvektorok meghatározása 🧩

  3. A legnagyobb sajátértékekhez tartozó sajátvektorok kiválasztása 🔎

  4. Az adatok vetítése az új tengelyekre 🔄

🔹 Matematikai háttér
Legyen egy XX adatmátrix (mérete: n×dn \times d), ahol nn a mintaelemek száma, dd pedig a dimenziók száma.
A PCA célja egy WW mátrix meghatározása, amely mentén a transzformált adatok:

X′=XWX' = XW

ahol a WW a legnagyobb sajátértékekhez tartozó sajátvektorokat tartalmazza.

✅ Fő előnyök:

  • Gyors és hatékony.

  • Képes csökkenteni a dimenziókat anélkül, hogy sok információt veszítene.

❌ Hátrányok:

  • Csak lineáris összefüggéseket képes kezelni.

  • Nem mindig alkalmas nemlineáris adatokhoz.

📌 Példa: PCA alkalmazása Pythonban (Sklearn)

---python

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits

# Adatok betöltése
digits = load_digits()
X = digits.data  # Képek (64 pixel/dimenzió)

# PCA alkalmazása (2 főkomponens)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# Vizualizáció
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=digits.target, cmap='viridis', alpha=0.7)
plt.colorbar(label="Címke")
plt.xlabel("Főkomponens 1")
plt.ylabel("Főkomponens 2")
plt.title("PCA vizualizáció (Digits adathalmaz)")
plt.show()

2️⃣ t-SNE (t-Distributed Stochastic Neighbor Embedding)

📌 Cél: A magas dimenziós adatok nemlineáris projekciója egy kisebb dimenziós térbe.

📌 Hogyan működik?

  1. A hasonlóságot Gauss-eloszlás alapján számítja magas dimenzióban.

  2. A kis dimenziójú térben t-eloszlást használ, hogy a közeli és távoli pontokat megkülönböztesse.

  3. Iteratívan minimalizál egy Kullback-Leibler divergenciát, hogy a magas és alacsony dimenzió közötti hasonlóságok megmaradjanak.

✅ Előnyei:

  • Kiválóan működik nemlineáris struktúráknál.

  • Cluster-eket jól elkülönít.

❌ Hátrányai:

  • Lassú nagy adathalmazokon.

  • Hyperparaméterekre érzékeny (pl. perplexity).

📌 t-SNE implementáció Pythonban (Sklearn)

---python

from sklearn.manifold import TSNE

# t-SNE alkalmazása (2 dimenzióra)
tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_tsne = tsne.fit_transform(X)

# Vizualizáció
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=digits.target, cmap='rainbow', alpha=0.7)
plt.colorbar(label="Címke")
plt.xlabel("t-SNE komponens 1")
plt.ylabel("t-SNE komponens 2")
plt.title("t-SNE vizualizáció (Digits adathalmaz)")
plt.show()

3️⃣ UMAP (Uniform Manifold Approximation and Projection)

📌 Cél: Az adatok nemlineáris szerkezetének megőrzése gyorsabb módon, mint a t-SNE.

📌 Hogyan működik?

  1. Helyi gráfot épít az adatok alapján.

  2. Az adatokat egy kisebb dimenziójú térbe vetíti, optimalizálva a szerkezetet.

  3. Gyorsabb és skálázhatóbb, mint a t-SNE.

✅ Előnyei:

  • Gyorsabb, mint a t-SNE nagy adathalmazokon.

  • Megőrzi az adatok szerkezetét (gráf-alapú megközelítés).

  • Robusztusabb és stabilabb, mint a t-SNE.

❌ Hátrányai:

  • Nem mindig könnyű értelmezni az eredményt.

  • Kis adatoknál kevésbé hatékony, mint a t-SNE.

📌 UMAP implementáció Pythonban

--- python

import umap

# UMAP alkalmazása (2 dimenzióra)
umap_reducer = umap.UMAP(n_components=2)
X_umap = umap_reducer.fit_transform(X)

# Vizualizáció
plt.scatter(X_umap[:, 0], X_umap[:, 1], c=digits.target, cmap='Spectral', alpha=0.7)
plt.colorbar(label="Címke")
plt.xlabel("UMAP komponens 1")
plt.ylabel("UMAP komponens 2")
plt.title("UMAP vizualizáció (Digits adathalmaz)")
plt.show()

4️⃣ PCA, t-SNE és UMAP összehasonlítása

MódszerLineáris/NemlineárisGyorsaságSkálázhatóságMegőrzi az adatszerkezetet?Vizualizációs célra?
PCALineáris🟢 Gyors🟢 Kiváló❌ Nem mindig🟡 Korlátozott
t-SNENemlineáris🔴 Lassú🔴 Rossz🟢 Igen🟢 Kiváló
UMAPNemlineáris🟢 Gyorsabb🟢 Jó🟢 Igen🟢 Kiváló

Összegzés

✅ PCA gyors, lineáris és jól skálázható.
✅ t-SNE jól elkülöníti a klasztereket, de lassú.
✅ UMAP gyorsabb és jobban skálázódik, mint a t-SNE.





Fuzzy C-means (FCM) klaszterezés

Ez egy népszerű, úgynevezett "puha" (soft) klaszterezési technika a mesterséges intelligencia és a gépi tanulás területén. Az FCM különösen alkalmas olyan helyzetekben, ahol az adatok nem oszthatók élesen elkülönülő csoportokra, hanem az elemek részben több klaszterhez is tartozhatnak. Lássuk lépésről lépésre!

1. Mi az a Fuzzy C-means klaszterezés?

A Fuzzy C-means egy felügyelet nélküli tanulási algoritmus, amely a hagyományos "kemény" (hard) klaszterezési módszerek (pl. K-means) továbbfejlesztett változata. A K-means esetében minden adatpont pontosan egy klaszterhez tartozik, míg az FCM "fuzzy" logikát használ, ami azt jelenti, hogy egy adatpont részleges tagsággal (membership) tartozhat több klaszterhez is. Ez a megközelítés a valós világban gyakran előforduló bizonytalanságokat és átfedéseket jobban modellezi.

Az FCM célja egy adathalmaz particionálása úgy, hogy minimalizálja a klaszterközéppontoktól való súlyozott távolságokat, figyelembe véve az adatpontok tagsági fokait.

2. Matematikai alapok

Az FCM algoritmus egy célfüggvény minimalizálásán alapul. Nézzük meg a részleteket:

a) Célfüggvény

Az FCM a következő célfüggvényt (objective function) optimalizálja:

Jm=∑i=1n∑j=1cuijm∥xi−vj∥2J_m = \sum_{i=1}^n \sum_{j=1}^c u_{ij}^m \| x_i - v_j \|^2
  • nn: Az adatpontok száma.
  • cc: A klaszterek száma (ezt előre meg kell adni).
  • xix_i: Az ii-edik adatpont.
  • vjv_j: A jj-edik klaszter középpontja (centroid).
  • uiju_{ij}: Az ii-edik adatpont tagsági foka a jj-edik klaszterhez (0 és 1 között mozog).
  • mm: A "fuzziness" paraméter (általában m>1m > 1, tipikusan 2), amely szabályozza, hogy mennyire legyen "puha" a klaszterezés.
  • ∥xi−vj∥2\| x_i - v_j \|^2: Az ii-edik adatpont és a jj-edik klaszter középpontja közötti euklideszi távolság négyzete.

A cél az, hogy JmJ_m-et minimalizáljuk, miközben a tagsági fokok teljesítik a következő feltételt:

∑j=1cuij=1∀i\sum_{j=1}^c u_{ij} = 1 \quad \forall i

Ez biztosítja, hogy minden adatpont tagsági fokainak összege 1 legyen.

b) Tagsági fokok frissítése

A tagsági fokokat iteratívan frissíti az algoritmus az alábbi képlettel:

uij=1∑k=1c(∥xi−vj∥∥xi−vk∥)2m−1u_{ij} = \frac{1}{\sum_{k=1}^c \left( \frac{\| x_i - v_j \|}{\| x_i - v_k \|} \right)^{\frac{2}{m-1}}}

Ez azt jelenti, hogy egy adatpont tagsága egy klaszterhez attól függ, hogy milyen közel van annak középpontjához a többi klaszterhez képest.

c) Klaszterközéppontok frissítése

A klaszterközéppontokat (centroidokat) az alábbi módon számoljuk újra:

vj=∑i=1nuijmxi∑i=1nuijmv_j = \frac{\sum_{i=1}^n u_{ij}^m x_i}{\sum_{i=1}^n u_{ij}^m}

Ez egy súlyozott átlag, ahol a súlyok a tagsági fokok mm-edik hatványai.

3. Az algoritmus lépései

Az FCM iteratív módon működik, hasonlóan a K-meanshez, de a fuzzy logika miatt összetettebb. A lépések a következők:

  1. Inicializáció:
    • Válasszunk ki cc klaszterszámot és egy mm fuzziness paramétert (pl. m=2m = 2).
    • Véletlenszerűen inicializáljuk a tagsági mátrixot (uiju_{ij}) úgy, hogy minden adatpont tagságainak összege 1 legyen.
  2. Klaszterközéppontok számítása:
    • Frissítsük a vjv_j centroidokat a fenti képlet alapján.
  3. Tagsági fokok frissítése:
    • Számoljuk újra a uiju_{ij} tagsági fokokat az adatpontok és a centroidok közötti távolságok alapján.
  4. Konvergencia ellenőrzése:
    • Számítsuk ki a célfüggvény változását. Ha a változás kisebb egy előre megadott küszöbnél (pl. ϵ=0.0001\epsilon = 0.0001), vagy elérjük a maximális iterációszámot, álljunk le.
  5. Iteráció:
    • Ismételjük a 2-4. lépéseket, amíg a konvergencia be nem következik.

A végeredmény egy olyan klaszterezés, ahol minden adatpont részleges tagsággal rendelkezik az egyes klaszterekhez.

4. Előnyök és hátrányok

Előnyök:

  • Rugalmasabb, mint a K-means: Az adatpontok nem kizárólagosan egy klaszterhez tartoznak, ami jól modellezi az átfedő vagy bizonytalan adatokat.
  • Valósághűbb eredmények: Például biológiai vagy társadalmi adatoknál, ahol a határok nem élesek.
  • Robusztus zajjal szemben: A fuzzy logika miatt kevésbé érzékeny a kiugró értékekre.

Hátrányok:

  • Számítási igény: Az iteratív tagság- és centroidszámítás miatt lassabb, mint a K-means, különösen nagy adathalmazoknál.
  • Paraméterérzékenység: Az mm és a klaszterek számának (cc) helyes megválasztása kritikus, és nincs univerzális optimum.
  • Lokális minimumok: Az inicializációtól függően az algoritmus nem mindig találja meg a globális optimumot.

5. Alkalmazási területek

Az FCM széles körben használatos olyan területeken, ahol az adatok nem különülnek el élesen:

  • Képfeldolgozás: Képek szegmentálása, pl. orvosi képeken tumorok azonosítása.
  • Adatbányászat: Fogyasztói szokások elemzése, ahol az ügyfelek több csoportba is részben tartozhatnak.
  • Bioinformatika: Génkifejeződési adatok klaszterezése.
  • Idősorok elemzése: Például gazdasági trendek csoportosítása.

6. Példa

Tegyük fel, hogy van 5 adatpontunk egy 2D térben, és 2 klasztert szeretnénk (c=2c = 2, m=2m = 2):

  • Adatok: (1,1),(2,2),(5,5),(6,6),(3,3)(1, 1), (2, 2), (5, 5), (6, 6), (3, 3).
  • Inicializáció: Véletlenszerű tagságok, pl. (1,1)(1, 1) 0.7-es tagsággal az 1. klaszterhez és 0.3-mal a 2.-hez.
  • Iterációk során a centroidok és tagságok frissülnek, és a végén pl. a (3,3)(3, 3) adatpont 0.5-ös tagsággal tartozhat mindkét klaszterhez, jelezve, hogy "köztes" pozícióban van.

7. Összegzés

A Fuzzy C-means klaszterezés egy erőteljes eszköz a puha klaszterezési feladatokhoz, amely a fuzzy logika erejét használja ki. Bár számításigényesebb, mint a K-means, rugalmassága és valósághűbb modellezési képessége miatt számos területen előnyös.




Címkék

Címkék:

Megjegyzések

Megjegyzés küldése