首页 > 解决方案 > NotFoundError:没有为 GPU/tf.eager 和 keras 注册的“ZerosLike”OpKernel

问题描述

我写下了我自己的网络复制pix2pixHD。这是对pix2pix的简单修改,只是将生成器复制为两个,将鉴别器复制为三个,它们处理不同级别的分辨率。

但是当我尝试训练时,它不断返回,Opkernel_zeroslike unfound error但找不到发生此错误的原因。

我通常修改了 pix2pix以制作此代码,并且pix2pix不会返回错误并且成功地进行了训练。

对此有任何提示Opkernel unfound error吗?

#### this sciprt based on tensorflow v.1.10

#!pip install --upgrade tensorflow-gpu==1.10.0 #normally the default provided by aws is 1.8.0

# Keras Implementation of pix2pix 

import os
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]="0"

import sys
import time
import glob
import random
from functools import reduce

import cv2
import pandas as pd
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
from IPython.display import clear_output


import scipy
import tensorflow as tf
tf.enable_eager_execution()

from tensorflow.python.data import Dataset
from tensorflow.python.data import Iterator
from tensorflow.python.framework import ops
from tensorflow.python.ops import math_ops

import collections
import math
import time

import util

now = time.strftime("%Y%m%d-%H%M%S")

# Paths

data = './data/ipx_2'
PATH = os.path.join(data, 'train')
image_paths = sorted(glob.glob(PATH+"/*"))

# Hypers

BUFFER_SIZE = len(image_paths) 
IMG_WIDTH = 256
IMG_HEIGHT = 256
BATCH_SIZE = {IMG_WIDTH == 256 : 16, IMG_WIDTH == 512: 10}.get(True, "IMG_WIDTH must be either 256 or 512")
TIME_SPACE = 11
print(BUFFER_SIZE, BATCH_SIZE, IMG_HEIGHT, TIME_SPACE) #for sanity check 

# I/O Utils

def load_image(image_path, diff = True, corr =True, time_space = TIME_SPACE):

    image = tf.read_file(image_path)
    image = tf.image.decode_png(image)

    w = tf.shape(image)[0]
    print(w)    

    target_image = image[:, -w:, :]
    input_image = image[:, :-w, :]

    input_image = tf.reshape(input_image, [256,256,66])
    target_image = tf.reshape(target_image, [256,256,3])

    target_image = tf.cast(target_image, tf.float32)
    input_image = tf.cast(input_image, tf.float32)

    # normalizing the images to [-1, 1]
    target_image = (target_image / 127.5) - 1
    input_image = (input_image / 127.5) - 1

    return input_image, target_image

EPOCHS = int(1e+3)

train_dataset = tf.data.Dataset.list_files(PATH+'/*.png')
train_dataset = train_dataset.shuffle(BUFFER_SIZE)
train_dataset = train_dataset.map(lambda x: load_image(x))
train_dataset = train_dataset.batch(BATCH_SIZE)
print(train_dataset)

# Generator

OUTPUT_CHANNELS = 3

class Downsample(tf.keras.Model): #conv2d && Lrelu
    def __init__(self, filters, size=4, apply_batchnorm=True, first = False):
        super(Downsample, self).__init__()
        self.apply_batchnorm = apply_batchnorm
        self.first = first 
        initializer = tf.random_normal_initializer(0., 0.02)

        self.conv1 = tf.keras.layers.Conv2D(filters, 
                                            (size, size), 
                                            strides=2, 
                                            padding='same',
                                            kernel_initializer=initializer,
                                            use_bias=False)
        if self.apply_batchnorm:
            self.batchnorm = tf.keras.layers.BatchNormalization()

    def call(self, x, training):
        x = self.conv1(x)
        if self.apply_batchnorm:
            x = self.batchnorm(x, training=training)
        if not self.first:
            x = tf.nn.leaky_relu(x)
        return x 

class Upsample(tf.keras.Model):
    def __init__(self, filters, size, apply_dropout=False, first = False):
        super(Upsample, self).__init__()
        self.apply_dropout = apply_dropout
        self.first = first 
        initializer = tf.random_normal_initializer(0., 0.02)

        self.up_conv = tf.keras.layers.Conv2DTranspose(filters, 
                                                       (size, size), 
                                                       strides=2, 
                                                       padding='same',
                                                       kernel_initializer=initializer,
                                                       use_bias=False)

        self.refine = tf.keras.layers.Conv2D(filters, 
                                            (3, 3), 
                                            strides=1, 
                                            padding='same',
                                            kernel_initializer=initializer,
                                            use_bias=False)

        self.batchnorm = tf.keras.layers.BatchNormalization()

        if self.apply_dropout:
            self.dropout = tf.keras.layers.Dropout(0.5) #drop_out rate here 

    def call(self, x1, x2, training):
        x = self.up_conv(x1)
        x = self.batchnorm(x, training=training)
        if self.apply_dropout:
            x = self.dropout(x, training=training)
        x = self.refine(x)
        x = tf.nn.relu(x)
        x = self.refine(x)        
        x = tf.nn.relu(x)
        if not self.first:
            x = tf.concat([x, x2], axis=-1)

        return x

class Generator(tf.keras.Model):

    def __init__(self):
        super(Generator, self).__init__()
        initializer = tf.random_normal_initializer(0., 0.02)

        self.down1 = Downsample(64, 4, first = True)
        self.down2 = Downsample(128, 4)
        self.down3 = Downsample(256, 4)
        self.down4 = Downsample(512, 4)
        self.down5 = Downsample(512, 4)
        self.down6 = Downsample(512, 4)
        self.down7 = Downsample(512, 4)
        self.down8 = Downsample(512, 4)

        self.up1 = Upsample(512, 4, apply_dropout=True, first = True)
        self.up2 = Upsample(512, 4, apply_dropout=True)
        self.up3 = Upsample(512, 4, apply_dropout=True)
        self.up4 = Upsample(512, 4)
        self.up5 = Upsample(256, 4)
        self.up6 = Upsample(128, 4)
        self.up7 = Upsample(64, 4)

        self.last = tf.keras.layers.Conv2DTranspose(OUTPUT_CHANNELS, 
                                                    (4, 4), 
                                                    strides=2, 
                                                    padding='same',
                                                    kernel_initializer=initializer)

    @tf.contrib.eager.defun
    def call(self, x, training):
        # x shape == (bs, 256, 256, 3)    
        x1 = self.down1(x, training=training) # (bs, 128, 128, 64)
        x2 = self.down2(x1, training=training) # (bs, 64, 64, 128)
        x3 = self.down3(x2, training=training) # (bs, 32, 32, 256)
        x4 = self.down4(x3, training=training) # (bs, 16, 16, 512)
        x5 = self.down5(x4, training=training) # (bs, 8, 8, 512)
        x6 = self.down6(x5, training=training) # (bs, 4, 4, 512)
        x7 = self.down7(x6, training=training) # (bs, 2, 2, 512)
        x8 = self.down8(x7, training=training) # (bs, 1, 1, 512)

        x9 = self.up1(x8, x7, training=training) # (bs, 2, 2, 1024)
        x10 = self.up2(x9, x6, training=training) # (bs, 4, 4, 1024)
        x11 = self.up3(x10, x5, training=training) # (bs, 8, 8, 1024)
        x12 = self.up4(x11, x4, training=training) # (bs, 16, 16, 1024)
        x13 = self.up5(x12, x3, training=training) # (bs, 32, 32, 512)
        x14 = self.up6(x13, x2, training=training) # (bs, 64, 64, 256)
        x15 = self.up7(x14, x1, training=training) # (bs, 128, 128, 128)

        x16 = self.last(x15) # (bs, 256, 256, 3)
        x16 = tf.nn.tanh(x16)

        return x16

# Discriminator

class DiscDownsample(tf.keras.Model):

    def __init__(self, filters, size, apply_batchnorm=True, first = False):
        super(DiscDownsample, self).__init__()
        self.first = first 
        self.apply_batchnorm = apply_batchnorm
        initializer = tf.random_normal_initializer(0., 0.02)

        self.conv1 = tf.keras.layers.Conv2D(filters, 
                                            (size, size), 
                                            strides=2, 
                                            padding='same',
                                            kernel_initializer=initializer,
                                            use_bias=False)
        if self.apply_batchnorm:
            self.batchnorm = tf.keras.layers.BatchNormalization()

    def call(self, x, training):
        x = self.conv1(x)
        if self.apply_batchnorm:
            x = self.batchnorm(x, training=training)
        x = tf.nn.leaky_relu(x)
        return x 

class Discriminator(tf.keras.Model):

    def __init__(self):
        super(Discriminator, self).__init__()
        initializer = tf.random_normal_initializer(0., 0.02)

        self.down1 = DiscDownsample(64, 4, False)
        self.down2 = DiscDownsample(128, 4)
        self.down3 = DiscDownsample(256, 4)

        # we are zero padding here with 1 because we need our shape to 
        # go from (batch_size, 32, 32, 256) to (batch_size, 31, 31, 512)
        self.zero_pad1 = tf.keras.layers.ZeroPadding2D()
        self.conv = tf.keras.layers.Conv2D(512, 
                                           (4, 4), 
                                           strides=1, 
                                           kernel_initializer=initializer, 
                                           use_bias=False)
        self.batchnorm1 = tf.keras.layers.BatchNormalization()

        # shape change from (batch_size, 31, 31, 512) to (batch_size, 30, 30, 1)
        self.zero_pad2 = tf.keras.layers.ZeroPadding2D()
        self.last = tf.keras.layers.Conv2D(1, 
                                           (4, 4), 
                                           strides=1,
                                           kernel_initializer=initializer)

    @tf.contrib.eager.defun
    def call(self, inp, tar, training):
        # concatenating the input and the target
        x = tf.concat([inp, tar], axis=-1) # (bs, 256, 256, channels*2)
        x = self.down1(x, training=training) # (bs, 128, 128, 64)
        x = self.down2(x, training=training) # (bs, 64, 64, 128)
        x = self.down3(x, training=training) # (bs, 32, 32, 256)

        x = self.zero_pad1(x) # (bs, 34, 34, 256)
        x = self.conv(x)      # (bs, 31, 31, 512)
        x = self.batchnorm1(x, training=training)
        x = tf.nn.leaky_relu(x)

        x = self.zero_pad2(x) # (bs, 33, 33, 512)
        # don't add a sigmoid activation here since
        # the loss function expects raw logits.
        x = self.last(x)      # (bs, 30, 30, 1)

        return x

generator = Generator()
discriminator = Discriminator()

# Loss and Opter

LAMBDA = 100 #param for l1_loss

def discriminator_loss(disc_real_output, disc_generated_output):
    real_loss = tf.losses.sigmoid_cross_entropy(multi_class_labels = tf.ones_like(disc_real_output), 
                                              logits = disc_real_output)
    generated_loss = tf.losses.sigmoid_cross_entropy(multi_class_labels = tf.zeros_like(disc_generated_output), 
                                                   logits = disc_generated_output)

    total_disc_loss = real_loss + generated_loss

    return total_disc_loss

def generator_loss(disc_generated_output, gen_output, target):
    gan_loss = tf.losses.sigmoid_cross_entropy(multi_class_labels = tf.ones_like(disc_generated_output),
                                             logits = disc_generated_output) 
    # mean absolute error
    l1_loss = tf.reduce_mean(tf.abs(target - gen_output))

    total_gen_loss = gan_loss + (LAMBDA * l1_loss) 

    return total_gen_loss

generator_optimizer = tf.train.AdamOptimizer(2e-4, beta1=0.5)
discriminator_optimizer = tf.train.AdamOptimizer(2e-4, beta1=0.5)

# ckpt

checkpoint_dir = os.path.join('./log/', now)
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
                                 discriminator_optimizer=discriminator_optimizer,
                                 generator=generator,
                                 discriminator=discriminator)

# Train

def generate_images(epoch, step, model, test_input, tar, logDir):
    # the training=True is intentional here since
    # we want the batch statistics while running the model
    # on the test dataset. If we use training=False, we will get 
    # the accumulated statistics learned from the training dataset
    # (which we don't want)
    prediction = model(test_input, training=True)

    ## for disply the plots, it takes 1.2sec 
    display_list = [tar[0], prediction[0]]

    img1 = (tar[0] + 1.) * 127.5
    img2 = (prediction[0] + 1.) * 127.5
    img3 = np.append(img1, img2, axis = 1)
    img3 = cv2.cvtColor(img3, cv2.COLOR_BGR2RGB)

    image_name = "step-" + str(epoch+1) + "-"+ str(step) + ".jpg"
    mkdirs(logDir + "/images/")
    cv2.imwrite(logDir + "/images/" + image_name, img3)

def train(dataset, epochs):  
    for epoch in range(epochs):
        if (epoch + 1) % 6 == 0:
            epoch_start = time.time()

        mkdirs(checkpoint_dir)

        for step , (input_image, target) in enumerate(dataset):
            if step % 100 == 0:
                step_start = time.time()
            with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
                gen_output = generator(input_image, training=True)

                disc_real_output = discriminator(input_image, target, training=True)
                disc_generated_output = discriminator(input_image, gen_output, training=True)

                gen_loss = generator_loss(disc_generated_output, gen_output, target)
                disc_loss = discriminator_loss(disc_real_output, disc_generated_output)

            generator_gradients = gen_tape.gradient(gen_loss, 
                                                  generator.variables)
            discriminator_gradients = disc_tape.gradient(disc_loss, 
                                                       discriminator.variables)

            generator_optimizer.apply_gradients(zip(generator_gradients, 
                                                  generator.variables))
            discriminator_optimizer.apply_gradients(zip(discriminator_gradients, 
                                                      discriminator.variables))

            if step % 100 == 0:
                print('Time taken for step {} of epoch {} is {} sec\n'.format(step + 1, epoch+1,
                                            time.time()-step_start))
                clear_output(wait=True)
                for inp, tar in dataset.take(1):
                    generate_images(epoch, step, generator, inp, tar, checkpoint_dir)

        # saving (checkpoint) the model every 6 epochs
        if (epoch + 1) % 6 == 0:
            print('Time taken for epoch {} is {} sec\n'.format(epoch + 1,
                                                        time.time()-epoch_start))
            checkpoint.save(file_prefix = checkpoint_prefix)

train(train_dataset, EPOCHS)

错误

NotFoundError: No registered 'ZerosLike' OpKernel for GPU devices compatible with node Func/_191 = ZerosLike[T=DT_RESOURCE](downsample_conv2d_conv2d_readvariableop_resource)
     (OpKernel was found, but attributes didn't match)
    .  Registered:  device='CPU'; T in [DT_VARIANT]
  device='CPU'; T in [DT_STRING]
  device='CPU'; T in [DT_BOOL]
  device='CPU'; T in [DT_COMPLEX128]
  device='CPU'; T in [DT_COMPLEX64]
  device='CPU'; T in [DT_DOUBLE]
  device='CPU'; T in [DT_FLOAT]
  device='CPU'; T in [DT_BFLOAT16]
  device='CPU'; T in [DT_HALF]
  device='CPU'; T in [DT_INT8]
  device='CPU'; T in [DT_UINT8]
  device='CPU'; T in [DT_INT16]
  device='CPU'; T in [DT_UINT16]
  device='CPU'; T in [DT_INT32]
  device='CPU'; T in [DT_INT64]
  device='GPU'; T in [DT_INT32]
  device='GPU'; T in [DT_VARIANT]
  device='GPU'; T in [DT_INT64]
  device='GPU'; T in [DT_COMPLEX128]
  device='GPU'; T in [DT_COMPLEX64]
  device='GPU'; T in [DT_DOUBLE]
  device='GPU'; T in [DT_FLOAT]
  device='GPU'; T in [DT_BFLOAT16]
  device='GPU'; T in [DT_HALF]
  device='GPU'; T in [DT_BOOL]

     [[Node: Func/_191 = ZerosLike[T=DT_RESOURCE](downsample_conv2d_conv2d_readvariableop_resource)]]
     [[Node: gradients/generator_1/StatefulPartitionedCall_grad/SymbolicGradient = SymbolicGradient[Tin=[DT_FLOAT, DT_RESOURCE, DT_RESOURCE, DT_RESOURCE, DT_RESOURCE, ..., DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT], Tout=[DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, ..., DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT], f=__forward___inference_call_1463_1839[Tin=[DT_FLOAT, DT_RESOURCE, DT_RESOURCE, DT_RESOURCE, DT_RESOURCE, ..., DT_RESOURCE, DT_RESOURCE, DT_RESOURCE, DT_RESOURCE, DT_RESOURCE], Tout=[DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, ..., DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT, DT_FLOAT], f=__forward___inference_call_1463_1839[]], _device="/job:localhost/replica:0/task:0/device:GPU:0"](resize_images_resizebilinear, generator_1_statefulpartitionedcall_args_1, generator_1_statefulpartitionedcall_args_2, generator_1_statefulpartitionedcall_args_3, generator_1_statefulpartitionedcall_args_4, generator_1_statefulpartitionedcall_args_5, generator_1_statefulpartitionedcall_args_6, generator_1_statefulpartitionedcall_args_7, generator_1_statefulpartitionedcall_args_8, generator_1_statefulpartitionedcall_args_9, generator_1_statefulpartitionedcall_args_10, generator_1_statefulpartitionedcall_args_11, generator_1_statefulpartitionedcall_args_12, generator_1_statefulpartitionedcall_args_13, generator_1_statefulpartitionedcall_args_14, generator_1_statefulpartitionedcall_args_15, generator_1_statefulpartitionedcall_args_16, generator_1_statefulpartitionedcall_args_17, generator_1_statefulpartitionedcall_args_18, generator_1_statefulpartitionedcall_args_19, generator_1_statefulpartitionedcall_args_20, generator_1_statefulpartitionedcall_args_21, generator_1_statefulpartitionedcall_args_22, generator_1_statefulpartitionedcall_args_23, generator_1_statefulpartitionedcall_args_24, generator_1_statefulpartitionedcall_args_25, generator_1_statefulpartitionedcall_args_26, generator_1_statefulpartitionedcall_args_27, generator_1_statefulpartitionedcall_args_28, generator_1_statefulpartitionedcall_args_29, generator_1_statefulpartitionedcall_args_30, generator_1_statefulpartitionedcall_args_31, generator_1_statefulpartitionedcall_args_32, generator_1_statefulpartitionedcall_args_33, generator_1_statefulpartitionedcall_args_34, generator_1_statefulpartitionedcall_args_35, generator_1_statefulpartitionedcall_args_36, generator_1_statefulpartitionedcall_args_37, generator_1_statefulpartitionedcall_args_38, generator_1_statefulpartitionedcall_args_39, generator_1_statefulpartitionedcall_args_40, generator_1_statefulpartitionedcall_args_41, generator_1_statefulpartitionedcall_args_42, generator_1_statefulpartitionedcall_args_43, generator_1_statefulpartitionedcall_args_44, generator_1_statefulpartitionedcall_args_45, generator_1_statefulpartitionedcall_args_46, generator_1_statefulpartitionedcall_args_47, generator_1_statefulpartitionedcall_args_48, generator_1_statefulpartitionedcall_args_49, generator_1_statefulpartitionedcall_args_50, generator_1_statefulpartitionedcall_args_51, generator_1_statefulpartitionedcall_args_52, generator_1_statefulpartitionedcall_args_53, generator_1_statefulpartitionedcall_args_54, generator_1_statefulpartitionedcall_args_55, generator_1_statefulpartitionedcall_args_56, generator_1_statefulpartitionedcall_args_57, generator_1_statefulpartitionedcall_args_58, generator_1_statefulpartitionedcall_args_59, generator_1_statefulpartitionedcall_args_60, generator_1_statefulpartitionedcall_args_61, generator_1_statefulpartitionedcall_args_62, generator_1_statefulpartitionedcall_args_63, generator_1_statefulpartitionedcall_args_64, generator_1_statefulpartitionedcall_args_65, generator_1_statefulpartitionedcall_args_66, generator_1_statefulpartitionedcall_args_67, generator_1_statefulpartitionedcall_args_68, generator_1_statefulpartitionedcall_args_69, generator_1_statefulpartitionedcall_args_70, gradients/downsample_6/conv2d_24/Conv2D_grad/Conv2DBackpropInput, gradients/zeros_like_88, gradients/zeros_like_89, gradients/zeros_like_90, gradients/zeros_like_91, gradients/zeros_like_92, gradients/zeros_like_93, gradients/zeros_like_94, gradients/zeros_like_95, gradients/zeros_like_96, gradients/zeros_like_97, gradients/zeros_like_98, gradients/zeros_like_99, gradients/zeros_like_100, gradients/zeros_like_101, gradients/zeros_like_102, gradients/zeros_like_103, gradients/zeros_like_104, gradients/zeros_like_105, gradients/zeros_like_106, gradients/zeros_like_107, gradients/zeros_like_108, gradients/zeros_like_109, gradients/zeros_like_110, gradients/zeros_like_111, gradients/zeros_like_112, gradients/zeros_like_113, gradients/zeros_like_114, gradients/zeros_like_115, gradients/zeros_like_116, gradients/zeros_like_117, gradients/zeros_like_118, gradients/zeros_like_119, gradients/zeros_like_120, gradients/zeros_like_121, gradients/zeros_like_122, gradients/zeros_like_123, gradients/zeros_like_124, gradients/zeros_like_125, gradients/zeros_like_126, gradients/zeros_like_127, gradients/zeros_like_128, gradients/zeros_like_129, gradients/zeros_like_130, gradients/zeros_like_131, gradients/zeros_like_132, gradients/zeros_like_133, gradients/zeros_like_134, gradients/zeros_like_135, gradients/zeros_like_136, gradients/zeros_like_137, gradients/zeros_like_138, gradients/zeros_like_139, gradients/zeros_like_140, gradients/zeros_like_141, gradients/zeros_like_142, gradients/zeros_like_143, gradients/zeros_like_144, gradients/zeros_like_145, gradients/zeros_like_146, gradients/zeros_like_147, gradients/zeros_like_148, gradients/zeros_like_149, gradients/zeros_like_150, gradients/zeros_like_151, gradients/zeros_like_152, gradients/zeros_like_153, gradients/zeros_like_154, gradients/zeros_like_155, gradients/zeros_like_156, gradients/zeros_like_157, gradients/zeros_like_158, gradients/zeros_like_159, gradients/zeros_like_160, gradients/zeros_like_161, gradients/zeros_like_162, gradients/zeros_like_163, gradients/zeros_like_164, gradients/zeros_like_165, gradients/zeros_like_166, gradients/zeros_like_167, gradients/zeros_like_168, gradients/zeros_like_169, gradients/zeros_like_170, gradients/zeros_like_171, gradients/zeros_like_172, gradients/zeros_like_173, gradients/zeros_like_174, gradients/zeros_like_175, gradients/zeros_like_176, gradients/zeros_like_177, gradients/zeros_like_178, gradients/zeros_like_179, gradients/zeros_like_180, gradients/zeros_like_181, gradients/zeros_like_182, gradients/zeros_like_183, gradients/zeros_like_184, gradients/zeros_like_185, gradients/zeros_like_186, gradients/zeros_like_187, gradients/zeros_like_188, gradients/zeros_like_189, gradients/zeros_like_190, gradients/zeros_like_191, gradients/zeros_like_192, gradients/zeros_like_193, gradients/zeros_like_194, gradients/zeros_like_195, gradients/zeros_like_196, gradients/zeros_like_197, gradients/zeros_like_198, gradients/zeros_like_199, gradients/zeros_like_200, gradients/zeros_like_201, gradients/zeros_like_202, gradients/zeros_like_203, gradients/zeros_like_204, gradients/zeros_like_205, gradients/zeros_like_206, gradients/zeros_like_207, gradients/zeros_like_208, gradients/zeros_like_209, gradients/zeros_like_210, gradients/zeros_like_211, gradients/zeros_like_212, gradients/zeros_like_213, gradients/zeros_like_214, gradients/zeros_like_215, gradients/zeros_like_216, gradients/zeros_like_217, gradients/zeros_like_218, gradients/zeros_like_219, gradients/zeros_like_220, gradients/zeros_like_221, gradients/zeros_like_222, gradients/zeros_like_223, gradients/zeros_like_224, gradients/zeros_like_225, gradients/zeros_like_226, gradients/zeros_like_227, gradients/zeros_like_228, gradients/zeros_like_229, gradients/zeros_like_230, gradients/zeros_like_231, gradients/zeros_like_232, gradients/zeros_like_233, gradients/zeros_like_234, gradients/zeros_like_235, gradients/zeros_like_236, gradients/zeros_like_237, gradients/zeros_like_238, gradients/zeros_like_239, gradients/zeros_like_240, gradients/zeros_like_241, gradients/zeros_like_242, gradients/zeros_like_243, gradients/zeros_like_244, gradients/zeros_like_245, gradients/zeros_like_246, gradients/zeros_like_247, gradients/zeros_like_248, gradients/zeros_like_249, gradients/zeros_like_250, gradients/zeros_like_251, gradients/zeros_like_252, gradients/zeros_like_253, gradients/zeros_like_254, gradients/zeros_like_255, gradients/zeros_like_256, gradients/zeros_like_257, gradients/zeros_like_258, gradients/zeros_like_259, gradients/zeros_like_260, gradients/zeros_like_261)]] [Op:PartitionedCall]

标签: tensorflowkeraskernelgpueager

解决方案


我也遇到过同样的问题,目前这个问题似乎没有明确的答案。您可以查看 Tensorflow 的 github 专用问题的演变: https ://github.com/tensorflow/tensorflow/issues/20369

但也有人指出,这可能与int32tensorflow 中的某些数据类型(例如 )不是由 GPU 处理而是由 CPU 处理有关。因此,可以通过将有问题的变量的类型更改为uint32or来解决您的问题int64


推荐阅读