Dòng chảy: Về các chức năng lưu lượng dòng chảy

Question

Tôi mới sử dụng lưu lượng tensorflow. Tôi có vấn đề sau đây:

đầu vào: danh sách các phao nổi (. Hoặc một mảng động Trong danh sách python là datatype để được sử dụng) Output: là một 2-d mảng có kích thước len(input) × len(input)

example1 :

Input:

[1.0, 2.0, 3.0] 

Output:

[[0.09003057, 0.24472847, 0.66524096], 
[0.26894142, 0.73105858, 0.0  ], 
[1.0,  0.0,  0.0  ]] 

Tôi cố gắng tạo hàm bằng cách sử dụng vòng lặp while và tính toán từng hàng một cách độc lập và nối chúng với nhau, nhưng người hướng dẫn của tôi đã yêu cầu tôi khám phá các cách khác.

Bạn có thể đề xuất cho tôi ý tưởng về cách tiếp cận vấn đề này không?

Answer 1

Bạn có thể đạt được điều này với các phương pháp sau đây:

1. Lặp lại các mảng đầu vào để tạo ra một ma trận vuông lát gạch các dữ liệu đầu vào
2. Tạo một mặt nạ với bao gồm những người ở góc trên bên trái
3. Làm softmax bằng mặt nạ. Lưu ý rằng chúng tôi không thể sử dụng tf.nn.softmax ở đây vì nó sẽ cho xác suất nhỏ cho những số không cũng

Đây là một TensorFlow (v0.12.1) mã mà thực hiện điều này:

def create_softmax(x): 
    x_len = int(x.get_shape()[0]) 

    # create a tiled array 
    # [1, 2, 3] 
    # => 
    # [[1,2,3], [1,2,3], [1,2,3]] 
    x_tiled = tf.tile(tf.expand_dims(x, 0), [x_len, 1]) 

    # get the mask to do element-wise multiplication 
    mask = tf.ones_like(x_tiled) # returns an array of the same size filled with 1 
    mask = tf.matrix_band_part(mask, 0, -1) # zeros everythings except from the upper triangular part 
    mask = tf.reverse(mask, [False, True]) # reverses the y dimension 

    # compute masked softmax 
    exp = tf.exp(x_tiled) * mask 
    sum_exp = tf.reshape(tf.reduce_sum(exp, reduction_indices=1), (-1, 1)) 

    x_softmax = exp/sum_exp 

    return x_softmax 

Answer 2

Đây có lẽ là hơi muộn cho lớp học của bạn, nhưng hy vọng nó sẽ giúp một ai đó.

Nếu mục tiêu của bạn là chỉ cần ra một mảng len(input)xlen(input), bạn có thể ma trận nhân một tensor 1xlen(input) với mảng đầu vào của bạn sau khi mở rộng kích thước của nó để len(input)x1:

input_ = tf.placeholder(tf.float32, [len(input)]) 
input_shape = input_.get_shape().as_list() 
tfvar = tf.Variable(tf.random_normal([1,input_shape[0]], mean=0.0, 
            stddev=.01, dtype=tf.float32)) 

def function(input_): 
    x = tf.expand_dims(input_, axis=1) # dims = len(input)x1 
    return tf.matmul(x,tfvar) # mtrx multiplication produces 3x3 mtrx 

Chức năng này nên khái quát cho bất kỳ 1D input_ tensor và tạo ra một dây chuyền hình vuông len(input_)xlen(input_).

Nếu mục tiêu của bạn là để đào tạo một biến tensorflow để sản xuất sản lượng cung cấp chính xác, sau đó bạn có thể đào tạo tfvar với một chức năng mất mát và tối ưu hóa:

desired_output = tf.constant([[0.09003057, 0.24472847, 0.66524096], 
           [0.26894142, 0.73105858, 0.0  ], 
           [1.0,  0.0,  0.0  ]], 
           dtype=tf.float32) 

actual_output = function(input_) 
loss = tf.reduce_mean(tf.square(actual_output-desired_output)) 
optimizer = tf.train.AdamOptimizer().minimize(loss) 

init = tf.global_variables_initializer() 
with tf.Session() as sess: 
    sess.run(init) 
    cost, opt = sess.run([loss, optimizer], feed_dict={input_:input}) 

Lưu ý, nếu bạn muốn có một buổi tập mạnh mẽ hơn, thêm một thiên vị, một phi tuyến tính, và nhiều lớp hơn.