Convolutional Neural Network-PyTorch-toteutus CIFAR-10-tietojoukossa

Tämä artikkeli julkaistiin osana Data Science Blogathon

esittely

Konvoluution hermoverkot, joita kutsutaan myös ConvNetsiksi, esittivät ensimmäisen kerran 1980 -luvulla taustalla työskennellyt tietojenkäsittelytieteen tutkija Yann LeCun. LeCun perustui japanilaisen tiedemiehen Kunihiko Fukushiman työhön, joka on kuvan tunnistamisen perusverkosto.

CNN: n vanha versio, nimeltään LeNet (LeCunin jälkeen), voi nähdä käsin kirjoitetut numerot. CNN auttaa löytämään postin PIN -koodeja. Mutta asiantuntemuksestaan ​​huolimatta ConvNets pysyi lähellä tietokonenäköä ja tekoälyä, koska heillä oli suuri ongelma: he eivät voineet skaalata paljon. CNN: t vaativat paljon dataa ja integroivat resursseja toimimaan hyvin suurille kuville.

Tuolloin tätä menetelmää sovellettiin vain matalan resoluution kuviin. Pytorch on kirjasto, joka voi suorittaa syväoppimistoimintoja. Voimme käyttää tätä konvoluution hermoverkkojen suorittamiseen. Konvoluution hermoverkot sisältävät monia kerroksia keinotekoisia neuroneja. Synteettiset neuronit, monimutkaiset biologisten vastineiden simulaatiot, ovat matemaattisia funktioita, jotka laskevat useiden tulojen ja tuotteen arvon aktivoinnin painotetun massan.

Yllä oleva kuva näyttää meille CNN-mallin, joka ottaa numeron kaltaisen kuvan 2 ja antaa meille tuloksen siitä, mikä numero näytettiin kuvassa numerona. Keskustelemme yksityiskohtaisesti, miten saamme tämän tässä artikkelissa.

CIFAR-10 on tietojoukko, joka sisältää kokoelman kuvia 10 eri luokasta. Tätä aineistoa käytetään laajalti tutkimustarkoituksiin eri koneoppimismallien testaamiseen ja erityisesti tietokoneen näköongelmiin. Tässä artikkelissa yritämme rakentaa hermoverkkomallin Pytorchia käyttäen ja testata sitä CIFAR-10-tietojoukolla tarkistaaksemme ennustustarkkuuden.

PyTorch-kirjaston tuonti 

tuoda numpy np: nä tuoda pandoja pd: nä

tuonti taskulamppu tuonti taskulamppu.nn. toimiva F -muodossa torchvision -tuontitietojoukoista, muuntuu taskulampun tuonnista nn tuonti matplotlib.pyplot kuten plt tuonti numpy np -tuonti merimies sns: nä #from tqdm.notebook tuonti tqdm tqdm -tuonnista tqdm

Tässä vaiheessa tuomme tarvittavat kirjastot. Voimme nähdä, että käytämme NumPy -ohjelmaa numeerisiin operaatioihin ja pandoja datakehysoperaatioihin. Polttimen kirjastoa käytetään Pytorchin tuontiin.

Pytorchissa on nn -komponentti, jota käytetään koneoppimistoimintojen ja -toimintojen abstraktioon. Tämä tuodaan F. Torchvision-kirjastoa käytetään, jotta voimme tuoda CIFAR-10-tietojoukon. Tässä kirjastossa on monia kuva -aineistoja ja sitä käytetään laajalti tutkimukseen. Muunnokset voidaan tuoda niin, että voimme muuttaa kuvan kokoa samankokoisiksi kaikille kuville. Tqdm: ää käytetään, jotta voimme seurata edistymistä koulutuksen aikana, ja sitä käytetään visualisointiin.

Lue tarvittava tietojoukko

trainData = pd.read_csv ('cifar-10/trainLabels.csv') trainData.head ()

Kun olemme lukeneet tietojoukon, voimme nähdä erilaisia ​​tarroja, kuten sammakko, kuorma -auto, peura, auto jne.

Tietojen analysointi PyTorchilla

print ("Pisteiden määrä:", trainData.shape [0]) print ("Ominaisuuksien lukumäärä:", trainData.shape [1]) print ("Ominaisuudet:", trainData.columns.values) print (" Ainutlaatuiset arvot ") col in trainData: print (col,": ", len (trainData [col] .unique ())) plt.figure (figsize = (12,8))

lähtö:

Pisteiden määrä: 50000 Ominaisuuksien määrä: 2 Ominaisuudet: ['id' 'label'] Ainutlaatuisten arvojen määrä: 50000 label: 10

Tässä vaiheessa analysoimme tietojoukon ja näemme, että junatiedoissamme on noin 50000 riviä tunnuksella ja niihin liittyvällä tunnisteella. Luokkia on yhteensä 10, kuten nimessä CIFAR-10.

Vahvistussarjan hakeminen PyTorchin avulla

osoitteesta torch.utils.data Import random_split val_size = 5000 train_size = len (tietojoukko) - val_size train_ds, val_ds = random_split (tietojoukko, [train_size, val_size]) len (train_ds), len (val_ds)

Tämä vaihe on sama kuin koulutusvaihe, mutta haluamme jakaa tiedot juna- ja validointisarjoihin.

(45000, 5000)

osoitteesta torch.utils.data.dataloader Tuo DataLoader batch_size = 64 train_dl = DataLoader (train_ds, batch_size, shuffle = True, num_workers = 4, pin_memory = True) val_dl = DataLoader (val_ds, batch_size, True_memers =

Torch.utilsissa on tietojen latauslaite, jonka avulla voimme ladata tarvittavat tiedot ohittamalla eri parametrit, kuten työntekijän numeron tai erän koon.

Vaadittujen toimintojen määrittäminen

@torch.no_grad () def tarkkuus (lähdöt, tarrat): _, preds = torch.max (lähdöt, himmeä = 1) return torch.tensor (torch.sum (preds == labels) .item () / len (preds )) luokka ImageClassificationBase (nn.Module): def training_step (itse, erä): kuvat, otsikot = erä = itse (kuvat) # Luo ennusteiden menetys = F.cross_entropy (ulos, tarrat) # Laske tappio accu = tarkkuus (out ) # Laske tarkkuuspaluu {'Loss': loss.detach (), 'Tarkkuus': acc} def validation_epoch_end (itse, lähdöt): batch_losses = [x ['Loss'] x tuloille] epoch_loss = torch.stack (batch_losses ) .mean () # Yhdistä häviöt batch_accs = [x ['Tarkkuus'] x tuloille] epoch_acc = torch.stack (batch_accs) .mean () # Yhdistä tarkkuuden palautus {'Loss': epoch_loss.item (), ' Tarkkuus ': epoch_acc.item ()} def epoch_end (self, epoch, result): pr int ("Epoch:", epoch + 1) print (f'Junan tarkkuus: {result ["train_accuality"]*100: .2f}% Validointitarkkuus: {result ["Tarkkuus"]*100: .2f}% ' ) print (f'Junan menetys: {result ["train_loss"]:. 4f} Validation Loss: {result ["Loss"] :. 4f} ')

Kuten näemme täällä, olemme käyttäneet ImageClassification -luokan toteutusta ja se vaatii yhden parametrin, joka on nn.Module. Tässä luokassa voimme toteuttaa erilaisia ​​toimintoja tai eri vaiheita, kuten koulutusta, validointia jne. Toiminnot ovat yksinkertaisia ​​python -toteutuksia.

Harjoitusvaihe ottaa kuvia ja tarroja erissä. käytämme ristiin entropiaa menetysfunktiolle ja laskemme tappion ja palautamme menetyksen. Tämä on samanlainen kuin vahvistusvaihe, kuten voimme nähdä toiminnossa. Aikakauden lopussa yhdistyvät tappiot ja tarkkuudet, ja lopuksi tulostamme tarkkuudet ja tappiot.

Konvoluution hermoverkkomoduulin toteutus

luokka Cifar10CnnModel (ImageClassificationBase): def __init __ (self): super () .__ init __ () self.network = nn.Sequential (nn.Conv2d (3, 32, kernel_size = 3, padding = 1), nn.ReLU (), nn.Conv2d (32, 64, ytimen_koko = 3, askel = 1, täyte = 1), nn.ReLU (), nn.MaxPool2d (2, 2), # lähtö: 64 x 16 x 16 nn.BatchNorm2d (64) , nn.Conv2d (64, 128, ytimen_koko = 3, askel = 1, täyte = 1), nn.ReLU (), nn.Conv2d (128, 128, kernel_size = 3, askel = 1, täyte = 1), nn .ReLU (), nn.MaxPool2d (2, 2), # ulostulo: 128 x 8 x 8 nn. nn.ReLU (), nn.Conv2d (128, 2, ytimen_koko = 128, askel = 256, täyte = 3), nn.ReLU (), nn.MaxPool1d (1, 2), # lähtö: 256 x 256 x 3 nn.BatchNorm1d (1), nn.Flatten (), nn.Linear (2*2*2, 256), nn.ReLU (), nn.Linear (4, 4), nn.ReLU (), nn.Linear (2, 256)) def forward (self, xb): return self.network (xb)

Tämä on tärkein osa hermoverkon toteutusta. Käytämme koko ajan taskulampusta tuomaamme nn -moduulia. Kuten voimme nähdä ensimmäisellä rivillä, Conv2d on moduuli, joka auttaa toteuttamaan konvoluution hermoverkon. Ensimmäinen parametri 3 osoittaa, että kuva on värillinen ja RGB -muodossa. Jos se olisi harmaasävyinen kuva, olisimme valinneet yhden.

32 on alkuperäisen lähtökanavan koko ja kun siirrymme seuraavaan konv2d -kerrokseen, meillä olisi tämä 32 tulokanavana ja 64 lähtökanavana.

Ensimmäisen rivin kolmatta parametria kutsutaan ytimen kooksi ja se auttaa meitä huolehtimaan käytetyistä suodattimista. Pehmustus on viimeinen parametri.

Konvoluutiotoiminto on kytketty aktivointikerrokseen ja Relu tähän. Kahden Conv2d-kerroksen jälkeen meillä on max-pooling-operaatio, jonka koko on 2 * 2. Tästä tuleva arvo on erä normalisoitu vakauden ja sisäisen kovariaattisen siirtymän välttämiseksi. Nämä toiminnot toistetaan useammalla kerroksella syventääksesi verkkoa ja pienentääksesi kokoa. Lopuksi tasoitamme kerroksen niin, että voimme rakentaa lineaarisen kerroksen, joka yhdistää arvot 10 arvoon. Näiden 10 neuronin jokaisen neuronin todennäköisyys määrittää suurimman todennäköisyyden perusteella, mihin luokkaan tietty kuva kuuluu.

Harjoittele mallia

@torch.no_grad () def arvioi (malli, datalataaja): model.eval () output = [model.validation_step (batch) for batch in data_loader] return model.validation_epoch_end (outputs) def fit (malli, juna_lataaja, val_lataaja, aikakaudet) = 10, oppimisnopeus = 0.001): best_valid = Ei mitään historiaa = [] optimoija = torch.optim.Adam (malli.parametrit (), oppimisnopeus, painon_arvo = 0.0005) ajanjaksolle (aikakaudet): # Koulutusvaiheen malli.koulutus ( ) train_losses = [] train_accuality = [] erän neliömetreinä (train_loader): tappio, accu = model.training_step (erä) train_losses.append (loss) train_accuality.append (accu) loss.backward () optimizer.step () optimoija .zero_grad () # Validointivaiheen tulos = arvioi (malli, val_loader) tulos ['train_loss'] = taskulamppu. keskiarvo (). item () malli. epoch_end (epoch, result) if (best_valid == None or best_valid

historia = sovi (malli, juna_dl, val_dl)

Tämä on perusaskel kouluttaa mallimme halutun tuloksen saamiseksi. sovitustoiminto sopii juna- ja Val -tietoihin luomamme mallin kanssa. Sovitustoiminto ottaa aluksi luettelon nimeltä historia, joka huolehtii jokaisen aikakauden iterointitiedoista. Suoritamme for -silmukan, jotta voimme toistaa jokaisen ajanjakson. Varmistamme jokaisen erän edistymisen tqdm: n avulla. Kutsumme harjoitusvaihetta, jonka olemme aiemmin toteuttaneet, ja laskemme tarkkuuden ja menetyksen. Siirry taaksepäin etenemiseen ja suorita optimoija, jonka määritimme aiemmin. Kun teemme tämän, seuraamme luetteloamme ja toiminnot auttavat meitä tulostamaan tiedot ja edistymisen.

Arviointitoiminto käyttää toisaalta eval -funktiota, ja jokaiselle vaiheelle otamme datalähteestä ladatun erän ja lähtö lasketaan. Arvo siirretään sitten aiemmin määrittämäämme validointikauden loppuun ja vastaava arvo palautetaan.

Tulosten piirtäminen

Tässä vaiheessa visualisoimme tarkkuuden kunkin aikakauden suhteen. Voimme havaita, että ajanjakson kasvaessa järjestelmän tarkkuus kasvaa jatkuvasti ja vastaavasti tappio pienenee. Punainen viiva osoittaa harjoitustietojen edistymistä ja sininen validointia varten. Voimme havaita, että tuloksissamme on ollut paljon liikaa, koska harjoitustiedot ylittävät validointituloksen ja vastaavasti menetyksen tapauksessa. Kymmenen ajanjakson jälkeen junatiedot näyttävät ohittavan 10% tarkkuuden, mutta menetys on noin 90. Testitiedot ovat noin 0.5% ja häviöt ovat lähellä 81.

def plot_accuracies (historia): Validation_accuracies = [x ['Tarkkuus'] x: lle historiassa] Training_Accuracies = [x ['train_accuality'] x: lle historiassa] plt.plot (Training_Accuracies, '-rx') plt.plot (Validation_accuracies , '-bx') plt.xlabel ('epoch') plt.ylabel ('tarkkuus') plt.legend (['Koulutus', 'Validointi']) plt.title ('Tarkkuus vs. aikakausien lukumäärä') ; plot_accuracies (historia)

def plot_losses (historia): train_losses = [x.get ('train_loss') x: lle historiassa] val_losses = [x ['Loss'] x: lle historiassa] plt.plot (train_losses, '-bx') plt.plot (val_losses, '-rx') plt.xlabel ('epoch') plt.ylabel ('loss') plt.legend (['Training', 'Validation']) plt.title ('Epoch vs. '); plot_losses (historia)

test_dataset = ImageFolder (data_dir+'/test', transform = ToTensor ()) test_loader = DeviceDataLoader (DataLoader (test_dataset, batch_size), device) tulos = arvio (final_model, test_loader) print (f'Test Tarkkuus: {result ["Precision") ]*100: .2f}%')

Testin tarkkuus: 81.07%

Voimme nähdä, että lopulta tarkkuus on 81.07%.

Johtopäätös:

Kuva: https: //unsplash.com/photos/5L0R8ZqPZHk

Tietoja minusta: Olen tutkijaopiskelija, joka on kiinnostunut syvän oppimisen ja luonnollisen kielen käsittelyn alalta ja pyrin parhaillaan valmistumaan tekoälystä.

Image Source

1. Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
2. Kuva 2: https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/

Ota rohkeasti yhteyttä minuun osoitteessa:

1.  Linkedin: https://www.linkedin.com/in/siddharth-m-426a9614a/
2.  Github: https://github.com/Siddharth1698

Tässä artikkelissa esitetyt tiedotusvälineet eivät ole Analytics Vidhyan omistuksessa ja niitä käytetään tekijän harkinnan mukaan.

liittyvä

Lähde: https://www.analyticsvidhya.com/blog/2021/09/convolutional-neural-network-pytorch-implementation-on-cifar10-dataset/