Content მიმოხილვა
- კონტაქტი
- კონტაქტი
- ტრენინგი, შეფასება და შეფასება
- Save და serialize
- გამოიყენეთ იგივე გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული
- ყველა მოდელები a callable, ისევე როგორც layers
- გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული
- Multiple Inputs და Outputs მოდელები
- ResNet მოდელი
კონტაქტი
import numpy as np
import tensorflow as tf
from tensorflow import keras
from keras import layers
კონტაქტი
Kerasფუნქციური APIეს არის გზა შექმნას მოდელები, რომლებიც უფრო მოქნილია, ვიდრეkeras.Sequential
API. The functional API can handle models with non-linear topology, shared layers, and even multiple inputs or outputs.
ძირითადი იდეა არის, რომ Deep Learning მოდელი ჩვეულებრივ გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკულიგრაფიკები Layers.
იხილეთ შემდეგი მოდელი:
ეს არის ძირითადი გრაფიკი, რომელიც შეიცავს სამი ფართობი. ამ მოდელის შექმნა ფუნქციური API- ის გამოყენებით, დაიწყეთ ინტენსიური ღონისძიების შექმნა:
inputs = keras.Input(shape=(784,))
მონაცემთა ფორმა დააყენა 784-dimensional vector. batch ზომა ყოველთვის გამოჩნდა, რადგან მხოლოდ ფორმა თითოეული ნიმუში დააყენა.
თუ, მაგალითად, თქვენ გაქვთ სურათის ინტეგრირება, რომელიც შეიცავს(32, 32, 3)
თქვენ უნდა გამოიყენოთ:
# Just for demonstration purposes.
img_inputs = keras.Input(shape=(32, 32, 3))
ესinputs
ეს შეიცავს ინფორმაცია ფორმის დაdtype
თქვენი მოდელი შეიცავს თქვენი მოდელი. აქ არის ფორმა:
inputs.shape
TensorShape([None, 784])
აქ არის dtype:
inputs.dtype
tf.float32
You create a new node in the graph of layers by calling a layer on thisinputs
კონტაქტი :
dense = layers.Dense(64, activation="relu")
x = dense(inputs)
"Layer Call" ოპერაცია არის, როგორიცაა ატვირთვა ფურცელი "inputs" ამ ფურცელი თქვენ შექმნილია. თქვენ "დაწვრილებით" input to thedense
ლიტერატურა, და თქვენ მიიღებთx
როგორიცაა წარმოება
დაახლოებით რამდენიმე გრაფიკული გრაფიკული გრაფიკული გრაფიკული:
x = layers.Dense(64, activation="relu")(x)
outputs = layers.Dense(10)(x)
ამ დროს, თქვენ შეგიძლიათ შექმნას aModel
მას შემდეგ, რაც მისი შეტყობინებები და შეტყობინებები გრაფიკში:
model = keras.Model(inputs=inputs, outputs=outputs, name="mnist_model")
შეამოწმეთ, თუ როგორ გამოიყურება მოდელი შეტყობინება:
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)
_________________________________________________________________
თქვენ ასევე შეგიძლიათ დააყენოთ მოდელი გრაფიკით:
keras.utils.plot_model(model, "my_first_model.png")
და, optionally, ჩვენება input და output ფორმები თითოეული ფართობი გრაფიკაში:
keras.utils.plot_model(model, "my_first_model_with_shape_info.png", show_shapes=True)
ეს ფურცელი და კოდი თითქმის იგივეა. კოდი ვერსია, კავშირის ფურცელი შეიცვალა კავშირის ოპერაცია.
გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული
ტრენინგი, შეფასება და შეფასება
Training, assessment, and inference მუშაობს בדיוק იგივე გზა მოდელები შექმნილია გამოყენებით ფუნქციური API, როგორცSequential
მოდელი
ესModel
კლასის უზრუნველყოფს ინტეგრირებული სასწავლო loop (thefit()
სტრუქტურა და სტრუქტურა (the built-in evaluation loop)evaluate()
იმიტომ, რომ თქვენ შეგიძლიათ ადვილადგააუმჯობესეთ ეს loopsსასწავლო სტრატეგიების განხორციელება უფრო მეტია, ვიდრე სასწავლო სტრატეგიების განხორციელება (გ.განი) და
აქ, დატვირთეთ MNIST სურათის მონაცემები, გადაიხადეთ მათ vektors, შეესაბამება მოდელი მონაცემებს (მაგონტაქტო შესრულების მონიტორინგი validation split), შემდეგ შეფასება მოდელი ტესტი მონაცემები:
(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
დამატებითი წაიკითხვისთვის, იხილეთსასწავლო და შეფასებამიმოხილვა
Save და serialize
მოდელის შენარჩუნება და serialization მუშაობს იგივე გზა მოდელები შექმნილია გამოყენებით ფუნქციური API, როგორც ისინი მუშაობენSequential
სტანდარტული გზა ფუნქციური მოდელი გადარჩენა არის დააჭირეთmodel.save()
მას შემდეგ, რაც მოდელი არ არის ხელმისაწვდომი, მას შემდეგ, რაც მოდელი არ არის ხელმისაწვდომი, მას შემდეგ, რაც მოდელი არ არის ხელმისაწვდომი.
ეს შენახული ფაილი მოიცავს:
- მოდელი არქიტექტურა
- მოდელი წონის ღირებულებები (მაგავსეთ სასწავლო დროს)
- მოდელი ტრენინგი config, თუ არსებობს (ჩვეულებრივ კომბინირება)
- გაუმჯობესება და მისი სტრუქტურა, თუ არსებობს (სახლეთ სასწავლო, სადაც თქვენ დასრულდა)
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")
დეტალები, წაიკითხეთ მოდელისერიაფიკაცია და შენარჩუნებამიმოხილვა
გამოიყენეთ იგივე გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული
ფუნქციური API- ში, მოდელები შექმნილია მათი ინტენსიების და outputs- ის გრაფიკაში. ეს იმას ნიშნავს, რომ ერთი გრაფიკული გრაფიკული გრაფიკები შეიძლება გამოყენებულ იქნას მრავალფეროვანი მოდელები შექმნას.
შემდეგი მაგალითად, იგივე ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო:encoder
მოდელი, რომელიც გადარჩენა სურათის ინტენსიები 16-dimensional vectors, და End-to-Endautoencoder
მოდელი სასწავლო.
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)
_________________________________________________________________
აქ, decoding არქიტექტურა არის მკაცრი symmetrical to encoding არქიტექტურა, ასე რომ output ფორმა არის იგივე, როგორც input ფორმა(28, 28, 1)
.
A- ის განსხვავებაConv2D
ლიტერატურა AConv2DTranspose
A- ს და A- ს კონფიგურაციაMaxPooling2D
Layer არისUpSampling2D
layer.
ყველა მოდელები არის მოკლე, ისევე როგორც layers
თქვენ შეგიძლიათ გამოიწვიოს ნებისმიერი მოდელი, როგორც ეს იყო layer მიერ მოვუწოდოს იგი on aInput
ან სხვა ფართობი გამოცემა. მოდელი არ არის მხოლოდ აღდგენა მოდელი არქიტექტურა, თქვენ ასევე აღდგენა მისი წონა.
იმისათვის, რომ ეს გაკეთდეს, აქ არის განსხვავებული მიმოხილვა autoencoder მაგალითად, რომელიც შექმნათ encoder მოდელი, decoder მოდელი, და ქსელის მათ ორი calls მიიღოს autoencoder მოდელი:
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)
_________________________________________________________________
როგორც ხედავთ, მოდელი შეიძლება იყოს ნიმუში: მოდელი შეიძლება შეიცავდეს ქვემოთ მოდელები (როგორიცაა მოდელი, როგორც ფართობი). საერთო გამოყენების შემთხვევაში მოდელი ნიმუში არისკონტაქტიმაგალითად, აქ არის, თუ როგორ შეესაბამება კომპლექტი მოდელები ერთი მოდელი, რომელიც საშუალო მათი პროგნოზი:
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)
გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული გრაფიკული
Multiple Inputs და Outputs მოდელები
ფუნქციური API- ის საშუალებას იძლევა მრავალფეროვანი ინტენსიების და outputs- ის მონიტორინგი. ეს არ არის შესაძლებელიSequential
ამინდი
For example, if you're building a system for ranking customer issue tickets by priority and routing them to the correct department, then the model will have three inputs:
- ბილეთების სახელი (ტექსტური ინტეგრირება)
- ბილეთების ტექსტური სხეულის (ტექსტური ინტეგრირება) და
- ნებისმიერი მაგიდა, რომელიც მომხმარებლის მიერ დაამატა (კლასიკური შეტყობინება)
ეს მოდელი იქნება ორი outputs:
- Priority Score 0 და 1 (Scalar Sigmoid Output) და
- დეპარტამენტი, რომელიც უნდა გაქირავდეს ბილეთი (softmax output over the set of departments).
თქვენ შეგიძლიათ შექმნათ ეს მოდელი რამდენიმე ხაზი ერთად ფუნქციური API:
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],
)
ახლა დააყენეთ მოდელი:
keras.utils.plot_model(model, "multi_input_and_output_model.png", show_shapes=True)
ამ მოდელის კომბინაციაში, თქვენ შეგიძლიათ განსხვავებული დაკარგები თითოეული გამოცემა. თქვენ ასევე შეგიძლიათ განსხვავებული წონა თითოეული დაკარგვა - მოდული მათი შემოსავალი საერთო სასწავლო დაკარგვა.
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],
)
იმის გამო, რომ output layers აქვს სხვადასხვა სახელიები, თქვენ ასევე შეგიძლიათ დააყენოთ დაკარგულების და დაკარგულების წონა corresponding layer names:
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- ის ინტენსიების და მიზნების სიაში:
# 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>
When calling fit with a Dataset
სავარაუდოდ, ეს მოიცავს ერთ-ერთი სია, როგორც([title_data, body_data, tags_data], [priority_targets, dept_targets])
ეს არის ერთ-ერთი უამრავი სიტყვა, როგორიცაა({'title': title_data, 'body': body_data, 'tags': tags_data}, {'priority': priority_targets, 'department': dept_targets})
.
უფრო დეტალური შეტყობინებები, გთხოვთ დაუკავშირდეთსასწავლო და შეფასებამიმოხილვა
ResNet მოდელი
გარდა ამისა, რომ მოდელები აქვს მრავალფეროვანი ინტენსიები და ექსტრაქტები, ფუნქციური API- ის საშუალებას იძლევა ადვილად manipulating non-linear connectivity topologies - ეს არის მოდელები ფართები, რომლებიც არ დააკავშირირებულ სექციურად, რომელიცSequential
API cannot handle.
ჩვენ ვიყენებთ ResNet მოდელი CIFAR10, რათა აჩვენოთ ეს:
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)
__________________________________________________________________________________________________
დასაწყისში მოდელი:
keras.utils.plot_model(model, "mini_resnet.png", show_shapes=True)
ახლა ატარებთ მოდელი:
(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>
დასაწყისი გამოქვეყნდა TensorFlow ვებ-გვერდზე, ამ სტატიაში გამოქვეყნდა ახალი სატელევიზიო და ლიცენზია CC BY 4.0. კოდი ნიმუშები გამოქვეყნდა Apache 2.0 ლიცენზია.
დასაწყისი გამოქვეყნდა TensorFlow ვებ-გვერდზე, ამ სტატიაში გამოქვეყნდა ახალი სატელევიზიო და ლიცენზია CC BY 4.0. კოდი ნიმუშები გამოქვეყნდა Apache 2.0 ლიცენზია.
TensorFlow