Klasyfikacja obrazów Tensorflow 2.0: instalacja, ładowanie danych, budowanie i trenowanie modelu

Klasyfikacja obrazów to kategoria rozpoznawania wzorców. Klasyfikuje obrazy według relacji między sąsiednimi pikselami. Innymi słowy, wykorzystuje informacje kontekstowe do porządkowania obrazów i jest dość popularny wśród różnych technologii. To ważny temat w Deep Learning i jeśli się o nim uczysz, z pewnością spodoba ci się ten artykuł.

Tutaj przeprowadzimy klasyfikację obrazu TensorFlow. Zbudujemy model, wyszkolimy go, a następnie zwiększymy jego dokładność, aby sklasyfikować obrazy kaktusów. TensorFlow to platforma uczenia maszynowego typu open source i produkt Google.

Zacznijmy.

Zainstaluj TensorFlow 2.0

Najpierw musisz zainstalować TensorFlow w Google Colab. Możesz go zainstalować przez pip:

!pip install tensorflow-gpu==2.0.0-alpha0

Następnie zweryfikujemy instalację:

importuj tensorflow jako tf

print(tf.__wersja)

# Wyjście: 2.0.0-alfa0

Źródło

Dowiedz się: 5 najpopularniejszych projektów TensorFlow dla początkujących

Załaduj dane

Po weryfikacji możemy wczytać dane za pomocą zestawu tf.data.dataset. Zbudujemy klasyfikator, który określi, czy obraz zawiera kaktusa, czy nie. Kaktus musi być kolumnowy. W tym celu możemy użyć zestawu danych Cactus Aerial Photos. Teraz załadujemy ścieżki plików wraz z ich etykietami:

train_csv = pd.read_csv('dane/pociąg.csv')

# Dołącz nazwy plików obrazów w pociągu/ ze ścieżką względną

filenames = ['train/' + fname dla fname w train_csv['id'].tolist()]

etykiety = train_csv['ma_kaktus'].tolist()

nazwy_plików_pociągów, nazwy_plików_wartości, etykiety_pociągów, etykiety_wartości =

train_test_split(nazwy plików,

etykiety,

wielkość_pociągu=0.9,

losowy_stan=42)

Gdy mamy już etykiety i nazwy plików, jesteśmy gotowi do utworzenia obiektów tf.data.Dataset:

train_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(train_filenames), tf.constant(train_labels))

)

val_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(val_filenames), tf.constant(val_labels))

)

Źródło

W tej chwili nasz zbiór danych nie zawiera rzeczywistych obrazów. Zawiera tylko ich nazwy plików. Będziemy potrzebować funkcji, która załaduje niezbędne obrazy i przetworzy je, abyśmy mogli wykonać na nich rozpoznawanie obrazów TensorFlow.

IMAGE_SIZE = 96 # Minimalny rozmiar obrazu do użytku z MobileNetV2

ROZMIAR_PARTII = 32

# Funkcja ładowania i wstępnego przetwarzania każdego obrazu

def _parse_fn(nazwa pliku, etykieta):

img = tf.io.read_file(img)

img = tf.image.decode_jpeg(img)

obraz = (tf.cast(img, tf.float32)/127,5) – 1

img = tf.image.resize(img, (IMAGE_SIZE, IMAGE_SIZE))

zwrot img, etykieta

# Uruchom _parse_fn na każdym przykładzie w zestawach danych train i val

# Również tasuj i twórz partie

train_data = (train_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

val_data = (val_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

Źródło

Budowanie modelu

W tym przykładzie klasyfikacji obrazów TensorFlow stworzymy model uczenia transferu. Modele te są szybkie, ponieważ mogą korzystać z istniejących modeli klasyfikacji obrazów, które zostały wcześniej przeszkolone. Muszą jedynie przeszkolić górną warstwę swojej sieci, ponieważ ta warstwa określa klasę wymaganego obrazu.

Użyjemy Keras API TensorFlow 2.0 do stworzenia naszego modelu klasyfikacji obrazów. A do celów uczenia się transferu użyjemy MobileNetV2 jako detektora atrybutów. Jest to druga wersja MobileNet i jest produktem Google. Jest lżejszy niż inne modele, takie jak Incepcja i ResNet i może działać na urządzeniach mobilnych. Załadujemy ten model do ImageNet, zamrozimy wagi, dodamy głowicę klasyfikacyjną i uruchomimy bez górnej warstwy.

IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3)

# Wstępnie przeszkolony model z MobileNetV2

base_model = tf.keras.applications.MobileNetV2(

input_shape=IMG_SHAPE,

include_top=Fałsz,

wagi='imagenet'

)

# Zamroź wytrenowane wzorce masy

base_model.trainable = Fałsz

# Możliwość trenowania głowy klasyfikacyjnej

maxpool_layer = tf.keras.layers.GlobalMaxPooling2D()

przewidywanie_warstwa = tf.keras.warstwy.Gęsty(1, aktywacja='sigmoid')

# Głowica klasyfikująca warstwy z detektorem funkcji

model = tf.keras.Sequential([

model_podstawowy,

maxpool_layer,

warstwa_przewidywania

])

wskaźnik_nauczenia = 0,0001

# Skompiluj model

model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),

strata='binary_crossentropy',

metryki=['dokładność']

)

Źródło

Powinieneś użyć optymalizatorów TensorFlow, jeśli zamierzasz trenować modele tf.keras. Optymalizatory w interfejsach API tf.keras.optimizers i tf.train znajdują się razem w tf.keras.optimizers w TensorFlow 2.0. W TensorFlow 2.0 wiele oryginalnych optymalizatorów tf.keras otrzymało aktualizacje i zamienniki dla lepszej wydajności. Umożliwiają nam stosowanie optymalizatorów bez uszczerbku dla wydajności, a także oszczędzają czas.

Przeczytaj: Samouczek wykrywania obiektów TensorFlow dla początkujących

Ucz się kursów nauki o danych z najlepszych światowych uniwersytetów. Zdobywaj programy Executive PG, Advanced Certificate Programs lub Masters Programs, aby przyspieszyć swoją karierę.

Szkolenie modelki

Po zbudowaniu modelu możemy go uczyć. Interfejs API tf.keras w TensorFlow 2.0 obsługuje interfejs API tf.data, więc musisz w tym celu użyć obiektów tf.data.Dataset. Potrafi sprawnie przeprowadzić trening, a my nie musielibyśmy iść na żadne kompromisy z wydajnością.

liczba_epok = 30

steps_per_epoch = round(num_train)//PARTCH_SIZE

val_steps = 20

model.fit(train_data.repeat(),

epoki=liczba_epok,

kroki_na_epokę = kroki_na_epokę,

validation_data=val_data.repeat(),

validation_steps=val_steps)

Źródło

Po 30 epokach dokładność modelu znacznie wzrasta, ale możemy ją jeszcze bardziej poprawić. Pamiętasz, wspominaliśmy o zamrażaniu ciężarów podczas nauki transferowej? Cóż, teraz, gdy wyszkoliliśmy szefa klasyfikacji, możemy odblokować te warstwy i dokładniej dostroić nasz zbiór danych:

# Odblokuj wszystkie warstwy MobileNetV2

base_model.trainable = Prawda

# Ponownie zamrażaj warstwy, aż warstwy, które chcemy dostroić

dla warstwy w base_model.layers[:100]:

layer.trainable = Fałsz

# Użyj niższej szybkości uczenia się

lr_finetune = wskaźnik_nauki / 10

# Ponownie skompiluj model

model.compile(loss='binary_crossentropy',

optymalizator = tf.keras.optimizers.Adam(lr=lr_finetune),

metryki=['dokładność'])

# Zwiększenie epok treningowych w celu dostrojenia

epoki_dostrojenia = 30

suma_epok = liczba_epok + fine_tune_epochs

# Dostrój model

# Uwaga: Ustaw Initial_epoch, aby rozpocząć trening po 30 epoce, ponieważ my

# wcześniej szkolony przez 30 epok.

model.fit(train_data.repeat(),

kroki_na_epokę = kroki_na_epokę,

epoki=całkowite_epok,

początkowa_epoka = liczba_epok,

validation_data=val_data.repeat(),

validation_steps=val_steps)

Źródło

30 epok później dokładność modelu jeszcze się poprawia. W kolejnych epokach widzieliśmy większą poprawę dokładności modelu. Teraz mamy odpowiedni model rozpoznawania obrazów TensorFlow, który potrafi rozpoznawać kaktusy kolumnowe na obrazach z dużą dokładnością.

Przeczytaj także: Pomysły na projekty Tensorflow dla początkujących

Dowiedz się więcej o klasyfikacji obrazów TensorFlow

Wysoce funkcjonalne interfejsy API TensorFlow i jego możliwości sprawiają, że jest to potężna technologia dla każdego programisty. Jego wysokopoziomowe interfejsy API usuwają również jego ogólną złożoność, ułatwiając korzystanie z niego.

Czy chcesz dowiedzieć się więcej o TensorFlow, klasyfikacji obrazów i powiązanych tematach? Następnie zalecamy zapoznanie się z dyplomem PG IIIT-B i upGrad w zakresie uczenia maszynowego i sztucznej inteligencji, który jest przeznaczony dla pracujących profesjonalistów i oferuje ponad 450 godzin rygorystycznego szkolenia, ponad 30 studiów przypadków i zadań, status absolwentów IIIT-B, ponad 5 praktyk praktycznych praktyczne projekty zwieńczenia i pomoc w pracy z najlepszymi firmami.