web-dev-qa-db-fra.com

Comment réparer MatMul Op a un type float64 qui ne correspond pas au type float32 TypeError?

J'essaie d'enregistrer les poids du réseau Nueral dans un fichier, puis de restaurer ces poids en initialisant le réseau au lieu d'une initialisation aléatoire. Mon code fonctionne bien avec une initialisation aléatoire. Mais, lorsque j'initialise des poids à partir d'un fichier, cela me montre une erreur TypeError: Input 'b' of 'MatMul' Op has type float64 that does not match type float32 of argument 'a'. Je ne sais pas comment résoudre ce problème. Voici mon code:

Initialisation du modèle 

# Parameters
training_epochs = 5
batch_size = 64
display_step = 5
batch = tf.Variable(0, trainable=False)
regualarization =  0.008

# Network Parameters
n_hidden_1 = 300 # 1st layer num features
n_hidden_2 = 250 # 2nd layer num features

n_input = model.layer1_size # Vector input (sentence shape: 30*10)
n_classes = 12 # Sentence Category detection total classes (0-11 categories)

#History storing variables for plots
loss_history = []
train_acc_history = []
val_acc_history = []

# tf Graph input
x = tf.placeholder("float", [None, n_input])
y = tf.placeholder("float", [None, n_classes])

Paramètres du modèle 

#loading Weights
def weight_variable(fan_in, fan_out, filename):
    stddev = np.sqrt(2.0/fan_in)
    if (filename == ""):
        initial  = tf.random_normal([fan_in,fan_out], stddev=stddev)
    else:
        initial  = np.loadtxt(filename)
    print initial.shape
    return tf.Variable(initial)

#loading Biases
def bias_variable(shape, filename):
    if (filename == ""):
     initial = tf.constant(0.1, shape=shape)
    else:
     initial  = np.loadtxt(filename)  
    print initial.shape
    return tf.Variable(initial)

# Create model
def multilayer_perceptron(_X, _weights, _biases):
    layer_1 = tf.nn.relu(tf.add(tf.matmul(_X, _weights['h1']), _biases['b1'])) 
    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2'])) 
    return tf.matmul(layer_2, weights['out']) + biases['out']  

# Store layers weight & bias
weights = {
'h1':  w2v_utils.weight_variable(n_input, n_hidden_1,    filename="weights_h1.txt"),
'h2':  w2v_utils.weight_variable(n_hidden_1, n_hidden_2, filename="weights_h2.txt"),
'out': w2v_utils.weight_variable(n_hidden_2, n_classes,  filename="weights_out.txt") 
}

 biases = {
'b1': w2v_utils.bias_variable([n_hidden_1], filename="biases_b1.txt"),
'b2': w2v_utils.bias_variable([n_hidden_2], filename="biases_b2.txt"),
'out': w2v_utils.bias_variable([n_classes], filename="biases_out.txt")
}

# Define loss and optimizer
#learning rate
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
learning_rate = tf.train.exponential_decay(
    0.02*0.01,           # Base learning rate. #0.002
    batch * batch_size,  # Current index into the dataset.
    X_train.shape[0],    # Decay step.
    0.96,                # Decay rate.
    staircase=True)


# Construct model
pred = tf.nn.relu(multilayer_perceptron(x, weights, biases))

#L2 regularization
l2_loss = tf.add_n([tf.nn.l2_loss(v) for v in tf.trainable_variables()])

#Softmax loss
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) 

#Total_cost
cost = cost+ (regualarization*0.5*l2_loss)

# Adam Optimizer
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost,global_step=batch)


# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Initializing the variables
init = tf.initialize_all_variables()

print "Network Initialized!"

DÉTAILS D'ERREUR enter image description here

pythonmachine-learningneural-networktensorflow
22
Nomiluks

L'opération tf.matmul() n'effectue pas de conversion de type automatique, donc ses deux entrées doivent avoir le même type d'élément. Le message d'erreur que vous voyez indique que vous avez un appel à tf.matmul() où le premier argument a le type tf.float32 Et le deuxième argument a le type tf.float64. Vous devez convertir l'une des entrées pour qu'elle corresponde à l'autre, par exemple en utilisant tf.cast(x, tf.float32) .

En regardant votre code, je ne vois nulle part où un tenseur tf.float64 Est explicitement créé (le dtype par défaut pour les valeurs à virgule flottante dans le TensorFlow Python API — par exemple pour tf.constant(37.0)— est tf.float32). Je suppose que les erreurs sont causées par les appels np.loadtxt(filename), qui pourraient charger un np.float64 Vous pouvez les modifier explicitement pour charger les tableaux np.float32 (qui sont convertis en tenseurs tf.float32) comme suit:

initial = np.loadtxt(filename).astype(np.float32)
41
mrry

Bien que ce soit une vieille question, mais j'aimerais que vous mentionniez que j'ai rencontré le même problème. Je l'ai résolu en utilisant dtype=tf.float64 pour l'initialisation des paramètres et pour la création d'espaces réservés X et Y également.

Voici l'instantané de mon code.

X = tf.placeholder(shape=[n_x, None],dtype=tf.float64)
Y = tf.placeholder(shape=[n_y, None],dtype=tf.float64)

et

parameters['W' + str(l)] = tf.get_variable('W' + str(l), [layers_dims[l],layers_dims[l-1]],dtype=tf.float64, initializer = tf.contrib.layers.xavier_initializer(seed = 1))
parameters['b' + str(l)] = tf.get_variable('b' + str(l), [layers_dims[l],1],dtype=tf.float64, initializer = tf.zeros_initializer())

La déclaration de tous les placholders et paramètres avec le type de données float64 résoudra ce problème.

4
Abdul Karim Khan