Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Hey Guys,

Hoop dat het jullie allemaal goed gaat.

In dit artikel zullen we leren hoe u een afbeeldingsclassificatie kunt ontwikkelen en implementeren met flask. Net als mijn andere artikelen, geeft dit artikel je praktische ervaring met code en aan het einde van dit artikel kun je een eenvoudige en effectieve kolf-API maken die de afbeelding classificeert. Dit artikel bevat eerst het theoriegedeelte en vervolgens het codeergedeelte. Ik zal later in dit artikel een link naar de code geven om je drukte te besparen. Dus laten we ons concentreren op leren. Nogmaals, dit artikel zal volledig gebaseerd zijn op PYTHON.

Dit artikel is toegankelijk voor alle categorieën kijkers (Beginner, Gemiddeld, Gevorderd). Hieronder staat de inhoudsopgave van dit artikel, dus voel je vrij om delen over te slaan waar je al vertrouwd mee bent.

Dit deel zal gericht zijn op beeldclassificatie met behulp van kolf. Het tweede deel vind je hier als u alleen geïnteresseerd bent in het maken van een flask-API.

Inhoudsopgave

1. Wat is beeldclassificatie?
   1. 1. Convolutief neuraal netwerk
   1. 2. Leren overdragen
2.  Codering voor beeldclassificatie
3. Conclusie

Afbeeldingsclassificatie

Afbeeldingsclassificatie is het proces van het categoriseren en labelen van groepen pixels of vectoren binnen een afbeelding op basis van specifieke regels. In termen van leken proberen we op de een of andere manier gerelateerde afbeeldingen of vergelijkbare afbeeldingen te groeperen.
Beeldclassificatietechnieken zijn hoofdzakelijk onderverdeeld in twee soorten: Unsupervised en Supervised Image-classificatie. We zullen hier de gesuperviseerde beeldclassificatietechnieken gebruiken. Ik ga er niet dieper op in.

De State of Art voor beeldclassificatie is gebaseerd op Deep Learning, bekend als Convolutional Neural Networks (CNN).

Convolutief neuraal netwerk

Laten we, voordat we verder gaan met CNN, eens kijken naar Neural Network.

Neuraal netwerk: Dit zijn reeksen algoritmen die de onderliggende patronen/relaties in een reeks gegevens herkennen via een proces dat lijkt op de werking van het menselijk brein. Diep leren: een subset van machine learning-algoritmen die erg goed is in het herkennen van patronen, maar die doorgaans een groot aantal gegevens vereist.

CNN ook bekend als Convnet is een speciaal type neuraal netwerk dat op dezelfde manier werkt als een gewoon neuraal netwerk, behalve dat het aan het begin een convolutielaag heeft.

Waarom gebruiken we CNN?

1. Eenvoudige feedforward neurale netwerken zien geen volgorde in hun invoer. Als je al je afbeeldingen op dezelfde manier zou schudden, zou het neurale netwerk dezelfde prestaties hebben als wanneer het werd getraind op niet-geschudde afbeeldingen.
2. profiteren van de lokale ruimtelijke samenhang van beelden. Dit betekent dat ze het aantal bewerkingen dat nodig is om een ​​afbeelding te verwerken drastisch kunnen verminderen door convolutie te gebruiken op patches van aangrenzende pixels, omdat aangrenzende pixels samen betekenisvol zijn.
3. Ze gebruiken iets dat een poolinglaag wordt genoemd om uw afbeelding te downsamplen.

De afbeelding hieronder toont een klassiek voorbeeld van CNN.

VIP-termen in CNN

Convolutie: Het bevat een set filters/kernels (set gewichten) die invoer als een subset van het invoerbeeld opneemt. Subsets van afbeeldingen worden vermenigvuldigd met de filters die over het algemeen kleiner zijn dan de afbeelding. De onderstaande afbeelding helpt u inzicht te krijgen in de convolutionele laag.

poolen: Deze laag helpt bij het downsamplen van onze afbeeldingen. We voeren een filter over de matrix uit en passen er een functie op toe om de uitvoer te genereren. MAXPOOL is een functie die uitvoer als maximale waarde geeft, zoals hieronder wordt getoond.

Afbeelding is afkomstig van https://cs231n.github.io/convolutional-networks/

ReLU

Rectified Linear Activation Function of kortweg ReLU is een stuksgewijs lineaire functie die de invoer direct zal uitvoeren als deze positief is, anders zal deze nul uitvoeren. Het is de standaard activeringsfunctie geworden voor veel soorten neurale netwerken omdat een model dat het gebruikt gemakkelijker te trainen is en vaak betere prestaties levert.

Afvaller

Deze laag helpt bij het voorkomen van overfitting van ons model door willekeurig bepaalde knooppunten in het neurale netwerk te laten vallen en rust te gebruiken voor voorspelling. Het is een regularisatietechniek die CNN dwingt om niet alleen afhankelijk te zijn van bepaalde knooppunten, maar heeft een component of zegt van alle knooppunten.

Volledig verbonden laag

Neuronen in een volledig verbonden laag hebben volledige verbindingen met alle activeringen in de vorige laag. Hun activeringen kunnen dus worden berekend met een matrixvermenigvuldiging gevolgd door een bias-offset.

U kunt meer details lezen hier.

Transfer leren 

Transfer Learning is het hergebruik van een eerder geleerd model op een nieuw probleem. Dit zijn de meest gebruikte technieken in Computer Vision omdat ze een hoop gedoe besparen wanneer je deze technieken gebruikt om een ​​soortgelijk nieuw probleem op te lossen. We hebben bijvoorbeeld een model gemaakt om kat versus aap te classificeren, kunnen we het gebruiken om tijger versus gorilla te classificeren? Met Transfer Learning kunnen we dat zeker.

We gaan ook Transfer Learning gebruiken bij het maken van ons model. Voorbeelden van transfer learning-modellen die worden gebruikt voor beeldclassificatie zijn Resnet50, MobileNet, VGG16, VGG19, DenseNet.

Lees meer over Transfer Learning hier.

Genoeg met theorie LAAT MIJ DE CODE zien!

Codering voor beeldclassificatie 

Voor beeldclassificaties zijn er veel modules zoals TensorFlow, PyTorch, fastai, enz. Voor deze blog zullen we TensorFlow. 

Bibliotheken importeren: 

# Helperbibliotheken importeren os import numpy als np import matplotlib.pyplot als plt

# Tensorflow importeert tensorflow als tf

Uw dataset maken

U moet variabelen declareren en wijzigen op basis van uw gebruik.

# Variabelen declareren train_data_dir = 'v_data/train' validation_data_dir = 'v_data/test' nb_train_samples =400 nb_validation_samples = 100 tijdperken = 10 batch_size = 16
img_width, img_height = 224, 224 input_shape = (img_width, img_height, 3)

tijdperken: 1 Epoch is wanneer de volledige dataset slechts één keer vooruit en achteruit door het neurale netwerk wordt doorgegeven.
seriegrootte: Aangezien het vooruit en achteruit doorgeven van de volledige dataset de berekeningskosten zal doen stijgen, gebruiken we een batchgrootte die wordt gedefinieerd als het aantal monsters dat via het netwerk wordt verspreid.

train_datagen = ImageDataGenerator( rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1./255) train_generator = train_datagen.flow_from_directory(train_data_dir, target_size=,img_heightth), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary')

Model maken

model = Sequential()
model.add(Conv2D(32, (2, 2), input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(32, (2, 2)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (2, 2)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))

We hebben hier de structuur voor ons model gemaakt.

model.compile(loss='binary_crossentropy',
optimizer='adam',metrics=['accuracy'])

van tensorflow.keras.applications.mobilenet_v2 import MobileNetV2 model = MobileNetV2(weights='imagenet')

Met deze code wordt een model gemaakt met de structuur van MobileNetV2 geladen met imagenet-gewichten.

Fijnafstemming Transfer Learning-model

Om vooraf getrainde neurale netwerken aan te passen aan ons probleem, moeten we ze trainen op onze dataset. We kunnen ook enkele extra lagen toevoegen aan het einde van het beeldclassificatiemodel.

van keras.applications import Resnet50 base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3))

output_categorie = 2 # aantal categorieën in de laatste laag. add_model = Sequential() add_model.add(Flatten(input_shape=base_model.output_shape[1:])) add_model.add(Dropout(0.3)) add_model.add(Dense(128, activatie='relu')) add_model.add( Dropout(0.3)) add_model.add(Dense(output_categories, activation='softmax')) model = Model(inputs=base_model.input, outputs=add_model(base_model.output))

Hier hebben we Resnet50 als een vooraf getraind model gebruikt en vervolgens hebben we enkele lagen aan het einde van ons model toegevoegd, zodat we het voor ons geval kunnen verfijnen.

Trainingsmodel

model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size)

Voorspellen met behulp van Model 

def model_predict(img, model): img = img.resize((224, 224))

 # Voorbewerking van de afbeelding x = image.img_to_array(img) # x = np.true_divide(x, 255) x = np.expand_dims(x, axis=0)

 # Wees voorzichtig met hoe uw getrainde model omgaat met de invoer # anders maakt het geen juiste voorspelling! x = preprocess_input(x, mode='tf')

 preds = model.predict(x) geeft preds terug

Besparingsmodel

model_json = model.to_json() met open("ImageClassifier.json", "w") als json_file: json_file.write(model_json) # serialiseer gewichten naar HDF5 model.save_weights("ImageClassifier.h5")

Locaties zullen veranderen afhankelijk van uw systeem.

Laadmodel

model_json = open(path_to_model_json, 'r') loaded_model_json = model_json.read() model_json.close() model = model_from_json(loaded_model_json) model.load_weights(path_to_model_wieght)

Conclusie

Dit is het einde van de afbeeldingsclassificatie met kolf. Ik hoop dat je een idee hebt van hoe je een beeldclassificatie kunt maken en hoe je transfer learning kunt toepassen en gebruiken om betere resultaten te krijgen voor je computervisieproblemen. In het vervolgartikel zullen we een API maken om onze afbeeldingsclassificatie vast te houden en deze te implementeren. Ik heb de volledige code voor deze tutorial al in de GitHub-repository hieronder geplaatst.

VIND CODE hier. 

OVER MIJ 

Ik ben een laatstejaarsstudent van IIIT en volg mijn bachelor in Computer Science and Engineering. Ik hou ervan om steeds meer over Deep en Machine Learning te ontdekken en uit te proberen. Als je wilt samenwerken, kun je de onderstaande links gebruiken:

Linkedin: Klik hier

Github: Klik hier

Kaggle: Klik hier

Stuur me een bericht: [e-mail beveiligd]

Ik hoop dat je mijn artikel over beeldclassificatie met Flask leuk vond. Bedankt voor het lezen!

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt. 

Verwant

Bron: https://www.analyticsvidhya.com/blog/2022/01/develop-and-deploy-image-classifier-using-flask-part-1/