څنګه د Keras او د کوډ د ځينو کرښه سره د دماغ جوړ کړئ

ډېر اوږد؛ لوستل

دا لارښود تاسو ته د ګرځنده عمیق زده کړې ماډلونه جوړولو لپاره د Keras فابریکه API کارولو سره راځي، په شمول روزنې، ارزیابی، ذخیره کولو او پرمختللي گراف ډیزاینونه.
featured image - څنګه د Keras او د کوډ د ځينو کرښه سره د دماغ جوړ کړئ
Tensor Flow - [Technical Documentation] HackerNoon profile picture
0-item

د موادو په څیر

  • د جوړولو
  • د نندارتون
  • د روزنې، 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.SequentialAPI. د فعالیت 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 ته "پړاو" کويdenselayer، او تاسو ترلاسه کړئ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د لویدیځ، او د لویدیځ AMaxPooling2Dlayer ده یو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 په تماس کېDatasetObject، دا باید د لیستونو په څیر یو 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


Trending Topics

blockchaincryptocurrencyhackernoon-top-storyprogrammingsoftware-developmenttechnologystartuphackernoon-booksBitcoinbooks