Ez a projekt egy olyan képfeldolgozáson alapuló automatikus osztályozó rendszer megvalósítását célozza, amely képes megkülönböztetni a hibátlan és hibás termékeket. A rendszer lelke egy EfficientNetB0 alapú, TensorFlow Lite (TFLite) formátumú neurális hálózat, amelyet transfer learning és fine-tuning technikákkal képeztünk ki a feladatra. A modell bináris osztályozóként működik, a kimeneti réteg sigmoid aktivációt használ a két osztály – hibás és hibátlan – szétválasztásához. A fine-tuning során a hálózat utolsó 10 rétege került újratanításra, hogy a modell jobban alkalmazkodjon a konkrét feladathoz.
A képi adatok forrását maga az eszköz szolgáltatja, amely élőben készít képeket a termékekről. Ez azt jelenti, hogy a modell ugyanazon környezeti és technikai feltételek mellett rögzített képeken tanul, mint amelyeket élesben osztályoznia kell. Ez a megközelítés jelentősen csökkenti az adatdisztribúcióbeli eltérések kockázatát, és lehetővé teszi, hogy a modell az „életszerű” mintákhoz optimalizálódjon. Ilyen esetben az overfitting nem tekinthető negatív jelenségnek, sőt, kifejezetten előnyös lehet, hiszen a cél az adott eszköz adott környezetében való minél pontosabb felismerés.
Javaslat a képadatok előkészítésére:
- Képformátum és felbontás: Egységes, lehetőleg RGB formátum, a modell input méretéhez (224×224 px) igazítva.
- Adatgyűjtés: Minden osztályból (hibás, hibátlan) több száz kép rögzítése különböző terméktípusokból, fényviszonyok és pozíciók mellett.
- Augmentáció (opcionális): Kis mértékű forgatás, fényerőváltoztatás, eltolás vagy zoomolás növelheti a robusztusságot, de mivel a cél az adott kameraállás szerinti pontos felismerés, ez csak óvatosan alkalmazandó.
- Adatok szétválasztása: A képek egy része kerüljön validációs halmazba (pl. 80–20% arány), a tanítási hatékonyság ellenőrzésére.
Ez a megközelítés egy célirányosan optimalizált, gyors és megbízható beágyazott rendszert eredményez, amely valós időben képes az ipari folyamatokba integrálódni.
Eltérésfelismerés megvalósítása TensorFlow, Keras és EfficientNetB0 segítségével
A bináris osztályozás (binary classification) egy gyakori gépi tanulási feladat, amikor két kategóriát kell megkülönböztetni. Ilyen például, amikor egy gyártósori kamera által készített képek alapján szeretnénk eldönteni, hogy egy termék hibás vagy hibátlan.
Ebben a cikkben bemutatjuk:
- a képgyűjtés és előfeldolgozás lépéseit,
- a transfer learning módszerét az EfficientNetB0 modellel,
- a tanítási folyamatot,
- a modell kiértékelését és használatát új képekre.
1. Követelmények
Telepítendő csomagok:
pip install tensorflow matplotlib scikit-learn
2. Mappa struktúra és adatok
A képek a következő struktúrában helyezkednek el:
bashMásolásSzerkesztésdataset/
│
├── train/
│ ├── good/
│ └── bad/
│
├── val/
│ ├── good/
│ └── bad/
│
└── test/
├── good/
└── bad/
good/– hibátlan termék képeibad/– hibás termék képei
3. Adatok betöltése és előfeldolgozása
import tensorflow as tf
from tensorflow.keras.preprocessing import image_dataset_from_directory
img_size = (224, 224)
batch_size = 32
train_ds = image_dataset_from_directory(
"dataset/train",
labels="inferred",
label_mode="binary",
image_size=img_size,
batch_size=batch_size
)
val_ds = image_dataset_from_directory(
"dataset/val",
labels="inferred",
label_mode="binary",
image_size=img_size,
batch_size=batch_size
)
test_ds = image_dataset_from_directory(
"dataset/test",
labels="inferred",
label_mode="binary",
image_size=img_size,
batch_size=batch_size
)
# Teljesítmény optimalizálás
AUTOTUNE = tf.data.AUTOTUNE
train_ds = train_ds.prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.prefetch(buffer_size=AUTOTUNE)
test_ds = test_ds.prefetch(buffer_size=AUTOTUNE)
4. Modell létrehozása – EfficientNetB0 + kimeneti rétegek
from tensorflow.keras import layers, models
from tensorflow.keras.applications import EfficientNetB0
base_model = EfficientNetB0(include_top=False, input_shape=(224, 224, 3), weights='imagenet')
base_model.trainable = False # Fagyasztjuk a rétegeket
model = models.Sequential([
base_model,
layers.GlobalAveragePooling2D(),
layers.Dropout(0.2),
layers.Dense(1, activation='sigmoid') # Bináris kimenet
])
5. Modell fordítása és tanítása
model.compile(
optimizer=tf.keras.optimizers.Adam(),
loss='binary_crossentropy',
metrics=['accuracy']
)
history = model.fit(
train_ds,
validation_data=val_ds,
epochs=10
)
6. Fine-tuning (haladó lépés)
base_model.trainable = True # Most már finomhangolhatjuk is
model.compile(
optimizer=tf.keras.optimizers.Adam(1e-5),
loss='binary_crossentropy',
metrics=['accuracy']
)
history_fine = model.fit(
train_ds,
validation_data=val_ds,
epochs=5
)
7. Modell mentése
model.save("defect_classifier_model.h5")
8. Új kép osztályozása
import numpy as np
from tensorflow.keras.preprocessing import image
img_path = "sample.jpg"
img = image.load_img(img_path, target_size=(224, 224))
img_array = image.img_to_array(img)
img_array = tf.expand_dims(img_array, 0) # Batch dimenzió
predictions = model.predict(img_array)
score = predictions[0][0]
if score > 0.5:
print("Rossz (hibás termék)")
else:
print("Jó (hibátlan termék)")
9. Tanítási eredmények megjelenítése
import matplotlib.pyplot as plt
plt.plot(history.history['accuracy'], label='Train acc')
plt.plot(history.history['val_accuracy'], label='Val acc')
plt.legend()
plt.title('Pontosság alakulása')
plt.xlabel('Epoch')
plt.ylabel('Pontosság')
plt.show()
10. Modell konvertálása TFLite formátumba
Hasznos lehet beágyazott rendszereknél:
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
f.write(tflite_model)
Összefoglalás
- A EfficientNetB0 kiváló választás kis méretű és hatékony bináris osztályozókhoz.
- A transfer learning gyorsítja a betanítást és jó eredményeket hoz kevés adat mellett is.
- A modell beágyazható TFLite formátumban akár Raspberry Pi-re, Coral-ra vagy Jetsonra.
- A megoldás kiterjeszthető: GUI frontendtel, élő kameraképpel, vagy integrálható ipari rendszerekbe is.
English 
Magyar