TensorFlow 2 में साफ कोड लिखने के लिए टिप्स

सामग्री समीक्षा समीक्षा सेटअप TensorFlow 2 के बारे में टिप्पणियाँ अपने कोड को छोटे मॉड्यूल में बदलें Adjust the default learning rate for some tf.keras.optimizers परिवर्तकों को प्रबंधित करने के लिए tf.Modules और Keras परतों का उपयोग करें tf.data.Datasets और tf.function को जोड़ें केरास प्रशिक्षण लूप का उपयोग करें प्रशिक्षण को अनुकूलित करें और अपने स्वयं के लूप लिखें Python नियंत्रण प्रवाह के साथ tf.function का लाभ उठाएं नई शैली मीट्रिक और नुकसान डिबगिंग अपने वस्तुओं में tf.tensors नहीं रखें संसाधन और आगे पढ़ने Overview यह गाइड TensorFlow 2 (TF2) का उपयोग करके कोड लिखने के लिए सर्वोत्तम प्रथाओं की एक सूची प्रदान करता है, यह उन उपयोगकर्ताओं के लिए लिखा गया है जिन्होंने हाल ही में TensorFlow 1 (TF1) से स्विच किया है। अपने TF1 कोड को TF2 में स्थानांतरित करने के बारे में अधिक जानकारी के लिए मार्गदर्शिका के माइग्रेन सेक्शन सेटअप Import TensorFlow and other dependencies for the examples in this guide. import tensorflow as tf import tensorflow_datasets as tfds 2023-10-04 01:22:53.526066: 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-04 01:22:53.526110: 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-04 01:22:53.526158: 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 TensorFlow 2 के बारे में टिप्पणियाँ Refactor your code into smaller modules एक अच्छा अभ्यास अपने कोड को छोटे कार्यों में पुनर्वर्ती करना है जिन्हें जरूरत के अनुसार बुलाया जाता है. सर्वोत्तम प्रदर्शन के लिए, आपको कंप्यूटिंग के सबसे बड़े ब्लॉकों को सजाने की कोशिश करनी चाहिए जिन्हें आप एक (नोट करें कि निहित पिथन कार्यों को एक के द्वारा कहा जाता है अपने स्वयं के अलग-अलग सजावट की आवश्यकता नहीं है, जब तक आप अलग-अलग का उपयोग नहीं करना चाहते हैं के लिए सेटिंग्स ) आपके उपयोग के मामले के आधार पर, यह कई प्रशिक्षण चरण या यहां तक कि आपके पूरे प्रशिक्षण चक्र हो सकता है। tf.function tf.function jit_compile tf.function Adjust the default learning rate for some s tf.keras.optimizer कुछ केरास अनुकूलक TF2 में अलग-अलग सीखने की दरें हैं. यदि आप अपने मॉडल के लिए संलग्नता व्यवहार में बदलाव देखते हैं, तो डिफ़ॉल्ट सीखने की दरों की जाँच करें. के लिए कोई बदलाव नहीं , , or . optimizers.SGD optimizers.Adam optimizers.RMSprop निम्नलिखित डिफ़ॉल्ट सीखने की दरें बदल गई हैं: optimizers.Adagrad 0.01 से 0.001 तक optimizers.Adadelta 1.0 से 0.001 तक optimizers.Adamax 0.002 से 0.001 तक optimizers.Nadam 0.002 से 0.001 तक Use s and Keras layers to manage variables tf.Module s और उपयुक्त की पेशकश करें और गुण, जो पुनरावृत्ति से सभी निर्भर बदलावों को इकट्ठा करते हैं. इससे उन्हें स्थानीय रूप से उस स्थान पर प्रबंधित करना आसान होता है जहां वे उपयोग किए जाते हैं. tf.Module tf.keras.layers.Layer variables trainable_variables केरास लेयर / मॉडल विरासत से और एकीकृत किया जाता है , जो सीधे केरास वस्तुओं से सहेजे गए मॉडल का निरीक्षण या निर्यात करना संभव बनाता है. आप केरास का उपयोग करने की जरूरत नहीं है API इन एकीकरणों का लाभ उठाने के लिए। tf.train.Checkpointable @tf.function Model.fit पढ़ें अनुभाग पर केरास गाइड में जानें कि केरास का उपयोग करके प्रासंगिक परिवर्तकों का एक उपसेट कैसे इकट्ठा किया जाए। Transfer learning और fine-tuning के बारे में जानें Combine s and tf.data.Dataset tf.function के package ( ) पहले से परिभाषित डेटा सेटों को लोड करने के लिए उपयोगिताओं को शामिल करता है इस उदाहरण के लिए, आप MNIST डेटासेट को लोड कर सकते हैं : TensorFlow डेटा सेट tfds tf.data.Dataset tfds datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True) mnist_train, mnist_test = datasets['train'], datasets['test'] 2023-10-04 01:22:57.406511: 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... फिर प्रशिक्षण के लिए डेटा तैयार करें: प्रत्येक छवि को फिर से स्केल करें। Shuffle the order of the examples. छवियों और लेबलों का बैच इकट्ठा करें। BUFFER_SIZE = 10 # Use a much larger value for real code BATCH_SIZE = 64 NUM_EPOCHS = 5 def scale(image, label): image = tf.cast(image, tf.float32) image /= 255 return image, label उदाहरण को संक्षिप्त रखने के लिए, डेटासेट को केवल 5 बैच को वापस करने के लिए काटें: train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE) test_data = mnist_test.map(scale).batch(BATCH_SIZE) STEPS_PER_EPOCH = 5 train_data = train_data.take(STEPS_PER_EPOCH) test_data = test_data.take(STEPS_PER_EPOCH) image_batch, label_batch = next(iter(train_data)) 2023-10-04 01:22:58.048011: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. नियमित पायथन पुनरावृत्ति का उपयोग करें प्रशिक्षण डेटा पर पुनरावृत्ति करने के लिए जो स्मृति में फिट होते हैं। डिस्क से प्रशिक्षण डेटा स्ट्रीम करने का सबसे अच्छा तरीका है। , और तीव्र निष्पादन में अन्य पायथन iterables की तरह काम करते हैं. आप अपने कोड में कवर करके डेटासेट async prefetching/streaming सुविधाओं का पूरी तरह से उपयोग कर सकते हैं , जो ऑटोग्राफ का उपयोग करके समकक्ष ग्राफ ऑपरेशनों के साथ पायथन पुनरावृत्ति को बदलता है। tf.data.Dataset Iterables (Iterators नहीं) tf.function @tf.function def train(model, dataset, optimizer): for x, y in dataset: with tf.GradientTape() as tape: # training=True is only needed if there are layers with different # behavior during training versus inference (e.g. Dropout). prediction = model(x, training=True) loss = loss_fn(prediction, y) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) यदि आप केरल का उपयोग करते हैं एपीआई, आपको डेटासेट पुनरावृत्ति के बारे में चिंता करने की आवश्यकता नहीं होगी। Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) केरास प्रशिक्षण लूप का उपयोग करें यदि आपको अपने प्रशिक्षण प्रक्रिया के कम स्तर के नियंत्रण की आवश्यकता नहीं है, तो केरास के अंतर्निहित का उपयोग करें , और इन तरीकों से मॉडल को प्रशिक्षित करने के लिए एक समान इंटरफ़ेस प्रदान किया जाता है, निष्पादन के बावजूद (संक्रमित, कार्यात्मक, या उप-ग्रेडिंग)। fit evaluate predict इन तरीकों के लाभों में शामिल हैं: वे Numpy रेंज, Python जनरेटर और, tf.data.Datasets स्वीकार करते हैं। वे नियमितता लागू करते हैं, और सक्रियण नुकसान स्वचालित रूप से। They support where the training code remains the same . tf.distribute regardless of the hardware configuration वे हानि और मीट्रिक के रूप में arbitrary callables का समर्थन करते हैं। वे tf.keras.callbacks.TensorBoard, और कस्टम कॉलबैक जैसे कॉलबैक का समर्थन करते हैं। वे प्रदर्शनशील हैं, स्वचालित रूप से TensorFlow ग्राफ का उपयोग करते हैं। Here is an example of training a model using a यह कैसे काम करता है के बारे में विस्तृत जानकारी के लिए, देखें . Dataset ट्यूटोरियल model = tf.keras.Sequential([ tf.keras.layers.Conv2D(32, 3, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.02), input_shape=(28, 28, 1)), tf.keras.layers.MaxPooling2D(), tf.keras.layers.Flatten(), tf.keras.layers.Dropout(0.1), tf.keras.layers.Dense(64, activation='relu'), tf.keras.layers.BatchNormalization(), tf.keras.layers.Dense(10) ]) # Model is the full model w/o custom layers model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) model.fit(train_data, epochs=NUM_EPOCHS) loss, acc = model.evaluate(test_data) print("Loss {}, Accuracy {}".format(loss, acc)) Epoch 1/5 5/5 [==============================] - 2s 44ms/step - loss: 1.6644 - accuracy: 0.4906 Epoch 2/5 2023-10-04 01:22:59.569439: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 9ms/step - loss: 0.5173 - accuracy: 0.9062 Epoch 3/5 2023-10-04 01:23:00.062308: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 9ms/step - loss: 0.3418 - accuracy: 0.9469 Epoch 4/5 2023-10-04 01:23:00.384057: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 8ms/step - loss: 0.2707 - accuracy: 0.9781 Epoch 5/5 2023-10-04 01:23:00.766486: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 8ms/step - loss: 0.2195 - accuracy: 0.9812 2023-10-04 01:23:01.120149: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 4ms/step - loss: 1.6036 - accuracy: 0.6250 Loss 1.6036441326141357, Accuracy 0.625 2023-10-04 01:23:01.572685: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Customize training and write your own loop If Keras models work for you, but you need more flexibility and control of the training step or the outer training loops, you can implement your own training steps or even entire training loops. See the Keras guide on अधिक सीखने के लिए। अनुकूलन fit आप एक के रूप में कई चीजें भी लागू कर सकते हैं . tf.keras.callbacks.Callback इस विधि के कई फायदे हैं , लेकिन आपको ट्रेन कदम और यहां तक कि बाहरी चक्र का नियंत्रण देता है। mentioned previously एक मानक प्रशिक्षण चक्र के लिए तीन चरण हैं: उदाहरणों के बैच प्राप्त करने के लिए एक पायथन जनरेटर या tf.data.Dataset पर पुनरावृत्ति करें। ग्रेडियंट्स को इकट्ठा करने के लिए tf.GradientTape का उपयोग करें। tf.keras.optimizers में से एक का उपयोग मॉडल के परिवर्तकों पर वजन अपडेट लागू करने के लिए करें। याद रखें : Always include a argument on the method of subclassed layers and models. training call Make sure to call the model with the argument set correctly. training उपयोग के आधार पर, मॉडल परिवर्तक तब तक मौजूद नहीं हो सकते हैं जब तक कि मॉडल डेटा बैच पर नहीं चलाया जाता है। आपको मॉडल के लिए नियमितता नुकसान जैसे चीजों को मैन्युअल रूप से संभालने की आवश्यकता है। There is no need to run variable initializers or to add manual control dependencies. आपके लिए रचना पर स्वचालित नियंत्रण निर्भरताओं और परिवर्तनीय प्रारंभिककरण को संभालता है। tf.function model = tf.keras.Sequential([ tf.keras.layers.Conv2D(32, 3, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.02), input_shape=(28, 28, 1)), tf.keras.layers.MaxPooling2D(), tf.keras.layers.Flatten(), tf.keras.layers.Dropout(0.1), tf.keras.layers.Dense(64, activation='relu'), tf.keras.layers.BatchNormalization(), tf.keras.layers.Dense(10) ]) optimizer = tf.keras.optimizers.Adam(0.001) loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) @tf.function def train_step(inputs, labels): with tf.GradientTape() as tape: predictions = model(inputs, training=True) regularization_loss=tf.math.add_n(model.losses) pred_loss=loss_fn(labels, predictions) total_loss=pred_loss + regularization_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) for epoch in range(NUM_EPOCHS): for inputs, labels in train_data: train_step(inputs, labels) print("Finished epoch", epoch) 2023-10-04 01:23:02.652222: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 0 2023-10-04 01:23:02.957452: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 1 2023-10-04 01:23:03.632425: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 2 2023-10-04 01:23:03.877866: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 3 Finished epoch 4 2023-10-04 01:23:04.197488: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. लाभ उठाएं with Python control flow tf.function provides a way to convert data-dependent control flow into graph-mode equivalents like और . tf.function tf.cond tf.while_loop एक आम जगह जहां डेटा-आधारित नियंत्रण प्रवाह दिखाई देता है अनुक्रम मॉडल में है। एक RNN कोशिका को लपेटता है, जिससे आप पुनरावृत्ति को स्थिर या गतिशील रूप से लपेटने में सक्षम हो सकते हैं. उदाहरण के लिए, आप गतिशील लपेटने को निम्नलिखित तरीके से फिर से लागू कर सकते हैं. tf.keras.layers.RNN class DynamicRNN(tf.keras.Model): def __init__(self, rnn_cell): super(DynamicRNN, self).__init__(self) self.cell = rnn_cell @tf.function(input_signature=[tf.TensorSpec(dtype=tf.float32, shape=[None, None, 3])]) def call(self, input_data): # [batch, time, features] -> [time, batch, features] input_data = tf.transpose(input_data, [1, 0, 2]) timesteps = tf.shape(input_data)[0] batch_size = tf.shape(input_data)[1] outputs = tf.TensorArray(tf.float32, timesteps) state = self.cell.get_initial_state(batch_size = batch_size, dtype=tf.float32) for i in tf.range(timesteps): output, state = self.cell(input_data[i], state) outputs = outputs.write(i, output) return tf.transpose(outputs.stack(), [1, 0, 2]), state lstm_cell = tf.keras.layers.LSTMCell(units = 13) my_rnn = DynamicRNN(lstm_cell) outputs, state = my_rnn(tf.random.normal(shape=[10,20,3])) print(outputs.shape) (10, 20, 13) पढ़ें ये अधिक जानकारी के लिए गाइड। tf.function नई शैली मीट्रिक और नुकसान मीट्रिक और नुकसान दोनों वस्तुएं हैं जो उत्सुकता से काम करती हैं और s. tf.function एक नुकसान वस्तु कॉल योग्य है, और उम्मीद करता है ( , तर्क के रूप में: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Use metrics to collect and display data आप उपयोग कर सकते हैं डेटा एकत्र करने के लिए और to log summaries and redirect it to a writer using a context manager. The summaries are emitted directly to the writer which means that you must provide the कॉल साइट पर मूल्य। tf.metrics tf.summary step summary_writer = tf.summary.create_file_writer('/tmp/summaries') with summary_writer.as_default(): tf.summary.scalar('loss', 0.1, step=42) उपयोग करें to aggregate data before logging them as summaries. Metrics are stateful; they accumulate values and return a cumulative result when you call the method (such as (Clear accumulated values with ) के साथ एकत्रित मूल्य स्पष्ट करें . tf.metrics result Mean.result Model.reset_states def train(model, optimizer, dataset, log_freq=10): avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32) for images, labels in dataset: loss = train_step(model, optimizer, images, labels) avg_loss.update_state(loss) if tf.equal(optimizer.iterations % log_freq, 0): tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations) avg_loss.reset_states() def test(model, test_x, test_y, step_num): # training=False is only needed if there are layers with different # behavior during training versus inference (e.g. Dropout). loss = loss_fn(model(test_x, training=False), test_y) tf.summary.scalar('loss', loss, step=step_num) train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train') test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test') with train_summary_writer.as_default(): train(model, optimizer, dataset) with test_summary_writer.as_default(): test(model, test_x, test_y, optimizer.iterations) उत्पन्न संक्षेपों को संक्षेप लॉग निर्देशिका पर TensorBoard को इंगित करके दृश्य करें: tensorboard --logdir /tmp/summaries Use the TensorBoard में विज़ुअलाइज़ेशन के लिए संक्षिप्त डेटा लिखने के लिए एपीआई. अधिक जानकारी के लिए, पढ़ें guide. tf.summary tf.summary # Create the metrics loss_metric = tf.keras.metrics.Mean(name='train_loss') accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy') @tf.function def train_step(inputs, labels): with tf.GradientTape() as tape: predictions = model(inputs, training=True) regularization_loss=tf.math.add_n(model.losses) pred_loss=loss_fn(labels, predictions) total_loss=pred_loss + regularization_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # Update the metrics loss_metric.update_state(total_loss) accuracy_metric.update_state(labels, predictions) for epoch in range(NUM_EPOCHS): # Reset the metrics loss_metric.reset_states() accuracy_metric.reset_states() for inputs, labels in train_data: train_step(inputs, labels) # Get the metric results mean_loss=loss_metric.result() mean_accuracy = accuracy_metric.result() print('Epoch: ', epoch) print(' loss: {:.3f}'.format(mean_loss)) print(' accuracy: {:.3f}'.format(mean_accuracy)) 2023-10-04 01:23:05.220607: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 0 loss: 0.176 accuracy: 0.994 2023-10-04 01:23:05.554495: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 1 loss: 0.153 accuracy: 0.991 2023-10-04 01:23:06.043597: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 2 loss: 0.134 accuracy: 0.994 2023-10-04 01:23:06.297768: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 3 loss: 0.108 accuracy: 1.000 Epoch: 4 loss: 0.095 accuracy: 1.000 2023-10-04 01:23:06.678292: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. मेट्रिक नाम Keras मॉडल मीट्रिक नामों को संभालने के बारे में लगातार हैं. जब आप मीट्रिक की सूची में एक श्रृंखला पार करते हैं, तो String का उपयोग metric के रूप में किया जाता है इन नामों को ऐतिहासिक वस्तु में दिखाई देता है जिसे और अख़बारों में गुज़रते हुए . उस श्रृंखला को सेट किया गया है जिसे आपने मीट्रिक सूची में पारित किया है। exact name model.fit keras.callbacks model.compile( optimizer = tf.keras.optimizers.Adam(0.001), loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")]) history = model.fit(train_data) 5/5 [==============================] - 1s 9ms/step - loss: 0.1077 - acc: 0.9937 - accuracy: 0.9937 - my_accuracy: 0.9937 2023-10-04 01:23:07.849601: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. history.history.keys() dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy']) Debugging आकार, डेटा प्रकार और मूल्यों की जांच करने के लिए अपने कोड को कदम-दर-चरण चलाने के लिए उत्सुक निष्पादन का उपयोग करें। , , etc. are designed to use Graph execution, for performance and portability. When debugging, use इस कोड के भीतर उत्तेजना का उपयोग करने के लिए। tf.function tf.keras tf.config.run_functions_eagerly(True) For example: @tf.function def f(x): if x > 0: import pdb pdb.set_trace() x = x + 1 return x tf.config.run_functions_eagerly(True) f(tf.constant(1)) >>> f() -> x = x + 1 (Pdb) l 6 @tf.function 7 def f(x): 8 if x > 0: 9 import pdb 10 pdb.set_trace() 11 -> x = x + 1 12 return x 13 14 tf.config.run_functions_eagerly(True) 15 f(tf.constant(1)) [EOF] यह केरास मॉडल और अन्य एपीआई के भीतर भी काम करता है जो उत्सुक निष्पादन का समर्थन करता है: class CustomModel(tf.keras.models.Model): @tf.function def call(self, input_data): if tf.reduce_mean(input_data) > 0: return input_data else: import pdb pdb.set_trace() return input_data // 2 tf.config.run_functions_eagerly(True) model = CustomModel() model(tf.constant([-2, -4])) >>> call() -> return input_data // 2 (Pdb) l 10 if tf.reduce_mean(input_data) > 0: 11 return input_data 12 else: 13 import pdb 14 pdb.set_trace() 15 -> return input_data // 2 16 17 18 tf.config.run_functions_eagerly(True) 19 model = CustomModel() 20 model(tf.constant([-2, -4])) Notes: tf.keras.Model विधियों जैसे फिट, मूल्यांकन, और पूर्वानुमान कैप के तहत tf.function के साथ ग्राफ के रूप में निष्पादित करें। tf.keras.Model.compile का उपयोग करते समय, एक tf.function में मॉडल तर्क को कवर करने से रोकने के लिए run_eagerly = True सेट करें। Use to enable the debug mode for . Read the for more details. tf.data.experimental.enable_debug_mode tf.data API docs Do not keep in your objects tf.Tensors इन टेंसर वस्तुओं को या तो एक में बनाया जा सकता है or in the eager context, and these tensors behave differently. Always use s केवल मध्यवर्ती मूल्यों के लिए। tf.function tf.Tensor राज्य का उपयोग करने के लिए, हमेशा दोनों संदर्भों से इस्तेमाल किया जा सकता है. पढ़ें guide to learn more. tf.Variable tf.Variable Resources and further reading TF2 का उपयोग करने के बारे में अधिक जानने के लिए TF2 गाइड और ट्यूटोरियल पढ़ें। If you previously used TF1.x, it is highly recommended you migrate your code to TF2. Read the to learn more. migration guides Originally published on the website, this article appears here under a new headline and is licensed under CC BY 4.0. Code samples shared under the Apache 2.0 License. TensorFlow मूल रूप से TensorFlow वेबसाइट पर प्रकाशित, यह लेख यहां एक नए शीर्षक के तहत दिखाई देता है और CC BY 4.0 के तहत लाइसेंस दिया गया है। TensorFlow TensorFlow के लिए