የ Keras fit() ይጠበቃል እና የእርስዎን ሞዴል እርስዎ መንገድ ያግኙ

አጠቃላይ ግምገማ አግኙን አግኙን የመጀመሪያው ቀላል ምሳሌ ዝቅተኛ ደረጃ የ sample_weight እና class_weight አጠቃቀም የእርስዎን ግምገማ ደረጃ ለማረጋገጥ አግኙን: አንድ End-to-End GAN ለምሳሌ አግኙን አንተ የፈጠራ መግቢያ መጠቀም ይችላሉ. ሁሉም ነገር ቀላል ይሰራል. fit() እርስዎ የእርስዎን የእርስዎን ስልጠና መስኮት ከታች መጻፍ አለብዎት, እርስዎ የ እያንዳንዱ አነስተኛ ዝርዝር መቆጣጠሪያ ይጠቀሙ. GradientTape ነገር ግን አንድ ብጁ ስልጠና አጠቃቀም ያስፈልጋል, ነገር ግን በእርግጥ ከባድ ባህሪያት አጠቃቀም ይፈልጋሉ? እንደ callbacks, የተመሠረተ የሽያጭ ድጋፍ, ወይም step fusing? fit() የ Keras Principle ነው በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃ ላይ ማግኘት ይችላሉ. progressive disclosure of complexity እናንተ ምንድን የሚፈልጉት ጊዜ እርስዎ አለብዎት ይህ አጠቃቀም ነው; ይህ አጠቃቀም ነው እያንዳንዱ ውሂብ ማግኘት ይችላሉ. እንደመሠረቱ - እና ይህ የእርስዎን የእርስዎን የመማር አግኝተዋል. fit() override the training step function of the Model fit() fit() ይህ ሞዴል በ Functional API በመጠቀም ሞዴሎች ለመፍጠር አይችሉም. ሞዴሎች, Functional API ሞዴሎች, ወይም subclassed ሞዴሎች. Sequential ይህ እንዴት ይሰራል ይመልከቱ. አግኙን የ TensorFlow 2.8 ወይም ከዚያ በላይ ያስፈልጋል. import tensorflow as tf from tensorflow import keras የመጀመሪያው ቀላል ምሳሌ አንድ ቀላል ለምሳሌ ይጀምራል: እኛ hard.Model subclasses አንድ አዲስ ክፍል ለመፍጠር. በ train_step (ወይም, ውሂብ) መሣሪያን ይቀበላሉ. የእርስዎ ግምገማዎች (እነዚህን ግምገማዎች) ወደ በአሁኑ መጠን ያውቃሉ. አግኙን Argument ይህ የሙከራ ውሂብ እንደ ተስማሚ ሊሆን ይችላል: data አንተ Numpy ቅርጸት ይሰጣል ከሆነ, fit (x, y, ...) ይደውሉ, ከዚያም ውሂብ ይሆናል tuple (x, y) አንድ tf.data.Dataset ይሰጣል ከሆነ, fit (dataset, ...) ይደውሉ, ከዚያም ውሂብ እያንዳንዱ batch ላይ በ dataset የተወሰነ ነገር ይሆናል. በሽታ ውስጥ የ መተግበሪያ ስርዓት, እኛ በተለምዶ የፈጠራ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ ጋር ተመሳሳይ ነው. ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ . train_step we compute the loss via self.compute_loss() compile() ተመሳሳይ መንገድ ይደውሉ ከ Metrics በመጨረሻው ጊዜ ውስጥ የሚከተሉትን ሜትሪኮች ለመቀየር እና እኛ ውጤቶች ከ በመጨረሻም የእርስዎን የአሁኑ ዋጋ ማግኘት ይችላሉ. metric.update_state(y, y_pred) self.metrics compile() self.metrics class CustomModel(keras.Model): def train_step(self, data): # Unpack the data. Its structure depends on your model and # on what you pass to `fit()`. x, y = data with tf.GradientTape() as tape: y_pred = self(x, training=True) # Forward pass # Compute the loss value # (the loss function is configured in `compile()`) loss = self.compute_loss(y=y, y_pred=y_pred) # Compute gradients trainable_vars = self.trainable_variables gradients = tape.gradient(loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Update metrics (includes the metric that tracks the loss) for metric in self.metrics: if metric.name == "loss": metric.update_state(loss) else: metric.update_state(y, y_pred) # Return a dict mapping metric names to current value return {m.name: m.result() for m in self.metrics} ይህን ይሞክሩ: import numpy as np # Construct and compile an instance of CustomModel inputs = keras.Input(shape=(32,)) outputs = keras.layers.Dense(1)(inputs) model = CustomModel(inputs, outputs) model.compile(optimizer="adam", loss="mse", metrics=["mae"]) # Just use `fit` as usual x = np.random.random((1000, 32)) y = np.random.random((1000, 1)) model.fit(x, y, epochs=3) Epoch 1/3 32/32 [==============================] - 3s 2ms/step - loss: 1.6446 Epoch 2/3 32/32 [==============================] - 0s 2ms/step - loss: 0.7554 Epoch 3/3 32/32 [==============================] - 0s 2ms/step - loss: 0.3924 ዝቅተኛ ደረጃ በእርግጥ, እርስዎ ብቻ አንድ ክፍት ክፍት መጠቀም ይችላሉ. ነገር ግን ሁሉም ነገር በ በሜትሪክ ላይ እንደዚህ. compile() ብጁ train_step እዚህ አንድ ዝቅተኛ ደረጃ ምሳሌ ነው, ይህም ብቻ ይጠቀማል optimizer ለመፍጠር: compile() እኛ የእኛን ፍላጎት እና የ MAE ስኬት (የ __init__() ውስጥ) ለመከታተል Metric ስኬትዎችን ለመፍጠር ይጀምራል. እኛ አንድ ብጁ train_step() መተግበሪያ ይሰራል, ይህም እነዚህ ሜትሪኮች ሁኔታን (እነርሱ ላይ update_state() ይደውሉ), ከዚያም እነርሱን (በ result()) በመጠቀም ያግኙ, የእነርሱ አጠቃቀም አጠቃቀም መጠን, በ Progress bar ላይ ይመልከቱ, እና ማንኛውም ግምገማዎች ላይ ይመዝገቡ. በእያንዳንዱ ልምድ መካከል የእኛን ሜትሪክስ ላይ reset_states() ይደውሉ አለብዎት ያውቃል! በዚያም ጊዜ, የእኛን ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ከሁሉም ልምድ ላይ ይደውሉ. class CustomModel(keras.Model): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.loss_tracker = keras.metrics.Mean(name="loss") self.mae_metric = keras.metrics.MeanAbsoluteError(name="mae") def train_step(self, data): x, y = data with tf.GradientTape() as tape: y_pred = self(x, training=True) # Forward pass # Compute our own loss loss = keras.losses.mean_squared_error(y, y_pred) # Compute gradients trainable_vars = self.trainable_variables gradients = tape.gradient(loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Compute our own metrics self.loss_tracker.update_state(loss) self.mae_metric.update_state(y, y_pred) return {"loss": self.loss_tracker.result(), "mae": self.mae_metric.result()} @property def metrics(self): # We list our `Metric` objects here so that `reset_states()` can be # called automatically at the start of each epoch # or at the start of `evaluate()`. # If you don't implement this property, you have to call # `reset_states()` yourself at the time of your choosing. return [self.loss_tracker, self.mae_metric] # Construct an instance of CustomModel inputs = keras.Input(shape=(32,)) outputs = keras.layers.Dense(1)(inputs) model = CustomModel(inputs, outputs) # We don't pass a loss or metrics here. model.compile(optimizer="adam") # Just use `fit` as usual -- you can use callbacks, etc. x = np.random.random((1000, 32)) y = np.random.random((1000, 1)) model.fit(x, y, epochs=5) Epoch 1/5 32/32 [==============================] - 0s 2ms/step - loss: 0.3240 - mae: 0.4583 Epoch 2/5 32/32 [==============================] - 0s 2ms/step - loss: 0.2416 - mae: 0.3984 Epoch 3/5 32/32 [==============================] - 0s 2ms/step - loss: 0.2340 - mae: 0.3919 Epoch 4/5 32/32 [==============================] - 0s 2ms/step - loss: 0.2274 - mae: 0.3870 Epoch 5/5 32/32 [==============================] - 0s 2ms/step - loss: 0.2197 - mae: 0.3808 ድጋፍ እና ሻጋታ - ክብደት ክብደት - Weight ሻጋታ - ክብደት ክብደት - Weight እርስዎ የእኛን የመጀመሪያው መሠረታዊ ምሳሌም የሞዴል ክብደት ላይ ማንኛውም ዝርዝር አይነሰም. ጥያቄዎች እና እርስዎ ብቻ የሚከተለውን ይሆናል: fit() sample_weight class_weight ከታች መለያ ከ sample_weight Unpack compute_loss & update_state (እናንተም በእርግጠኝነት compile() ለቀበቀስ እና ሜትሪኮች ላይ አይተም ከሆነ, እርስዎ ደግሞ እያንዳንዱ እያንዳንዱ መተግበሪያ መጠቀም ይችላሉ) ይህ ነው class CustomModel(keras.Model): def train_step(self, data): # Unpack the data. Its structure depends on your model and # on what you pass to `fit()`. if len(data) == 3: x, y, sample_weight = data else: sample_weight = None x, y = data with tf.GradientTape() as tape: y_pred = self(x, training=True) # Forward pass # Compute the loss value. # The loss function is configured in `compile()`. loss = self.compute_loss( y=y, y_pred=y_pred, sample_weight=sample_weight, ) # Compute gradients trainable_vars = self.trainable_variables gradients = tape.gradient(loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Update the metrics. # Metrics are configured in `compile()`. for metric in self.metrics: if metric.name == "loss": metric.update_state(loss) else: metric.update_state(y, y_pred, sample_weight=sample_weight) # Return a dict mapping metric names to current value. # Note that it will include the loss (tracked in self.metrics). return {m.name: m.result() for m in self.metrics} # Construct and compile an instance of CustomModel inputs = keras.Input(shape=(32,)) outputs = keras.layers.Dense(1)(inputs) model = CustomModel(inputs, outputs) model.compile(optimizer="adam", loss="mse", metrics=["mae"]) # You can now use sample_weight argument x = np.random.random((1000, 32)) y = np.random.random((1000, 1)) sw = np.random.random((1000, 1)) model.fit(x, y, sample_weight=sw, epochs=3) Epoch 1/3 32/32 [==============================] - 0s 2ms/step - loss: 0.1298 Epoch 2/3 32/32 [==============================] - 0s 2ms/step - loss: 0.1179 Epoch 3/3 32/32 [==============================] - 0s 2ms/step - loss: 0.1121 የእርስዎን ግምገማ ደረጃ ለማረጋገጥ ነገር ግን እርስዎ ከባድ ስልክ ጋር ተመሳሳይ ነገር ማድረግ የሚፈልጉ ከሆነ ከዚያም እርስዎ ከባድ ይሆናል ተመሳሳይ መንገድ ነው. እዚህ ምን ይሆናል: model.evaluate() test_step class CustomModel(keras.Model): def test_step(self, data): # Unpack the data x, y = data # Compute predictions y_pred = self(x, training=False) # Updates the metrics tracking the loss self.compute_loss(y=y, y_pred=y_pred) # Update the metrics. for metric in self.metrics: if metric.name != "loss": metric.update_state(y, y_pred) # Return a dict mapping metric names to current value. # Note that it will include the loss (tracked in self.metrics). return {m.name: m.result() for m in self.metrics} # Construct an instance of CustomModel inputs = keras.Input(shape=(32,)) outputs = keras.layers.Dense(1)(inputs) model = CustomModel(inputs, outputs) model.compile(loss="mse", metrics=["mae"]) # Evaluate with our custom test_step x = np.random.random((1000, 32)) y = np.random.random((1000, 1)) model.evaluate(x, y) 32/32 [==============================] - 0s 1ms/step - loss: 0.9028 0.9028095006942749 አግኙን: አንድ End-to-End GAN ለምሳሌ እርስዎ ከሁሉም ነገር ያውቃሉ, እርስዎ ከሁሉም ነገር ያውቃሉ. ይበልጥ ይመልከቱ: አንድ ጄኔሬተር አውታረ መረብ 28x28x1 ፎቶዎችን ለመፍጠር ነው. የ 28x28x1 ፎቶዎችን ሁለት ደረጃዎች ("fake" እና "real"") ያካትታል. እያንዳንዱ ላይ አንድ optimizer. የክፍያዎችን ለመፍጠር የክፍያዎችን ይጠቀማል. from tensorflow.keras import layers # Create the discriminator discriminator = keras.Sequential( [ keras.Input(shape=(28, 28, 1)), layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"), layers.LeakyReLU(alpha=0.2), layers.GlobalMaxPooling2D(), layers.Dense(1), ], name="discriminator", ) # Create the generator latent_dim = 128 generator = keras.Sequential( [ keras.Input(shape=(latent_dim,)), # We want to generate 128 coefficients to reshape into a 7x7x128 map layers.Dense(7 * 7 * 128), layers.LeakyReLU(alpha=0.2), layers.Reshape((7, 7, 128)), layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"), layers.LeakyReLU(alpha=0.2), layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(1, (7, 7), padding="same", activation="sigmoid"), ], name="generator", ) እዚህ አንድ ባህሪያት-ተጨማሪ GAN ክፍል, overriding የ GAN አግኝተዋል እና በ 17 መስመሮች ውስጥ የ GAN አግኝተዋል : compile() train_step class GAN(keras.Model): def __init__(self, discriminator, generator, latent_dim): super().__init__() self.discriminator = discriminator self.generator = generator self.latent_dim = latent_dim self.d_loss_tracker = keras.metrics.Mean(name="d_loss") self.g_loss_tracker = keras.metrics.Mean(name="g_loss") def compile(self, d_optimizer, g_optimizer, loss_fn): super().compile() self.d_optimizer = d_optimizer self.g_optimizer = g_optimizer self.loss_fn = loss_fn def train_step(self, real_images): if isinstance(real_images, tuple): real_images = real_images[0] # Sample random points in the latent space batch_size = tf.shape(real_images)[0] random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) # Decode them to fake images generated_images = self.generator(random_latent_vectors) # Combine them with real images combined_images = tf.concat([generated_images, real_images], axis=0) # Assemble labels discriminating real from fake images labels = tf.concat( [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0 ) # Add random noise to the labels - important trick! labels += 0.05 * tf.random.uniform(tf.shape(labels)) # Train the discriminator with tf.GradientTape() as tape: predictions = self.discriminator(combined_images) d_loss = self.loss_fn(labels, predictions) grads = tape.gradient(d_loss, self.discriminator.trainable_weights) self.d_optimizer.apply_gradients( zip(grads, self.discriminator.trainable_weights) ) # Sample random points in the latent space random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) # Assemble labels that say "all real images" misleading_labels = tf.zeros((batch_size, 1)) # Train the generator (note that we should *not* update the weights # of the discriminator)! with tf.GradientTape() as tape: predictions = self.discriminator(self.generator(random_latent_vectors)) g_loss = self.loss_fn(misleading_labels, predictions) grads = tape.gradient(g_loss, self.generator.trainable_weights) self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights)) # Update metrics and return their value. self.d_loss_tracker.update_state(d_loss) self.g_loss_tracker.update_state(g_loss) return { "d_loss": self.d_loss_tracker.result(), "g_loss": self.g_loss_tracker.result(), } እርስዎ መጫወት ይመልከቱ: # Prepare the dataset. We use both the training & test MNIST digits. batch_size = 64 (x_train, _), (x_test, _) = keras.datasets.mnist.load_data() all_digits = np.concatenate([x_train, x_test]) all_digits = all_digits.astype("float32") / 255.0 all_digits = np.reshape(all_digits, (-1, 28, 28, 1)) dataset = tf.data.Dataset.from_tensor_slices(all_digits) dataset = dataset.shuffle(buffer_size=1024).batch(batch_size) gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim) gan.compile( d_optimizer=keras.optimizers.Adam(learning_rate=0.0003), g_optimizer=keras.optimizers.Adam(learning_rate=0.0003), loss_fn=keras.losses.BinaryCrossentropy(from_logits=True), ) # To limit the execution time, we only train on 100 batches. You can train on # the entire dataset. You will need about 20 epochs to get nice results. gan.fit(dataset.take(100), epochs=1) Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz 11490434/11490434 [==============================] - 0s 0us/step 100/100 [==============================] - 8s 15ms/step - d_loss: 0.4372 - g_loss: 0.8775 የሙዚቃ ግምገማዎች በጣም ቀላል ናቸው, ስለዚህ መተግበሪያው እንዴት ይበልጥ ቀላል ነው? በመጀመሪያ በ TensorFlow ድር ጣቢያ ላይ የተለጠፈው, ይህ ጽሑፍ እዚህ አንድ አዲስ ምልክት ውስጥ ይመልከቱ እና በ CC BY 4.0 ላይ የተመሠረተ ነው. በመጀመሪያ በ TensorFlow ድር ጣቢያ ላይ የተለጠፈው, ይህ ጽሑፍ እዚህ አንድ አዲስ ምልክት ውስጥ ይመልከቱ እና በ CC BY 4.0 ላይ የተመሠረተ ነው. የ TensorFlow