Zastosowanie Deep Learning w Identyfikacji Narzędzi na Podstawie Śladów Narzędziowych

W dzisiejszych czasach rozwój technologii deep learning umożliwia tworzenie systemów wspierających pracę służb policyjnych w identyfikacji narzędzi na podstawie śladów, takich jak scratch patterns, tool impressions oraz analiza microstructure. Celem takiego systemu jest porównywanie nowo uzyskanych śladów z istniejącą bazą danych, a następnie wskazywanie potencjalnych dopasowań do dalszej analizy przez ekspertów. W niniejszym artykule przedstawiono najważniejsze aspekty projektowania takiego systemu, obejmujące:

  • Wybór modelu – omówienie architektur, takich jak CNN, Siamese network oraz Triplet network.
  • Przygotowanie danych – zasady wstępnego przetwarzania, augmentacji oraz normalizacji obrazów.
  • Wymagania dotyczące zbioru danych – ile danych jest potrzebne oraz jak je rozszerzać.
  • Implementację przykładowego kodu w bibliotece Keras.
  • Mechanizm wyszukiwania – jak efektywnie porównywać nowe ślady z bazą danych.

Wybór Modelu

CNN (Convolutional Neural Networks)

  • Feature Learning: Sieci CNN automatycznie uczą się cech wizualnych (krawędzie, tekstury, stria - czyli rowki / zadrapania) z obrazów, co jest niezwykle przydatne przy analizie drobnych śladów narzędziowych (por. [8]).
  • Architektury: Popularne modele, takie jak ResNet czy VGG, można dostroić do specyficznych wymagań analizy śladów. Dla ograniczonych zbiorów danych można również zaprojektować mniejszą, dedykowaną sieć CNN, która skupi się na uchwyceniu subtelnych szczegółów.

Siamese Network

  • Cel: Architektura Siamese network składa się z dwóch identycznych sieci CNN (dzielących te same wagi) i służy do porównywania par obrazów. Sieć uczy się, czy dwa obrazy (np. dwa ślady narzędziowe) pochodzą z tego samego narzędzia, generując wynik w postaci prawdopodobieństwa (match vs. non-match) (por. [8], [28]).
  • Zastosowanie: Idealne rozwiązanie do porównywania śladów, ponieważ system uczy się efektywnej metryki podobieństwa, która pozwala na porównanie dowolnej pary śladów, niezależnie od liczby narzędzi w bazie danych.

Triplet Network

  • Cel: W architekturze Triplet network wykorzystywane są trzy obrazy: anchor, positive (pochodzący z tego samego narzędzia co anchor) oraz negative (pochodzący z innego narzędzia). Funkcja straty typu triplet loss wymusza, aby embedding anchor był bliższy embeddingowi obrazu pozytywnego niż negatywnego (por. [28]).
  • Zalety: Dzięki temu podejściu sieć uczy się przestrzeni, w której ślady tego samego narzędzia są skupione, co poprawia trafność wyszukiwania w bazie danych.

Vision Transformers (ViT)

  • Opis: Vision Transformers stosują architekturę Transformer do przetwarzania obrazów, dzieląc je na mniejsze fragmenty (patches) i stosując mechanizm self-attention do modelowania globalnych zależności.
  • Zalety i wyzwania: Mogą uchwycić globalny kontekst obrazu, co bywa przydatne przy analizie rozkładu śladów na całej powierzchni. Jednak wymagają zazwyczaj większych zbiorów danych lub wstępnego trenowania, dlatego przy ograniczonej liczbie danych mogą być trudniejsze w użyciu niż klasyczne CNN (por. [27]).

Przygotowanie Danych

Kluczowe kroki:

  • Wysokiej jakości obrazowanie:
    Używamy technik obrazowania wysokiej rozdzielczości (np. 3D confocal microscopy lub structured light scanning), aby uchwycić subtelne detale śladów narzędziowych.

  • Wyodrębnienie Regionu Zainteresowania (ROI):
    Przycinamy lub wyodrębnij fragmenty obrazu, na których widoczny jest ślad, aby model nie był rozpraszany przez nieistotne elementy tła.

  • Wyrównanie i Normalizacja:
    Upewniamy się, że obrazy są wyrównane do wspólnej orientacji (np. obrót, aby stria były poziome) oraz że skalowanie i rozdzielczość są jednolite.

  • Wstępne przetwarzanie:
    Stosujemy filtrowanie (np. smoothing, median filtering) oraz poprawę kontrastu (histogram equalization), aby wyeksponować cechy charakterystyczne.

  • Augmentacja danych:
    Aby zwiększyć różnorodność zbioru danych, stosujemy:
    • Rotacje (małe zmiany kątów),
    • Translacje i przycinanie,
    • Skalowanie i zoom,
    • Regulację jasności/kontrastu,
    • Dodawanie szumu,
    • Elastic distortions (do symulacji zmiennych nacisków).
  • Strukturyzacja i Etykietowanie:
    • Dla klasyfikacji: przypisujemy obrazy do konkretnego narzędzia.
    • Dla podejścia Siamese/Triplet: generujemy pary lub triplet-y, gdzie etykieta wskazuje, czy dane obrazy pochodzą z tego samego narzędzia.

Wymagania Dotyczące Zbioru Danych i Strategie Rozszerzania

  • Wielkość zbioru:
    • Modele CNN zazwyczaj potrzebują tysięcy obrazów na klasę.
    • Modele Siamese/Triplet mogą osiągnąć dobre wyniki nawet przy mniejszej liczbie przykładów (np. kilkaset obrazów łącznie) (por. [28]).

  • Transfer Learning:
    Wykorzystanie modeli wstępnie wytrenowanych (np. ResNet na ImageNet) pozwala na efektywne dostrojenie systemu nawet przy ograniczonej liczbie danych. Możemy zamrozić wcześniejsze warstwy lub fine-tune’ować model z niską stopą uczenia (por. [24]).

  • Augmentacja i Dane Syntetyczne:
    Augmentacja pozwala “sztucznie” zwiększyć zbiór danych. Dodatkowo moemy rozważyć generowanie danych syntetycznych:
    • Eksperymentalne podejścia z użyciem GAN-ów (Generative Adversarial Networks)
      • W skład GAN-a wchodzą dwa modele neuronowe:
        • Generator – próbuje tworzyć fałszywe, ale realistyczne dane.
        • Dyskryminator – uczy się rozpoznawać, czy dane są prawdziwe, czy wygenerowane.
      • Te dwa modele rywalizują ze sobą jak “fałszerz banknotów” i “detektyw”, dzięki czemu generator staje się coraz lepszy w tworzeniu danych, które wyglądają jak prawdziwe.
    • Symulacje komputerowe, jeśli geometria narzędzia jest znana.
  • Few-Shot Learning:
    W przypadku, gdy dla każdego narzędzia dostępnych jest tylko kilka przykładów, metody few-shot learning, w tym architektury Siamese network, mogą być bardzo pomocne.

Przykładowa Implementacja w Keras

Poniżej znajduje się przykładowy kod w Keras, ilustrujący budowę modelu Siamese network dla analizy śladów narzędziowych.

Budowa Bazowego Modelu CNN

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Funkcja budująca bazowy model CNN, który wyodrębnia cechy z obrazu
def build_base_cnn(input_shape=(128, 128, 1)):
    model = keras.Sequential([
        layers.Conv2D(32, (3,3), activation='relu', input_shape=input_shape),
        layers.MaxPooling2D(pool_size=(2,2)),
        layers.Conv2D(64, (3,3), activation='relu'),
        layers.MaxPooling2D(pool_size=(2,2)),
        layers.Conv2D(128, (3,3), activation='relu'),
        layers.GlobalAveragePooling2D(),  # otrzymujemy 128-wymiarowy wektor cech
        layers.Dense(128, activation='relu')  # embedding o wymiarze 128
    ])
    return model

base_cnn = build_base_cnn()

Budowa Siamese Network

# Definiowanie wejść dla dwóch obrazów (para)
input_a = keras.Input(shape=(128, 128, 1))
input_b = keras.Input(shape=(128, 128, 1))

# Uzyskiwanie embeddingów dla obu wejść przy użyciu wspólnego modelu base_cnn
emb_a = base_cnn(input_a)
emb_b = base_cnn(input_b)

# Obliczenie wektora różnicy absolutnej między dwoma embeddingami (L1 distance)
L1_layer = layers.Lambda(lambda tensors: tf.abs(tensors[0] - tensors[1]))
L1_distance = L1_layer([emb_a, emb_b])

# Dodanie małej sieci w celu predykcji podobieństwa
x = layers.Dense(64, activation='relu')(L1_distance)
output = layers.Dense(1, activation='sigmoid')(x)  # wynik jako prawdopodobieństwo podobieństwa

# Definicja modelu Siamese
siamese_model = keras.Model(inputs=[input_a, input_b], outputs=output)
siamese_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
siamese_model.summary()

Trenowanie Modelu

Do trenowania modelu należy podawać pary obrazów wraz z etykietą (1 – pasujące, 0 – niepasujące). Poniżej przykładowy pseudokod do generowania par:


import numpy as np

def generate_pair(tool_mark_dataset):
    # tool_mark_dataset to struktura danych grupująca obrazy wg identyfikatora narzędzia
    tool_ids = list(tool_mark_dataset.keys())
    if np.random.rand() < 0.5:
        # Generowanie pary pasującej (same narzędzie)
        tool = np.random.choice(tool_ids)
        img1, img2 = np.random.choice(tool_mark_dataset[tool], size=2, replace=False)
        label = 1
    else:
        # Generowanie pary niepasującej (różne narzędzia)
        tool1, tool2 = np.random.choice(tool_ids, size=2, replace=False)
        img1 = np.random.choice(tool_mark_dataset[tool1])
        img2 = np.random.choice(tool_mark_dataset[tool2])
        label = 0
    return img1, img2, label

def generate_batch(batch_size):
    X1 = np.zeros((batch_size, 128, 128, 1), dtype='float32')
    X2 = np.zeros((batch_size, 128, 128, 1), dtype='float32')
    Y  = np.zeros((batch_size,), dtype='float32')
    for i in range(batch_size):
        img1, img2, label = generate_pair(train_data)
        X1[i] = img1
        X2[i] = img2
        Y[i]  = label
    return [X1, X2], Y

# Przykładowy proces trenowania:
for epoch in range(num_epochs):
    for step in range(steps_per_epoch):
        X_pair, y_pair = generate_batch(batch_size=32)
        loss, acc = siamese_model.train_on_batch(X_pair, y_pair)
    # Opcjonalna ewaluacja na zbiorze walidacyjnym

W praktyce można wykorzystać tf.data.Dataset do stworzenia wydajnego pipeline’u generującego pary lub triplet-y. Powyższy kod ilustruje koncepcję, gdzie model uczy się minimalizować dystans między embeddingami obrazów pasujących oraz maksymalizować różnicę dla obrazów niepasujących.

Mechanizm Wyszukiwania w Bazie Danych

Po wytrenowaniu modelu system musi efektywnie porównywać nowo uzyskany ślad narzędziowy z istniejącą bazą danych. Proces wyszukiwania przebiega następująco:

Ekstrakcja Cech (Feature Extraction):

Używając wytrenowanego modelu (np. warstwy base_cnn), dla każdego obrazu obliczamy embedding (wektor cech, np. 128-wymiarowy).

Baza Embeddingów:

Dla każdego znanego śladu w bazie danych zapisujemy odpowiedni embedding. Dzięki temu porównywanie nowego śladu sprowadza się do wyszukiwania najbliższych sąsiadów w przestrzeni wektorowej.

Obliczanie Podobieństwa:

Nowy embedding porównujemy z embeddingami z bazy przy użyciu metryk odległości, takich jak Euclidean distance (L2) lub cosine similarity. W przypadku modeli trenowanych z contrastive loss lub triplet loss, mniejsze wartości odległości wskazują na większe podobieństwo.

Efektywne Wyszukiwanie:

Aby nie porównywać nowego śladu z każdym elementem bazy (brute-force), warto zastosować struktury indeksujące, takie jak KD-tree lub biblioteki do approximate nearest neighbors, np. FAISS. Takie rozwiązania umożliwiają szybkie odnalezienie top-K najbliższych embeddingów.

Weryfikacja:

Wyniki wyszukiwania (lista potencjalnych dopasowań) mogą być przekazane do weryfikacji przez eksperta, który oceni, czy ślady rzeczywiście pasują.

Podsumowanie

W niniejszym artykule omówiłem pobieżnie, jak za pomocą deep learning stworzyć system do identyfikacji narzędzi na podstawie śladów narzędziowych (scratch patterns, tool impressions, microstructure analysis).

Kluczowe punkty to:

Wybór modelu:

Wykorzystanie CNN do ekstrakcji cech oraz architektur Siamese network lub Triplet network do uczenia się metryki podobieństwa między śladami.

Przygotowanie danych:

Zapewnienie wysokiej jakości obrazowania, wyodrębnienie regionu zainteresowania (ROI), normalizacja, odpowiednia augmentacja oraz przygotowanie danych do generowania par lub triplet-ów.

Rozszerzanie zbioru danych:

Wykorzystanie metod transfer learning, augmentacji, danych syntetycznych oraz podejść few-shot learning, aby skutecznie trenować modele nawet przy ograniczonej liczbie danych.

Implementacja w Keras:

Przykładowy kod przedstawia budowę bazowego modelu CNN oraz rozwinięcie go do architektury Siamese network, która na podstawie L1 distance uczy się porównywania obrazów.

Mechanizm wyszukiwania:

Ekstrakcja embeddingów z wytrenowanego modelu, budowanie bazy danych embeddingów, a następnie efektywne wyszukiwanie najbliższych sąsiadów przy użyciu metryk takich jak Euclidean distance lub cosine similarity (z użyciem narzędzi takich jak FAISS).

Tak zaprojektowany system może znacząco wspierać prace śledcze, pozwalając na szybką identyfikację potencjalnych narzędzi użytych przy popełnieniu przestępstwa. System taki powinien stanowić wsparcie dla ekspertów i wymagać dokładnej walidacji na rzeczywistych danych.

(Dodatkowo) Formalna Weryfikacja i Metryki Oceny w Forensyce

W zastosowaniach kryminalistycznych (forensic science) nie wystarczy wytrenować modelu, który „działa dobrze” na testach – konieczne jest formalnie udowodnienie, że metoda jest rzetelna, powtarzalna i spełnia określone standardy akredytacyjne (np. ISO 17025 lub odpowiednie wymogi prawne). Poniżej kluczowe aspekty weryfikacji oraz metryki oceny przydatne w systemach wspierających identyfikację narzędzi na podstawie śladów narzędziowych.

1. Wyodrębnienie Zbioru Walidacyjnego i Testowego

  • Reprezentatywność danych:
    Dane testowe powinny odzwierciedlać pełną różnorodność rzeczywistych przypadków – różne typy narzędzi, zmienne warunki śladów (np. różna intensywność nacisku, kąt przyłożenia, stopień zużycia).

  • Selekcja danych:
    Zbiór walidacyjny oraz testowy musi być całkowicie odseparowany od danych treningowych, aby uniknąć data leakage i zapewnić wiarygodną ocenę działania systemu.

2. Standardowe Metryki Oceny

W kontekście forensyki, oprócz typowych metryk stosowanych w rozpoznawaniu obrazów, szczególnie istotne są miary, które pomagają zminimalizować błędy mające krytyczne konsekwencje prawne.

a) Macierz Pomyłek

  • True Positive (TP): System prawidłowo wykrył dopasowanie (ten sam egzemplarz narzędzia).
  • True Negative (TN): System prawidłowo odrzucił niedopasowanie (różne narzędzia).
  • False Positive (FP): System błędnie przypisał ślad do niewłaściwego narzędzia.
  • False Negative (FN): System nie wykrył dopasowania, mimo że ślady należą do tego samego narzędzia.

from sklearn.metrics import confusion_matrix

# Przykładowe dane:
# y_true - rzeczywiste etykiety (1: ten sam egzemplarz narzędzia, 0: różne narzędzia)
# y_pred - przewidywane etykiety przez system
y_true = [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]
y_pred = [1, 0, 0, 1, 0, 1, 1, 0, 1, 0]

# Obliczenie macierzy pomyłek
# Używamy kolejności etykiet: [0, 1] aby wiersz 0 odpowiadał klasie 0, a wiersz 1 klasie 1.
cm = confusion_matrix(y_true, y_pred, labels=[0, 1])
print("Macierz pomyłek:")
print(cm)

# Interpretacja macierzy:
#               Predicted 0    Predicted 1
# Actual 0       TN              FP
# Actual 1       FN              TP

TN = cm[0, 0]  # True Negative: system prawidłowo odrzucił niedopasowanie
FP = cm[0, 1]  # False Positive: system błędnie przypisał ślad do niewłaściwego narzędzia
FN = cm[1, 0]  # False Negative: system nie wykrył dopasowania
TP = cm[1, 1]  # True Positive: system prawidłowo wykrył dopasowanie

print("\nSzczegółowe wyniki:")
print("True Positive (TP):", TP)
print("True Negative (TN):", TN)
print("False Positive (FP):", FP)
print("False Negative (FN):", FN)

Wyjaśnienie:

Dane wejściowe: Wektor y_true zawiera rzeczywiste etykiety, a y_pred – etykiety przewidywane przez system. W tym przykładzie wartość 1 oznacza, że ślady należą do tego samego egzemplarza narzędzia, natomiast 0 – że do różnych narzędzi.

Macierz pomyłek:

Funkcja confusion_matrix oblicza macierz, w której:

Wiersz 0 odpowiada etykiecie 0 (różne narzędzia), Wiersz 1 odpowiada etykiecie 1 (ten sam egzemplarz).

Analogicznie, kolumny odpowiadają przewidywanym etykietom. Wyodrębnienie TP, TN, FP, FN: Zgodnie z interpretacją:

\[TN = cm[0, 0]\] \[FP = cm[0, 1]\] \[FN = cm[1, 0]\] \[TP = cm[1, 1]\]

Kod ten można łatwo dostosować do własnych danych, zmieniając wartości wektorów y_true oraz y_pred.

b) Miary Skuteczności

  • Accuracy (Dokładność): Ogólna poprawność klasyfikacji, choć może być myląca przy nierównomiernie rozłożonych klasach.
  • Precision (Precyzja): Stosunek poprawnych pozytywów do wszystkich pozytywnie zaklasyfikowanych przypadków. Kluczowa w minimalizacji fałszywych alarmów.
  • Recall (Czułość): Stosunek poprawnych pozytywów do wszystkich rzeczywistych przypadków dopasowania.
  • F1-score: Średnia harmoniczna precyzji i czułości, przydatna przy ocenie równowagi między tymi dwoma miarami.

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Przykładowe dane: etykiety rzeczywiste oraz przewidywane przez model
y_true = [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]  # rzeczywiste etykiety
y_pred = [1, 0, 0, 1, 0, 1, 1, 0, 1, 0]  # przewidywane etykiety

# Obliczanie Accuracy (Dokładność)
accuracy = accuracy_score(y_true, y_pred)

# Obliczanie Precision (Precyzja)
precision = precision_score(y_true, y_pred)

# Obliczanie Recall (Czułość)
recall = recall_score(y_true, y_pred)

# Obliczanie F1-score (średnia harmoniczna precyzji i czułości)
f1 = f1_score(y_true, y_pred)

# Wyświetlenie wyników
print("Dokładność (Accuracy):", accuracy)
print("Precyzja (Precision):", precision)
print("Czułość (Recall):", recall)
print("F1-score:", f1)

Wyjaśnienie:

  • Accuracy (Dokładność): Liczba poprawnie zaklasyfikowanych przypadków podzielona przez łączną liczbę przypadków.
  • Precision (Precyzja): Stosunek liczby prawidłowo przewidzianych pozytywów do liczby wszystkich przypadków zaklasyfikowanych jako pozytywne.
  • Recall (Czułość): Stosunek liczby prawidłowo przewidzianych pozytywów do liczby wszystkich rzeczywistych pozytywów.
  • F1-score: Średnia harmoniczna precyzji i czułości, która łączy te dwie miary w jedną wartość.

Powyższy kod demonstruje, jak przy pomocy gotowych funkcji z biblioteki scikit-learn można łatwo obliczyć i wyświetlić podstawowe miary skuteczności dla klasyfikatora. Możemy dostosować przykładowe dane (y_true i y_pred) do swoich potrzeb.

c) Krzywe ROC i AUC

  • ROC (Receiver Operating Characteristic): Graficzna prezentacja zależności między True Positive Rate (TPR) a False Positive Rate (FPR) dla różnych progów decyzyjnych.
  • AUC (Area Under the ROC Curve): Wskaźnik jakości klasyfikatora w skali 0–1, gdzie wyższa wartość oznacza lepsze rozróżnianie dopasowań od niedopasowań.

d) Equal Error Rate (EER)

  • EER: Punkt, w którym wskaźnik fałszywych akceptacji (FAR) zrówna się z wskaźnikiem fałszywych odrzuceń (FRR). Metryka często stosowana w systemach biometrycznych, która może być analogicznie wykorzystana w analizie śladów narzędziowych.

e) Top-K Accuracy / Rank-K

  • Top-K Accuracy: W systemach wyszukiwania, gdzie system zwraca listę potencjalnych dopasowań, kluczowe jest określenie, czy prawidłowy wynik znajduje się wśród pierwszych K pozycji (np. top-5, top-10).

3. Wyznaczanie Progów Decyzyjnych i Kalibracja

  • Ustalanie progu:
    W architekturach typu Siamese lub Triplet, wynik porównania dwóch śladów wyrażany jest często jako odległość (np. L1 lub L2). Konieczne jest określenie progu, powyżej którego ślady są traktowane jako niepochodzące z tego samego narzędzia.

  • Metody optymalizacji progu:
    Wykorzystanie krzywych ROC lub DET (Detection Error Tradeoff) pozwala dobrać optymalny próg, biorąc pod uwagę kompromis między minimalizacją fałszywych alarmów a maksymalizacją wykrycia rzeczywistych dopasowań.

  • Kalibracja wyników:
    Można zastosować techniki takie jak Platt scaling, aby przekształcić surowe miary podobieństwa w interpretowalne prawdopodobieństwa.

4. Powtarzalność i Walidacja Międzylaboratoryjna

  • Powtarzalność:
    Ta sama metoda, użyta przez tego samego operatora na tych samych danych w identycznych warunkach, powinna dawać zbliżone wyniki.

  • Odtwarzalność:
    Wyniki uzyskane w jednym laboratorium powinny być możliwe do uzyskania również w innych laboratoriach, korzystających z podobnych metod i sprzętu.

  • Walidacja Międzylaboratoryjna:
    Przeprowadzanie testów „round-robin”, gdzie ta sama próbka jest analizowana przez różne zespoły, pomaga potwierdzić wiarygodność metody.

5. Dokumentacja i Zgodność z Wymogami Prawnymi

  • Raportowanie wyników:
    Wyniki analizy muszą być dokumentowane w sposób przejrzysty, zawierając szczegółowe informacje o:
    • Parametrach użytych przy przetwarzaniu i analizie,
    • Wersji oprogramowania i modelu,
    • Wyznaczonych progach decyzyjnych,
    • Interpretacji wyników wraz z informacją o poziomie niepewności.
  • Standardy prawne:
    Systemy forensyczne często muszą spełniać wymagania standardów takich jak Daubert Standard (w USA) lub analogiczne normy w innych krajach. Wymagania te obejmują:
    1. Sprawdzalność naukową metody,
    2. Poddanie metody testom i recenzji w środowisku naukowym,
    3. Znajomość oraz oszacowanie poziomów błędów,
    4. Ustandaryzowane procedury operacyjne.

6. Interpretacja i Ekspercka Weryfikacja

  • Rola systemów wspomagających:
    Wyniki systemów automatycznych powinny być traktowane jako wsparcie dla biegłego sądowego, a nie jako ostateczne dowody.
  • Ekspercka analiza:
    Biegły powinien dokonać końcowej oceny, uwzględniając zarówno wyniki systemu, jak i kontekst sprawy oraz dodatkowe dowody.

Podsumowanie

Formalna weryfikacja systemów deep learning w forensyce wymaga:

  1. Solidnego i reprezentatywnego zbioru danych – odseparowanego od danych treningowych.
  2. Stosowania kompleksowych metryk – takich jak Precision, Recall, AUC, EER oraz Top-K Accuracy.
  3. Starannie wyznaczonych progów decyzyjnych – z uwzględnieniem kalibracji wyników.
  4. Powtarzalności i odtwarzalności wyników – potwierdzonych przez testy międzylaboratoryjne.
  5. Dokumentacji oraz zgodności z normami prawnymi – co jest kluczowe przy wykorzystaniu metod w dowodach sądowych.
  6. Eksperckiej weryfikacji – gdzie systemy automatyczne wspierają, a nie zastępują ocenę przez specjalistę.

Bibliografia

  1. [8] Koch, G., Zemel, R. and Salakhutdinov, R. (2015). Siamese Neural Networks for One-shot Image Recognition.
    PDF

  2. [28] Schroff, F., Kalenichenko, D. and Philbin, J. (2015). FaceNet: A Unified Embedding for Face Recognition and Clustering.
    arXiv:1503.03832

  3. [27] Dosovitskiy, A. et al. (2020). An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale.
    arXiv:2010.11929

  4. [24] Zhuang, F., Qi, Z., Duan, K., Xiang, S., Zhu, W. and He, Q. (2020). A Comprehensive Survey on Transfer Learning.
    arXiv:2009.10003

  5. [10] Johnson, J., Douze, M. and Jégou, H. (2019). Billion-scale Similarity Search with GPUs.
    FAISS: A library for efficient similarity search and clustering of dense vectors