Keras ve Birkaç Kodu Hatları ile Beyin Nasıl Oluşturulur

içerik genel bakış

• setup
• Giriş
• Eğitim, Değerlendirme ve Sonuçlama
• Kaydet ve Serialize
• Birden fazla model tanımlamak için aynı tabloyu kullanın
• Tüm modeller bir çağrılabilir, layers gibi
• karmaşık graf topolojileri
• Çeşitli Giriş ve Çıkışlı Modeller
• Resnet Oyuncak Modelleri

setup

import numpy as np
import tensorflow as tf
from tensorflow import keras
from keras import layers

Giriş

Keras HakkındaFonksiyonel APIModellerin daha esnek olmasını sağlayan bir yöntemdir.keras.SequentialFonksiyonel API, non-lineer topolojisi, paylaşılan katmanları ve hatta çoklu girişleri veya çıkışları olan modellerle başa çıkabilir.

Temel fikir, derin öğrenme modeli genellikle katmanların yönlendirilmiş aciklik grafik (DAG) olduğunu.Grafikler Layers.

Aşağıdaki modeli düşünün:

[Dense (64 ünite, relu aktivasyonu)] [Dense (64 ünite, relu aktivasyonu)] [Dense (10 ünite, softmax aktivasyonu)] (çıkış: 10 sınıf üzerinde bir olasılık dağılımının logitleri)

Bu üç katmanlı temel bir grafiktir.Bu modeli işlevsel API'yi kullanarak oluşturmak için, bir giriş düğmesi oluşturarak başlayın:

inputs = keras.Input(shape=(784,))

Verilerin şekli, 784 boyutlu bir vektör olarak ayarlanır. Her örnekin şekli belirlenirken, seri boyutu her zaman gözden kaçırılır.

Örneğin, bir görüntü girdiğinizde,(32, 32, 3)Siz de kullanırsınız:

# Just for demonstration purposes.
img_inputs = keras.Input(shape=(32, 32, 3))

veinputsdönüştürüldüğü şekli ile ilgili bilgi içerir vedtypemodelinize ileteceğiniz giriş verilerinden. şurası şekli:

inputs.shape

TensorShape([None, 784])

İşte o dType:

inputs.dtype

tf.float32

Yeni bir düğme oluşturursanız bu düzeyde bir düzey arar.inputsObjektör :

dense = layers.Dense(64, activation="relu")
x = dense(inputs)

“Layer Call” eylemi, oluşturduğunuz bu katman için “inputs”dan bir ok atmak gibidir.denselayer, ve alırsınızxTıpkı çıkış gibi.

Layers grafikine birkaç kat daha ekleyelim:

x = layers.Dense(64, activation="relu")(x)
outputs = layers.Dense(10)(x)

Bu noktada, birModelGirişleri ve çıkışları tabloya yazarak:

model = keras.Model(inputs=inputs, outputs=outputs, name="mnist_model")

Bakalım model özet nasıl görünüyor:

model.summary()

Model: "mnist_model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 784)]             0         
                                                                 
 dense (Dense)               (None, 64)                50240     
                                                                 
 dense_1 (Dense)             (None, 64)                4160      
                                                                 
 dense_2 (Dense)             (None, 10)                650       
                                                                 
=================================================================
Total params: 55050 (215.04 KB)
Trainable params: 55050 (215.04 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

Aynı zamanda şablonu grafik olarak da kullanabilirsiniz:

keras.utils.plot_model(model, "my_first_model.png")

Ve, isteğe bağlı olarak, çizilmiş grafikte her katmanın giriş ve çıkış şekillerini gösterin:

keras.utils.plot_model(model, "my_first_model_with_shape_info.png", show_shapes=True)

Bu rakam ve kod neredeyse aynıdır. kod sürümünde, bağlantı okları çağrı işlemiyle değiştirilir.

"Dil grafikleri" derin bir öğrenme modeli için sezgisel bir zihinsel görüntüdür ve fonksiyonel API bunu yakından yansıtan modeller oluşturmanın bir yoludur.

Eğitim, Değerlendirme ve Sonuçlama

Eğitim, değerlendirme ve varsayım, fonksiyonel API kullanılarak oluşturulan modeller için tam olarak aynı şekilde çalışır.Sequentialmodelleri için.

veModelKurumsal bir eğitim kursu sunuyoruz (Türkçe)fit()(İçinde bir değerlendirme çubuğu (the built-in evaluation loop)evaluate()kolaylıkla yapabileceğinize dikkat edinBu çubukları düzenleyinEğitimin ötesinde (örneğin eğitimin ötesinde)Hançer) için

Burada, MNIST görüntü verilerini yükleyin, vektörlere yeniden şekillendirin, modeli verilere (validasyon bölünmesinde performans izlerken) yerleştirin, daha sonra test verilerine göre modeli değerlendirin:

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255

model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=keras.optimizers.RMSprop(),
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

history = model.fit(x_train, y_train, batch_size=64, epochs=2, validation_split=0.2)

test_scores = model.evaluate(x_test, y_test, verbose=2)
print("Test loss:", test_scores[0])
print("Test accuracy:", test_scores[1])

Epoch 1/2
750/750 [==============================] - 4s 3ms/step - loss: 0.3556 - sparse_categorical_accuracy: 0.8971 - val_loss: 0.1962 - val_sparse_categorical_accuracy: 0.9422
Epoch 2/2
750/750 [==============================] - 2s 2ms/step - loss: 0.1612 - sparse_categorical_accuracy: 0.9527 - val_loss: 0.1461 - val_sparse_categorical_accuracy: 0.9592
313/313 - 0s - loss: 0.1492 - sparse_categorical_accuracy: 0.9556 - 463ms/epoch - 1ms/step
Test loss: 0.14915992319583893
Test accuracy: 0.9556000232696533

Daha fazla okumak için, bakınızEğitim ve değerlendirmeBir rehber.

Kaydet ve Serialize

Model kaydetme ve serializasyon, fonksiyonel API kullanılarak oluşturulan modellerde aynı şekilde çalışır.Sequentialİşlevsel bir model kaydetmenin standart yolu,model.save()Tüm modeli tek bir dosya olarak kaydetmek için. daha sonra bu dosyadan aynı modeli yeniden oluşturabilirsiniz, modeli oluşturan kodu artık kullanılamıyor olsa bile.

This saved file includes the:

• model mimarisi
• Model ağırlık değerleri (öğretim sırasında öğrendiğimiz)
• model eğitim config, varsa (kompilasyon için geçtiği gibi)
• optimizasyonu ve durumunu, eğer varsa (dışarı çıktığınız yerde eğitimini yeniden başlatmak için)

model.save("path_to_my_model.keras")
del model
# Recreate the exact same model purely from the file:
model = keras.models.load_model("path_to_my_model.keras")

Detaylar için, modelini okuyunSerializasyon ve tasarrufBir rehber.

Birden fazla model tanımlamak için aynı tabloyu kullanın

Fonksiyonel API'de, modeller, giriş ve çıkışlarını bir katman grafiğinde belirterek oluşturulur.Bu, tek bir katman grafiğinin birden fazla model oluşturmak için kullanılabileceğini ifade eder.

Aşağıdaki örnekte, aynı katman kümesini kullanarak iki modelin örneğini oluşturursunuz:encodergörüntü girişlerini 16 boyutlu vektörlere dönüştüren model veautoencoderEğitim için model.

encoder_input = keras.Input(shape=(28, 28, 1), name="img")
x = layers.Conv2D(16, 3, activation="relu")(encoder_input)
x = layers.Conv2D(32, 3, activation="relu")(x)
x = layers.MaxPooling2D(3)(x)
x = layers.Conv2D(32, 3, activation="relu")(x)
x = layers.Conv2D(16, 3, activation="relu")(x)
encoder_output = layers.GlobalMaxPooling2D()(x)

encoder = keras.Model(encoder_input, encoder_output, name="encoder")
encoder.summary()

x = layers.Reshape((4, 4, 1))(encoder_output)
x = layers.Conv2DTranspose(16, 3, activation="relu")(x)
x = layers.Conv2DTranspose(32, 3, activation="relu")(x)
x = layers.UpSampling2D(3)(x)
x = layers.Conv2DTranspose(16, 3, activation="relu")(x)
decoder_output = layers.Conv2DTranspose(1, 3, activation="relu")(x)

autoencoder = keras.Model(encoder_input, decoder_output, name="autoencoder")
autoencoder.summary()

Model: "encoder"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 img (InputLayer)            [(None, 28, 28, 1)]       0         
                                                                 
 conv2d (Conv2D)             (None, 26, 26, 16)        160       
                                                                 
 conv2d_1 (Conv2D)           (None, 24, 24, 32)        4640      
                                                                 
 max_pooling2d (MaxPooling2  (None, 8, 8, 32)          0         
 D)                                                              
                                                                 
 conv2d_2 (Conv2D)           (None, 6, 6, 32)          9248      
                                                                 
 conv2d_3 (Conv2D)           (None, 4, 4, 16)          4624      
                                                                 
 global_max_pooling2d (Glob  (None, 16)                0         
 alMaxPooling2D)                                                 
                                                                 
=================================================================
Total params: 18672 (72.94 KB)
Trainable params: 18672 (72.94 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
Model: "autoencoder"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 img (InputLayer)            [(None, 28, 28, 1)]       0         
                                                                 
 conv2d (Conv2D)             (None, 26, 26, 16)        160       
                                                                 
 conv2d_1 (Conv2D)           (None, 24, 24, 32)        4640      
                                                                 
 max_pooling2d (MaxPooling2  (None, 8, 8, 32)          0         
 D)                                                              
                                                                 
 conv2d_2 (Conv2D)           (None, 6, 6, 32)          9248      
                                                                 
 conv2d_3 (Conv2D)           (None, 4, 4, 16)          4624      
                                                                 
 global_max_pooling2d (Glob  (None, 16)                0         
 alMaxPooling2D)                                                 
                                                                 
 reshape (Reshape)           (None, 4, 4, 1)           0         
                                                                 
 conv2d_transpose (Conv2DTr  (None, 6, 6, 16)          160       
 anspose)                                                        
                                                                 
 conv2d_transpose_1 (Conv2D  (None, 8, 8, 32)          4640      
 Transpose)                                                      
                                                                 
 up_sampling2d (UpSampling2  (None, 24, 24, 32)        0         
 D)                                                              
                                                                 
 conv2d_transpose_2 (Conv2D  (None, 26, 26, 16)        4624      
 Transpose)                                                      
                                                                 
 conv2d_transpose_3 (Conv2D  (None, 28, 28, 1)         145       
 Transpose)                                                      
                                                                 
=================================================================
Total params: 28241 (110.32 KB)
Trainable params: 28241 (110.32 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

Burada, kodlama mimarisi kodlama mimarisi ile kesinlikle simetriktir, bu nedenle çıkış şekli giriş şekli ile aynıdır.(28, 28, 1).

A’nın tersiConv2Dlayer aConv2DTransposeA ve A’nın tersiMaxPooling2DLayer birUpSampling2DLayer ı

Tüm modeller çağrılabilir, tıpkı katmanlar gibi

Herhangi bir malzemeyi bir katman gibi tedavi edebilirsiniz.InputBir model çağırarak sadece model mimarisini yeniden kullanmıyorsunuz, aynı zamanda ağırlıklarını da yeniden kullanıyorsunuz.

Bunu eylemde görmek için, bir kodlayıcı modeli, bir dekodör modeli oluşturan ve otomatik kodlayıcı modeli elde etmek için iki çağrıya zincirlenen otomatik kodlayıcı örneğinin farklı bir örneğidir:

encoder_input = keras.Input(shape=(28, 28, 1), name="original_img")
x = layers.Conv2D(16, 3, activation="relu")(encoder_input)
x = layers.Conv2D(32, 3, activation="relu")(x)
x = layers.MaxPooling2D(3)(x)
x = layers.Conv2D(32, 3, activation="relu")(x)
x = layers.Conv2D(16, 3, activation="relu")(x)
encoder_output = layers.GlobalMaxPooling2D()(x)

encoder = keras.Model(encoder_input, encoder_output, name="encoder")
encoder.summary()

decoder_input = keras.Input(shape=(16,), name="encoded_img")
x = layers.Reshape((4, 4, 1))(decoder_input)
x = layers.Conv2DTranspose(16, 3, activation="relu")(x)
x = layers.Conv2DTranspose(32, 3, activation="relu")(x)
x = layers.UpSampling2D(3)(x)
x = layers.Conv2DTranspose(16, 3, activation="relu")(x)
decoder_output = layers.Conv2DTranspose(1, 3, activation="relu")(x)

decoder = keras.Model(decoder_input, decoder_output, name="decoder")
decoder.summary()

autoencoder_input = keras.Input(shape=(28, 28, 1), name="img")
encoded_img = encoder(autoencoder_input)
decoded_img = decoder(encoded_img)
autoencoder = keras.Model(autoencoder_input, decoded_img, name="autoencoder")
autoencoder.summary()

Model: "encoder"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 original_img (InputLayer)   [(None, 28, 28, 1)]       0         
                                                                 
 conv2d_4 (Conv2D)           (None, 26, 26, 16)        160       
                                                                 
 conv2d_5 (Conv2D)           (None, 24, 24, 32)        4640      
                                                                 
 max_pooling2d_1 (MaxPoolin  (None, 8, 8, 32)          0         
 g2D)                                                            
                                                                 
 conv2d_6 (Conv2D)           (None, 6, 6, 32)          9248      
                                                                 
 conv2d_7 (Conv2D)           (None, 4, 4, 16)          4624      
                                                                 
 global_max_pooling2d_1 (Gl  (None, 16)                0         
 obalMaxPooling2D)                                               
                                                                 
=================================================================
Total params: 18672 (72.94 KB)
Trainable params: 18672 (72.94 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
Model: "decoder"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 encoded_img (InputLayer)    [(None, 16)]              0         
                                                                 
 reshape_1 (Reshape)         (None, 4, 4, 1)           0         
                                                                 
 conv2d_transpose_4 (Conv2D  (None, 6, 6, 16)          160       
 Transpose)                                                      
                                                                 
 conv2d_transpose_5 (Conv2D  (None, 8, 8, 32)          4640      
 Transpose)                                                      
                                                                 
 up_sampling2d_1 (UpSamplin  (None, 24, 24, 32)        0         
 g2D)                                                            
                                                                 
 conv2d_transpose_6 (Conv2D  (None, 26, 26, 16)        4624      
 Transpose)                                                      
                                                                 
 conv2d_transpose_7 (Conv2D  (None, 28, 28, 1)         145       
 Transpose)                                                      
                                                                 
=================================================================
Total params: 9569 (37.38 KB)
Trainable params: 9569 (37.38 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
Model: "autoencoder"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 img (InputLayer)            [(None, 28, 28, 1)]       0         
                                                                 
 encoder (Functional)        (None, 16)                18672     
                                                                 
 decoder (Functional)        (None, 28, 28, 1)         9569      
                                                                 
=================================================================
Total params: 28241 (110.32 KB)
Trainable params: 28241 (110.32 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

Gördüğünüz gibi, model yuvarlanabilir: bir model alt modeller içerebilir (bir model bir katman gibi olduğu için).BirleşmeÖrneğin, bunların tahminlerini ortalamak için tek bir modelde bir dizi model nasıl birleştirilir:

def get_model():
    inputs = keras.Input(shape=(128,))
    outputs = layers.Dense(1)(inputs)
    return keras.Model(inputs, outputs)


model1 = get_model()
model2 = get_model()
model3 = get_model()

inputs = keras.Input(shape=(128,))
y1 = model1(inputs)
y2 = model2(inputs)
y3 = model3(inputs)
outputs = layers.average([y1, y2, y3])
ensemble_model = keras.Model(inputs=inputs, outputs=outputs)

karmaşık graf topolojileri

Çeşitli Giriş ve Çıkışlı Modeller

İşlevsel API, birden fazla giriş ve çıkışları kolayca manipüle etmenizi sağlar.SequentialAteş için.

Örneğin, müşteri çıkış biletlerini öncelikli olarak sıralamak ve doğru departmana yönlendirmek için bir sistem oluşturursanız, o zaman modelin üç girişi olacak:

• Bilet Adı (Tekstil İçeriği )
• Biletin metin vücudu (tekstil girdisi) ve
• Kullanıcı tarafından eklenen herhangi bir etiket (kategorik giriş)

Bu modelin iki çıkışı olacak:

• 0 ile 1 arasındaki öncelikli puan (scalar sigmoid output), ve
• Biletleri işlemek zorunda kalan departman (dış departmanlar üzerinde yumuşak maksimum çıkış).

Bu modeli işlevsel API ile birkaç çizgide oluşturabilirsiniz:

num_tags = 12  # Number of unique issue tags
num_words = 10000  # Size of vocabulary obtained when preprocessing text data
num_departments = 4  # Number of departments for predictions

title_input = keras.Input(
    shape=(None,), name="title"
)  # Variable-length sequence of ints
body_input = keras.Input(shape=(None,), name="body")  # Variable-length sequence of ints
tags_input = keras.Input(
    shape=(num_tags,), name="tags"
)  # Binary vectors of size `num_tags`

# Embed each word in the title into a 64-dimensional vector
title_features = layers.Embedding(num_words, 64)(title_input)
# Embed each word in the text into a 64-dimensional vector
body_features = layers.Embedding(num_words, 64)(body_input)

# Reduce sequence of embedded words in the title into a single 128-dimensional vector
title_features = layers.LSTM(128)(title_features)
# Reduce sequence of embedded words in the body into a single 32-dimensional vector
body_features = layers.LSTM(32)(body_features)

# Merge all available features into a single large vector via concatenation
x = layers.concatenate([title_features, body_features, tags_input])

# Stick a logistic regression for priority prediction on top of the features
priority_pred = layers.Dense(1, name="priority")(x)
# Stick a department classifier on top of the features
department_pred = layers.Dense(num_departments, name="department")(x)

# Instantiate an end-to-end model predicting both priority and department
model = keras.Model(
    inputs=[title_input, body_input, tags_input],
    outputs=[priority_pred, department_pred],
)

Şimdi modelini belirleyin:

keras.utils.plot_model(model, "multi_input_and_output_model.png", show_shapes=True)

Bu modeli oluştururken, her bir çıkışa farklı kayıplar atırabilirsiniz. Hatta her kayıp için farklı ağırlıklar atırabilirsiniz - toplam eğitim kaybına katkılarını modüle etmek için.

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[
        keras.losses.BinaryCrossentropy(from_logits=True),
        keras.losses.CategoricalCrossentropy(from_logits=True),
    ],
    loss_weights=[1.0, 0.2],
)

Çıkış katmanlarının farklı isimleri olduğu için, kayıp ve kayıp ağırlıklarını da ilgili katman isimleriyle belirleyebilirsiniz:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "priority": keras.losses.BinaryCrossentropy(from_logits=True),
        "department": keras.losses.CategoricalCrossentropy(from_logits=True),
    },
    loss_weights={"priority": 1.0, "department": 0.2},
)

NumPy giriş ve hedef aralığının listelerini geçerek modeli eğitmek:

# Dummy input data
title_data = np.random.randint(num_words, size=(1280, 10))
body_data = np.random.randint(num_words, size=(1280, 100))
tags_data = np.random.randint(2, size=(1280, num_tags)).astype("float32")

# Dummy target data
priority_targets = np.random.random(size=(1280, 1))
dept_targets = np.random.randint(2, size=(1280, num_departments))

model.fit(
    {"title": title_data, "body": body_data, "tags": tags_data},
    {"priority": priority_targets, "department": dept_targets},
    epochs=2,
    batch_size=32,
)

Epoch 1/2
40/40 [==============================] - 8s 112ms/step - loss: 1.2982 - priority_loss: 0.6991 - department_loss: 2.9958
Epoch 2/2
40/40 [==============================] - 3s 64ms/step - loss: 1.3110 - priority_loss: 0.6977 - department_loss: 3.0666
<keras.src.callbacks.History at 0x7f08d51fab80>

İstiklal namazı kılınırken,Datasetgibi bir listeye sahip olması gerekmektedir.([title_data, body_data, tags_data], [priority_targets, dept_targets])Tıpkı bir sözlük gibi({'title': title_data, 'body': body_data, 'tags': tags_data}, {'priority': priority_targets, 'department': dept_targets}).

Daha ayrıntılı bir açıklama için,Eğitim ve değerlendirmeBir rehber.

Resnet Oyuncak Modelleri

Birden fazla giriş ve çıkışlı modellerin yanı sıra, fonksiyonel API, lineer olmayan bağlantı topolojilerinin kolayca manipüle edilmesini sağlar - bunlar sıralı olarak bağlanmayan katmanlı modellerdir.SequentialAteş işe yaramaz.

Bunu göstermek için CIFAR10 için bir oyuncak ResNet modeli oluşturalım:

inputs = keras.Input(shape=(32, 32, 3), name="img")
x = layers.Conv2D(32, 3, activation="relu")(inputs)
x = layers.Conv2D(64, 3, activation="relu")(x)
block_1_output = layers.MaxPooling2D(3)(x)

x = layers.Conv2D(64, 3, activation="relu", padding="same")(block_1_output)
x = layers.Conv2D(64, 3, activation="relu", padding="same")(x)
block_2_output = layers.add([x, block_1_output])

x = layers.Conv2D(64, 3, activation="relu", padding="same")(block_2_output)
x = layers.Conv2D(64, 3, activation="relu", padding="same")(x)
block_3_output = layers.add([x, block_2_output])

x = layers.Conv2D(64, 3, activation="relu")(block_3_output)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(256, activation="relu")(x)
x = layers.Dropout(0.5)(x)
outputs = layers.Dense(10)(x)

model = keras.Model(inputs, outputs, name="toy_resnet")
model.summary()

Model: "toy_resnet"
__________________________________________________________________________________________________
 Layer (type)                Output Shape                 Param #   Connected to                  
==================================================================================================
 img (InputLayer)            [(None, 32, 32, 3)]          0         []                            
                                                                                                  
 conv2d_8 (Conv2D)           (None, 30, 30, 32)           896       ['img[0][0]']                 
                                                                                                  
 conv2d_9 (Conv2D)           (None, 28, 28, 64)           18496     ['conv2d_8[0][0]']            
                                                                                                  
 max_pooling2d_2 (MaxPoolin  (None, 9, 9, 64)             0         ['conv2d_9[0][0]']            
 g2D)                                                                                             
                                                                                                  
 conv2d_10 (Conv2D)          (None, 9, 9, 64)             36928     ['max_pooling2d_2[0][0]']     
                                                                                                  
 conv2d_11 (Conv2D)          (None, 9, 9, 64)             36928     ['conv2d_10[0][0]']           
                                                                                                  
 add (Add)                   (None, 9, 9, 64)             0         ['conv2d_11[0][0]',           
                                                                     'max_pooling2d_2[0][0]']     
                                                                                                  
 conv2d_12 (Conv2D)          (None, 9, 9, 64)             36928     ['add[0][0]']                 
                                                                                                  
 conv2d_13 (Conv2D)          (None, 9, 9, 64)             36928     ['conv2d_12[0][0]']           
                                                                                                  
 add_1 (Add)                 (None, 9, 9, 64)             0         ['conv2d_13[0][0]',           
                                                                     'add[0][0]']                 
                                                                                                  
 conv2d_14 (Conv2D)          (None, 7, 7, 64)             36928     ['add_1[0][0]']               
                                                                                                  
 global_average_pooling2d (  (None, 64)                   0         ['conv2d_14[0][0]']           
 GlobalAveragePooling2D)                                                                          
                                                                                                  
 dense_6 (Dense)             (None, 256)                  16640     ['global_average_pooling2d[0][
                                                                    0]']                          
                                                                                                  
 dropout (Dropout)           (None, 256)                  0         ['dense_6[0][0]']             
                                                                                                  
 dense_7 (Dense)             (None, 10)                   2570      ['dropout[0][0]']             
                                                                                                  
==================================================================================================
Total params: 223242 (872.04 KB)
Trainable params: 223242 (872.04 KB)
Non-trainable params: 0 (0.00 Byte)
__________________________________________________________________________________________________

Bu model için:

keras.utils.plot_model(model, "mini_resnet.png", show_shapes=True)

Şimdi modelini kullanın:

(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=keras.losses.CategoricalCrossentropy(from_logits=True),
    metrics=["acc"],
)
# We restrict the data to the first 1000 samples so as to limit execution time
# on Colab. Try to train on the entire dataset until convergence!
model.fit(x_train[:1000], y_train[:1000], batch_size=64, epochs=1, validation_split=0.2)

13/13 [==============================] - 4s 39ms/step - loss: 2.3086 - acc: 0.0988 - val_loss: 2.3020 - val_acc: 0.0850
<keras.src.callbacks.History at 0x7f078810c880>

Başlangıçta TensorFlow web sitesinde yayınlanan bu makale burada yeni bir başlık altında görünür ve CC BY 4.0 altında lisanslanmıştır.