টেনসরফ্লো :: অপস:: MatrixDiagV2

প্রদত্ত ব্যাচ করা তির্যক মান সহ একটি ব্যাচড তির্যক টেনসর প্রদান করে।

সারাংশ

একটি ম্যাট্রিক্সের k[0] -th থেকে k[1] -th কর্ণ হিসাবে diagonal বিষয়বস্তু সহ একটি টেনসর প্রদান করে, বাকি সবকিছু padding দিয়ে প্যাড করা হয়। num_rows এবং num_cols আউটপুটের অন্তর্নিহিত ম্যাট্রিক্সের মাত্রা নির্দিষ্ট করে। যদি উভয়টি নির্দিষ্ট করা না থাকে, তাহলে op অনুমান করে সবচেয়ে ভিতরের ম্যাট্রিক্সটি বর্গক্ষেত্র এবং k থেকে এর আকার এবং diagonal ভেতরেরতম মাত্রা অনুমান করে। যদি তাদের মধ্যে শুধুমাত্র একটি নির্দিষ্ট করা হয়, op অনুমান করে যে অনির্দিষ্ট মানটি অন্যান্য মানদণ্ডের উপর ভিত্তি করে সম্ভাব্য সবচেয়ে ছোট।

ধরা যাক diagonal r মাত্রা আছে [I, J, ..., L, M, N] । আউটপুট টেনসরের আকৃতির সাথে r+1 আছে [I, J, ..., L, M, num_rows, num_cols] যখন শুধুমাত্র একটি তির্যক দেওয়া হয় ( k হল একটি পূর্ণসংখ্যা বা k[0] == k[1] ) . অন্যথায়, এটির আকৃতির সাথে r আছে [I, J, ..., L, num_rows, num_cols] ।

diagonal দ্বিতীয় অন্তরতম মাত্রার দ্বিগুণ অর্থ রয়েছে। যখন k স্কেলার বা k[0] == k[1] , M ব্যাচ আকারের অংশ [I, J, ..., M], এবং আউটপুট টেনসর হল:

output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
    padding_value                             ; otherwise

অন্যথায়, M একই ব্যাচের ম্যাট্রিক্সের জন্য কর্ণের সংখ্যা হিসাবে বিবেচনা করা হয় ( M = k[1]-k[0]+1 ), এবং আউটপুট টেনসর হল:

output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
    padding_value                                     ; otherwise

যেমন:

# The main diagonal.
diagonal = np.array([[1, 2, 3, 4],            # Input shape: (2, 4)
                     [5, 6, 7, 8]])
tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0],  # Output shape: (2, 4, 4)
                               [0, 2, 0, 0],
                               [0, 0, 3, 0],
                               [0, 0, 0, 4]],
                              [[5, 0, 0, 0],
                               [0, 6, 0, 0],
                               [0, 0, 7, 0],
                               [0, 0, 0, 8]]]

# A superdiagonal (per batch).
diagonal = np.array([[1, 2, 3],  # Input shape: (2, 3)
                     [4, 5, 6]])
tf.matrix_diag(diagonal, k = 1)
  ==> [[[0, 1, 0, 0],  # Output shape: (2, 4, 4)
        [0, 0, 2, 0],
        [0, 0, 0, 3],
        [0, 0, 0, 0]],
       [[0, 4, 0, 0],
        [0, 0, 5, 0],
        [0, 0, 0, 6],
        [0, 0, 0, 0]]]

# A band of diagonals.
diagonals = np.array([[[1, 2, 3],  # Input shape: (2, 2, 3)
                       [4, 5, 0]],
                      [[6, 7, 9],
                       [9, 1, 0]]])
tf.matrix_diag(diagonals, k = (-1, 0))
  ==> [[[1, 0, 0],  # Output shape: (2, 3, 3)
        [4, 2, 0],
        [0, 5, 3]],
       [[6, 0, 0],
        [9, 7, 0],
        [0, 1, 9]]]

# Rectangular matrix.
diagonal = np.array([1, 2])  # Input shape: (2)
tf.matrix_diag(diagonal, k = -1, num_rows = 3, num_cols = 4)
  ==> [[0, 0, 0, 0],  # Output shape: (3, 4)
       [1, 0, 0, 0],
       [0, 2, 0, 0]]

# Rectangular matrix with inferred num_cols and padding_value = 9.
tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 9)
  ==> [[9, 9],  # Output shape: (3, 2)
       [1, 9],
       [9, 2]]

যুক্তি:

• স্কোপ: একটি স্কোপ অবজেক্ট
• তির্যক: র্যাঙ্ক r , যেখানে r >= 1
• k: তির্যক অফসেট(গুলি)। ধনাত্মক মান মানে অতিকর্ণ, 0 প্রধান কর্ণকে বোঝায় এবং ঋণাত্মক মান মানে উপকর্ণ। k একটি একক পূর্ণসংখ্যা হতে পারে (একটি একক তির্যকের জন্য) বা একটি ম্যাট্রিক্স ব্যান্ডের নিম্ন এবং উচ্চ প্রান্তগুলি নির্দিষ্ট করে এমন এক জোড়া পূর্ণসংখ্যা হতে পারে। k[0] অবশ্যই k[1] এর চেয়ে বড় হবে না।
• num_rows: আউটপুট ম্যাট্রিক্সের সারির সংখ্যা। যদি এটি প্রদান করা না হয়, op অনুমান করে যে আউটপুট ম্যাট্রিক্সটি একটি বর্গ ম্যাট্রিক্স এবং k থেকে ম্যাট্রিক্সের আকার এবং diagonal সবচেয়ে ভিতরের মাত্রা অনুমান করে।
• num_cols: আউটপুট ম্যাট্রিক্সের কলামের সংখ্যা। যদি এটি প্রদান করা না হয়, op অনুমান করে যে আউটপুট ম্যাট্রিক্সটি একটি বর্গ ম্যাট্রিক্স এবং k থেকে ম্যাট্রিক্সের আকার এবং diagonal সবচেয়ে ভিতরের মাত্রা অনুমান করে।
• padding_value: নির্দিষ্ট তির্যক ব্যান্ডের বাইরের এলাকাটি যে সংখ্যা দিয়ে পূরণ করতে হবে। ডিফল্ট 0।

রিটার্ন:

• Output : র্যাঙ্ক r+1 আছে যখন k একটি পূর্ণসংখ্যা বা k[0] == k[1] , অন্যথায় r ।

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

Operation operation

::tensorflow::Output output

 MatrixDiagV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input diagonal,
  ::tensorflow::Input k,
  ::tensorflow::Input num_rows,
  ::tensorflow::Input num_cols,
  ::tensorflow::Input padding_value
)

::tensorflow::Node * node() const 

 operator::tensorflow::Input() const 

 operator::tensorflow::Output() const