Comment résoudre une erreur d'argument Tensorflow Fetch en essayant de passer des arguments via feed_dict?

Question

Ci-dessous le code que je suis en cours d'exécution dans lequel je suis en train de mettre en œuvre un document. Je prends deux matrices, les multiplie et ensuite fais des regroupements. Qu'est-ce que je fais mal?

import tensorflow as tf 
from sklearn.cluster import KMeans 
import numpy as np 

a = np.random.rand(10,10) 
b = np.random.rand(10,5) 
F = tf.placeholder("float", [None, 10], name='F') 
mask = tf.placeholder("float", [None, 5], name='mask') 

def getZfeature(F,mask): 
    return tf.matmul(F,mask) 

def cluster(zfeature):  
    #km = KMeans(n_clusters=3) 
    #km.fit(x) 
    #mu = km.cluster_centers_ 
    return zfeature 

def computeQ(zfeature,mu): 
    print "computing q matrix" 
    print type(zfeature), type(mu) 

#construct model 
zfeature = getZfeature(F,mask) 
mu = cluster(zfeature) 
q = computeQ(zfeature,mu) 

init = tf.global_variables_initializer() 

with tf.Session() as sess: 
    sess.run(init) 
    sess.run(q, feed_dict={F: a, mask: b}) 

Answer 1

Code de travail ci-dessous. Votre problème est que q et mu ne font rien. q est une référence à la fonction computeQ car elle ne renvoie rien. mu ne fait rien donc dans cette réponse j'ai évalué zfeature. Vous pouvez faire plus d'opérations tensorielles dans ces deux fonctions, mais vous devez retourner un tenseur pour que cela fonctionne.

import tensorflow as tf 
from sklearn.cluster import KMeans 
import numpy as np 

a = np.random.rand(10,10) 
b = np.random.rand(10,5) 
F = tf.placeholder("float", [None, 10], name='F') 
mask = tf.placeholder("float", [None, 5], name='mask') 

def getZfeature(F,mask): 
    return tf.matmul(F,mask) 

def cluster(zfeature): 
    #km = KMeans(n_clusters=3) 
    #km.fit(x) 
    #mu = km.cluster_centers_ 
    return zfeature 

def computeQ(zfeature,mu): 
    print ("computing q matrix") 
    print (type(zfeature), type(mu)) 

#construct model 
zfeature = getZfeature(F,mask) 
mu = cluster(zfeature) 
q = computeQ(zfeature,mu) 

init = tf.global_variables_initializer() 

with tf.Session() as sess: 
    sess.run(init) 
    result=sess.run(zfeature, feed_dict={F: a, mask: b}) 
    print(result) 

Answer 2

Voici le code pour k-means utilisant tensorflow de https://codesachin.wordpress.com/2015/11/14/k-means-clustering-with-tensorflow/

import tensorflow as tf 
from random import choice, shuffle 
from numpy import array 


def TFKMeansCluster(vectors, noofclusters): 
    """ 
    K-Means Clustering using TensorFlow. 
    'vectors' should be a n*k 2-D NumPy array, where n is the number 
    of vectors of dimensionality k. 
    'noofclusters' should be an integer. 
    """ 

    noofclusters = int(noofclusters) 
    assert noofclusters < len(vectors) 

    #Find out the dimensionality 
    dim = len(vectors[0]) 

    #Will help select random centroids from among the available vectors 
    vector_indices = list(range(len(vectors))) 
    shuffle(vector_indices) 

    #GRAPH OF COMPUTATION 
    #We initialize a new graph and set it as the default during each run 
    #of this algorithm. This ensures that as this function is called 
    #multiple times, the default graph doesn't keep getting crowded with 
    #unused ops and Variables from previous function calls. 

    graph = tf.Graph() 

    with graph.as_default(): 

     #SESSION OF COMPUTATION 

     sess = tf.Session() 

     ##CONSTRUCTING THE ELEMENTS OF COMPUTATION 

     ##First lets ensure we have a Variable vector for each centroid, 
     ##initialized to one of the vectors from the available data points 
     centroids = [tf.Variable((vectors[vector_indices[i]])) 
        for i in range(noofclusters)] 
     ##These nodes will assign the centroid Variables the appropriate 
     ##values 
     centroid_value = tf.placeholder("float64", [dim]) 
     cent_assigns = [] 
     for centroid in centroids: 
      cent_assigns.append(tf.assign(centroid, centroid_value)) 

     ##Variables for cluster assignments of individual vectors(initialized 
     ##to 0 at first) 
     assignments = [tf.Variable(0) for i in range(len(vectors))] 
     ##These nodes will assign an assignment Variable the appropriate 
     ##value 
     assignment_value = tf.placeholder("int32") 
     cluster_assigns = [] 
     for assignment in assignments: 
      cluster_assigns.append(tf.assign(assignment, 
              assignment_value)) 

     ##Now lets construct the node that will compute the mean 
     #The placeholder for the input 
     mean_input = tf.placeholder("float", [None, dim]) 
     #The Node/op takes the input and computes a mean along the 0th 
     #dimension, i.e. the list of input vectors 
     mean_op = tf.reduce_mean(mean_input, 0) 

     ##Node for computing Euclidean distances 
     #Placeholders for input 
     v1 = tf.placeholder("float", [dim]) 
     v2 = tf.placeholder("float", [dim]) 
     euclid_dist = tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(
      v1, v2), 2))) 

     ##This node will figure out which cluster to assign a vector to, 
     ##based on Euclidean distances of the vector from the centroids. 
     #Placeholder for input 
     centroid_distances = tf.placeholder("float", [noofclusters]) 
     cluster_assignment = tf.argmin(centroid_distances, 0) 

     ##INITIALIZING STATE VARIABLES 

     ##This will help initialization of all Variables defined with respect 
     ##to the graph. The Variable-initializer should be defined after 
     ##all the Variables have been constructed, so that each of them 
     ##will be included in the initialization. 
     init_op = tf.initialize_all_variables() 

     #Initialize all variables 
     sess.run(init_op) 

     ##CLUSTERING ITERATIONS 

     #Now perform the Expectation-Maximization steps of K-Means clustering 
     #iterations. To keep things simple, we will only do a set number of 
     #iterations, instead of using a Stopping Criterion. 
     noofiterations = 100 
     for iteration_n in range(noofiterations): 

      ##EXPECTATION STEP 
      ##Based on the centroid locations till last iteration, compute 
      ##the _expected_ centroid assignments. 
      #Iterate over each vector 
      for vector_n in range(len(vectors)): 
       vect = vectors[vector_n] 
       #Compute Euclidean distance between this vector and each 
       #centroid. Remember that this list cannot be named 
       #'centroid_distances', since that is the input to the 
       #cluster assignment node. 
       distances = [sess.run(euclid_dist, feed_dict={ 
        v1: vect, v2: sess.run(centroid)}) 
          for centroid in centroids] 
       #Now use the cluster assignment node, with the distances 
       #as the input 
       assignment = sess.run(cluster_assignment, feed_dict = { 
        centroid_distances: distances}) 
       #Now assign the value to the appropriate state variable 
       sess.run(cluster_assigns[vector_n], feed_dict={ 
        assignment_value: assignment}) 

      ##MAXIMIZATION STEP 
      #Based on the expected state computed from the Expectation Step, 
      #compute the locations of the centroids so as to maximize the 
      #overall objective of minimizing within-cluster Sum-of-Squares 
      for cluster_n in range(noofclusters): 
       #Collect all the vectors assigned to this cluster 
       assigned_vects = [vectors[i] for i in range(len(vectors)) 
            if sess.run(assignments[i]) == cluster_n] 
       #Compute new centroid location 
       new_location = sess.run(mean_op, feed_dict={ 
        mean_input: array(assigned_vects)}) 
       #Assign value to appropriate variable 
       sess.run(cent_assigns[cluster_n], feed_dict={ 
        centroid_value: new_location}) 

     #Return centroids and assignments 
     centroids = sess.run(centroids) 
     assignments = sess.run(assignments) 
     return centroids, assignments