텐서플로우:: 텐서

이 텐서를 1차원으로 분할합니다.

즉, 반환된 텐서는 return[i, ...] == this[dim0_start + i, ...]를 충족합니다. 반환된 텐서는 이 텐서와 기본 텐서 버퍼를 공유합니다.

참고: 반환된 텐서는 모양에 따라 이 텐서와 동일한 정렬 요구 사항을 충족하지 않을 수 있습니다. 호출자는 정렬 요구 사항이 있는 특정 메서드(예: flat() , tensor() )를 호출하기 전에 반환된 텐서의 정렬을 확인해야 합니다.

참고: N차원 텐서를 제공하는 경우 이 메서드는 N차원의 텐서도 반환합니다. 하위 텐서를 선택하려면 SubSlice를 참조하세요.

필수 사항: dims() >= 1 필수 사항: 0 <= dim0_start <= dim0_limit <= dim_size(0)

1차원을 따라 이 텐서에서 하위 슬라이스를 선택합니다.

N차원 텐서가 제공되면 이 메서드는 N-1 차원의 텐서를 반환합니다. 여기서 반환된 텐서는 첫 번째 차원을 따른 입력 텐서의 하위 슬라이스입니다. 반환된 텐서의 N-1 차원은 입력 텐서의 마지막 N-1 차원입니다.

참고: 반환된 텐서는 모양에 따라 이 텐서와 동일한 정렬 요구 사항을 충족하지 않을 수 있습니다. 호출자는 정렬 요구 사항이 있는 특정 메서드(예: flat() , tensor() )를 호출하기 전에 반환된 텐서의 정렬을 확인해야 합니다.

필수 사항: dims() >= 1 필수 사항: 0 <= index < dim_size(0)

*this 의 첫 번째 max_entries 값을 문자열로 렌더링합니다.

1차원, 요소가 0개인 부동 소수점 텐서를 생성합니다.

반환된 Tensor는 스칼라(모양 {})가 아니라 대신 빈 1차원 Tensor (모양 {0}, NumElements() == 0)입니다. 요소가 없으므로 값을 할당할 필요가 없으며 기본적으로 초기화됩니다( IsInitialized() 가 true). 이것이 바람직하지 않은 경우 초기화가 필요한 단일 요소 스칼라 생성을 고려하십시오.

Tensor(DT_FLOAT, TensorShape({}))

기본 버퍼를 할당하기 위해 할당자 a 사용하여 입력 type 및 shape 있는 텐서를 생성합니다.

LogMemory::IsEnabled()인 경우 할당은 알 수 없는 커널 및 단계에서 오는 것으로 기록됩니다. Op 내에서 직접 Tensor 생성자를 호출하는 것은 더 이상 사용되지 않습니다. OpKernelConstruction/OpKernelContext 할당_* 메소드를 사용하여 커널과 단계를 기록하는 새 텐서를 할당합니다.

a 이 Tensor 의 수명보다 오래 지속되어야 합니다.

기본 버퍼를 할당하기 위해 할당자 a 와 지정된 "allocation_attr"을 사용하여 입력 type 과 shape 가진 텐서를 생성합니다.

커널과 단계가 알려진 경우 할당_attr.allocation_will_be_logged를 true로 설정해야 하며 텐서가 구성된 후 LogMemory::RecordTensorAllocation을 호출해야 합니다. Op 내에서 직접 Tensor 생성자를 호출하는 것은 더 이상 사용되지 않습니다. OpKernelConstruction/OpKernelContext 할당_* 메소드를 사용하여 커널과 단계를 기록하는 새 텐서를 할당합니다.

a 이 Tensor 의 수명보다 오래 지속되어야 합니다.

입력 데이터 유형, 모양 및 buf를 사용하여 텐서를 생성합니다.

이 Tensor 에 속하는 buf에 대한 참조를 획득합니다.

주어진 데이터 유형의 빈 Tensor를 생성합니다.

Tensor() 와 마찬가지로 IsInitialized() 가 True를 반환하는 1차원, 요소가 0개인 Tensor를 반환합니다. 자세한 내용은 Tensor() 문서를 참조하세요.

텐서

 Tensor(
  double scalar_value
)

 Tensor(
  int32 scalar_value
)

 Tensor(
  uint32 scalar_value
)

 Tensor(
  uint16 scalar_value
)

 Tensor(
  uint8 scalar_value
)

 Tensor(
  int16 scalar_value
)

 Tensor(
  int8 scalar_value
)

 Tensor(
  tstring scalar_value
)

 Tensor(
  complex64 scalar_value
)

 Tensor(
  complex128 scalar_value
)

 Tensor(
  int64 scalar_value
)

 Tensor(
  uint64 scalar_value
)

 Tensor(
  bool scalar_value
)

 Tensor(
  qint8 scalar_value
)

 Tensor(
  quint8 scalar_value
)

 Tensor(
  qint16 scalar_value
)

 Tensor(
  quint16 scalar_value
)

 Tensor(
  qint32 scalar_value
)

 Tensor(
  bfloat16 scalar_value
)

 Tensor(
  Eigen::half scalar_value
)

 Tensor(
  ResourceHandle scalar_value
)

 Tensor(
  const char *scalar_value
)

 Tensor(
  const Tensor & other
)

 Tensor(
  Tensor && other
)

 Tensor(
  T *t
)=delete

size_t TotalBytes() const 

void UnsafeCopyFromInternal(
  const Tensor & other,
  DataType dtype,
  const TensorShape & shape
)

TTypes< T, NDIMS >::Tensor bit_casted_shaped(
  gtl::ArraySlice< int64 > new_sizes
)

TTypes< T, NDIMS >::ConstTensor bit_casted_shaped(
  gtl::ArraySlice< int64 > new_sizes
) const 

TTypes< T, NDIMS >::Tensor bit_casted_tensor()

TTypes< T, NDIMS >::ConstTensor bit_casted_tensor() const 

void * data() const 

int64 dim_size(
  int d
) const 

int dims() const 

DataType dtype() const 

TTypes< T >::Flat flat()

  
    typedef float T;
    Tensor my_ten(...built with Shape{planes: 4, rows: 3, cols: 5}...);
    // 1D Eigen::Tensor, size 60:
    auto flat = my_ten.flat();
    // 2D Eigen::Tensor 12 x 5:
    auto inner = my_ten.flat_inner_dims();
    // 2D Eigen::Tensor 4 x 15:
    auto outer = my_ten.shaped<T, 2>({4, 15});
    // CHECK fails, bad num elements:
    auto outer = my_ten.shaped<T, 2>({4, 8});
    // 3D Eigen::Tensor 6 x 5 x 2:
    auto weird = my_ten.shaped<T, 3>({6, 5, 2});
    // CHECK fails, type mismatch:
    auto bad   = my_ten.flat();

TTypes< T >::ConstFlat flat() const 

TTypes< T, NDIMS >::Tensor flat_inner_dims()

TTypes< T, NDIMS >::ConstTensor flat_inner_dims() const 

TTypes< T, NDIMS >::Tensor flat_inner_outer_dims(
  int64 begin
)

TTypes< T, NDIMS >::ConstTensor flat_inner_outer_dims(
  int64 begin
) const 

TTypes< T, NDIMS >::Tensor flat_outer_dims()

TTypes< T, NDIMS >::ConstTensor flat_outer_dims() const 

TTypes< T >::Matrix matrix()

TTypes< T >::ConstMatrix matrix() const 

Tensor & operator=(
  const Tensor & other
)

Tensor & operator=(
  Tensor && other
)

TTypes< T, NDIMS >::Tensor reinterpret_last_dimension()

TTypes< T, NDIMS >::ConstTensor reinterpret_last_dimension() const 

TTypes< T >::Scalar scalar()

TTypes< T >::ConstScalar scalar() const 

const TensorShape & shape() const 

TTypes< T, NDIMS >::Tensor shaped(
  gtl::ArraySlice< int64 > new_sizes
)

TTypes< T, NDIMS >::ConstTensor shaped(
  gtl::ArraySlice< int64 > new_sizes
) const 

TTypes< T, NDIMS >::Tensor tensor()

TTypes< T, NDIMS >::ConstTensor tensor() const 

StringPiece tensor_data() const 

TTypes< T >::UnalignedFlat unaligned_flat()

TTypes< T >::UnalignedConstFlat unaligned_flat() const 

TTypes< T, NDIMS >::UnalignedTensor unaligned_shaped(
  gtl::ArraySlice< int64 > new_sizes
)

TTypes< T, NDIMS >::UnalignedConstTensor unaligned_shaped(
  gtl::ArraySlice< int64 > new_sizes
) const 

TTypes< T >::Vec vec()

  
    typedef float T;
    Tensor my_mat(...built with Shape{rows: 3, cols: 5}...);
    auto mat = my_mat.matrix();    // 2D Eigen::Tensor, 3 x 5.
    auto mat = my_mat.tensor<T, 2>(); // 2D Eigen::Tensor, 3 x 5.
    auto vec = my_mat.vec();       // CHECK fails as my_mat is 2D.
    auto vec = my_mat.tensor<T, 3>(); // CHECK fails as my_mat is 2D.
    auto mat = my_mat.matrix();// CHECK fails as type mismatch.

TTypes< T >::ConstVec vec() const 

 ~Tensor()