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

#include <array_ops.h>

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

সারাংশ

একটি ম্যাট্রিক্সের 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
 যেখানে d = n - m , diag_index = [k] - d , এবং index_in_diag = n - max(d, 0) + offset ।

offset শূন্য হয় যখন তির্যকটির প্রান্তিককরণ ডানদিকে থাকে।

offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT}
                                           and `d >= 0`) or
                                         (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                           and `d <= 0`)
         0                          ; otherwise
 যেখানে diag_len(d) = min(cols - max(d, 0), rows + min(d, 0))

যেমন: 

# 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 tridiagonal band (per batch).
diagonals = np.array([[[0, 8, 9],  # Input shape: (2, 2, 3)
                       [1, 2, 3],
                       [4, 5, 0]],
                      [[0, 2, 3],
                       [6, 7, 9],
                       [9, 1, 0]]])
tf.matrix_diag(diagonals, k = (-1, 1))
  ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
        [4, 2, 9],
        [0, 5, 3]],
       [[6, 2, 0],
        [9, 7, 3],
        [0, 1, 9]]]

# LEFT_RIGHT alignment.
diagonals = np.array([[[8, 9, 0],  # Input shape: (2, 2, 3)
                       [1, 2, 3],
                       [0, 4, 5]],
                      [[2, 3, 0],
                       [6, 7, 9],
                       [0, 9, 1]]])
tf.matrix_diag(diagonals, k = (-1, 1), align="LEFT_RIGHT")
  ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
        [4, 2, 9],
        [0, 5, 3]],
       [[6, 2, 0],
        [9, 7, 3],
        [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]]

  

  
Arguments:
    
      
  • scope: A Scope object
    • 
      
  • diagonal: Rank r, where r >= 1
    • 
      
  • k: Diagonal offset(s). Positive value means superdiagonal, 0 refers to the main diagonal, and negative value means subdiagonals. k can be a single integer (for a single diagonal) or a pair of integers specifying the low and high ends of a matrix band. k[0] must not be larger than k[1].
    • 
      
  • num_rows: The number of rows of the output matrix. If it is not provided, the op assumes the output matrix is a square matrix and infers the matrix size from k and the innermost dimension of diagonal.
    • 
      
  • num_cols: The number of columns of the output matrix. If it is not provided, the op assumes the output matrix is a square matrix and infers the matrix size from k and the innermost dimension of diagonal.
    • 
      
  • padding_value: The number to fill the area outside the specified diagonal band with. Default is 0.
    • 
    

  
Optional attributes (see Attrs):
    
      
  • align: Some diagonals are shorter than max_diag_len and need to be padded. align is a string specifying how superdiagonals and subdiagonals should be aligned, respectively. There are four possible alignments: "RIGHT_LEFT" (default), "LEFT_RIGHT", "LEFT_LEFT", and "RIGHT_RIGHT". "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals to the left (right-pads the row). It is the packing format LAPACK uses. cuSPARSE uses "LEFT_RIGHT", which is the opposite alignment.
    • 
    

  
Returns:
    
      
  • Output: Has rank r+1 when k is an integer or k[0] == k[1], rank r otherwise. 
    • 
    

                                              




        
Constructors and Destructors

      		





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

      		





        MatrixDiagV3(const ::tensorflow::Scope & scope, ::tensorflow::Input diagonal, ::tensorflow::Input k, ::tensorflow::Input num_rows, ::tensorflow::Input num_cols, ::tensorflow::Input padding_value, const MatrixDiagV3::Attrs & attrs)
        

      		




                                                          




        
Public attributes

      		





        operation
      

        
      





        output
      

        
      




                                                                              




        
Public functions

      		





        node() const 
      

        

          ::tensorflow::Node *
        

      		





        operator::tensorflow::Input() const 
      

        

          
        

      		





        operator::tensorflow::Output() const 
      

        

          
        

      		




                                      




        
Public static functions

      		





        Align(StringPiece x)
      

        
      




                                      




        
Structs

      		





        tensorflow::ops::MatrixDiagV3::Attrs
      

        
Optional attribute setters for MatrixDiagV3. 

      		




  
Public attributes

  

    
operation

    
Operation operation
 আউটপুট 
::tensorflow::Output output
 পাবলিক ফাংশন 
 MatrixDiagV3 
 MatrixDiagV3(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input diagonal,
  ::tensorflow::Input k,
  ::tensorflow::Input num_rows,
  ::tensorflow::Input num_cols,
  ::tensorflow::Input padding_value
)
 MatrixDiagV3 
 MatrixDiagV3(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input diagonal,
  ::tensorflow::Input k,
  ::tensorflow::Input num_rows,
  ::tensorflow::Input num_cols,
  ::tensorflow::Input padding_value,
  const MatrixDiagV3::Attrs & attrs
)
 নোড 
::tensorflow::Node * node() const 
 অপারেটর::টেনসরফ্লো::ইনপুট 
 operator::tensorflow::Input() const 
 অপারেটর::টেনসরফ্লো::আউটপুট 
 operator::tensorflow::Output() const 
 পাবলিক স্ট্যাটিক ফাংশন 
 সারিবদ্ধ 
Attrs Align(
  StringPiece x
)