د موادو په څیر
- د جوړولو
- د نندارتون
- د روزنې، evaluating او inference
- Save او serialize
- د ډیری ماډلونه تنظیمولو لپاره د کټګوریو په ورته ګراف استعمال کړئ
- ټول ماډلونه د Callable، لکه layers
- د پیچلي graph topologies manipulate
- د څو inputs او outputs سره ماډلونه
- د Toy ResNet نمونوي
د جوړولو
import numpy as np
import tensorflow as tf
from tensorflow import keras
from keras import layers
د نندارتون
د کیرید API کارولدا یو لاره ده چې د ماډلونو جوړ کړي چې ډیر انعطاف دي دkeras.Sequential
API. د فعالیت API کولای شي د غیر لاینر تپولوژۍ، مشترکه کټګورۍ، او حتی د ډیرو انټروټونه او یا صادراتو سره ماډلونه ترسره کړي.
اصلي مفهوم دا دی چې د عمیق زده کړې ماډل معمولا د کټګورۍ په مستقیمه توګه acyclic graph (DAG) دی. نو د فعالیت API د جوړولو یوه لاره دهGraphs د layers.
د لاندې نمونوي په اړه فکر وکړئ:
[Dense (64 واحدونه، relu فعاليت)] [Dense (64 واحدونه، relu فعاليت)] [Dense (10 واحدونه، softmax فعاليت)] (تولید: د 10 ټولګي کې د احتمالي توزیع لګټونه)
دا د درې کچې سره یو بنسټیز ګراف دی. د دې ماډل جوړولو لپاره د فعالیت API په کارولو سره، د input node جوړولو سره پیل کړئ:
inputs = keras.Input(shape=(784,))
د معلوماتو شکل د 784-dimensional وکتور په توګه تنظیم شوی دی. د بیلګې اندازه تل له دې امله چې یوازې د هر نمونه په شکل کې مشخص شوی دی.
که، د مثال په توګه، که تاسو د انځور سره یو شکل(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
تاسو د کټګورۍ د کټګورۍ کې د نوي نان جوړ کړئ د دې په کټګورۍ کې د کټګورۍ په تماس کېinputs
د موضوع:
dense = layers.Dense(64, activation="relu")
x = dense(inputs)
د "Layer Call" عمل دی لکه د "Inputs" څخه د دې کچه چې تاسو جوړ کړ. تاسو د Inputs ته "پړاو" کويdense
layer، او تاسو ترلاسه کړئx
لکه څنګه چې د محصول
موږ به د کټګورۍ د کټګورۍ په ګراف کې ځینې کټګورۍ اضافه کړئ:
x = layers.Dense(64, activation="relu")(x)
outputs = layers.Dense(10)(x)
په دې وخت کې، تاسو کولی شئ دModel
له خوا په کچه د ګراف کې د انستونو او انستونو ځانګړتیاوې:
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")
او، په اختیاري توګه، د هر کچه د وارداتو او صادرولو شکلونه په ګراف کې نندارې:
keras.utils.plot_model(model, "my_first_model_with_shape_info.png", show_shapes=True)
دا انځور او کوډ تقریبا ورته دي. په کوډ نسخه کې، د اړیکو پټونه د تماس عملیاتو لخوا بدل شوي دي.
د "گراف کچه" د عمیق زده کړې ماډل لپاره یو حساس ذهني انځور دی، او د عامه API د ماډل جوړولو یوه لاره ده چې د دې په اوږدو کې ښکاره کوي.
د روزنې، ارزیابی، او inference
د روزنې، evaluating، او inference په بشپړه توګه په ورته ډول کار کوي د ماډلونو په کارولو سره د فعالیت API جوړSequential
د نمونوي
دModel
د کلاس د جوړ شوي روزنې چڼاسکه وړاندې کوي (دfit()
method) او د جوړ شوي evaluation loop (دevaluate()
روش). یاد وکړئ چې تاسو کولی شئ په اسانۍ سرهد دې لوپونو customizeد څیړنې روزنې روزنې د څیړنې څیړنې څخه نور (د مثال په توګه.ژانرهمدارنګه
دلته، د MNIST انځور ډاټا لوډ کړئ، دا په ویټورونو کې جوړ کړئ، د نمونوي په ډاټا کې شامل کړئ (په داسې حال کې چې د تصدیق تقسیم کې د کړنو څارنه کوي)، بیا د نمونوي په ازموینې ډاټا کې ارزیابی کړئ:
(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، که څه هم (چون چې د کمپیوټر ته انتقال شوي)
- optimizer او د دې حالت، که څه هم (د روزنې د دوبلو پیل چې تاسو بند)
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")
د تفصيلاتو لپاره، د نمونوي وګورئserialization & سپارښتنهد لارښود
د ډیری ماډلونه تنظیمولو لپاره د کټګوریو په ورته ګراف استعمال کړئ
په فعال API کې، ماډلونه د ګرامرونو په ګرامر کې د دوی د وارداتو او صادراتو ځانګړنې له لارې جوړ شوي دي. دا معنی لري چې د ګرامرونو یوه ګرامر کولی شي د څو ماډلونه جوړولو لپاره کارول شي.
په لاندې مثال کې، تاسو د دوو ماډلونو په انټرنټ کولو لپاره ورته کټګوریو کاروي:encoder
د نمونوي چې د انځور د وارداتو په 16dimensional وکتورونه بدلوي، اوautoencoder
د روزنې د نمونوي.
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)
_________________________________________________________________
Here, the decoding architecture is strictly symmetrical to the encoding architecture, so the output shape is the same as the input shape (28, 28, 1)
.
د A مخکښConv2D
layer is a Conv2DTranspose
د لویدیځ، او د لویدیځ AMaxPooling2D
layer ده یوUpSampling2D
د لیور
ټول ماډلونه د صداقت وړ دي، لکه څنګه چې layers
تاسو کولی شئ د هر ماډل په توګه د یو کټګورۍ په توګه درملنه ونیسئ.Input
یا د بل کچه د محصول پرته. د يو ماډل په تماس کې تاسو نه یوازې د ماډل آرکټیکټریټ دوبله وکاروي، تاسو هم د هغه وزنونه دوبله وکاروي.
د دې په عمل کې وګورئ، دلته د اتوماتیکډر مثال په مختلفو توګه وګورئ چې د اتوماتیکډر ماډل، د ډکډر ماډل جوړوي، او د اتوماتیکډر ماډل ترلاسه کولو لپاره دوی په دوو تماسونو کې چټکوي:
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)
_________________________________________________________________
لکه څنګه چې تاسو کولی شئ وګورئ، د ماډل کولی شي نښلول شي: د ماډل کولی شي د زیرموډلونه لري (چې د ماډل د layer په څیر دی). د ماډل نښلول لپاره یو عام کارونه دهد مجموعې. For example, here's how to ensemble a set of models into a single model that averages their predictions:
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)
د پیچلي graph topologies manipulate
د څو inputs او outputs سره ماډلونه
د فعالیت API په اسانۍ سره د ډیرو انډولونو او انډولونو په کارولو سره مرسته کوي. دا دSequential
د آتشې
د مثال په توګه، که تاسو د مشتریانو د نندارتون ټکټونو د ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو ترټولو
- د ټکټ نوم (کتاب داخل)
- د ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ ټکټ
- any tags added by the user (categorical input)
دا ماډل به د دوو پایلو لري:
- د 0 او 1 (scalar sigmoid output)، او
- د وزارت چې باید د ټکټ په کارولو (softmax د برخو په اړه د محصول).
تاسو کولی شئ د دې ماډل سره د فعالیت 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],
)
لکه څنګه چې د صادراتو کچه د مختلفو نومونه لري، تاسو کولی شئ د کڅوړې او کڅوړې وزنونه د اړونده کڅوړې نومونو سره هم مشخص کړئ:
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>
کله چې د A سره د FIT په تماس کېDataset
Object، دا باید د لیستونو په څیر یو tuple تولید کړي لکه([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})
.
د تفصيلاتو لپاره، دد روزنې او ارزیابید لارښود
د Toy ResNet نمونوي
د ډیری انډولونو او صادراتو سره د ماډلونو سربیره، د فعالیت API په اسانۍ سره د غیر لاینری کنکشن ټاپولوژونو په کارولو سره آسانوي - دا ماډلونه دي چې کټګوریو نه لري چې sequentially سره اړیکه ونیسئ، چې دSequential
API cannot handle.
د دې لپاره یو عمده کارونه شتونونه شتونونه دي. د CIFAR10 لپاره د Toy ResNet ماډل جوړ کړئ ترڅو دا ډیزاین کړئ:
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