Com es pot construir la seva primera xarxa neuronal per predir els preus immobiliaris amb Keras

Una guia pas a pas per a principiants per construir la vostra primera xarxa neuronal en poques línies de codi, com un professional d’aprenentatge profund.

L’escriptura de la primera xarxa neuronal es pot fer amb només unes poques línies de codi. En aquesta publicació, explorarem com podem utilitzar un paquet anomenat Keras per construir la nostra primera xarxa neuronal per predir si els preus de les propietats estan per sobre o per sota de la mitjana. En particular, passarem per tot el canal d’aprenentatge profund, des de:

  • Navegació i processament de les dades
  • Construint i entrenant la nostra xarxa neuronal
  • Visualitzeu la pèrdua i la precisió
  • Afegint regularització a la nostra xarxa neuronal

En només 20 a 30 minuts, tindreu la vostra pròpia xarxa neuronal codificada com ho faria un professional d’aprenentatge profund.

Requisits:

Aquesta publicació suposa que heu configurat un bloc de notes Jupyter amb un entorn en el qual s’instal·len els paquets keras, tensorflow, pandas, scikit-learn i matplotlib. Si no ho heu fet, seguiu les instruccions del tutorial següent:

  • Introducció a Python per a l’aprenentatge profund i la ciència de dades

Es tracta d'un acompanyament de l'estudi intuïtiu i profund de la part 1. Per tant, suposem que teniu una comprensió intuïtiva de les xarxes neuronals i el seu funcionament, inclosos alguns detalls com l'adequació i les estratègies que s'han d'utilitzar. Si necessiteu una actualització, llegiu aquestes guies intuïtives:

  • Part d'aprenentatge profund intuïtiu 1a: Introducció a les xarxes neuronals
  • Aprenentatge profund intuïtiu, part 1b: Introducció a les xarxes neuronals

Recursos que necessitareu:

El conjunt de dades que farem servir avui s’ha adaptat a partir de les dades competitives de Zagow’s Home Value Prediction Kaggle. Hem reduït el nombre de funcions d'entrada i hem canviat la tasca per predir si el preu de l'habitatge és superior o inferior a la mitjana. Visiteu l’enllaç següent per descarregar el conjunt de dades modificat i col·loqueu-lo al mateix directori que el vostre bloc de notes. La icona de baixada hauria d’estar a l’extrem superior dret.

Baixeu el conjunt de dades

Opcionalment, també podeu descarregar un bloc de notes Jupyter anotat, que conté tot el codi d’aquesta publicació: Jupyter Notebook.

Tingueu en compte que per descarregar aquest bloc de notes de Github heu d’anar a la pàgina d’inici i descarregar ZIP per descarregar tots els fitxers:

I ara comencem!

Navegació i processament de les dades

Abans de poder codificar un algorisme ML, primer hem de portar les nostres dades al format que desitgi l'algorisme. En particular, hem de:

  • Llegiu el fitxer Valors separats per comes (CSV) i converteu-lo en matrius. Les matrius són un format de dades que el nostre algorisme pot processar.
  • Divideix el nostre conjunt de dades en funcions d’entrada (que anomenarem x) i etiqueta (que anomenarem y).
  • Escaleu les dades (anomenem això normalització) de manera que les característiques d’entrada siguin d’una magnitud similar.
  • Divideix el nostre conjunt de dades en el conjunt de formació, el de validació i el conjunt de proves. Si necessiteu una actualització del motiu pel qual necessitem aquests tres conjunts de dades, consulteu la part 1b d’aprenentatge profund intuitiu.

Comencem, doncs, Des del tutorial Introducció a Python for Deep Learning i Data Science, hauríeu d’haver descarregat el paquet pandas al vostre entorn. Hem d’indicar a la nostra llibreta que importem aquest paquet. Introduïu el codi següent i premeu la combinació de tecles Alt-Retorn:

importar pandes com a pd

Només vol dir que em refereixo al codi del paquet pandas anomenat pd. A continuació, llegim el fitxer CSV executant la següent línia de codi:

df = pd.read_csv ('housepricedata.csv')

Aquesta línia de codi significa que llegim el fitxer csv "housepricedata.csv" (que hauria d'estar al mateix directori que el vostre bloc de notes) i el desem a la variable "df". Si volem esbrinar què hi ha a df, només cal que escriviu df al quadre gris i premeu Alt-Retorn:

df

La vostra llibreta hauria de ser semblant a aquesta:

Aquí podeu explorar una mica les dades. Tenim les nostres funcions d’entrada a les deu primeres columnes:

  • Superfície del terreny (en m²)
  • Qualitat general (escala d'1 a 10)
  • Estat general (escala d'1 a 10)
  • Superfície total del soterrani (en m²)
  • Nombre de banys
  • Nombre de mig banys
  • Nombre d'habitacions sobre rasant
  • Nombre total d'habitacions sobre terra
  • Nombre de xemeneies
  • Zona de garatge (en m²)

A la nostra última columna tenim la funció que volem predir:

  • El preu de la casa és superior a la mediana o no? (1 per si i 0 per no)

Ara que hem vist l'aspecte de les nostres dades, volem convertir-les en matrius perquè la nostra màquina processi:

conjunt de dades = valors df

Per convertir el nostre marc de dades a una matriu, simplement emmagatzemem els valors de df (accedint a df.values) a la variable "conjunt de dades". Per veure què hi ha en aquesta variable "conjunt de dades", només cal que introduïu "conjunt de dades" en un quadre gris de la vostra llibreta i executeu la cel·la (Alt-Enter):

registre

Com podeu veure, ara tot s’emmagatzema en una matriu:

Convertiu el nostre marc de dades en una matriu

Ara dividim el nostre conjunt de dades en funcions d’entrada (X) i la característica que volem predir (Y). Per fer-ho, simplement assignem les primeres 10 columnes de la nostra matriu a una variable anomenada X i l’última columna de la nostra matriu a una variable anomenada Y. El codi per a la primera tasca és:

X = registre de dades [:, 0:10]

Pot semblar una mica estrany, però permeteu-me explicar què hi ha dins dels claudàtors. Tot el que hi ha abans de la coma es relaciona amb les files de la matriu i tot el que hi ha després de la coma amb les columnes de la matriu.

Com que no dividim les línies, posem ":" davant de la coma. Això significa que totes les files del conjunt de dades s'inclouran a X.

Volem extreure les primeres 10 columnes. Per tant, "0:10" després de la coma significa que les columnes 0 a 9 es col·loquen a X (la columna 10 no està inclosa). Les nostres columnes comencen amb l’índex 0, de manera que les primeres 10 columnes són realment de 0 a 9.

A continuació, assignem l’última columna de la nostra matriu a Y:

Y = registre de dades [:, 10]

D’acord, ara dividim el nostre conjunt de dades en funcions d’entrada (X) i l’etiqueta del que volem predir (Y).

El següent pas del nostre processament és assegurar-nos que l’escala de les característiques d’entrada sigui similar. Actualment, característiques com ara la superfície terrestre són de l’ordre de milers, la qualitat general es classifica entre 1 i 10 i el nombre de xemeneies sol ser de 0, 1 o 2.

Això dificulta la inicialització de la xarxa neuronal, cosa que provoca alguns problemes pràctics. Una manera d’escalar les dades és fer servir un paquet existent de scikit-learn (que hem instal·lat a la publicació "Introducció").

Primer hem d’importar el codi que volem utilitzar:

del preprocés d'importació de sklearn

Això diu que vull fer servir el codi en el processament previ del paquet sklearn. A continuació, fem servir una funció anomenada escalador mínim-màxim que escala el conjunt de dades de manera que totes les característiques d’entrada estiguin entre 0 i 1:

min_max_scaler = Preprocessament.MinMaxScaler () X_scale = min_max_scaler.fit_transform (X)

Tingueu en compte que hem escollit deliberadament 0 i 1 per ajudar a entrenar la nostra xarxa neuronal. No passarem per la teoria que hi ha al darrere. El nostre conjunt de dades a escala ara es desa a la matriu "X_scale". Si voleu veure l'aspecte de "X_scale", només cal que executeu la cel·la:

X_escala

El vostre portàtil Jupyter ara hauria de tenir un aspecte semblant a aquest:

Ara hem arribat al nostre darrer pas en el processament de les dades, que consisteix a dividir el nostre conjunt de dades en un conjunt de formació, un de validació i un conjunt de proves.

Utilitzarem el codi de scikit-learn anomenat "train_test_split" que, com el seu nom indica, divideix el nostre conjunt de dades en un conjunt d'entrenament i un conjunt de proves. Primer importarem el codi que necessitem:

des de sklearn.model_selection import train_test_split

A continuació, dividiu el vostre conjunt de dades de la següent manera:

X_train, X_val_and_test, Y_train, Y_val_and_test = train_test_split (X_scale, Y, test_size = 0.3)

Això indica a scikit-learn que la vostra mida val_and_test és el 30% del conjunt de dades. El codi emmagatzema les dades dividides a les quatre primeres variables a l'esquerra del signe igual, tal com suggereixen els noms de les variables.

Malauradament, aquesta funció només ens ajuda a dividir el nostre conjunt de dades en dues parts. Com que volem un conjunt de validació i un conjunt de proves separats, podem utilitzar la mateixa funció per tornar a dividir per a val_and_test:

X_val, X_test, Y_val, Y_test = train_test_split (X_val_and_test, Y_val_and_test, test_size = 0,5)

El codi anterior divideix la mida de val_and_test per igual en el conjunt de validació i el conjunt de proves.

En resum, ara tenim un total de sis variables per als nostres conjunts de dades que utilitzarem:

  • X_train (10 funcions d'entrada, el 70% del conjunt de dades)
  • X_val (10 funcions d'entrada, el 15% del conjunt de dades)
  • X_test (10 funcions d'entrada, el 15% del conjunt de dades)
  • Y_train (1 etiqueta, el 70% de tot el conjunt de dades)
  • Y_val (1 etiqueta, el 15% de tot el conjunt de dades)
  • Y_test (1 etiqueta, el 15% de tot el conjunt de dades)

Si voleu veure quines són les formes de les matrius per a cadascuna d'elles (és a dir, de quines dimensions són), simplement executeu-les

print (X_train.shape, X_val.shape, X_test.shape, Y_train.shape, Y_val.shape, Y_test.shape)

Així ha de ser el vostre portàtil Jupyter:

Com podeu veure, el conjunt d’entrenament conté 1022 punts de dades, mentre que el conjunt de proves i validació conté 219 punts de dades cadascun. Les variables X tenen 10 funcions d’entrada mentre que les variables Y només tenen una funció de predicció.

I ara les nostres dades ja estan llestes! Uf!

Resum: en processar les dades, tenim:

  • Llegiu el fitxer Valors separats per comes (CSV) i converteu-lo en matrius.
  • Divideix el nostre conjunt de dades en les funcions d’entrada i l’etiqueta.
  • Escaleu les dades de manera que les característiques d’entrada siguin d’una magnitud similar.
  • Divideix el nostre conjunt de dades en el conjunt de formació, el de validació i el conjunt de proves.

Construint i entrenant la nostra primera xarxa neuronal

A la part 1a d’aprenentatge profund intuïtiu, dèiem que l’aprenentatge automàtic consta de dos passos. El primer pas és proporcionar una plantilla (arquitectura) i el segon pas és trobar els millors números de les dades per emplenar aquesta plantilla. El nostre codi també seguirà aquests dos passos a partir d’ara.

Primer pas: configurar l'arquitectura

El primer que hem de fer és configurar l’arquitectura. En primer lloc, considerem quin tipus d’arquitectura de xarxes neuronals volem. Suposem que volem aquesta xarxa neuronal:

Arquitectura de xarxes neuronals que utilitzarem per al nostre problema

En paraules, volem tenir aquests nivells:

  • Nivell 1:32 neurones ocultes, activació ReLU
  • Nivell ocult 2: 32 neurones, activació ReLU
  • Capa de sortida: 1 neurona, activació sigmoide

Ara hem de descriure aquesta arquitectura a Keras. Utilitzarem el model seqüencial, el que significa que només hem de descriure les capes anteriors per ordre.

Primer importem el codi requerit de Keras:

importació de keras.models importació seqüencial de keras.layers Dense

A continuació, especifiquem que en el nostre model Keras seqüencial, segueix:

model = Seqüencial ([Dens (32, activation = 'relu', input_shape = (10,)), Dense (32, activation = 'relu'), Dense (1, activation = 'Sigmoid'),])

I això és exactament com el fragment de codi anterior va definir la nostra arquitectura. El codi anterior es pot interpretar de la següent manera:

model = Seqüencial ([...])

Això vol dir que desem el nostre model a la variable "model" i el descrivim un darrere l'altre (capa per capa) entre claudàtors.

Tight (32, activation = 'relu', input_shape = (10,)),

Tenim la nostra primera capa com una capa densa amb 32 neurones, activació ReLU i el formulari d’entrada és 10 ja que tenim 10 funcions d’entrada. Tingueu en compte que "densitat" fa referència a una capa totalment connectada que utilitzarem.

Tight (32, activation = 'relu'),

La nostra segona capa també és una capa densa amb 32 neurones, l’activació ReLU. Tingueu en compte que no cal descriure el formulari d’entrada, ja que Keras pot deduir de la sortida del nostre primer nivell.

Dens (1, activation = 'Sigmoid'),

La nostra tercera capa és una capa densa amb 1 neurona, activació sigma.

I així vam escriure la nostra arquitectura model (plantilla) en codi.

Segon pas: introduïu els millors números

Ara que hem especificat la nostra arquitectura, hem de trobar-ne els millors números. Abans de començar a entrenar, hem de configurar el model

  • Indiqueu quin algorisme voleu utilitzar per a l'optimització
  • Digueu-li quina funció de pèrdua ha d'utilitzar
  • Digueu-li quines altres mètriques voleu fer un seguiment a més de la funció de pèrdua

Per configurar el model amb aquests paràmetres, hem de trucar a la funció model.compile de la següent manera:

model.compile (optimitzador = 'sgd', pèrdua = 'binary_crossentropy', mètriques = ['precisió'])

Posem la configuració següent entre claudàtors després de model.compile:

optimitzador = 'sgd'

"Sgd" es refereix al descens de gradient estocàstic (aquí es refereix al descens de gradient de minibatch) que vam veure a la part 1b d'Intuitive Deep Learning.

loss = 'binary_crossentropy'

La funció de pèrdua de les sortides amb els valors 1 o 0 s’anomena entropia creuada binària.

mètrica = ['precisió']

Finalment, seguim la precisió a més de la funció de pèrdua. Un cop tinguem aquesta cel·la en funcionament, ja podrem fer exercici.

La formació de les dades és bastant senzilla i requereix que escrivim una línia de codi:

hist = model.fit (X_train, Y_train, batch_size = 32, epochs = 100, validation_data = (X_val, Y_val))

La funció s’anomena “ajustar” perquè adaptem els paràmetres a les dades. Hem d’especificar sobre quines dades estem entrenant, és a dir, X_train i Y_train. A continuació, establim la mida del nostre mini lot i quant de temps volem entrenar-lo (èpoques). Finalment, indiquem quines són les nostres dades de validació perquè el model ens expliqui en qualsevol moment com gestionem les dades de validació. Aquesta funció genera un historial que desem a la variable hist. Utilitzarem aquesta variable una mica més tard quan arribem a la visualització.

Ara deixeu que la cel·la funcioni i mireu com s’entrena! El vostre portàtil Jupyter hauria de tenir aquest aspecte:

Ja podeu veure que el model s’està entrenant. Si mireu els números, hauríeu de poder veure que la pèrdua disminueix i que la precisió augmenta amb el pas del temps. En aquest punt podeu experimentar amb els hiperparàmetres i l'arquitectura de xarxes neuronals. Torneu a executar les cel·les per veure com va canviar el vostre entrenament a mesura que ajustàveu els hiperparàmetres.

Tan bon punt estigueu satisfet amb el vostre model final, el podrem avaluar al conjunt de proves. Per determinar la precisió del nostre conjunt de proves, executem aquest fragment de codi:

model.evaluate (X_test, Y_test) [1]

La raó per la qual tenim l’índex 1 després de la funció model.evaluate és perquè la funció retorna la pèrdua com a primer element i la precisió com a segon element. Per obtenir la precisió, només cal que accediu al segon element (que està indexat amb 1 ja que el primer element comença a indexar-se a 0).

A causa de l'atzar en la divisió del conjunt de dades i la inicialització dels pesos, els números i els gràfics difereixen lleugerament cada vegada que s'inicia la nostra llibreta. Tanmateix, hauríeu d'obtenir una precisió de prova entre el 80% i el 95% si seguiu l'arquitectura indicada anteriorment.

Avaluació del conjunt de proves

I ja ho teniu, heu xifrat i entrenat la vostra primera xarxa neuronal. Enhorabona!

Resum: Només calia unes quantes línies de codi per codificar la nostra primera xarxa neuronal:

  • Especifiquem l'arquitectura amb el model seqüencial de Keras.
  • Definim algunes de les nostres opcions de configuració (optimitzador, funció de pèrdua, mètriques a seguir) amb model.compile
  • Formem el nostre model (trobem els millors paràmetres per a la nostra arquitectura) amb les dades de formació amb model.fit
  • Avaluem el nostre model en el conjunt de proves amb model.evaluate

Visualitzeu la pèrdua i la precisió

A la part 1b de l’aprenentatge intuïtiu en profunditat, vam parlar sobre l’adequació excessiva i algunes tècniques de regularització. Com sabem si actualment el nostre model està sent revisat?

El que podríem voler fer és traçar la pèrdua d’entrenament i la pèrdua de valor sobre el nombre d’època que ha passat. Per mostrar alguns gràfics agradables utilitzem el paquet matplotlib. Com és habitual, hem d’importar el codi que volem utilitzar:

importar matplotlib.pyplot com a plt

A continuació, volem visualitzar la pèrdua de formació i la pèrdua de validació. Per fer-ho, executeu aquest fragment de codi:

plt.plot (hist.history ['pèrdua']) plt.plot (hist.history ['val_loss']) plt.title ('pèrdua del model') plt.ylabel ('Pèrdua') plt.xlabel ('època') plt.legend (['Train', 'Val'], loc = 'Upper Right') plt.show ()

A continuació, explicarem cada línia del fragment de codi. Les dues primeres línies diuen que volem representar la pèrdua i la pèrdua de val. La tercera línia dóna el títol d'aquest diagrama, "Pèrdua del model". La quarta i la cinquena línia indiquen quines etiquetes s’han d’utilitzar per als eixos y i x. La sisena línia conté una llegenda per al nostre diagrama. La posició de la llegenda és a la part superior dreta. I la setena línia indica a Jupyter Notebook que mostri el gràfic.

El vostre portàtil Jupyter hauria de tenir un aspecte semblant a aquest:

Un gràfic de pèrdues de models que hauríeu de veure a la vostra llibreta Jupyter

Podem fer el mateix per representar la precisió de la nostra formació i la precisió de la validació amb el codi següent:

plt.plot (hist.history ['acc']) plt.plot (hist.history ['val_acc']) plt.title ('precisió del model') plt.ylabel ('precisió') plt.xlabel ('època') plt.legend (['Tren', 'Val'], loc = 'inferior dret') plt.show ()

Haureu d'obtenir un diagrama que tingui un aspecte semblant a aquest:

Gràfic de precisió del model per al conjunt d’entrenament i validació

Atès que les millores del nostre model per al conjunt de formació coincideixen en certa mesura amb les millores del conjunt de validació, l'adequació del nostre model no sembla ser un problema important.

Resum: fem servir matplotlib per visualitzar la pèrdua / precisió de la formació i la validació al llarg del temps i per determinar si hi ha un excés d’adequació al nostre model.

Afegint regularització a la nostra xarxa neuronal

Per introduir la regularització a la nostra xarxa neuronal, formulem amb una xarxa neuronal que superi malament el nostre conjunt d’entrenament. A aquest model l’anomenem 2.

model_2 = Seqüencial ([Dens (1000, activation = 'relu', input_shape = (10,)), Dense (1000, activation = 'relu'), Dense (1000, activation = 'relu'), Dense (1000, activation) = 'relu'), Dicht (1, activation = 'Sigmoid'),])
model_2.compile (optimitzador = 'Adam', pèrdua = 'binary_crossentropy', mètriques = ['precisió'])
hist_2 = model_2.fit (X_train, Y_train, batch_size = 32, epochs = 100, validation_data = (X_val, Y_val))

Aquí hem construït un model molt més gran i utilitzem l’optimitzador Adam. Adam és un dels optimitzadors més comuns que afegeix algunes optimitzacions al descens de gradient estocàstic de manera que arriba a la funció amb una pèrdua inferior més ràpida. Si executem aquest codi i dibuixem els gràfics de pèrdua per a hist_2 amb el següent codi (tingueu en compte que el codi és el mateix, tret que fem servir "hist_2" en lloc de "hist"):

plt.plot (hist_2.history ['pèrdua']) plt.plot (hist_2.history ['val_loss']) plt.title ('pèrdua del model') plt.ylabel ('Pèrdua') plt.xlabel ('època') plt.legend (['Train', 'Val'], loc = 'Upper Right') plt.show ()

Tenim un acte com aquest:

Corbes de pèrdua per a un model massa ajustat

Aquest és un clar senyal d’excés d’adequació. La pèrdua d'entrenament disminueix, però la pèrdua de validació està molt per sobre de la pèrdua d'entrenament i augmenta (després del punt d'inflexió de l'època 20). Si representem la precisió amb el codi següent:

plt.plot (hist_2.history ['acc']) plt.plot (hist_2.history ['val_acc']) plt.title ('precisió del model') plt.ylabel ('precisió') plt.xlabel ('època') plt.legend (['Tren', 'Val'], loc = 'inferior dret') plt.show ()

També podem veure una discrepància més significativa entre el tren i la precisió de la validació:

Precisió de formació i validació del nostre model d’ajust excessiu

Ara anem a provar algunes de les nostres estratègies per reduir l'adequació (a part de revertir la nostra arquitectura al nostre primer model). Recordeu que a la part 1b d’aprenentatge en profunditat intuïtiu vam introduir tres estratègies per reduir l’excés de condicionament.

Dels tres, aquí inclourem la regularització i el fracàs de L2. La raó per la qual no afegim l’aturada prematura aquí és que després d’utilitzar les dues primeres estratègies, la pèrdua de validació no pren la forma d’U que es mostra anteriorment i, per tant, l’aturada prematura no és tan eficaç.

En primer lloc, importem el codi que necessitem per a la regularització i abandonament de L2:

des de keras.layers import dropout del regularitzador d'importació de keras

A continuació, exposem el nostre tercer model així:

model_3 = Seqüencial ([densitat (1000, activació = 'relu', kernel_regularizer = regularitzadors.l2 (0,01), input_shape = (10,)), abandonament (0,3), densitat (1000, activation = 'relu', kernel_regularizer = regularitzadors.l2 (0,01)), abandonaments (0,3), densitat (1000, activació = "relu", kernel_regularizer = regularitzadors.l2 (0,01)), abandonaments (0,3), densitat (1000, activació = " relu ', kernel_regularizer = regularizers.l2 (0,01)), abandonaments (0,3), densitat (1, activació =' Sigmoid ', Kernel_regularizer = regularizers.l2 (0,01)),])

Es poden diferenciar entre el model 3 i el model 2? Hi ha dues diferències principals:

Diferència 1: per afegir regularització L2, tingueu en compte que hem afegit una mica de codi addicional a cadascuna de les nostres capes denses:

kernel_regularizer = regularizers.l2 (0,01)

Això indica a Keras que inclogui els valors quadrats d’aquests paràmetres a la nostra funció de pèrdua total i que els ponderi amb 0,01 a la funció de pèrdua.

Diferència 2: Per afegir abandonament, hem afegit una nova capa:

Abandonament (0,3),

Això significa que les neurones del canvi anterior tenen una probabilitat de 0,3 fracàs durant l'entrenament. Compilem-lo i executem-lo amb els mateixos paràmetres que el nostre Model 2 (el sobreeixit):

model_3.compile (optimitzador = 'Adam', pèrdua = 'binary_crossentropy', mètriques = ['precisió'])
hist_3 = model_3.fit (X_train, Y_train, batch_size = 32, èpoques = 100, validation_data = (X_val, Y_val))

Ara dibuixem els gràfics de pèrdues i precisió. Trobareu que la pèrdua és molt més gran al principi i això és perquè hem canviat la nostra funció de pèrdua. Per dibuixar de manera que la finestra de la pèrdua s'ampliï entre 0 i 1,2, afegim una línia de codi addicional (plt.ylim) en dibuixar:

plt.plot (hist_3.history ['pèrdua']) plt.plot (hist_3.history ['val_loss']) plt.title ('pèrdua del model') plt.ylabel ('Pèrdua') plt.xlabel ('època') plt.legend (['Train', 'Val'], loc = 'Upper Right') plt.ylim (above = 1,2, below = 0) plt.show ()

Veureu un gràfic de pèrdues que té aquest aspecte:

Podeu veure que la pèrdua de validació és molt més propera a la nostra pèrdua de formació. Representem la precisió mitjançant un fragment de codi similar:

plt.plot (hist_3.history ['acc']) plt.plot (hist_3.history ['val_acc']) plt.title ('precisió del model') plt.ylabel ('precisió') plt.xlabel ('època') plt.legend (['Tren', 'Val'], loc = 'inferior dret') plt.show ()

I aconseguirem una trama com aquesta:

En comparació amb el nostre model del model 2, hem reduït significativament l’adequació. Així doncs, apliquem les nostres tècniques de regularització per reduir la sobreequipació del conjunt d’entrenament.

Resum: per fer front a l'adequació excessiva, podem programar les següents estratègies al nostre model, cadascuna amb aproximadament una línia de codi:

  • Regularització L2
  • Sortir

Si imaginem la pèrdua i la precisió de l’entrenament / validació, podem veure que aquestes addicions van contribuir a l’adequació.

Resum consolidat:

En aquest post vam escriure el codi Python per a:

  • Examinar i processar dades
  • Construeix i forma la nostra xarxa neuronal
  • Visualitzeu la pèrdua i la precisió
  • Afegiu regularització a la nostra xarxa neuronal

Hem passat moltes coses, però no hem escrit massa línies de codi. La creació i l’entrenament de la nostra xarxa neuronal només necessitaven de 4 a 5 línies de codi, i experimentar amb diferents arquitectures de models és només una qüestió senzilla d’intercanviar en diferents nivells o canviar diferents hiperparàmetres. De fet, Keras va facilitar la construcció de les nostres xarxes neuronals i el seguirem utilitzant per a aplicacions més avançades en processament d’imatges i processament de llenguatge natural.

Que segueix? A la nostra pròxima part de codificació, explorarem com codificar les nostres xarxes neuronals convolucionals (CNN) per reconèixer imatges.

Comenceu a utilitzar CNN aquí: Intuitive Deep Learning Part 2: CNNs for Computer Vision

Sobre l'autor:

Hola, em dic Joseph! Recentment em vaig graduar a la Universitat de Stanford, on vaig treballar amb Andrew Ng al Stanford Machine Learning Group. Vull fer que els conceptes d’aprenentatge profund siguin el més intuïtius i entenedors possible per a tothom, cosa que va motivar la meva publicació: Aprenentatge profund intuïtiu.