tensorflow - get max von Tensor

Question

So habe ich einen Tensor h_in der Form (50, ?, 1, 100), die ich jetzt gerne in Form (50, 1, 1, 100) durch die Übernahme der max über die Achse 1 werden würde.

Wie mache ich das?

Ich versuchte

h_out = max_pool(h_in) 

mit

def max_pool(h,ksize=[1,-1,1,1],strides=[1,1,1,1],padding='VALID'): 
    return tf.nn.max_pool(h,ksize=ksize,strides=strides,padding=padding) 

aber das scheint nicht die Größe zu reduzieren.

runnable Beispiel:

import tensorflow as tf 
import numpy as np 
import numpy.random as nprand 

def _weight_variable(shape,name): 
    initial = tf.truncated_normal(shape,stddev=0.1) 
    v = tf.Variable(initial,name=name) 
    return v 

def _bias_variable(shape,name): 
    initial = tf.constant(0.1,shape=shape) 
    v = tf.Variable(initial,name=name) 
    return v 

def _embedding_variable(shape,name): 
    initial = tf.truncated_normal(shape) 
    v = tf.Variable(initial,name=name) 
    return v 

def conv2d(x,W,strides=[1,1,1,1],padding='VALID'): 
    return tf.nn.conv2d(x,W,strides=strides,padding=padding) 

def max_pool(h,ksize=[1,-1,1,1],strides=[1,1,1,1],padding='VALID'): 
    return tf.nn.max_pool(h,ksize=ksize,strides=strides,padding=padding) 

nof_embeddings= 55000 
dim_embeddings = 300 

batch_size = 50 
filter_size = 100 
x_input = tf.placeholder(tf.int32, shape=[batch_size, None]) 

def _model(): 

    embeddings = _embedding_variable([nof_embeddings,dim_embeddings],'embeddings') 

    h_lookup = tf.nn.embedding_lookup(embeddings,x_input) 
    h_embed = tf.reshape(h_lookup,[batch_size,-1,dim_embeddings,1]) 

    f = 3 

    W_conv1f = _weight_variable([f,dim_embeddings,1,filter_size],f'W_conv1_{f}') 
    b_conv1f = _bias_variable([filter_size],f'b_conv1_{f}') 
    h_conv1f = tf.nn.relu(conv2d(h_embed,W_conv1f) + b_conv1f) 

    h_pool1f = max_pool(h_conv1f) 

    print("h_embed:",h_embed.get_shape()) 
    print() 
    print(f'h_conv1_{f}:',h_conv1f.get_shape()) 
    print(f'h_pool1_{f}:',h_pool1f.get_shape()) 
    print() 

    return tf.shape(h_pool1f) 

if __name__ == '__main__': 

    tensor_length = 35 

    model = _model() 
    with tf.Session() as sess: 
     tf.global_variables_initializer().run() 
     batch = nprand.randint(0,nof_embeddings,size=[batch_size,tensor_length]) 
     shape = sess.run(model, 
         feed_dict ={ 
           x_input : batch 
           }) 
     print('result:',shape) 

die Ausgänge

h_embed: (50, ?, 300, 1) 

h_conv1_3: (50, ?, 1, 100) 
h_pool1_3: (50, ?, 1, 100) 

result: [ 50 35 1 100] 

Sagen wir, ich stattdessen die Größe codieren, was ich will:

h_pool1f = max_pool(h_conv1f,ksize=[1,35-f+1,1,1]) 

, das funktioniert. Aber jetzt bin ich in Schwierigkeiten, sobald ich die tensor_length (die zur Laufzeit festgelegt ist, also nein, ich kann es nicht fest codieren).

Eine "Lösung" wäre es, die Eingabe bis zu einer festen maximalen Länge durch Auffüllen oder etwas zu blasen, aber das führt wiederum unnötige Berechnungen und eine künstliche Kappe ein, die ich sehr gerne vermeiden würde.

So gibt es

• einen Weg tensorflow "richtig" erkennt die -1 in k_size zu machen?
• oder eine andere Möglichkeit, das Maximum zu berechnen?

Answer 1

ich tf.reduce_max denken ist, was Sie suchen: https://www.tensorflow.org/api_docs/python/tf/reduce_max

Verbrauch:

tens = some tensorflow.Tensor 
ax = some positive integer, or -1 or None 
red_m = tf.reduce_max(tens, axis=ax) 

Wenn zig hat [shape_0, shape_1, shape_2] Form, der resultierende Tensor red_m Form haben [shape_1, shape_2] wenn ax=0, Form [shape_0, shape_2] wenn ax=1, und so weiter. Wenn ax=-1, wird die letzte Achse abgeleitet, während bei ax=None die Reduzierung entlang aller Achsen erfolgt.