Content Overzicht 
 
 
 
 
 
 Keras Leeuwen De bouwstap Keras modellen Keras modellen redden Checkpointing van Keras modellen Merk op dat er tot op dit punt geen vermelding is van Keras. U kunt uw eigen API op hoog niveau bouwen. En mensen hebben. tf.Module In deze sectie onderzoekt u hoe Keras Een volledige gebruikersgids voor Keras-modellen is te vinden in de . tf.Module Keras gids Keras lagen en modellen hebben veel meer extra functies, waaronder: 
 
 
 
 
 
 optionele verliezen Ondersteuning voor metrics Ingebouwde ondersteuning voor een optioneel trainingsargument om onderscheid te maken tussen training en inferentie-gebruik Python-objecten opslaan en herstellen in plaats van alleen zwarte doosfuncties get_config en from_config methoden waarmee u configuraties nauwkeurig kunt opslaan om modelklonen in Python mogelijk te maken Deze functies maken het mogelijk om veel complexere modellen door middel van subklasse, zoals een aangepaste GAN of een Variational AutoEncoder (VAE) model. Voor custom layers en modellen. Volledige gids Keras-modellen zijn ook voorzien van extra functionaliteit waardoor ze gemakkelijk kunnen worden getraind, geëvalueerd, geladen, opgeslagen en zelfs getraind op meerdere machines. Keras Leeuwen is de basisklasse van alle Keras lagen, en het erft van . tf.keras.layers.Layer tf.Module U kunt een module omzetten in een Keras-laag door de ouder te vervangen en vervolgens te wijzigen Twee : __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 layers hebben hun eigen dat doet wat boekhouding beschreven in de volgende sectie en dan roept U moet geen verandering in functionaliteit opmerken. __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)>
 De Stapje build Zoals opgemerkt, is het in veel gevallen handig om te wachten op het maken van variabelen totdat u zeker bent van de invoervorm. Keras lagen worden geleverd met een extra levenscyclus stap die u meer flexibiliteit in hoe u uw lagen te definiëren. Het functioneren. build wordt precies één keer genoemd, en het wordt genoemd met de vorm van de input. build Je kunt opnieuw schrijven de bovenstaande laag om flexibel te zijn voor de grootte van de inputs: 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)
 Op dit moment is het model niet gebouwd, dus er zijn geen variabelen: flexible_dense.variables
 []
 Het oproepen van de functie toewijst variabelen van de juiste grootte: # 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)>]
 Sinds is slechts één keer geroepen, worden inputs afgewezen als de invoervorm niet compatibel is met de variabelen van de laag: 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)
 Keras modellen U kunt uw model definiëren als ingesloten Keras lagen. Keras biedt echter ook een volledig functionele modelklasse genaamd Het is geërfd van Keras modellen komen met extra functionaliteit die het gemakkelijk maakt om te trainen, evalueren, laden, opslaan en zelfs trainen op meerdere machines. tf.keras.Model tf.keras.layers.Layer Je kunt het definiëren van bovenaf met bijna identieke code, opnieuw converteren Twee Het veranderen van de ouder: 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 dezelfde functies zijn beschikbaar, inclusief het volgen van variabelen en submodules. 
 
 Opmerking: Een ruwe tf.Module ingebed in een Keras-laag of -model krijgt zijn variabelen niet verzameld voor training of opslaan. Opmerking: Een ruwe tf.Module ingebed in een Keras-laag of -model krijgt zijn variabelen niet verzameld voor training of opslaan. 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>)
 Overrijden is een zeer Pythonic benadering voor het bouwen van TensorFlow-modellen. Als u modellen van andere frameworks migreert, kan dit heel eenvoudig zijn. tf.keras.Model Als u modellen bouwt die eenvoudige assemblages zijn van bestaande lagen en inputs, kunt u tijd en ruimte besparen door de , die wordt geleverd met extra functies rond model reconstructie en architectuur. Functioneel vuur Hier is hetzelfde model met de functionele 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)>
 Het belangrijkste verschil hierin is dat de invoervorm vooraf wordt gespecificeerd als onderdeel van het functionele bouwproces. argument in dit geval hoeft niet volledig te worden gespecificeerd; u kunt enkele dimensies als . input_shape None 
 
 Opmerking: U hoeft geen input_shape of een InputLayer in een subklasse-model aan te geven; deze argumenten en lagen worden genegeerd. U hoeft niet te specificeren Of een in een subklasseerd model; deze argumenten en lagen worden genegeerd. Note: input_shape InputLayer Keras modellen redden Keras modellen hebben hun eigen gespecialiseerde zip archief opslaan formaat, gemarkeerd door de uitbreiding. bij het bellen Voeg toe a Uitbreiding van de bestandsnaam, bijvoorbeeld: .keras tf.keras.Model.save .keras my_sequential_model.save("exname_of_file.keras")
 Net zo gemakkelijk kunnen ze worden geladen in: reconstructed_model = tf.keras.models.load_model("exname_of_file.keras")
 Keras zip archieven - bestanden – ook metric, loss en optimizer-staten opslaan. .keras Dit gereconstrueerde model kan worden gebruikt en zal hetzelfde resultaat opleveren wanneer op dezelfde gegevens wordt geroepen: 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 van Keras modellen Keras modellen kunnen ook worden gecontroleerd, en dat zal er hetzelfde uitzien als . tf.Module Er is meer te weten over het opslaan en serialiseren van Keras-modellen, inclusief het verstrekken van configuratiemethoden voor aangepaste lagen voor functieondersteuning. . Gids voor besparen en serialiseren Wat is het volgende Als u meer details over Keras wilt weten, kunt u de bestaande Keras-gids volgen . hier Een ander voorbeeld van een high-level API gebouwd op is Sonnet van DeepMind, die wordt gedekt op . tf.module hun site 
 
 Oorspronkelijk gepubliceerd op de website van TensorFlow, verschijnt dit artikel hier onder een nieuwe kop en is gelicentieerd onder CC BY 4.0. Oorspronkelijk gepubliceerd op de Dit artikel verschijnt hier onder een nieuwe kop en is gelicentieerd onder CC BY 4.0. De TensorFlow De TensorFlow

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

Deze audio wordt geproduceerd in de originele taal van het verhaal!

Modellen bouwen, trainen en opslaan met Keras en tf.Module

About Author

OPMERKINGEN

LABELS

DIT ARTIKEL WERD GEPRESENTEERD IN

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps