Indholdsoversigt 
 
 
 
 
 
 Læser Keras Bygge et skridt Modeller af Keras Spare Keras modeller Checkpointing af Keras modeller Bemærk, at indtil dette punkt er der ingen omtale af Keras. Du kan opbygge dit eget API på højt niveau på toppen af Og folk har. tf.Module I dette afsnit vil du undersøge, hvordan Keras bruger En komplet brugervejledning til Keras modeller kan findes i . tf.Module Kerry vejledning Keras lag og modeller har mange flere ekstra funktioner, herunder: 
 
 
 
 
 
 Valgfrie tab Støtte til metrologi Indbygget understøttelse af et valgfrit træningsargument for at skelne mellem træning og konklusion Gem og gendannelse af python-objekter i stedet for bare black-box-funktioner get_config og from_config metoder, der giver dig mulighed for nøjagtigt at gemme konfigurationer for at tillade modelkloning i Python Disse funktioner tillader langt mere komplekse modeller gennem underklasse, såsom en brugerdefineret GAN eller en Variational AutoEncoder (VAE) model. til brug af lagre og modeller. Fuld guide Keras modeller kommer også med ekstra funktionalitet, der gør dem nemme at træne, evaluere, indlæse, gemme og endda træne på flere maskiner. Læser Keras er den grundlæggende klasse af alle Keras lag, og det arver fra . tf.keras.layers.Layer tf.Module Du kan konvertere et modul til et Keras-lag blot ved at udskifte forældremodellen og derefter ændre To af : __call__ call 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)
 Keras lagere har deres egne det gør nogle bogføring beskrevet i næste afsnit og derefter kalder Du bør ikke bemærke nogen ændringer i funktionalitet. __call__ call() simple_layer([[2.0, 2.0, 2.0]])
 <tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[1.1688161, 0.       , 0.       ]], dtype=float32)>
 Den trin build Som nævnt er det praktisk i mange tilfælde at vente på at oprette variabler, indtil du er sikker på indtastningsformen. Keras lag kommer med et ekstra livscyklus trin, der giver dig mere fleksibilitet i, hvordan du definerer dine lag. af funktion. build kaldes nøjagtigt én gang, og det kaldes med formen af input. Det bruges normalt til at skabe variabler (vægte). build Du kan genskrive De skal være fleksible i forhold til størrelsen på deres input: MyDense 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)
 På dette tidspunkt er modellen ikke bygget, så der er ingen variabler: flexible_dense.variables
 []
 Ved at kalde funktionen tildeles passende store variabler: # 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)>]
 Siden Når indtastninger kun kaldes én gang, vil de blive afvist, hvis indtastningsformen ikke er kompatibel med lagets variabler: build 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)
 Modeller af Keras Du kan definere din model som nestede Keras lag. Men Keras giver også en fuldt funktionel modelklasse kaldet Det er arvet fra Keras modeller kommer med ekstra funktionalitet, der gør dem nemme at træne, evaluere, indlæse, gemme og endda træne på flere maskiner. tf.keras.Model tf.keras.layers.Layer Du kan definere den fra oven med næsten identisk kode, igen konvertere To af Ændring af forælder: SequentialModule __call__ call() @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)
 Alle de samme funktioner er tilgængelige, herunder sporing af variabler og undermoduler. 
 
 Bemærk: En rå tf.Module indlejret i et Keras lag eller model vil ikke få sine variabler indsamlet til træning eller opbevaring. af RAW Nestede i et Keras lag eller model vil ikke få sine variabler indsamlet til træning eller opbevaring. i stedet, nest Keras lag inde i Keras lag. Note: tf.Module 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>)
 Overrejsende er en meget Pythonic tilgang til at opbygge TensorFlow modeller. Hvis du migrerer modeller fra andre rammer, kan dette være meget simpelt. tf.keras.Model Hvis du bygger modeller, der er enkle samlinger af eksisterende lag og input, kan du spare tid og plads ved at bruge , som kommer med yderligere funktioner omkring modelrekonstruktion og arkitektur. Funktionel ild Her er den samme model med det funktionelle API: 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)>
 Den største forskel her er, at indgangsformen er angivet op foran som en del af den funktionelle konstruktionsproces. argument i dette tilfælde behøver ikke at være helt angivet; du kan efterlade nogle dimensioner som . input_shape None 
 
 Bemærk!: Du behøver ikke at angive input_shape eller en InputLayer i en underklassificeret model; disse argumenter og lag ignoreres. Bemærk!: Du behøver ikke at angive input_shape eller en InputLayer i en underklassificeret model; disse argumenter og lag ignoreres. Spare Keras modeller Keras modeller har deres eget specialiserede zip arkiv opbevaring format, markeret med forlængelse. når du ringer Tilføj a udvidelse til filenavnet. For eksempel: .keras tf.keras.Model.save .keras my_sequential_model.save("exname_of_file.keras")
 Lige så nemt kan de indlæses i: reconstructed_model = tf.keras.models.load_model("exname_of_file.keras")
 Gennemgang af zip arkiver - filer – også gemme metrik, tab og optimizer tilstande. .keras Denne rekonstruerede model kan bruges og vil producere det samme resultat, når det kaldes på de samme data: 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)>
 Checkpointing af Keras modeller Keras modeller kan også tjekkes, og det vil se det samme ud som . tf.Module Der er mere at vide om opbevaring og serialisering af Keras-modeller, herunder tilvejebringelse af konfigurationsmetoder til brugerdefinerede lag til funktionsstøtte. . Guide til opsparing og serialisering Hvad er næste Hvis du vil vide mere om Keras, kan du følge de eksisterende Keras guider . Her er Et andet eksempel på et højt niveau API bygget på er Sonnet fra DeepMind, som er dækket på . tf.module Deres hjemmeside 
 
 Oprindeligt offentliggjort på TensorFlow hjemmeside, denne artikel vises her under en ny overskrift og er licenseret under CC BY 4.0. Oprindeligt offentliggjort på TensorFlow hjemmeside, denne artikel vises her under en ny overskrift og er licenseret under CC BY 4.0. Tensorflyve

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Denne lyd er produceret på historiens originalsprog!

Byg, træ og gem modeller ved hjælp af Keras og tf.Module

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Meet Tailscale: HackerNoon Company of the Week

Meet Sentry: HackerNoon Company of the Week

Meet Surfshark: HackerNoon Company of the Week

Meet KuCoin Community Chain: HackerNoon Company of the Week

Meet Tailscale: HackerNoon Company of the Week

Meet Sentry: HackerNoon Company of the Week

Meet Surfshark: HackerNoon Company of the Week

Meet KuCoin Community Chain: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps