Ukwakhiwa, Ukuqeqesha, nokugcina imodeli Usebenzisa i-Keras ne-tf.Module

Kude kakhulu; Uzofunda

Umhlahlandlela le-Keras usebenzisa ukukhiqiza izindandatho ze-Keras, ukwakha amamodeli nge-tf.keras.Model, futhi ukugcina kwabo nge-TensorFlow izixhobo ezinzima.
featured image - Ukwakhiwa, Ukuqeqesha, nokugcina imodeli Usebenzisa i-Keras ne-tf.Module
Tensor Flow - [Technical Documentation] HackerNoon profile picture
0-item

Imininingwane Overview

  • Ukuhlobisa
  • Ukwakhiwa kwe-Step
  • Izakhiwo ze-Keras
  • Ukuvikelwa Keras amamodeli
  • Ukuhlolwa kwe-Keras Models

Qaphela ukuthi kuze kube lokhu isikhathi, akukho ukuguqulwa kwe-Keras. Ungakwazi ukwakha i-API yakho ye-high-level phezulutf.ModuleFuthi abantu kukhona.

Kule isigaba, uzothola indlela Keras usebenzisatf.Module. Umhlahlandlela oluphelele we-user guide ku-Keras models ingatholakala ku-Umhlahlandlela.

I-Keras layers kanye nemodeli zihlanganisa izici eziningi ezengeziwe, kuhlanganise:

  • Izindleko optional
  • Ukusekela Metrics
  • Ukusekela ku-in-built-in for an optional training argument ukuze ukwahlukanisa phakathi kokufunda nokufunda ukusetshenziswa
  • Ukubhalisa nokuguqulwa kwezinto ze-python kunokuba kuphela izicelo ze-black-box
  • get_config kanye izindlela from_config ezivumela ukuvikela ngokunemba ngokunemba ukuze akwazi ukulungisa imodeli ku-Python

Lezi zindlela zithumela amamodeli eziningana kakhulu ngokusebenzisa i-subclassing, njenge-custom GAN noma i-Variational AutoEncoder (VAE) model.UmhlahlandlelaI-custom layers kanye nemodeli.

Amamodeli we-Keras iyatholakala nokusebenza okwengeziwe okwenza kube lula ukuqeqeshwa, ukulawula, ukulanda, ukugcina, futhi ngisho ukuqeqeshwa kumakhasimende amaningi.

Ukuhlobisa

tf.keras.layers.LayerIsigaba se-base ye-Keras layers, futhi ivela kusuka ku-tf.Module.

Ungayibhalisa i-module ku-Keras layer nje ngokubhalisa i-parent bese ukuguqulwa__call__ikhayacall:


class MyDense(tf.keras.layers.Layer):
  # Adding **kwargs to support base Keras layer arguments
  def __init__(self, in_features, out_features, **kwargs):
    super().__init__(**kwargs)

    # This will soon move to the build step; see below
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def call(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

simple_layer = MyDense(name="simple", in_features=3, out_features=3)

I-Keras layers has its own__call__Kuyinto ezinye accounting ebhalwe ku-section elandelayo futhi ke amaphuzucall(). Ufuna ukuba akufanele ukuphazamiseka umsebenzi.


simple_layer([[2.0, 2.0, 2.0]])


<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[1.1688161, 0.       , 0.       ]], dtype=float32)>

WazebuildNgena ngemvume

Njengoba kubhalwe, kulula kwezimo eziningi ukujabulela ukuvelisa izinguquko kuze kube ngempumelelo yokufaka.

Izingubo ze-Keras zihlanganisa isinyathelo se-life-cycle engaphezulu okuvumela ukunikezela ukunambitheka okwengeziwe ngokufanisa izingubo zakho. Lokhu kubhalwe ku-buildUkusebenza

buildis a name exactly once, and it is called with the shape of the input. It is usually used to create variables (izinga).

Ngaba ushiyeMyDenselayer phezulu ukuba flexible ubukhulu ingxubevange yayo:


class FlexibleDense(tf.keras.layers.Layer):
  # Note the added `**kwargs`, as Keras supports many arguments
  def __init__(self, out_features, **kwargs):
    super().__init__(**kwargs)
    self.out_features = out_features

  def build(self, input_shape):  # Create the state of the layer (weights)
    self.w = tf.Variable(
      tf.random.normal([input_shape[-1], self.out_features]), name='w')
    self.b = tf.Variable(tf.zeros([self.out_features]), name='b')

  def call(self, inputs):  # Defines the computation from inputs to outputs
    return tf.matmul(inputs, self.w) + self.b

# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)

Okwamanje, imodeli ayizakhiwa, ngakho-ke akukho izinguquko:


flexible_dense.variables


[]

Ukubalwa ifomula i-allocates ama-variables emangalisayo:


# Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))


Model results: tf.Tensor(
[[-2.531786  -5.5550847 -0.4248762]
 [-3.7976792 -8.332626  -0.6373143]], shape=(2, 3), dtype=float32)


flexible_dense.variables


[<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[-0.77719826, -1.9281565 ,  0.82326293],
        [ 0.85628736, -0.31845194,  0.10916236],
        [-1.3449821 , -0.5309338 , -1.1448634 ]], dtype=float32)>,
 <tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

ukususelabuildifayilishwe kuphela, inguqulo izikhwama ifakwe uma isakhiwo inguqulo akufanele izinguquko ze-layer:


try:
  print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
  print("Failed:", e)


Failed: Exception encountered when calling layer 'flexible_dense' (type FlexibleDense).

{ {function_node __wrapped__MatMul_device_/job:localhost/replica:0/task:0/device:CPU:0} } Matrix size-incompatible: In[0]: [1,4], In[1]: [3,3] [Op:MatMul] name: 

Call arguments received by layer 'flexible_dense' (type FlexibleDense):
  • inputs=tf.Tensor(shape=(1, 4), dtype=float32)

Izakhiwo ze-Keras

Ungahambisa imodeli yakho njengezingxubevange ze-Keras.

Nangona kunjalo, i-Keras inikeza isakhiwo se-model ephelele ebizwa ngokuthitf.keras.ModelUkulungiswa kusuka ku-tf.keras.layers.Layer, ukuze imodeli ye-Keras ingasetshenziselwa nokuhlanganiswa ngokufanayo ne-Keras layers. Amamodeli we-Keras iboniswa ne-functionality engaphezulu okwenza kube lula ukuqeqeshwa, ukubuyekeza, ukubuyekeza, futhi ngisho ukuqeqeshwa kumakhasimende amaningi.

Uyakwazi ukucacisaSequentialModuleukusuka emaphaketheni nge-coding efanayo, bese ukuguqulwa__call__ikhayacall()Ukuguqulwa kwe-parent


@keras.saving.register_keras_serializable()
class MySequentialModel(tf.keras.Model):
  def __init__(self, name=None, **kwargs):
    super().__init__(**kwargs)

    self.dense_1 = FlexibleDense(out_features=3)
    self.dense_2 = FlexibleDense(out_features=2)
  def call(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")

# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))


Model results: tf.Tensor([[ 0.26034355 16.431221  ]], shape=(1, 2), dtype=float32)

Zonke izici ezifanayo zitholakala, kuhlanganise ukucubungula ama-variables kanye nama-submodules.

Qaphela: I-tf.Module ebonakalayo ebonakalayo ngaphakathi kwe-Keras layer noma imodeli ayikwazi ukuthatha izinguquko zayo zihlanganiswe ukuze zihlanganiswe noma ukugcina. Ngaphandle kwalokho, izinguquko ze-Keras zihlanganisa ngaphakathi kwezinguquko ze-Keras.

Qaphela: I-tf.Module ebonakalayo ebonakalayo ngaphakathi kwe-Keras layer noma imodeli ayikwazi ukuthatha izinguquko zayo zihlanganiswe ukuze zihlanganiswe noma ukugcina. Ngaphandle kwalokho, izinguquko ze-Keras zihlanganisa ngaphakathi kwezinguquko ze-Keras.


my_sequential_model.variables


[<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[ 1.4749854 ,  0.16090827,  2.2669017 ],
        [ 1.6850946 ,  1.1545411 ,  0.1707306 ],
        [ 0.8753734 , -0.13549292,  0.08751986]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
 array([[-0.8022977 ,  1.9773549 ],
        [-0.76657015, -0.8485579 ],
        [ 1.6919082 ,  0.49000967]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]


my_sequential_model.submodules


(<__main__.FlexibleDense at 0x7f790c7e0e80>,
 <__main__.FlexibleDense at 0x7f790c7e6940>)

Ukuhlobisatf.keras.Modelis a very Pythonic approach to building TensorFlow models. Uma ungahambisa amamodeli evela ku-frameworks, lokhu kungenziwa kulula kakhulu.

Uma uye ukwakha amamodeli okuzenzakalelayo ama-assemblies ye-layers kanye nama-inputs eyenziwe, ungakwazi ukucubungula isikhathi futhi indawo ngokusetshenziswa kwe-DigitalIphrofayili, okuyinto kuhlanganisa izici ezengeziwe ezivela ku-model reconstruction kanye ne-architecture.

Ngiyazi i-model efanayo ne-API yokusebenza:


inputs = tf.keras.Input(shape=[3,])

x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)

my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)

my_functional_model.summary()


Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 3)]               0         
                                                                 
 flexible_dense_3 (Flexible  (None, 3)                 12        
 Dense)                                                          
                                                                 
 flexible_dense_4 (Flexible  (None, 2)                 8         
 Dense)                                                          
                                                                 
=================================================================
Total params: 20 (80.00 Byte)
Trainable params: 20 (80.00 Byte)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________


my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))


<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[3.4276495, 2.937252 ]], dtype=float32)>

Umbala wesikhulu lapha kuyinto ukuthi umbala wokufaka ufakwe ngaphambi njengesikhathi se-functional construction process. Theinput_shapeinguqulo kulesi kungekho kufuneka zihlanganiswe ngokuphelele; ungahambisa ezinye izigaba njengobaNone.

Qaphela: Unemibuzo ye-input_shape noma i-InputLayer ku-model e-subclassed, ama-arguments kanye nama-layers ahlabayo.

Qaphela: Unemibuzo ye-input_shape noma i-InputLayer ku-model e-subclassed, ama-arguments kanye nama-layers ahlabayo.

Ukuvikelwa Keras amamodeli

I-Keras models has its own specialized zip archive saving format, eyenziwe ngu:.kerasekupheleni. Xa ushiyetf.keras.Model.saveThumela A.kerasisixazululo se-filename. Ngokwesibonelo:


my_sequential_model.save("exname_of_file.keras")

Ngaphezu kwalokho, kungenziwa ngokushesha ku:


reconstructed_model = tf.keras.models.load_model("exname_of_file.keras")

Izixhobo zeZip -.kerasamafayela - futhi ukugcina izimo ze-metric, i-loss, ne-optimizer.

Uhlobo le-reconstructed ingasetshenziswa futhi uzothola imiphumela efanayo uma usebenzisa idatha efanayo:


reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))


<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[ 0.26034355, 16.431221  ]], dtype=float32)>

Ukuhlolwa kwe-Keras Models

Keras amamodeli futhi kungenziwa checkpointed, futhi kuya kubona efanayotf.Module.

Kuhlolwe kulungile ku-Save and serialization ye-Keras models, kuhlanganise ukunikela izindlela zokufaka izindandatho ze-custom layers yokusekela izici.Umhlahlandlela we-Save and Serialization.

Yini elandelayo

Uma ufuna ukwazi okwengeziwe mayelana ne-Keras, ungakwazi ukuqondisa izifundo ze-Keras ezivamileNgiya.

Olunye isibonelo ye-API ephezulu eyenziwetf.moduleis Sonnet kusukela DeepMind, okuyinto ifakwe kuSite Yakho.


Okwakhiwa kwebhizinisi le-TensorFlow, le ncwadi ifumaneke lapha ngaphansi kwebhizinisi elisha futhi isetshenziswe ngaphansi kwe-CC BY 4.0. Isampula se-codes ifakwe ngaphansi kwe-Apache 2.0 License.

Okwakhiwa kwebhizinisi le-TensorFlow, le ncwadi ifumaneke lapha ngaphansi kwebhizinisi elisha futhi isetshenziswe ngaphansi kwe-CC BY 4.0. Isampula se-codes ifakwe ngaphansi kwe-Apache 2.0 License.

Ukuhlobisa


Trending Topics

blockchaincryptocurrencyhackernoon-top-storyprogrammingsoftware-developmenttechnologystartuphackernoon-booksBitcoinbooks