Alai

Wprowadzenie

„Zbudować model głębokiego uczenia w kilka minut? To zajmie godziny, aby trenować! Nie mam nawet wystarczająco dobrej maszyny.” Słyszałem to niezliczoną ilość razy od aspirujących naukowców danych, którzy wzbraniają się przed budowaniem modeli głębokiego uczenia na własnych maszynach.

Nie musisz pracować dla Google lub innych dużych firm technologicznych, aby pracować na zestawach danych głębokiego uczenia! Jest całkowicie możliwe, aby zbudować własną sieć neuronową od podstaw w ciągu kilku minut, bez konieczności wynajmowania serwerów Google. Studenci Fast.ai zaprojektowali model na zbiorze danych Imagenet w 18 minut – a ja zaprezentuję coś podobnego w tym artykule.

Głębokie uczenie to rozległa dziedzina, więc zawęzimy nieco naszą uwagę i podejmiemy wyzwanie rozwiązania projektu klasyfikacji obrazów. Dodatkowo, będziemy używać bardzo prostej architektury głębokiego uczenia, aby osiągnąć całkiem imponujący wynik dokładności.

Kod Pythona, który zobaczymy w tym artykule, można traktować jako wzorzec do budowania modeli klasyfikacji obrazów. Kiedy już dobrze opanujesz tę koncepcję, śmiało baw się kodem, bierz udział w konkursach i pnij się w górę tabeli liderów!

Jeśli jesteś nowy w głębokim uczeniu i fascynuje Cię dziedzina widzenia komputerowego (kto nie jest?!), sprawdź kurs 'Computer Vision using Deep Learning’. Jest to kompleksowe wprowadzenie do tego wspaniałego pola i ustawi cię na to, co nieuchronnie będzie ogromny rynek pracy w najbliższej przyszłości.

Projekt zastosowania klasyfikacji obrazu

Ponad 25% całego przychodu w E-Commerce jest przypisane do odzieży & akcesoriów. Głównym problemem jest kategoryzacja tych ubrań tylko z obrazów, zwłaszcza gdy kategorie dostarczone przez marki są niespójne. Stanowi to interesujący problem widzenia komputerowego, który przykuł uwagę kilku badaczy głębokiego uczenia się.

Fashion MNIST jest drop-in zamiennikiem dla bardzo dobrze znanego, uczenia maszynowego hello world – MNIST dataset, który można sprawdzić na 'Identify the digits’ problem praktyki. Zamiast cyfr, obrazy przedstawiają rodzaj odzieży, np. koszulkę, spodnie, torbę, itp. Zbiór danych użyty w tym problemie został stworzony przez Zalando Research.

Practice Now

Table of Contents

1. What is Image Classification and its use cases
2. Setting up the Structure of our Image Data
3. Breaking Down the Model Building Process
4. Setting up the Problem Statement and Understanding the Data
5. Steps to Build the Image Classification Model
6. Taking up Another Challenge

What is Image Classification?

Rozważ poniższy obraz:

Na pewno od razu go rozpoznałeś – to (wypasiony) samochód. Zrób krok do tyłu i przeanalizuj, jak doszedłeś do tego wniosku – pokazano Ci obraz i sklasyfikowałeś klasę, do której należał (w tym przypadku samochód). I to, w skrócie, jest to, co klasyfikacja obrazu jest o.

Istnieje potencjalnie n liczba kategorii, w których dany obraz może być sklasyfikowany. Ręczne sprawdzanie i klasyfikowanie obrazów jest bardzo żmudnym procesem. Zadanie to staje się prawie niemożliwe, gdy mamy do czynienia z ogromną liczbą obrazów, powiedzmy 10,000 lub nawet 100,000. Jak użyteczne byłoby, gdybyśmy mogli zautomatyzować cały ten proces i szybko etykietować obrazy według odpowiadającej im klasy?

Samojeżdżące samochody są świetnym przykładem, aby zrozumieć, gdzie klasyfikacja obrazów jest używana w świecie rzeczywistym. Aby umożliwić autonomiczną jazdę, możemy zbudować model klasyfikacji obrazu, który rozpoznaje różne obiekty, takie jak pojazdy, ludzie, obiekty ruchome itp. na drodze. Zobaczymy kilka innych przypadków użycia w dalszej części tego artykułu, ale istnieje wiele innych zastosowań wokół nas. Skorzystaj z sekcji komentarzy pod artykułem, aby dać mi znać, jakie potencjalne przypadki użycia możesz wymyślić!

Teraz, gdy mamy już uchwyt na nasz temat, zanurzmy się w tym, jak zbudowany jest model klasyfikacji obrazów, jakie są jego warunki wstępne i jak można go zaimplementować w Pythonie.

Ustawianie struktury naszych danych obrazowych

Nasze dane muszą być w określonym formacie, aby rozwiązać problem klasyfikacji obrazów. Zobaczymy to w akcji w kilku sekcjach, ale po prostu pamiętaj o tych wskazówkach, dopóki tam nie dotrzemy.

Powinieneś mieć 2 foldery, jeden dla zbioru treningowego i drugi dla zbioru testowego. W zestawie treningowym będziesz miał plik .csv i folder obrazów:

• Plik .csv zawiera nazwy wszystkich obrazów treningowych i odpowiadające im prawdziwe etykiety
• Folder obrazów zawiera wszystkie obrazy treningowe.

Plik .csv w naszym zestawie testowym jest inny niż ten obecny w zestawie treningowym. Ten plik .csv zawiera nazwy wszystkich obrazów testowych, ale nie ma odpowiadających im etykiet. Czy domyślasz się dlaczego? Nasz model będzie trenowany na obrazach obecnych w zbiorze treningowym, a przewidywanie etykiet będzie się odbywało na obrazach ze zbioru testowego

Jeśli twoje dane nie są w formacie opisanym powyżej, będziesz musiał je odpowiednio przekonwertować (w przeciwnym razie przewidywania będą błędne i całkiem bezużyteczne).

Przełamanie procesu budowania modelu

Zanim zagłębimy się w kod Pythona, poświęćmy chwilę na zrozumienie, jak typowo projektuje się model klasyfikacji obrazów. Proces ten możemy podzielić ogólnie na 4 etapy. Każdy etap wymaga określonej ilości czasu na wykonanie:

1. Wczytywanie i wstępne przetwarzanie danych – 30% czasu
2. Definiowanie architektury modelu – 10% czasu
3. Trenowanie modelu – 50% czasu
4. Oszacowanie wydajności – 10% czasu

Pozwól, że wyjaśnię każdy z powyższych etapów nieco bardziej szczegółowo. Ta sekcja jest kluczowa, ponieważ nie każdy model jest zbudowany za pierwszym razem. Będziesz musiał wrócić do niego po każdej iteracji, dostroić swoje kroki i uruchomić go ponownie. Solidne zrozumienie podstawowych pojęć znacznie przyspieszy cały proces.

Etap 1: Ładowanie i wstępne przetwarzanie danych

Dane to złoto, jeśli chodzi o modele głębokiego uczenia się. Twój model klasyfikacji obrazu ma o wiele większe szanse na dobre wyniki, jeśli masz dobrą ilość obrazów w zestawie treningowym. Ponadto, kształt danych różni się w zależności od architektury/ramework, których używamy.

Stąd krytyczny krok wstępnego przetwarzania danych (wiecznie ważny krok w każdym projekcie). Gorąco polecam przejście przez „Podstawy przetwarzania obrazu w Pythonie”, aby zrozumieć więcej o tym, jak wstępne przetwarzanie działa z danymi obrazu.

Ale nie jesteśmy jeszcze całkiem tam. Aby zobaczyć jak nasz model radzi sobie na niewidzianych danych (i przed wystawieniem go na zbiór testowy), musimy stworzyć zbiór walidacyjny. Odbywa się to poprzez partycjonowanie danych zbioru treningowego.

W skrócie, trenujemy model na danych treningowych i walidujemy go na danych walidacyjnych. Gdy jesteśmy zadowoleni z wydajności modelu na zbiorze walidacyjnym, możemy go użyć do tworzenia przewidywań na danych testowych.

Czas potrzebny na ten krok: Potrzebujemy około 2-3 minut na to zadanie.

Etap 2: Definiowanie architektury modelu

Jest to kolejny kluczowy krok w naszym procesie budowania modelu głębokiego uczenia. Musimy określić, jak będzie wyglądał nasz model, a to wymaga odpowiedzi na pytania takie jak:

• Ile warstw konwolucyjnych chcemy?
• Jaka powinna być funkcja aktywacji dla każdej warstwy?
• Ile jednostek ukrytych powinna mieć każda warstwa?

I wiele innych. Są to zasadniczo hiperparametry modelu, które odgrywają ogromną rolę w decydowaniu o tym, jak dobre będą przewidywania.

Jak decydujemy o tych wartościach? Doskonałe pytanie! Dobrym pomysłem jest wybranie tych wartości w oparciu o istniejące badania/studia. Innym pomysłem jest eksperymentowanie z wartościami, aż znajdziesz najlepsze dopasowanie, ale może to być dość czasochłonny proces.

Czas potrzebny na ten krok: Zdefiniowanie architektury modelu powinno zająć około 1 minuty.

Etap 3: Trening modelu

Do treningu modelu potrzebujemy:

• Obrazy treningowe i odpowiadające im prawdziwe etykiety
• Obrazy walidacyjne i odpowiadające im prawdziwe etykiety (używamy tych etykiet tylko do walidacji modelu, a nie podczas fazy treningu)

W tym kroku określamy również liczbę epok. Na początek, uruchomimy model na 10 epok (możesz zmienić liczbę epok później).

Czas wymagany na ten krok: Ponieważ trening wymaga, aby model nauczył się struktur, potrzebujemy około 5 minut, aby przejść przez ten krok.

A teraz czas na przewidywania!

Etap 4: Oszacowanie wydajności modelu

W końcu, ładujemy dane testowe (obrazy) i przechodzimy przez etap wstępnego przetwarzania również tutaj. Następnie przewidujemy klasy dla tych obrazów używając wytrenowanego modelu.

Czas wymagany na ten krok: ~ 1 minuta.

Ustawienie problemu i zrozumienie danych

Podejmiemy naprawdę fajne wyzwanie, aby zrozumieć klasyfikację obrazów. Musimy zbudować model, który może sklasyfikować dany zestaw obrazów w zależności od odzieży (koszula, spodnie, buty, skarpetki, itp.). Jest to właściwie problem, z którym boryka się wielu sprzedawców e-commerce, co czyni go jeszcze bardziej interesującym problemem widzenia komputerowego.

To wyzwanie nazywa się 'Identify the Apparels’ i jest jednym z problemów ćwiczeniowych, które mamy na naszej platformie DataHack. Musisz się zarejestrować i pobrać zbiór danych z powyższego linku.

Mamy w sumie 70 000 obrazów (wymiar 28 x 28), z czego 60 000 pochodzi z zestawu treningowego, a 10 000 z testowego. Obrazy treningowe są wstępnie oznakowane zgodnie z typem odzieży, z 10 całkowitymi klasami. Obrazy testowe nie mają oczywiście etykiet. Wyzwanie polega na zidentyfikowaniu typu odzieży obecnej na wszystkich obrazach testowych.

Budujemy nasz model na Google Colab, ponieważ zapewnia on darmowy procesor graficzny do trenowania naszych modeli.

Kroki do zbudowania naszego modelu

Czas, aby uruchomić swoje umiejętności Pythona i pobrudzić sobie ręce. W końcu jesteśmy w części implementacyjnej naszej nauki!

1. Ustawianie Google Colab
2. Importowanie bibliotek
3. Wczytywanie i wstępne przetwarzanie danych – (3 minuty)
4. Tworzenie zbioru walidacyjnego

.

5. Definiowanie struktury modelu – (1 min)
6. Trenowanie modelu – (5 min)
7. Wykonywanie przewidywań – (1 min)

Przyjrzyjrzyjmy się szczegółowo każdemu z kroków.

Krok 1: Konfiguracja Google Colab

Ponieważ importujemy nasze dane z łącza Google Drive, będziemy musieli dodać kilka linii kodu w naszym notatniku Google Colab. Utwórz nowy notatnik Python 3 i napisz następujące bloki kodu:

!pip install PyDrive

To zainstaluje PyDrive. Teraz zaimportujemy kilka wymaganych bibliotek:

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

Następnie utworzymy zmienną drive, aby uzyskać dostęp do Google Drive:

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

Aby pobrać zbiór danych, użyjemy identyfikatora pliku przesłanego na Google Drive:

download = drive.CreateFile({'id': '1BZOv422XJvxFUnGh-0xVeSvgFgqVY45q'})

Zastąpimy 'id’ w powyższym kodzie identyfikatorem naszego pliku. Teraz pobierzemy ten plik i rozpakujemy go:

download.GetContentFile('train_LbELtWX.zip')!unzip train_LbELtWX.zip

Musisz uruchamiać te bloki kodu za każdym razem, gdy uruchamiasz swój notebook.

Krok 2: Zaimportuj biblioteki, które będą nam potrzebne w fazie budowania modelu.

import kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

Krok 3: Przypomnij sobie kroki wstępnego przetwarzania, które omówiliśmy wcześniej. Użyjemy ich tutaj po załadowaniu danych.

train = pd.read_csv('train.csv')

Następnie odczytamy wszystkie obrazy treningowe, przechowamy je na liście, a na koniec przekonwertujemy tę listę na tablicę numpy.

# We have grayscale images, so while loading the images we will keep grayscale=True, if you have RGB images, you should set grayscale as Falsetrain_image = for i in tqdm(range(train.shape)): img = image.load_img('train/'+train.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

Ponieważ jest to problem klasyfikacji wieloklasowej (10 klas), zakodujemy one-hot zmienną docelową.

y=train.valuesy = to_categorical(y)

Krok 4: Tworzenie zbioru walidacyjnego z danych treningowych.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

Krok 5: Definiowanie struktury modelu.

Stworzymy prostą architekturę z 2 warstwami konwolucyjnymi, jedną gęstą warstwą ukrytą i warstwą wyjściową.

model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

Następnie skompilujemy stworzony przez nas model.

model.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

Krok 6: Trening modelu.

W tym kroku, wytrenujemy model na obrazach z zestawu treningowego i zwalidujemy go używając, zgadłeś, zestawu walidacyjnego.

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

Krok 7: Tworzenie przewidywań!

Początkowo będziemy postępować zgodnie z krokami, które wykonaliśmy podczas zajmowania się danymi treningowymi. Załaduj obrazy testowe i przepowiedz ich klasy za pomocą funkcji model.predict_classes().

download = drive.CreateFile({'id': '1KuyWGFEpj7Fr2DgBsW8qsWvjqEzfoJBY'})download.GetContentFile('test_ScVgIM0.zip')!unzip test_ScVgIM0.zip

Zaimportujmy plik testowy:

test = pd.read_csv('test.csv')

Teraz odczytamy i zapiszemy wszystkie obrazy testowe:

test_image = for i in tqdm(range(test.shape)): img = image.load_img('test/'+test.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

# making predictionsprediction = model.predict_classes(test)

Utworzymy również plik do przesłania na stronę platformy DataHack (aby zobaczyć, jak nasze wyniki wypadają na tablicy liderów).

download = drive.CreateFile({'id': '1z4QXy7WravpSj-S4Cs9Fk8ZNaX-qh5HF'})download.GetContentFile('sample_submission_I5njJSF.csv')

# creating submission filesample = pd.read_csv('sample_submission_I5njJSF.csv')sample = predictionsample.to_csv('sample_cnn.csv', header=True, index=False)

Ściągnij ten przykładowy plik_cnn.csv i prześlij go na stronę konkursu, aby wygenerować swoje wyniki i sprawdzić swoją pozycję na tablicy liderów. To da ci rozwiązanie wzorcowe, abyś mógł zacząć od każdego problemu z klasyfikacją obrazu!

Możesz wypróbować techniki dostrajania hiperparametrów i regularyzacji, aby jeszcze bardziej poprawić wydajność swojego modelu. Zachęcam do zapoznania się z tym artykułem, aby zrozumieć ten krok dostrajania w sposób bardziej szczegółowy – 'A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch’.

Picking up a Different Challenge

Sprawdźmy naszą naukę na innym zestawie danych. W tej części zajmiemy się problemem ćwiczeniowym „Rozpoznaj cyfry”. Ściągnij zestaw danych. Zanim przejdziesz dalej, spróbuj rozwiązać ten problem samodzielnie. Masz już narzędzia do jego rozwiązania – musisz je tylko zastosować! Wróć tutaj, aby sprawdzić swoje wyniki lub jeśli utkniesz w jakimś punkcie.

W tym zadaniu musimy zidentyfikować cyfrę na danym obrazku. Mamy w sumie 70 000 obrazów – 49 000 oznaczonych w zbiorze treningowym i pozostałe 21 000 w zbiorze testowym (obrazy testowe są nieoznaczone). Musimy zidentyfikować/przewidzieć klasę tych nieoznakowanych obrazów.

Gotowy do rozpoczęcia? Wspaniale! Stwórz nowy notatnik Pythona 3 i uruchom następujący kod:

# Setting up Colab!pip install PyDrive

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

# Replace the id and filename in the below codesdownload = drive.CreateFile({'id': '1ZCzHDAfwgLdQke_GNnHp_4OheRRtNPs-'})download.GetContentFile('Train_UQcUa52.zip')!unzip Train_UQcUa52.zip

# Importing librariesimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

train = pd.read_csv('train.csv')

# Reading the training imagestrain_image = for i in tqdm(range(train.shape)): img = image.load_img('Images/train/'+train, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

# Creating the target variabley=train.valuesy = to_categorical(y)

# Creating validation setX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Define the model structuremodel = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

# Compile the modelmodel.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

# Training the modelmodel.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

download = drive.CreateFile({'id': '1zHJR6yiI06ao-UAh_LXZQRIOzBO3sNDq'})download.GetContentFile('Test_fCbTej3.csv')

test_file = pd.read_csv('Test_fCbTej3.csv')

test_image = for i in tqdm(range(test_file.shape)): img = image.load_img('Images/test/'+test_file, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

prediction = model.predict_classes(test)

download = drive.CreateFile({'id': '1nRz5bD7ReGrdinpdFcHVIEyjqtPGPyHx'})download.GetContentFile('Sample_Submission_lxuyBuB.csv')

sample = pd.read_csv('Sample_Submission_lxuyBuB.csv')sample = test_filesample = predictionsample.to_csv('sample.csv', header=True, index=False)

Wyślij ten plik na stronie z problemem praktycznym, aby uzyskać całkiem przyzwoity numer dokładności. To dobry początek, ale zawsze jest miejsce na poprawę. Baw się dalej wartościami hiperparametrów i zobacz, czy możesz poprawić nasz podstawowy model.

Uwagi końcowe

Kto powiedział, że modele głębokiego uczenia wymagają godzin lub dni na trening. Moim celem było pokazanie, że możesz wymyślić całkiem przyzwoity model głębokiego uczenia się w dwukrotnie szybszym czasie. Powinieneś podnieść podobne wyzwania i spróbować zakodować je również ze swojego końca. Nie ma to jak nauka przez działanie!

Najlepsi naukowcy i analitycy danych mają te kody gotowe, zanim jeszcze rozpocznie się Hackathon. Używają tych kodów, aby dokonać wczesnych zgłoszeń przed zanurzeniem się w szczegółowej analizie. Kiedy mają już rozwiązanie wzorcowe, zaczynają ulepszać swój model, używając różnych technik.

.