টেনসরফ্লো :: অপস:: সংগ্রহ করা

#include <array_ops.h>

indices দ্বারা নির্দিষ্ট আকৃতি সহ একটি টেনসরে params থেকে স্লাইস সংগ্রহ করুন ।

সারাংশ

indices হল একটি K-মাত্রিক পূর্ণসংখ্যার টেনসর, সর্বোত্তমভাবে বিবেচনা করা হয় একটি (K-1)-মাত্রিক টেনসর হিসাবে সূচকগুলির params , যেখানে প্রতিটি উপাদান params একটি স্লাইস সংজ্ঞায়িত করে:

output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]

যেখানে tf.gather indices params axis মাত্রায় স্লাইসগুলিকে সংজ্ঞায়িত করে, tf.gather_nd এ, indices params প্রথম N মাত্রাগুলিতে স্লাইসগুলিকে সংজ্ঞায়িত করে, যেখানে N = indices.shape[-1] ।

indices শেষ মাত্রা সর্বাধিক params র্যাঙ্ক হতে পারে:

indices.shape[-1] <= params.rank

indices শেষ মাত্রা উপাদানগুলির সাথে মিলে যায় (যদি indices.shape[-1] == params.rank ) বা params মাত্রা indices.shape[-1] বরাবর স্লাইস ( indices.shape[-1] indices.shape[-1] < params.rank ) . আউটপুট টেনসরের আকৃতি আছে

indices.shape[:-1] + params.shape[indices.shape[-1]:]

মনে রাখবেন যে CPU-তে, আউট অফ বাউন্ড সূচক পাওয়া গেলে, একটি ত্রুটি ফেরত দেওয়া হয়। GPU-তে, যদি একটি আউট অফ বাউন্ড সূচক পাওয়া যায়, একটি 0 সংশ্লিষ্ট আউটপুট মানের মধ্যে সংরক্ষণ করা হয়।

নিচে কিছু উদাহরণ।

একটি ম্যাট্রিক্সে সহজ সূচীকরণ:

    indices = [[0, 0], [1, 1]]
    params = [['a', 'b'], ['c', 'd']]
    output = ['a', 'd']

একটি ম্যাট্রিক্সে সূচী স্লাইস করুন:

    indices = [[1], [0]]
    params = [['a', 'b'], ['c', 'd']]
    output = [['c', 'd'], ['a', 'b']]

একটি 3-টেনসরে সূচীকরণ:

    indices = [[1]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [[['a1', 'b1'], ['c1', 'd1']]]

    indices = [[0, 1], [1, 0]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [['c0', 'd0'], ['a1', 'b1']]

    indices = [[0, 0, 1], [1, 0, 1]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = ['b0', 'b1']

একটি ম্যাট্রিক্সে ব্যাচ করা ইন্ডেক্সিং:

    indices = [[[0, 0]], [[0, 1]]]
    params = [['a', 'b'], ['c', 'd']]
    output = [['a'], ['b']]

একটি ম্যাট্রিক্সে ব্যাচড স্লাইস ইন্ডেক্সিং:

    indices = [[[1]], [[0]]]
    params = [['a', 'b'], ['c', 'd']]
    output = [[['c', 'd']], [['a', 'b']]]

একটি 3-টেনসরে ব্যাচ করা ইন্ডেক্সিং:

    indices = [[[1]], [[0]]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [[[['a1', 'b1'], ['c1', 'd1']]],
              [[['a0', 'b0'], ['c0', 'd0']]]]

    indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [[['c0', 'd0'], ['a1', 'b1']],
              [['a0', 'b0'], ['c1', 'd1']]]

    indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [['b0', 'b1'], ['d0', 'c1']]

এছাড়াও tf.gather এবং tf.batch_gather দেখুন।

যুক্তি:

• স্কোপ: একটি স্কোপ অবজেক্ট
• params: যে টেনসর থেকে মান সংগ্রহ করতে হয়।
• indices: সূচক টেনসর।

রিটার্ন:

• Output : indices দ্বারা প্রদত্ত সূচকগুলি থেকে সংগৃহীত params থেকে মানগুলি, আকৃতির indices.shape[:-1] + params.shape[indices.shape[-1]:] সহ।

কনস্ট্রাক্টর এবং ডেস্ট্রাক্টর
GatherNd (const :: tensorflow::Scope & scope, :: tensorflow::Input params, :: tensorflow::Input indices)

পাবলিক বৈশিষ্ট্য
operation	Operation
output	:: tensorflow::Output

পাবলিক ফাংশন
node () const	::tensorflow::Node *
operator::tensorflow::Input () const
operator::tensorflow::Output () const

পাবলিক বৈশিষ্ট্য

অপারেশন

Operation operation

আউটপুট

::tensorflow::Output output

পাবলিক ফাংশন

সংগ্রহ করা

 GatherNd(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input params,
  ::tensorflow::Input indices
)

নোড

::tensorflow::Node * node() const 

অপারেটর::টেনসরফ্লো::ইনপুট

 operator::tensorflow::Input() const 

অপারেটর::টেনসরফ্লো::আউটপুট

 operator::tensorflow::Output() const