Content overview 
 
 
 
 
 
 
 
 Establiment Mòduls TensorFlow Construcció de mòduls A l'espera de crear variables Estalvi de pes Funcions d'estalvi Creació d'un model salvatge Per fer l'aprenentatge automàtic a TensorFlow, és probable que necessiti definir, guardar i restaurar un model. Un model és, de manera abstracta: 
 
 
 Una funció que calcula alguna cosa en els tensors (un passatge cap endavant) Algunes variables que es poden actualitzar en resposta a la formació En aquesta guia, aniràs per sota de la superfície de Keras per veure com es defineixen els models de TensorFlow. Establiment import tensorflow as tf
import keras
from datetime import datetime

%load_ext tensorboard
 2023-10-18 01:21:05.536666: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2023-10-18 01:21:05.536712: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2023-10-18 01:21:05.536766: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
 Mòduls TensorFlow La majoria dels models estan fets de capes. Les capes són funcions amb una estructura matemàtica coneguda que es pot reutilitzar i que tenen variables entrenables. , es construeixen sobre la mateixa classe fundacional: . Sonet tf.Module Construcció de mòduls Aquí teniu un exemple molt senzill que funciona en un tensor escalar: tf.Module class SimpleModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)
    self.a_variable = tf.Variable(5.0, name="train_me")
    self.non_trainable_variable = tf.Variable(5.0, trainable=False, name="do_not_train_me")
  def __call__(self, x):
    return self.a_variable * x + self.non_trainable_variable

simple_module = SimpleModule(name="simple")

simple_module(tf.constant(5.0))
 2023-10-18 01:21:08.181350: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2211] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...
<tf.Tensor: shape=(), dtype=float32, numpy=30.0>
 Els mòduls i, per extensió, les capes són terminologies d'aprenentatge profund per a "objectes": tenen estats interns i mètodes que utilitzen aquest estat. No hi ha res especial sobre A més d’actuar com a Podeu invocar els vostres models amb les funcions que vulgueu. __call__ Python trucada Podeu configurar la capacitat d'aprenentatge de les variables per qualsevol motiu, incloent-hi la congelació de les capes i les variables durant l'ajust. 
 
 Nota: tf.Module és la classe base tant per a tf.keras.layers.Layer com per a tf.keras.Model, de manera que tot el que trobeu aquí també s'aplica a Keras. Per raons de compatibilitat històrica, les capes de Keras no recullen variables dels mòduls, de manera que els vostres models només han d'utilitzar mòduls o només capes de Keras.   És la classe de base per a tots dos i , així que tot el que trobeu aquí també s'aplica a Keras. Per raons de compatibilitat històrica, les capes de Keras no recullen variables dels mòduls, de manera que els vostres models només han d'utilitzar mòduls o només capes de Keras. Note: tf.Module tf.keras.layers.Layer tf.keras.Model Subclassificació Qualsevol o Les instàncies assignades a les propietats d'aquest objecte es recullen automàticament. Això li permet guardar i carregar variables, i també crear col·leccions de El s. tf.Module tf.Variable tf.Module tf.Module # All trainable variables
print("trainable variables:", simple_module.trainable_variables)
# Every variable
print("all variables:", simple_module.variables)
 trainable variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>,)
all variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>, <tf.Variable 'do_not_train_me:0' shape=() dtype=float32, numpy=5.0>)
 Aquest és un exemple d'un model de capa lineal de dues capes fet de mòduls. Primer una capa densa (lineal): class Dense(tf.Module):
  def __init__(self, in_features, out_features, name=None):
    super().__init__(name=name)
    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)
 I després el model complet, que fa dues instàncies de capes i les aplica: class SequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model!
my_model = SequentialModule(name="the_model")

# Call it, with random results
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
 Model results: tf.Tensor([[0.       3.415034]], shape=(1, 2), dtype=float32)
 Les dades es recullen automàticament, recurrentment, en qualsevol o d’aquest sistema, permet gestionar les col·leccions de s amb una sola instància de model, i guardar i carregar models sencers. tf.Module tf.Variable tf.Module tf.Module print("Submodules:", my_model.submodules)
 Submodules: (<__main__.Dense object at 0x7f7931aea250>, <__main__.Dense object at 0x7f77ed5b8a00>)
 for var in my_model.variables:
  print(var, "\n")
 <tf.Variable 'b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 3) dtype=float32, numpy=
array([[-2.8161757, -2.6065955,  1.9061812],
       [-0.9430401, -0.4624743, -0.4531979],
       [-1.3428234,  0.7062293,  0.7874674]], dtype=float32)> 

<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=
array([[ 1.0474309 , -0.6920227 ],
       [ 1.2405277 ,  0.36411622],
       [-1.6990206 ,  0.762131  ]], dtype=float32)>
 A l'espera de crear variables Potser heu notat aquí que heu de definir tant les dimensions d'entrada com de sortida a la capa. La variable té una forma coneguda i es pot assignar. w En posposar la creació de variables a la primera vegada que es crida el mòdul amb una forma d'entrada específica, no cal especificar la mida d'entrada cap endavant. class FlexibleDenseModule(tf.Module):
  # Note: No need for `in_features`
  def __init__(self, out_features, name=None):
    super().__init__(name=name)
    self.is_built = False
    self.out_features = out_features

  def __call__(self, x):
    # Create variables on first call.
    if not self.is_built:
      self.w = tf.Variable(
        tf.random.normal([x.shape[-1], self.out_features]), name='w')
      self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
      self.is_built = True

    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)
 # Used in a module
class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = FlexibleDenseModule(out_features=3)
    self.dense_2 = FlexibleDenseModule(out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

my_model = MySequentialModule(name="the_model")
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
 Model results: tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
 Aquesta flexibilitat és la raó per la qual les capes de TensorFlow sovint només necessiten especificar la forma de les seves sortides, com en , en comptes de la mida d'entrada i de sortida. tf.keras.layers.Dense Estalvi de pes Es pot salvar a Ambdós a i a . tf.Module Checkpoint SalvatgeModel Els punts de control són només els pesos (és a dir, els valors del conjunt de variables dins del mòdul i els seus submòduls): chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
 'my_checkpoint'
 Els punts de control consisteixen en dos tipus de fitxers: les dades mateixes i un fitxer d'índex per a les metadades. El fitxer d'índex manté el seguiment del que realment s'està guardant i la numeració dels punts de control, mentre que les dades del punt de control contenen els valors variables i els seus camins de cerca d'atributs. ls my_checkpoint*
 my_checkpoint.data-00000-of-00001  my_checkpoint.index
 Podeu mirar dins d'un punt de control per assegurar-vos que tota la col·lecció de variables està guardada, ordenada per l'objecte de Python que els conté. tf.train.list_variables(chkp_path)
 [('_CHECKPOINTABLE_OBJECT_GRAPH', []),
 ('model/dense_1/b/.ATTRIBUTES/VARIABLE_VALUE', [3]),
 ('model/dense_1/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 3]),
 ('model/dense_2/b/.ATTRIBUTES/VARIABLE_VALUE', [2]),
 ('model/dense_2/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 2])]
 Durant l'entrenament distribuït (multi-màquina) poden ser trencats, per la qual cosa estan numerats (per exemple, '00000-de-00001'). Quan torneu a carregar models, sobreescriureu els valors en el vostre objecte de Python. new_model = MySequentialModule()
new_checkpoint = tf.train.Checkpoint(model=new_model)
new_checkpoint.restore("my_checkpoint")

# Should be the same result as above
new_model(tf.constant([[2.0, 2.0, 2.0]]))
 <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[0., 0.]], dtype=float32)>
 
 
 Nota: Com que els punts de control són el cor dels llargs fluxos de treball d'entrenament, consulteu.checkpoint.CheckpointManager és una classe d'ajuda que fa que la gestió dels punts de control sigui molt més fàcil. Com que els punts de control són el cor dels llargs fluxos de treball de formació és una classe d'ajuda que fa que la gestió de punts de control sigui molt més fàcil. Per a més detalls. Note: tf.checkpoint.CheckpointManager Guia de control de punts d'entrenament Guia de control de punts d'entrenament Funcions d'estalvi TensorFlow pot executar models sense els objectes originals de Python, com demostra i , fins i tot quan descarregueu un model format des de TensorFlow Serving TensorFlow Lite TensorFlow Hub. TensorFlow necessita saber com fer els càlculs descrits en Python, però Per fer-ho, es pot fer un El que es descriu en el . without the original code graph Introducció als gràfics i funcions Aquest gràfic conté operacions, o Això és el que realitza la funció. OPS Podeu definir un gràfic en el model anterior afegint el decoratori per indicar que aquest codi s'ha d'executar com un gràfic. @tf.function class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  @tf.function
  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model with a graph!
my_model = MySequentialModule(name="the_model")
 El mòdul que heu creat funciona exactament igual que abans. Cada signatura única passada a la funció crea un gràfic separat. Per a detalls. Introducció als gràfics i funcions print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
 tf.Tensor([[0.31593648 0.        ]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0.31593648 0.        ]
  [0.31593648 0.        ]]], shape=(1, 2, 2), dtype=float32)
 Podeu visualitzar el gràfic rastrejant-lo dins d'un resum de TensorBoard. # Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = "logs/func/%s" % stamp
writer = tf.summary.create_file_writer(logdir)

# Create a new model to get a fresh trace
# Otherwise the summary will not see the graph.
new_model = MySequentialModule()

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True)
tf.profiler.experimental.start(logdir)
# Call only one tf.function when tracing.
z = print(new_model(tf.constant([[2.0, 2.0, 2.0]])))
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)
 tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
 Llançar TensorBoard per veure la pista resultant: #docs_infra: no_execute
%tensorboard --logdir logs/func
 Creació a SavedModel La manera recomanada de compartir models completament entrenats és utilitzar . el Conté tant una col·lecció de funcions com una col·lecció de pesos. SavedModel SavedModel Podeu guardar el model que acabeu d'entrenar de la següent manera: tf.saved_model.save(my_model, "the_saved_model")
 INFO:tensorflow:Assets written to: the_saved_model/assets
 # Inspect the SavedModel in the directory
ls -l the_saved_model
 total 32
drwxr-sr-x 2 kbuilder kokoro  4096 Oct 18 01:21 assets
-rw-rw-r-- 1 kbuilder kokoro    58 Oct 18 01:21 fingerprint.pb
-rw-rw-r-- 1 kbuilder kokoro 17704 Oct 18 01:21 saved_model.pb
drwxr-sr-x 2 kbuilder kokoro  4096 Oct 18 01:21 variables
 # The variables/ directory contains a checkpoint of the variables
ls -l the_saved_model/variables
 total 8
-rw-rw-r-- 1 kbuilder kokoro 490 Oct 18 01:21 variables.data-00000-of-00001
-rw-rw-r-- 1 kbuilder kokoro 356 Oct 18 01:21 variables.index
 El El fitxer és a Descriure el funcionament . saved_model.pb Protocol de buffer tf.Graph Això és desitjable en situacions en què no teniu (o voleu) un interpretador de Python, com servir a escala o en un dispositiu de vora, o en situacions en què el codi original de Python no està disponible o pràctic per utilitzar. Podeu carregar el model com a nou objecte: new_model = tf.saved_model.load("the_saved_model")
 , creat per carregar un model guardat, és un objecte d'usuari intern de TensorFlow sense cap coneixement de classe. . new_model SequentialModule isinstance(new_model, SequentialModule)
 False
 Aquest nou model funciona amb les signatures d'entrada ja definides. No podeu afegir més signatures a un model restaurat d'aquesta manera. print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
 tf.Tensor([[0.31593648 0.        ]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0.31593648 0.        ]
  [0.31593648 0.        ]]], shape=(1, 2, 2), dtype=float32)
 Així, utilitzant , és possible guardar pesos i gràfics de TensorFlow utilitzant I després tornar a carregar-los. SavedModel tf.Module 
 
 Originalment publicat al lloc web de TensorFlow, aquest article apareix aquí sota un nou títol i està llicenciat sota CC BY 4.0. Originalment publicat al lloc web de TensorFlow, aquest article apareix aquí sota un nou títol i està llicenciat sota CC BY 4.0. TensorFlow

Aquest àudio és produït a l'idioma original de la història!

Massa Llarg; Per llegir

Make resilience your competitive advantage

Com definir, guardar i restaurar models en TensorFlow

About Author

COMENTARIS

Etiquetes penjant

AQUEST ARTICLE VA SER PRESENTAT A

Related Stories

Startups of The Year: Meet the Healthcare Industry

Startups of The Year: Meet the Programming Industry

Startups of The Year: Meet the Web3 Industry

The Jewel Robbery at the Grand Metropolitan

Startups of The Year: Meet the Healthcare Industry

Startups of The Year: Meet the Programming Industry

Startups of The Year: Meet the Web3 Industry

The Jewel Robbery at the Grand Metropolitan

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps