텐서

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
표시자5 l10n-
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
자리 표시
extension Tensor: TensorGroup
표시
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: TensorProtocol
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

벡터와 행렬을 잠재적으로 더 높은 차원으로 일반화한 요소의 다차원 배열입니다.

일반 매개변수 Scalar 텐서의 스칼라 유형(예: Int32 , Float 등)을 설명합니다.

  • 기본 TensorHandle .

    메모

    handle 사용자 정의 작업을 허용하기 위해 공개되지만 일반적으로 사용해서는 안 됩니다.

    선언

    public let handle: TensorHandle<Scalar>
  • 선언

    public init(handle: TensorHandle<Scalar>)
  • 랭크 R 텐서의 주어진 차원을 여러 랭크 (R-1) 텐서로 압축 해제합니다. N 은 이 텐서의 모양에서 추론되는 axis 차원을 따라 분할하여 이 텐서에서 N 텐서를 압축 해제합니다. 예를 들어 [A, B, C, D] 모양의 텐서가 있다고 가정해 보겠습니다.

    • axis == 0 이면 반환된 배열의 i 번째 텐서는 self[i, :, :, :] 슬라이스이고 해당 배열의 각 텐서는 [B, C, D] 모양을 갖습니다. ( Tensor.split(numSplits:alongAxis) 또는 Tensor.split(sizes:alongAxis) 와 달리 압축이 풀린 차원은 사라집니다.)
    • axis == 1 이면 반환된 배열의 i 번째 텐서는 슬라이스 value[:, i, :, :] 이고 해당 배열의 각 텐서는 [A, C, D] 모양을 갖습니다.
    • 등.

    이는 Tensor.init(stacking:alongAxis:) 의 반대입니다.

    전제조건

    axis [-rank, rank) 범위에 있어야 합니다. 여기서 rank 제공된 텐서의 순위입니다.

    선언

    @differentiable
    public func unstacked(alongAxis axis: Int = 0) -> [Tensor]

    매개변수

    axis

    언스택할 치수입니다. 음수 값이 래핑됩니다.

    반환 값

    스택되지 않은 텐서를 포함하는 배열입니다.

  • 텐서를 여러 텐서로 분할합니다. 텐서는 차원 axis 따라 더 작은 개수의 count 로 분할됩니다. 이를 위해서는 count shape[axis] 균등하게 나누어야 합니다.

    예를 들어:

    // 'value' is a tensor with shape [5, 30]
    // Split 'value' into 3 tensors along dimension 1:
    let parts = value.split(count: 3, alongAxis: 1)
    parts[0] // has shape [5, 10]
    parts[1] // has shape [5, 10]
    parts[2] // has shape [5, 10]
    

    전제조건

    count 차원 axis 크기를 균등하게 나누어야 합니다.

    전제조건

    axis [-rank, rank) 범위에 있어야 합니다. 여기서 rank 제공된 텐서의 순위입니다.

    선언

    @differentiable
    public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]

    매개변수

    count

    생성할 분할 수입니다.

    axis

    이 텐서를 분할할 차원입니다. 음수 값이 래핑됩니다.

    반환 값

    텐서 부분을 포함하는 배열입니다.

  • 텐서를 여러 텐서로 분할합니다. 텐서는 sizes.shape[0] 조각으로 분할됩니다. i 번째 조각의 모양은 크기가 sizes[i] 인 차원 axis 따른다는 점을 제외하면 이 텐서와 모양이 동일합니다.

    예를 들어:

    // 'value' is a tensor with shape [5, 30]
    // Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
    let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
    parts[0] // has shape [5, 4]
    parts[1] // has shape [5, 15]
    parts[2] // has shape [5, 11]
    

    전제조건

    sizes 값의 합은 차원 axis 크기와 같아야 합니다.

    전제조건

    axis [-rank, rank) 범위에 있어야 합니다. 여기서 rank 제공된 텐서의 순위입니다.

    선언

    @differentiable(wrt: self)
    public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]

    매개변수

    sizes

    각 분할의 크기를 포함하는 1차원 텐서.

    axis

    이 텐서를 분할할 차원입니다. 음수 값이 래핑됩니다.

    반환 값

    텐서 부분을 포함하는 배열입니다.

  • 선언

    @differentiable(wrt: self)
    public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]
  • 이 텐서를 타일링하여 생성된 타일형 텐서를 반환합니다.

    이 생성자는 이 텐서를 multiples 번 복제하여 새 텐서를 생성합니다. 구성된 텐서의 i 번째 차원 self.shape[i] * multiples[i] 요소가 있으며 이 텐서의 값은 i 번째 차원을 따라 배수 multiples[i] 번 복제됩니다. 예를 들어, [abcd] [2] 로 타일링하면 [abcdabcd] 가 생성됩니다.

    전제조건

    배수의 예상 rank1 이어야 합니다.

    전제조건

    multiples 의 모양은 [tensor.rank] 여야 합니다.

    전제조건

    multiples 의 모든 스칼라는 음수가 아니어야 합니다.

    선언

    @differentiable(wrt: self)
    public func tiled(multiples: [Int]) -> Tensor
  • 이 텐서를 타일링하여 생성된 타일형 텐서를 반환합니다.

    이 생성자는 이 텐서를 multiples 번 복제하여 새 텐서를 생성합니다. 구성된 텐서의 i 번째 차원 self.shape[i] * multiples[i] 요소가 있으며 이 텐서의 값은 i 번째 차원을 따라 배수 multiples[i] 번 복제됩니다. 예를 들어, [abcd] [2] 로 타일링하면 [abcdabcd] 가 생성됩니다.

    전제조건

    배수의 예상 rank1 이어야 합니다.

    전제조건

    multiples 의 모양은 [tensor.rank] 여야 합니다.

    선언

    @differentiable(wrt: self)
    public func tiled(multiples: Tensor<Int32>) -> Tensor
  • 지정된 Tensor 의 모양으로 모양을 변경합니다.

    전제조건

    스칼라 수가 새 모양과 일치합니다.

    선언

    @differentiable(wrt: self)
    public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
  • 지정된 모양으로 모양을 변경합니다.

    전제조건

    스칼라 수가 새 모양과 일치합니다.

    선언

    @differentiable(wrt: self)
    public func reshaped(to newShape: TensorShape) -> Tensor
  • 모양을 나타내는 지정된 Tensor 로 모양을 변경합니다.

    전제조건

    스칼라 수가 새 모양과 일치합니다.

    선언

    @differentiable(wrt: self)
    public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
  • 행 우선 순서로 1차원 Tensor 로 축소된 텐서의 복사본을 반환합니다.

    선언

    @differentiable(wrt: self)
    public func flattened() -> Tensor
  • 지정된 모양 인덱스에 차원 1이 삽입된 모양 확장된 Tensor 반환합니다.

    선언

    @differentiable(wrt: self)
    public func expandingShape(at axes: Int...) -> Tensor
  • 지정된 모양 인덱스에 차원 1이 삽입된 모양 확장된 Tensor 반환합니다.

    선언

    @differentiable(wrt: self)
    public func expandingShape(at axes: [Int]) -> Tensor
  • 선행 차원이 1인 순위가 상승된 Tensor 반환합니다.

    선언

    @differentiable(wrt: self)
    public func rankLifted() -> Tensor
  • 텐서의 모양에서 지정된 크기 1의 차원을 제거합니다. 치수를 지정하지 않으면 크기 1의 모든 치수가 제거됩니다.

    선언

    @differentiable(wrt: self)
    public func squeezingShape(at axes: Int...) -> Tensor
  • 텐서의 모양에서 지정된 크기 1의 차원을 제거합니다. 치수를 지정하지 않으면 크기 1의 모든 치수가 제거됩니다.

    선언

    @differentiable(wrt: self)
    public func squeezingShape(at axes: [Int]) -> Tensor
  • 지정된 순서로 차원이 순열된 전치된 텐서를 반환합니다.

    선언

    @differentiable(wrt: self)
    public func transposed(permutation: Tensor<Int32>) -> Tensor
  • 지정된 순서로 차원이 순열된 전치된 텐서를 반환합니다.

    선언

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
  • 지정된 순서로 차원이 순열된 전치된 텐서를 반환합니다.

    선언

    @differentiable(wrt: self)
    public func transposed(permutation: [Int]) -> Tensor
  • 지정된 순서로 차원이 순열된 전치된 텐서를 반환합니다.

    선언

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: [Int]) -> Tensor
  • 지정된 순서로 차원이 순열된 전치된 텐서를 반환합니다.

    선언

    @differentiable(wrt: self)
    public func transposed(permutation: Int...) -> Tensor
  • 지정된 순서로 차원이 순열된 전치된 텐서를 반환합니다.

    선언

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Int...) -> Tensor
  • 차원이 역순으로 치환된 전치된 텐서를 반환합니다.

    선언

    @differentiable(wrt: self)
    public func transposed() -> Tensor
  • 지정된 차원이 반전된 텐서를 반환합니다.

    전제조건

    axes 각 값은 -rank..<rank 범위에 있어야 합니다.

    전제조건

    axes 에는 중복이 없어야 합니다.

    선언

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
  • 지정된 차원이 반전된 텐서를 반환합니다.

    전제조건

    axes 각 값은 -rank..<rank 범위에 있어야 합니다.

    전제조건

    axes 에는 중복이 없어야 합니다.

    선언

    @differentiable(wrt: self)
    public func reversed(inAxes axes: [Int]) -> Tensor
  • 지정된 차원이 반전된 텐서를 반환합니다.

    전제조건

    axes 각 값은 -rank..<rank 범위에 있어야 합니다.

    전제조건

    axes 에는 중복이 없어야 합니다.

    선언

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Int...) -> Tensor
  • 지정된 축을 따라 연결된 텐서를 반환합니다.

    전제조건

    텐서는 지정된 축을 제외하고 동일한 차원을 가져야 합니다.

    전제조건

    축은 -rank..<rank 범위에 있어야 합니다.

    선언

    @differentiable
    public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
  • 연결 연산자.

    메모

    ++ 는 Swift에는 존재하지 않지만 Haskell/Scala에는 존재하는 사용자 정의 연산자입니다. 그 추가는 사소한 언어 변화가 아니며 논란의 여지가 있을 수 있습니다. ++ 의 존재/이름 지정은 이후 API 설계 단계에서 논의됩니다.

    선언

    @differentiable
    public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
  • axis 차원을 따라 indices 에서 입력 조각을 모아 텐서를 반환합니다.

    0차원(스칼라) indices 의 경우:

    result[p_0,          ..., p_{axis-1},
           p_{axis + 1}, ..., p_{N-1}] =
    self[p_0,          ..., p_{axis-1},
         indices,
         p_{axis + 1}, ..., p_{N-1}]
    

    1차원(벡터) indices 의 경우:

    result[p_0,          ..., p_{axis-1},
           i,
           p_{axis + 1}, ..., p_{N-1}] =
    self[p_0,          ..., p_{axis-1},
         indices[i],
         p_{axis + 1}, ..., p_{N-1}]
    

    일반적인 경우에는 다음과 같은 결과 텐서를 생성합니다.

    result[p_0,             ..., p_{axis-1},
           i_{batch\_dims}, ..., i_{M-1},
           p_{axis + 1},    ..., p_{N-1}] =
    self[p_0,             ..., p_{axis-1},
         indices[i_0,     ..., i_{M-1}],
         p_{axis + 1},    ..., p_{N-1}]
    

    여기서 N = self.rankM = indices.rank .

    결과 텐서의 모양 self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] 입니다.

    메모

    CPU에서 범위를 벗어난 인덱스가 발견되면 오류가 발생합니다. GPU에서는 범위를 벗어난 인덱스가 발견되면 해당 출력 값에 0이 저장됩니다.

    전제조건

    axis [-rank, rank) 범위에 있어야 합니다.

    선언

    @differentiable(wrt: self)
    public func gathering<Index: TensorFlowIndex>(
      atIndices indices: Tensor<Index>,
      alongAxis axis: Int = 0
    ) -> Tensor

    매개변수

    indices

    수집할 인덱스를 포함합니다.

    axis

    수집할 차원입니다. 음수 값이 래핑됩니다.

    반환 값

    수집된 텐서.

  • axis 차원에 해당하는 첫 번째 batchDimensionCount 차원을 무시하고 축 차원을 따라 indices 에 있는 이 텐서의 조각을 반환합니다. 수집은 첫 번째 비배치 차원을 따라 수행됩니다.

    결과 텐서 모양이 이제 shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] gathering 과 유사한 기능을 수행합니다.

    전제조건

    axis -rank..<rank 범위에 있어야 하며, 또한 batchDimensionCount 보다 크거나 같아야 합니다.

    전제조건

    batchDimensionCount indices.rank 보다 작아야 합니다.

    선언

    @differentiable(wrt: self)
    public func batchGathering<Index: TensorFlowIndex>(
      atIndices indices: Tensor<Index>,
      alongAxis axis: Int = 1,
      batchDimensionCount: Int = 1
    ) -> Tensor

    매개변수

    indices

    수집할 인덱스가 포함되어 있습니다.

    axis

    수집할 차원입니다. 음수 값이 래핑됩니다.

    batchDimensionCount

    무시할 주요 배치 차원의 수입니다.

    반환 값

    수집된 텐서.

  • 제공된 부울 마스크를 입력에 적용한 후 값을 모아서 텐서를 반환합니다.

    예를 들어:

    // 1-D example
    // tensor is [0, 1, 2, 3]
    // mask is [true, false, true, false]
    tensor.gathering(where: mask) // is [0, 2]
    
    // 2-D example
    // tensor is [[1, 2], [3, 4], [5, 6]]
    // mask is [true, false, true]
    tensor.gathering(where: mask) // is [[1, 2], [5, 6]]
    

    일반적으로 0 < mask.rank = K <= tensor.rank 이며 mask 의 모양은 tensor 모양의 첫 번째 K 차원과 일치해야 합니다. 그러면 다음과 같습니다: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] where [i1, ..., iK]maski 번째 true 항목입니다(행 우선 순서).

    axis mask 와 함께 사용하여 마스크할 축을 나타낼 수 있습니다. 이 경우, axis + mask.rank <= tensor.rankmask 's shape must match the first 텐서 모양 dimensions of the 과 일치해야 합니다.

    전제조건

    mask 스칼라일 수 없습니다( mask.rank != 0 ).

    선언

    @differentiable(wrt: self)
    public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor

    매개변수

    mask

    KD 부울 텐서, 여기서 K <= self.rank .

    axis

    마스크할 self 의 축을 나타내는 0차원 정수 텐서. 여기서 K + axis <= self.rank .

    반환 값

    (self.rank - K + 1) masktrue 에 해당하는 이 텐서의 항목으로 채워진 차원 텐서.

  • 이 텐서에서 0이 아닌 값/참 값의 위치를 ​​반환합니다.

    좌표는 2차원 텐서로 반환됩니다. 여기서 첫 번째 차원(행)은 0이 아닌 요소의 수를 나타내고 두 번째 차원(열)은 0이 아닌 요소의 좌표를 나타냅니다. 출력 텐서의 모양은 이 텐서에 실제 값이 얼마나 많이 있는지에 따라 달라질 수 있다는 점을 명심하세요. 인덱스는 행 우선 순서로 출력됩니다.

    예를 들어:

    // 'input' is [[true, false], [true, false]]
    // 'input' has 2 true values and so the output has 2 rows.
    // 'input' has rank of 2, and so the second dimension of the output has size 2.
    input.nonZeroIndices() // is [[0, 0], [1, 0]]
    
    // 'input' is [[[ true, false], [ true, false]],
    //             [[false,  true], [false,  true]],
    //             [[false, false], [false,  true]]]
    // 'input' has 5 true values and so the output has 5 rows.
    // 'input' has rank 3, and so the second dimension of the output has size 3.
    input.nonZeroIndices() // is [[0, 0, 0],
                           //     [0, 1, 0],
                           //     [1, 0, 1],
                           //     [1, 1, 1],
                           //     [2, 1, 1]]
    

    선언

    public func nonZeroIndices() -> Tensor<Int64>

    반환 값

    모양이 (num_true, rank(condition)) 인 텐서.

  • 선언

    @differentiable(wrt: self)
    public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor
  • 선언

    @differentiable(wrt: self)
    public func broadcasted(to shape: TensorShape) -> Tensor
  • 지정된 Tensor 와 동일한 형태로 브로드캐스트합니다.

    전제조건

    지정된 모양은 방송에 적합해야 합니다.

    선언

    @differentiable(wrt: self)
    public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • 선언

    public static func .= (lhs: inout Tensor, rhs: Tensor)
  • 각 차원의 하한 및 상한으로 정의된 텐서에서 슬라이스를 추출합니다.

    선언

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor

    매개변수

    lowerBounds

    각 차원의 하한입니다.

    upperBounds

    각 차원의 상한입니다.

  • 선언

    @differentiable(wrt: self)
    public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor
  • 선언

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor
  • 선언

    @differentiable(wrt: self)
    public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
  • axes 의 각 요소가 self 의 축을 나타내는지 확인하고, 그렇지 않으면 진단을 통해 프로그램을 중지합니다.

    선언

    func ensureValid(
      axes: Tensor<Int32>,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • axes 의 각 요소가 self 의 축을 나타내는지 확인하고, 그렇지 않으면 진단을 통해 프로그램을 중지합니다.

    선언

    func ensureValid(
      axes: [Int],
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • k self 의 축을 나타내는지 확인하고, 그렇지 않으면 진단을 통해 프로그램을 중지합니다.

    선언

    func ensureValid(
      axis k: Int,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • 선언

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
    where BatchSamples.Element == Self
  • 지정된 Device 에서 other 의 복사본을 만듭니다.

    선언

    public init(copying other: Tensor, to device: Device)
  • 지정된 모양과 단일 반복 스칼라 값을 사용하여 텐서를 생성합니다.

    선언

    @available(*, deprecated, renamed: "init(repeating:shape:﹚")
    public init(shape: TensorShape, repeating repeatedValue: Scalar)

    매개변수

    shape

    텐서의 차원.

    repeatedValue

    반복할 스칼라 값입니다.

  • 지정된 모양과 단일 반복 스칼라 값을 사용하여 텐서를 생성합니다.

    선언

    @differentiable
    public init(
      repeating repeatedValue: Scalar, shape: TensorShape,
      on device: Device = .default
    )

    매개변수

    repeatedValue

    반복할 스칼라 값입니다.

    shape

    텐서의 차원.

  • 모든 차원이 1인 지정된 순위에 지정된 스칼라를 브로드캐스팅하여 텐서를 생성합니다.

    선언

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
  • 텐서 배열(그 자체가 스칼라일 수 있음)에서 텐서를 생성합니다.

    선언

    @differentiable
    public init(_ elements: [Tensor])
  • axis 차원을 따라 tensors 쌓아 현재 텐서와 tensors 의 각 텐서보다 순위가 1 높은 새 텐서로 만듭니다.

    tensors 모양이 모두 [A, B, C] 이고 tensors.count = N 이면 다음과 같습니다.

    • axis == 0 이면 결과 텐서의 모양은 [N, A, B, C] 입니다.
    • axis == 1 이면 결과 텐서는 [A, N, B, C] 모양을 갖게 됩니다.
    • 등.

    예를 들어:

    // 'x' is [1, 4]
    // 'y' is [2, 5]
    // 'z' is [3, 6]
    Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
    Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]
    

    이는 Tensor.unstacked(alongAxis:) 와 반대입니다.

    전제조건

    모든 텐서의 모양은 동일해야 합니다.

    전제조건

    axis [-rank, rank) 범위에 있어야 합니다. 여기서 rank 제공된 텐서의 순위입니다.

    선언

    @differentiable
    public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)

    매개변수

    tensors

    스택할 텐서.

    axis

    스택할 치수입니다. 음수 값이 래핑됩니다.

    반환 값

    스택형 텐서.

  • axis 차원을 따라 tensors 연결합니다.

    tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] 이면 연결된 결과의 모양은 [D0, D1, ... Raxis, ...Dn] 입니다. 여기서 Raxis = sum(Daxis(i)) 입니다. 즉, 입력 텐서의 데이터가 axis 차원을 따라 결합됩니다.

    예를 들어:

    // t1 is [[1, 2, 3], [4, 5, 6]]
    // t2 is [[7, 8, 9], [10, 11, 12]]
    Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
    Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]
    
    // t3 has shape [2, 3]
    // t4 has shape [2, 3]
    Tensor(concatenating: [t3, t4]) // has shape [4, 3]
    Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]
    

    메모

    새 축을 따라 연결하는 경우 Tensor.init(stacking:alongAxis:) 사용을 고려하세요.

    전제조건

    모든 텐서는 동일한 순위를 가져야 하며 axis 제외한 모든 차원이 동일해야 합니다.

    전제조건

    axis [-rank, rank) 범위에 있어야 합니다. 여기서 rank 제공된 텐서의 순위입니다.

    선언

    @differentiable
    public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)

    매개변수

    tensors

    연결할 텐서.

    axis

    연결할 차원입니다. 음수 값이 래핑됩니다.

    반환 값

    연결된 텐서.

  • 이 텐서의 요소를 masktrue 인 레인의 other 요소로 바꿉니다.

    전제조건

    selfother 같은 모양을 가져야 합니다. selfother 가 스칼라이면 mask 도 스칼라여야 합니다. selfother 의 순위가 1 보다 크거나 같은 경우, mask self 와 동일한 모양을 가지거나 mask.scalarCount == self.shape[0] 과 같은 1 Tensor 텐서여야 합니다.

    선언

    @differentiable(wrt: (self, other)
    ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
  • 물리적 스칼라 유형의 정밀도가 감소된 경우 true를 반환합니다.

    현재 축소된 정밀도 물리적 스칼라 유형에는 BFloat16 만 포함됩니다.

    선언

    public var isReducedPrecision: Bool { get }
  • 지정된 텐서와 동일한 장치 및 정밀도를 사용하여 스칼라를 텐서로 승격합니다.

    선언

    @differentiable
    public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
  • BFloat16 물리적 스칼라 유형으로 변환된 self 의 복사본을 반환합니다.

    선언

    public var toReducedPrecision: `Self` { get }
  • Scalar 물리적 스칼라 유형으로 변환된 self 복사본을 반환합니다.

    선언

    public var toFullPrecision: `Self` { get }
  • Tensor 의 차원 수입니다.

    선언

    public var rank: Int { get }
  • Tensor 의 모양.

    선언

    public var shape: TensorShape { get }
  • Tensor 의 스칼라 수입니다.

  • 선언

    public var scalarCount: Int { get }
  • Tensor<Int32> 로 표시되는 텐서의 순위입니다.

    선언

    public var rankTensor: Tensor<Int32> { get }
  • Tensor<Int32> 로 표현되는 텐서의 차원입니다.

    선언

    public var shapeTensor: Tensor<Int32> { get }
  • Tensor<Int32> 로 표시되는 텐서의 스칼라 수입니다.

    선언

    public var scalarCountTensor: Tensor<Int32> { get }
  • rank 0이면 true 반환하고 그렇지 않으면 false 반환합니다.

    선언

    public var isScalar: Bool { get }
  • rank 0이면 단일 스칼라 요소를 반환하고 그렇지 않으면 nil 반환합니다.

    선언

    public var scalar: Scalar? { get }
  • 스칼라로 형태를 변경합니다.

    전제조건

    텐서에는 정확히 하나의 스칼라가 있습니다.

    선언

    @differentiable
    public func scalarized() -> Scalar
  • 선언

    public var array: ShapedArray<Scalar> { get }
  • 선언

    @differentiable
    public var scalars: [Scalar] { get }
  • 스칼라 값에서 0차원 텐서를 생성합니다.

    선언

    @differentiable
    public init(_ value: Scalar, on device: Device = .default)
  • 스칼라에서 1D 텐서를 생성합니다.

    선언

    @differentiable
    public init(_ scalars: [Scalar], on device: Device = .default)
  • 스칼라에서 1D 텐서를 생성합니다.

    선언

    public init<C: Collection>(
      _ vector: C, on device: Device = .default
    ) where C.Element == Scalar
  • 지정된 형태와 연속 스칼라를 행 우선 순서로 사용하여 텐서를 생성합니다.

    전제조건

    도형의 크기의 곱은 스칼라 수와 같아야 합니다.

    선언

    @differentiable
    public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)

    매개변수

    shape

    텐서의 모양.

    scalars

    텐서의 스칼라 내용입니다.

  • 지정된 형태와 연속 스칼라를 행 우선 순서로 사용하여 텐서를 생성합니다.

    전제조건

    도형의 크기의 곱은 스칼라 수와 같아야 합니다.

    선언

    public init(
      shape: TensorShape,
      scalars: UnsafeBufferPointer<Scalar>,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 모양.

    scalars

    텐서의 스칼라 내용입니다.

  • 지정된 형태와 연속 스칼라를 행 우선 순서로 사용하여 텐서를 생성합니다.

    전제조건

    도형의 크기의 곱은 스칼라 수와 같아야 합니다.
  • 지정된 형태와 연속 스칼라를 행 우선 순서로 사용하여 텐서를 생성합니다.

    전제조건

    도형의 크기의 곱은 스칼라 수와 같아야 합니다.

    선언

    public init<C: Collection>(
      shape: TensorShape, scalars: C, on device: Device = .default
    ) where C.Element == Scalar

    매개변수

    shape

    텐서의 모양.

    scalars

    텐서의 스칼라 내용입니다.

  • 배열 리터럴 요소의 유형입니다.

    선언

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
  • 주어진 요소로 초기화된 텐서를 생성합니다.

    선언

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
  • 텐서의 텍스트 표현입니다.

    메모

    모든 스칼라를 표시하는 보기 좋게 인쇄되지 않은 설명에는 fullDescription 사용하십시오.

    선언

    public var description: String { get }
  • 텐서의 텍스트 표현입니다. summarize true이고 요소 수가 edgeElementCount 두 배를 초과하는 경우 요약된 설명을 반환합니다.

    선언

    public func description(
      lineWidth: Int = 80,
      edgeElementCount: Int = 3,
      summarizing: Bool = false
    ) -> String

    매개변수

    lineWidth

    인쇄를 위한 최대 선 너비입니다. 한 줄에 인쇄할 스칼라 수를 결정하는 데 사용됩니다.

    edgeElementCount

    줄임표( ... )를 통해 요약 전후에 인쇄할 최대 요소 수입니다.

    summarizing

    true인 경우 요소 수가 edgeElementCount 두 배를 초과하면 설명을 요약합니다.

  • 모든 스칼라를 표시하는 텐서의 전체적이고 보기 좋게 인쇄되지 않은 텍스트 표현입니다.

    선언

    public var fullDescription: String { get }
  • 선언

    public var playgroundDescription: Any { get }
  • 선언

    public var customMirror: Mirror { get }
  • 이 텐서를 설명하는 주석입니다.

    선언

    public var annotations: String { get }
  • 주석의 별칭입니다.

    선언

    public var summary: String { get }
  • 선언

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
  • 선언

    public init<C: RandomAccessCollection>(
      _handles: C
    ) where C.Element: _AnyTensorHandle
  • 선언

    public init(_ array: ShapedArray<Scalar>, on device: Device = .default)
  • 선언

    init(_xla: XLATensor)
  • 선언

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)
  • 선언

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }
  • 선언

    var xlaTensor: XLATensor { get }
`Scalar`: `Numeric`에서 사용 가능
  • 선언

    @differentiable(wrt: self)
    public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor
  • 선언

    @differentiable(wrt: self)
    public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • 선언

    @differentiable(wrt: self)
    public func unbroadcasted(to shape: TensorShape) -> Tensor
  • 텐서가 패딩되는 방식을 지정하는 모드입니다.

    선언

    public enum PaddingMode
  • 지정된 패딩 크기에 따라 상수로 패딩된 텐서를 반환합니다.

    선언

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
      -> Tensor
  • 지정된 패딩 크기 및 모드에 따라 패딩된 텐서를 반환합니다.

    선언

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
'스칼라': '숫자' 및 '비교 가능'에서 사용 가능
  • lhs < rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    선언

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs <= rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    선언

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs > rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    선언

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs >= rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    선언

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs < rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .< 방송을 지원합니다.

    선언

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs <= rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .<= 방송을 지원합니다.

    선언

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs > rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .> 방송을 지원합니다.

    선언

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs >= rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .>= 방송을 지원합니다.

    선언

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs < rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .< 방송을 지원합니다.

    선언

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs <= rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .<= 방송을 지원합니다.

    선언

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs > rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .> 방송을 지원합니다.

    선언

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs >= rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .>= 방송을 지원합니다.

    선언

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
`Scalar`: `Equatable`에서 사용 가능
  • lhs == rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .== 방송을 지원합니다.

    선언

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs != rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .!= 방송을 지원합니다.

    선언

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs == rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .== 방송을 지원합니다.

    선언

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs != rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .!= 방송을 지원합니다.

    선언

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs == rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .== 방송을 지원합니다.

    선언

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs != rhs 요소별로 계산하여 부울 스칼라의 텐서를 반환합니다.

    메모

    .!= 방송을 지원합니다.

    선언

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
`Scalar`: `TensorFlowFloatingPoint` 및 `Equatable`에서 사용 가능
  • self 의 요소가 other 의 요소와 대략 동일한지 여부를 나타내는 부울 값의 텐서를 반환합니다.

    전제조건

    selfother 같은 모양이어야 합니다.

    선언

    public func elementsAlmostEqual(
      _ other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Tensor<Bool>
'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
  • self 의 모든 요소가 other 의 요소와 거의 같으면 true 반환합니다.

    전제조건

    selfother 같은 모양이어야 합니다.

    선언

    public func isAlmostEqual(
      to other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Bool
`Scalar`: `TensorFlowNumeric`에서 사용 가능
  • 이 텐서에 대해 교차 복제 합계를 실행합니다. 합계에 참여하는 다른 각 장치에서 동일한 교차 복제 합계가 발생해야 합니다.

    선언

    public mutating mutating func crossReplicaSum(_ scale: Double)
'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
`Scalar`: `Numeric`에서 사용 가능
  • Bool 텐서에서 요소별 유형 변환을 수행합니다.

    선언

    public init(_ other: Tensor<Bool>)
  • 다른 Tensor 에서 요소별 변환을 수행합니다.

    선언

    @differentiable
    public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
`Scalar`: `Numeric`에서 사용 가능
  • 모든 스칼라가 0으로 설정된 텐서를 생성합니다.

    선언

    public init(zeros shape: TensorShape, on device: Device = .default)

    매개변수

    shape

    텐서의 모양.

  • 모든 스칼라가 1로 설정된 텐서를 생성합니다.

    선언

    public init(ones shape: TensorShape, on device: Device = .default)

    매개변수

    shape

    텐서의 모양.

  • 제공된 텐서와 모양 및 유형이 동일한 모든 스칼라가 0으로 설정된 텐서를 생성합니다.

    선언

    public init(zerosLike other: Tensor)

    매개변수

    other

    사용할 모양과 데이터 유형의 Tensor입니다.

  • 모든 스칼라가 제공된 텐서와 모양 및 유형이 동일한 텐서로 설정된 텐서를 생성합니다.

    선언

    public init(onesLike other: Tensor)

    매개변수

    other

    사용할 모양과 데이터 유형의 Tensor입니다.

  • 시작 값부터 끝 값까지(포함하지 않음), 지정된 양만큼 단계별로 시퀀스를 나타내는 1차원 텐서를 생성합니다.

    선언

    public init(
      rangeFrom start: Scalar, to end: Scalar, stride: Scalar,
      on device: Device = .default
    )

    매개변수

    start

    시퀀스에 사용할 시작 값입니다. 시퀀스에 값이 포함되어 있으면 첫 번째 값은 start 입니다.

    end

    시퀀스를 제한하는 종료 값입니다. end 는 결과 시퀀스의 요소가 아닙니다.

    stride

    각 반복마다 단계별로 수행할 양입니다. stride 긍정적이어야 합니다.

  • 시작 값부터 끝 값까지(포함하지 않음), 지정된 양만큼 단계별로 시퀀스를 나타내는 1차원 텐서를 생성합니다.

    선언

    public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)

    매개변수

    start

    시퀀스에 사용할 시작 값입니다. 시퀀스에 값이 포함되어 있으면 첫 번째 값은 start 입니다.

    end

    시퀀스를 제한하는 종료 값입니다. end 는 결과 시퀀스의 요소가 아닙니다.

    stride

    각 반복마다 단계별로 수행할 양입니다. stride 긍정적이어야 합니다.

  • 주어진 인덱스에서 원-핫 텐서를 생성합니다. indices 로 표시되는 위치는 onValue (기본값 1 ) 값을 가지며, 다른 모든 위치는 offValue (기본값 0 ) 값을 갖습니다. 입력 indices 가 순위 n 이면 새 텐서의 순위는 n+1 입니다. 새 축은 차원 axis 에 생성됩니다. 기본적으로 새 축은 끝에 추가됩니다.

    indices 스칼라인 경우 새 텐서의 모양은 길이가 depth 인 벡터가 됩니다.

    indices 길이의 features 벡터인 경우 출력 모양은 다음과 같습니다: 축 == -1인 경우 특징 x 깊이, 축 == 0인 경우 x 특징

    indices [batch, features] 모양의 행렬(배치)인 경우 출력 모양은 다음과 같습니다. 배치 x 기능 x 깊이, 축 == -1 배치 x 깊이 x 기능, 축 == 1 깊이 x 배치 x 기능인 경우 , 축 == 0인 경우

    선언

    public init(
      oneHotAtIndices indices: Tensor<Int32>,
      depth: Int,
      onValue: Scalar = 1,
      offValue: Scalar = 0,
      axis: Int = -1
    )

    매개변수

    indices

    인덱스의 Tensor .

    depth

    하나의 핫 차원의 깊이를 정의하는 스칼라입니다.

    onValue

    indices 의 일부 인덱스가 참조하는 위치의 값을 정의하는 스칼라입니다.

    offValue

    indices 의 어떤 인덱스에서도 참조되지 않는 위치의 값을 정의하는 스칼라입니다.

    axis

    채울 축입니다. 기본값은 새로운 가장 안쪽 축인 -1 입니다.

'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
  • 지정된 값 수를 생성하기 위해 시작 값부터 끝 값까지의 시퀀스를 균일한 간격으로 나타내는 1차원 텐서를 생성합니다.

    선언

    public init(
      linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default
    )

    매개변수

    start

    시퀀스에 사용할 시작 값입니다. 시퀀스에 값이 포함되어 있으면 첫 번째 값은 start 입니다.

    end

    시퀀스를 제한하는 종료 값입니다. end 는 결과 시퀀스의 마지막 요소입니다.

    count

    결과 시퀀스의 값 수입니다. count 양수여야 합니다.

  • 지정된 값 수를 생성하기 위해 시작 값부터 끝 값까지의 시퀀스를 균일한 간격으로 나타내는 1차원 텐서를 생성합니다.

    전제조건

    start , to , count 단일 스칼라 값을 포함하는 Tensor여야 합니다.

    선언

    public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)

    매개변수

    start

    시퀀스에 사용할 시작 값입니다. 시퀀스에 값이 포함되어 있으면 첫 번째 값은 start 입니다.

    end

    시퀀스를 제한하는 종료 값입니다. end 는 결과 시퀀스의 마지막 요소입니다.

    count

    결과 시퀀스의 값 수입니다. count 양수여야 합니다.

`Scalar`: `TensorFlowIndex`에서 사용 가능
  • lowerBoundupperBound 사이의 균일 분포에서 스칼라 값을 무작위로 샘플링하여 지정된 모양의 텐서를 생성합니다.

    선언

    public init(
      randomUniform shape: TensorShape,
      lowerBound: Tensor<Scalar>? = nil,
      upperBound: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    lowerBound

    분포의 하한입니다.

    upperBound

    분포의 상한입니다.

    seed

    시드 값입니다.

'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
  • lowerBoundupperBound 사이의 균일 분포에서 스칼라 값을 무작위로 샘플링하여 지정된 모양의 텐서를 생성합니다.

    선언

    public init(
      randomUniform shape: TensorShape,
      lowerBound: Tensor<Scalar>? = nil,
      upperBound: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    lowerBound

    분포의 하한입니다.

    upperBound

    분포의 상한입니다.

    seed

    시드 값입니다.

  • 정규 분포에서 스칼라 값을 무작위로 샘플링하여 지정된 형태의 텐서를 생성합니다.

    선언

    public init(
      randomNormal shape: TensorShape,
      mean: Tensor<Scalar>? = nil,
      standardDeviation: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    mean

    분포의 평균입니다.

    standardDeviation

    분포의 표준 편차입니다.

    seed

    시드 값입니다.

  • 잘린 정규 분포에서 스칼라 값을 무작위로 샘플링하여 지정된 형태의 텐서를 생성합니다.

    선언

    public init(
      randomTruncatedNormal shape: TensorShape,
      mean: Tensor<Scalar>? = nil,
      standardDeviation: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    mean

    분포의 평균입니다.

    standardDeviation

    분포의 표준 편차입니다.

    seed

    시드 값입니다.

`Scalar`: `TensorFlowIndex`에서 사용 가능
  • 범주형 분포에서 샘플을 추출하여 텐서를 생성합니다.

    선언

    public init<T: TensorFlowFloatingPoint>(
      randomCategorialLogits: Tensor<T>,
      sampleCount: Int32,
      seed: TensorFlowSeed = Context.local.randomSeed
    )

    매개변수

    randomCategorialLogits

    [batchSize, classCount] 형태의 2차원 텐서. 각 슬라이스 [i, :] 는 모든 클래스에 대한 정규화되지 않은 로그 확률을 나타냅니다.

    sampleCount

    0-D. 각 행 조각에 대해 그릴 독립 샘플 수입니다.

    seed

    시드 값입니다.

    반환 값

    [batchSize, sampleCount] 형태의 2차원 텐서. 각 슬라이스 [i, :] [0, classCount) 범위의 그려진 클래스 레이블이 포함되어 있습니다.

'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
  • Glorot(Xavier) 균일 초기화를 수행하여 지정된 모양의 텐서를 생성합니다.

    기본 난수 생성기에 의해 생성된 -limitlimit 사이의 균일 분포에서 무작위 샘플을 추출합니다. 여기서 limitsqrt(6 / (fanIn + fanOut)) 이고 fanIn / fanOut 입력 및 출력 기능의 수에 수용 기능을 곱한 것을 나타냅니다. 필드 크기.

    참고 자료: “심층 피드포워드 신경망 훈련의 어려움 이해”

    선언

    public init(
      glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    seed

    시드 값입니다.

  • Glorot(Xavier) 일반 초기화를 수행하여 지정된 모양의 텐서를 생성합니다.

    기본 난수 생성기에 의해 생성된 표준 편차 sqrt(2 / (fanIn + fanOut)) 사용하여 0 중심으로 하는 잘린 정규 분포에서 무작위 샘플을 추출합니다. 여기서 fanIn / fanOut 입력 및 출력 기능의 수에 수용 필드를 곱한 것을 나타냅니다. 크기.

    참고 자료: “심층 피드포워드 신경망 훈련의 어려움 이해”

    선언

    public init(
      glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    seed

    시드 값입니다.

  • He(Kaiming) 균일 초기화를 수행하여 지정된 모양의 텐서를 생성합니다.

    기본 난수 생성기에 의해 생성된 -limitlimit 사이의 균일 분포에서 무작위 샘플을 추출합니다. 여기서 limitsqrt(6 / fanIn) 이고 fanIn 입력 기능 수에 수용 필드 크기를 곱한 값을 나타냅니다.

    참조: "정류기에 대한 심층 탐구: ImageNet 분류에서 인간 수준의 성능 능가"

    선언

    public init(
      heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    seed

    시드 값입니다.

  • He(Kaiming) 정규 초기화를 수행하여 지정된 모양의 텐서를 생성합니다.

    기본 난수 생성기에서 생성된 표준 편차 sqrt(2 / fanIn)) 사용하여 0 중심으로 하는 잘린 정규 분포에서 무작위 샘플을 추출합니다. 여기서 fanIn 입력 기능 수에 수용 필드 크기를 곱한 값을 나타냅니다.

    참조: "정류기에 대한 심층 탐구: ImageNet 분류에서 인간 수준의 성능 능가"

    선언

    public init(
      heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    seed

    시드 값입니다.

  • LeCun 균일 초기화를 수행하여 지정된 모양의 텐서를 생성합니다.

    기본 난수 생성기에 의해 생성된 -limitlimit 사이의 균일 분포에서 무작위 샘플을 추출합니다. 여기서 limitsqrt(3 / fanIn) 이고 fanIn 입력 기능 수에 수용 필드 크기를 곱한 값을 나타냅니다.

    참조: “효율적인 BackProp”

    선언

    public init(
      leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    seed

    시드 값입니다.

  • LeCun 정규 초기화를 수행하여 지정된 모양의 텐서를 생성합니다.

    기본 난수 생성기에 의해 생성된 표준 편차 sqrt(1 / fanIn) 사용하여 0 중심으로 하는 잘린 정규 분포에서 무작위 샘플을 추출합니다. 여기서 fanIn 입력 특성 수에 수용 필드 크기를 곱한 값을 나타냅니다.

    참조: “효율적인 BackProp”

    선언

    public init(
      leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    매개변수

    shape

    텐서의 차원.

    seed

    시드 값입니다.

  • 직교 행렬 또는 텐서를 생성합니다.

    초기화하려는 텐서의 형태가 2차원인 경우, 정규분포에서 도출된 난수 행렬을 QR 분해하여 얻은 직교 행렬로 초기화합니다. 행렬의 행이 열보다 적으면 출력에는 직교 행이 포함됩니다. 그렇지 않으면 출력에 직교 열이 포함됩니다.

    초기화하려는 텐서의 모양이 2차원 이상 [shape[0] * ... * shape[rank - 2], shape[rank - 1]] 행렬이 초기화됩니다. 이후 행렬은 원하는 모양의 텐서를 제공하기 위해 재구성됩니다.

    선언

    public init(
      orthogonal shape: TensorShape,
      gain: Tensor<Scalar> = Tensor<Scalar>(1),
      seed: TensorFlowSeed = Context.local.randomSeed
    )

    매개변수

    shape

    텐서의 모양.

    gain

    직교 텐서에 적용할 곱셈 요소입니다.

    seed

    난수 생성기를 시드하기 위한 두 정수의 튜플입니다.

`Scalar`: `TensorFlowNumeric`에서 사용 가능
  • [배치] 텐서의 [배치] 대각선 부분을 반환합니다. [..., M, N] 모양의 텐서 인스턴스의 경우 출력은 [..., K] 모양의 텐서입니다. 여기서 Kmin(N, M) 과 같습니다.

    예를 들어:

    // 't' is [[1, 0, 0, 0]
    //         [0, 2, 0, 0]
    //         [0, 0, 3, 0]
    //         [0, 0, 0, 4]]
    t.diagonalPart()
    // [1, 2, 3, 4]
    

    선언

    @differentiable
    public func diagonalPart() -> Tensor
  • [배치] 대각선 배열을 구성합니다. [..., M] 모양의 텐서 인스턴스의 경우 출력은 [..., M, M] 모양의 텐서입니다.

    예를 들어:

    // 't' is [1, 2, 3, 4]
    
    t.diagonal()
    // [[1, 0, 0, 0]
    //  [0, 2, 0, 0]
    //  [0, 0, 3, 0]
    //  [0, 0, 0, 4]]
    

    선언

    @differentiable
    public func diagonal() -> Tensor
  • self 선택적으로 일괄 처리된 행렬인 경우 새로운 대각선 값으로 self 를 반환합니다.

    반환된 텐서는 diagonal 의 값으로 덮어쓰여지는 가장 안쪽 행렬의 지정된 대각선을 제외하고 self 와 모양 및 값이 동일합니다.

    매개변수 대각선: 순위 rank - 1 인 텐서로 새 대각선 값을 나타냅니다.

    선언

    public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor
  • 선언

    @differentiable(wrt: self)
    public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
  • 중앙 밴드 경계로 정의된 가장 안쪽 텐서의 복사본을 반환합니다. 출력은 인스턴스 [..., :, :] 와 동일한 모양의 텐서입니다.

    예를 들어:

    // 't' is [[ 0,  1,  2, 3]
    //         [-1,  0,  1, 2]
    //         [-2, -1,  0, 1]
    //         [-3, -2, -1, 0]]
    
    t.bandPart(1, -1)
    // [[ 0,  1,  2, 3]
    //  [-1,  0,  1, 2]
    //  [ 0, -1,  0, 1]
    //  [ 0,  0, -1, 0]]
    
    t.bandPart(2, 1)
    // [[ 0,  1,  0, 0]
    //  [-1,  0,  1, 0]
    //  [-2, -1,  0, 1]
    //  [ 0, -2, -1, 0]]
    

    선언

    @differentiable
    public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor

    매개변수

    subdiagonalCount

    유지할 하부대각선의 수입니다. 음수인 경우 아래쪽 삼각형 전체를 유지합니다.

    superdiagonalCount

    유지할 상부대각선의 수입니다. 음수인 경우 전체 위쪽 삼각형을 유지합니다.

'Scalar': 'TensorFlowFloatingPoint'에서 사용 가능
  • 텐서의 각 내부 행렬(내부 직교 행렬 q 가 포함된 텐서 및 내부 상부 삼각 행렬이 포함된 텐서)의 QR 분해를 반환합니다. r 텐서는 matmul(q, r) 과 같습니다.

    선언

    public func qrDecomposition(fullMatrices: Bool = false) -> (
      q: Tensor<Scalar>, r: Tensor<Scalar>
    )

    매개변수

    fullMatrices

    true 인 경우 전체 크기의 qr 계산합니다. 그렇지 않으면 q 의 선행 min(shape[rank - 1], shape[rank - 2]) 열만 계산합니다.

  • self 선택적으로 일괄 처리된 행렬인 경우 self 의 특이값 분해를 반환합니다.

    선택적으로 일괄 처리된 행렬 self 의 특이값 분해(SVD)는 다음과 같은 값 s , uv 입니다.

    self[..., :, :] = u[..., :, :]  s[..., :, :].diagonal()  v[..., :, :].transposed()`
    

    self 는 […, M, N] must be a tensor with shape . Let K = min(M, N)` . Let .

    전제조건

    self [..., M, N] 형태의 텐서여야 합니다.

    선언

    public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> (
      s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>?
    )

    매개변수

    computeUV

    true 인 경우 왼쪽 및 오른쪽 특이 벡터가 각각 uv 로 계산되어 반환됩니다. false 이면 nil 값이 uv 로 반환됩니다.

    fullMatrices

    true 인 경우 uv 각각 [..., M, M][..., N, N] 모양을 갖습니다. false 인 경우 uv 각각 [..., M, K][..., K, N] 모양을 갖습니다. computeUV 가 false인 경우 무시됩니다.

    반환 값

    • s: [..., K] 모양의 특이값입니다. 각 벡터 내에서 특이값은 내림차순으로 정렬됩니다.
    • u: 왼쪽 특이 벡터입니다.
    • v: 오른쪽 특이 벡터.
  • x 의 제곱근입니다.

    실제 유형의 경우 x 가 음수이면 결과는 .nan 입니다. 복합 유형의 경우 음의 실수 축에 분기 절단이 있습니다.

    선언

    @differentiable
    public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
  • x 의 코사인은 라디안 단위의 각도로 해석됩니다.

    선언

    @differentiable
    public static func cos(_ x: `Self`) -> Tensor<Scalar>
  • x 의 사인은 라디안 단위의 각도로 해석됩니다.

    선언

    @differentiable
    public static func sin(_ x: `Self`) -> Tensor<Scalar>
  • x 의 탄젠트(라디안 단위의 각도)입니다.

    선언

    @differentiable
    public static func tan(_ x: `Self`) -> Tensor<Scalar>
  • x 의 역코사인(라디안)입니다.

    선언

    @differentiable
    public static func acos(_ x: `Self`) -> Tensor<Scalar>
  • x 의 역사인(라디안)입니다.

    선언

    @differentiable
    public static func asin(_ x: `Self`) -> Tensor<Scalar>
  • x 의 역탄젠트(라디안 단위)입니다.

    선언

    @differentiable
    public static func atan(_ x: `Self`) -> Tensor<Scalar>
  • x 의 쌍곡선 코사인입니다.

    선언

    @differentiable
    public static func cosh(_ x: `Self`) -> Tensor<Scalar>
  • x 의 쌍곡선 사인입니다.

    선언

    @differentiable
    public static func sinh(_ x: `Self`) -> Tensor<Scalar>
  • x 의 쌍곡선 탄젠트입니다.

    선언

    @differentiable
    public static func tanh(_ x: `Self`) -> Tensor<Scalar>
  • x 의 역쌍곡선 코사인입니다.

    선언

    @differentiable
    public static func acosh(_ x: `Self`) -> Tensor<Scalar>
  • x 의 역쌍곡선 사인입니다.

    선언

    @differentiable
    public static func asinh(_ x: `Self`) -> Tensor<Scalar>
  • x 의 역쌍곡탄젠트입니다.

    선언

    @differentiable
    public static func atanh(_ x: `Self`) -> Tensor<Scalar>
  • x 또는 e**x 에 적용되는 지수 함수입니다.

    선언

    @differentiable
    public static func exp(_ x: `Self`) -> Tensor<Scalar>
  • 두 개를 x 거듭제곱합니다.

    선언

    @differentiable
    public static func exp2(_ x: `Self`) -> Tensor<Scalar>
  • 10을 x 거듭제곱합니다.

    선언

    @differentiable
    public static func exp10(_ x: `Self`) -> Tensor<Scalar>
  • exp(x) - 1 평가됩니다.

    선언

    @differentiable
    public static func expm1(_ x: `Self`) -> Tensor<Scalar>
  • x 의 자연 로그입니다.

    선언

    @differentiable
    public static func log(_ x: `Self`) -> Tensor<Scalar>
  • x 의 밑이 2인 로그입니다.

    선언

    @differentiable
    public static func log2(_ x: `Self`) -> Tensor<Scalar>
  • x 의 밑이 10인 로그입니다.

    선언

    @differentiable
    public static func log10(_ x: `Self`) -> Tensor<Scalar>
  • log(1 + x) 0에 가까운 정확도를 유지하도록 계산되었습니다.

    선언

    @differentiable
    public static func log1p(_ x: `Self`) -> Tensor<Scalar>
  • exp(y log(x)) 중간 정밀도 손실 없이 계산됩니다.

    실수 유형의 경우 x 가 음수이면 y 에 정수 값이 있더라도 결과는 NaN입니다. 복합 유형의 경우 음의 실수 축에 분기 절단이 있습니다.

    선언

    @differentiable
    public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
  • x n 승으로 올렸습니다.

    xn 복사본의 곱입니다.

    선언

    @differentiable
    public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • xn 번째 루트입니다.

    실수 유형의 경우 x 가 음수이고 n 이 짝수이면 결과는 NaN입니다. 복합 유형의 경우 음의 실수 축을 따라 분기 절단이 있습니다.

    선언

    @differentiable
    public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • 선언

    public typealias VectorSpaceScalar = Float
  • 선언

    public func scaled(by scale: Float) -> Tensor<Scalar>
  • 선언

    public func adding(_ scalar: Float) -> Tensor<Scalar>
  • 선언

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
`Scalar`: `Numeric`에서 사용 가능
  • 텐서의 모든 스칼라에 스칼라를 더하고 합계를 생성합니다.

    선언

    @differentiable
    public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
  • 텐서의 모든 스칼라에 스칼라를 추가하고 합을 생성합니다.

    선언

    @differentiable
    public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
  • 텐서의 모든 스칼라에서 스칼라를 빼고 차이를 생성합니다.

    선언

    @differentiable
    public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
  • 텐서의 모든 스칼라에서 스칼라를 빼고 차이를 생성합니다.

    선언

    @differentiable
    public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
  • 두 개의 텐서를 추가하고 결과를 왼쪽 변수에 저장합니다.

    메모

    += 방송을 지원합니다.

    선언

    public static func += (lhs: inout Tensor, rhs: Tensor)
  • 텐서의 모든 스칼라에 스칼라를 추가하고 결과를 왼쪽 변수에 저장합니다.

    선언

    public static func += (lhs: inout Tensor, rhs: Scalar)
  • 첫 번째 텐서에서 두 번째 텐서를 빼고 결과를 왼쪽 변수에 저장합니다.

    메모

    -= 방송을 지원합니다.

    선언

    public static func -= (lhs: inout Tensor, rhs: Tensor)
  • 텐서의 모든 스칼라에서 스칼라를 빼고 결과를 왼쪽 변수에 저장합니다.

    선언

    public static func -= (lhs: inout Tensor, rhs: Scalar)
  • 두 텐서를 곱하여 생성 된 텐서를 반환합니다.

    메모

    * 방송을 지원합니다.

    선언

    @differentiable
    public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
  • 텐서에 텐서의 모든 스칼라를 곱하여 텐서를 반환합니다.

    선언

    @differentiable
    public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
  • 스칼라에 텐서의 모든 스칼라를 곱하고 제품을 생산합니다.

    선언

    @differentiable
    public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
  • 두 개의 텐서를 곱하고 결과를 왼쪽 변수에 저장합니다.

    메모

    *= 방송을 지원합니다.

    선언

    public static func *= (lhs: inout Tensor, rhs: Tensor)
  • 텐서에 스칼라를 곱하고 스칼라를 방송하고 결과를 왼쪽 변수에 저장합니다.

    선언

    public static func *= (lhs: inout Tensor, rhs: Scalar)
  • 첫 번째 텐서를 두 번째 텐서로 나누는 지수를 반환합니다.

    메모

    / 방송을 지원합니다.

    선언

    @differentiable
    public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
  • 스칼라를 텐서로 나누고 스칼라를 방송하는 몫을 반환합니다.

    선언

    @differentiable
    public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
  • 텐서를 스칼라로 나누고 스칼라를 방송하는 몫을 반환합니다.

    선언

    @differentiable
    public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
  • 첫 번째 텐서를 두 번째 텐서로 나누고 왼쪽 변수에 몫을 저장합니다.

    선언

    public static func /= (lhs: inout Tensor, rhs: Tensor)
  • 텐서를 스칼라로 나누고 스칼라를 방송하고 왼쪽 변수에 몫을 저장합니다.

    선언

    public static func /= (lhs: inout Tensor, rhs: Scalar)
  • 첫 번째 텐서를 두 번째 텐서로 나누는 나머지를 반환합니다.

    메모

    % 방송을 지원합니다.

    선언

    public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
  • 텐서를 스칼라로 나누고 스칼라를 방송하는 나머지 부분을 반환합니다.

    선언

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
  • 스칼라를 텐서로 나누고 스칼라를 방송하는 나머지를 반환합니다.

    선언

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
  • 첫 번째 텐서를 두 번째 텐서로 나누고 나머지는 왼쪽 변수에 저장합니다.

    선언

    public static func %= (lhs: inout Tensor, rhs: Tensor)
  • 텐서를 스칼라로 나누고 나머지는 왼쪽 변수에 저장합니다.

    선언

    public static func %= (lhs: inout Tensor, rhs: Scalar)
`scalar` ==` bool '에서 사용할 수 있습니다
  • 반환 !self 요소 별.

    선언

    public func elementsLogicalNot() -> Tensor
  • self && other 요소 별을 반환합니다.

    메모

    && 방송을 지원합니다.

    선언

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor
  • self && other 요소 면적, other 방송합니다.

    선언

    public func elementsLogicalAnd(_ other: Scalar) -> Tensor
  • self || other 반환합니다 self || other 요소 측면.

    선언

    public func elementsLogicalOr(_ other: Tensor) -> Tensor
  • self || other 반환합니다 self || other 요소 측면에서 방송하는 other .

    선언

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
`scalar ':`tensorflownumeric'
  • max(min(self, max), min) 반환합니다.

    선언

    @differentiable
    public func clipped(min: Tensor, max: Tensor) -> Tensor
  • max(min(self, max), min) 반환합니다.

    선언

    @differentiable(wrt: (self, min)
    ) public func clipped(min: Tensor, max: Scalar) -> Tensor
  • max(min(self, max), min) 반환합니다.

    선언

    @differentiable(wrt: (self, max)
    ) public func clipped(min: Scalar, max: Tensor) -> Tensor
  • max(min(self, max), min) 반환합니다.

    선언

    @differentiable(wrt: self)
    public func clipped(min: Scalar, max: Scalar) -> Tensor
`Scalar`: `SignedNumeric`에서 사용 가능
  • 지정된 텐서 요소 별 부정을 반환합니다.

    선언

    @differentiable
    public prefix static func - (rhs: Tensor) -> Tensor
`스칼라 ':`숫자'
  • 선언

    @differentiable(wrt: self)
    public func squared() -> Tensor
`scalar ':`tensorflowfloatingpoint'에서 사용할 수 있습니다
  • x 의 어떤 요소가 유한한지를 나타내는 부울 텐서를 반환합니다.

    선언

    public var isFinite: Tensor<Bool> { get }
  • x 의 요소가 무한한 부울 텐서를 반환합니다.

    선언

    public var isInfinite: Tensor<Bool> { get }
  • x 의 어떤 요소가 NAN 값을 나타내는 부울 텐서를 반환합니다.

    선언

    public var isNaN: Tensor<Bool> { get }
`scalar` ==` bool '에서 사용할 수 있습니다
  • 모든 스칼라가 true 와 같으면 true 반환합니다. 그렇지 않으면 false 반환합니다.

    선언

    public func all() -> Bool
  • 스칼라가 true true 합니다. 그렇지 않으면 false 반환합니다.

    선언

    public func any() -> Bool
  • 지정된 축을 따라 논리 및 작동을 수행합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func all(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 논리 및 작동을 수행합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func any(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 논리 및 작동을 수행합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func all(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 논리 또는 작동을 수행합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func any(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

`scalar ':`numeric` &`비슷한'곳에서 사용할 수 있습니다.
  • 선언

    @differentiable
    public func min() -> Tensor
  • 선언

    @differentiable
    public func max() -> Tensor
  • 지정된 축을 따라 최대 값을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최대 값을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최대 값을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최대 값의 지수를 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값의 지수를 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func min(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func min(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func min(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func max(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func max(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 최소값을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func max(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 평평한 스칼라의 최대 값의 인덱스를 반환합니다.

    선언

    public func argmax() -> Tensor<Int32>
  • 평평한 스칼라의 최소값의 인덱스를 반환합니다.

    선언

    public func argmin() -> Tensor<Int32>
`스칼라 ':`숫자'
  • 지정된 축을 따라 합계를 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 합계를 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 합계를 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 선언

    @differentiable(wrt: self)
    public func sum() -> Tensor
  • 지정된 축을 따라 합계를 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func sum(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 합계를 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func sum(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 합계를 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func sum(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 제품을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 제품을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 제품을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 선언

    @differentiable(wrt: self)
    public func product() -> Tensor
  • 지정된 축을 따라 제품을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func product(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 제품을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func product(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 제품을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    public func product(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 산술 평균을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 산술 평균을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 산술 평균을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 -rank...rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 선언

    @differentiable(wrt: self)
    public func mean() -> Tensor
  • 지정된 축을 따라 산술 평균을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func mean(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 산술 평균을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func mean(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 산술 평균을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func mean(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 분산을 반환합니다. 감소 된 치수가 제거됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 분산을 반환합니다. 감소 된 치수가 제거됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 분산을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 선언

    @differentiable(wrt: self)
    public func variance() -> Tensor
  • 지정된 축을 따라 분산을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func variance(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 분산을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func variance(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 분산을 반환합니다. 감소 된 치수는 값 1으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func variance(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 이 텐서의 누적 합을 지정된 축을 따라 반환합니다. 기본적 으로이 함수는 포괄적 인 누적 합을 수행하는데, 이는 입력의 첫 번째 요소가 출력의 첫 번째 요소와 동일하다는 것을 의미합니다.

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
    

    exclusive 인수를 true 로 설정하면 대신 독점적 누적 합계가 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
    

    역수를 true 으로 설정함으로써 reverse 합계는 반대 방향으로 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
        Tensor<Float>([a + b + c, a + b, a])
    

    이것은 결과 텐서를 별도로 역전시키는 것보다 더 효율적입니다.

    전제조건

    axis -rank..<rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func cumulativeSum(
      alongAxis axis: Int,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    매개변수

    axis

    누적 합계 작업을 수행하는 축.

    exclusive

    독점 누적 합계를 수행할지 여부를 나타냅니다.

    reverse

    누적 합계를 역 순서로 수행할지 여부를 나타냅니다.

    반환 값

    누적 합계 작업의 결과.

  • 이 텐서의 누적 합을 지정된 축을 따라 반환합니다. 기본적 으로이 함수는 포괄적 인 누적 합을 수행하는데, 이는 입력의 첫 번째 요소가 출력의 첫 번째 요소와 동일하다는 것을 의미합니다.

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
    

    exclusive 인수를 true 로 설정하면 대신 독점적 누적 합계가 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
    

    역수를 true 으로 설정함으로써 reverse 합계는 반대 방향으로 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
        Tensor<Float>([a + b + c, a + b, a])
    

    이것은 결과 텐서를 별도로 역전시키는 것보다 더 효율적입니다.

    전제조건

    axis.rank 0 이어야합니다.

    전제조건

    axis -rank..<rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func cumulativeSum(
      alongAxis axis: Tensor<Int32>,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    매개변수

    axis

    누적 합계 작업을 수행하는 축.

    exclusive

    독점 누적 합계를 수행할지 여부를 나타냅니다.

    reverse

    누적 합계를 역 순서로 수행할지 여부를 나타냅니다.

    반환 값

    누적 합계 작업의 결과.

  • 지정된 축을 따라이 텐서의 누적 제품을 반환합니다. 기본적 으로이 함수는 포괄적 인 누적 제품을 수행합니다. 이는 입력의 첫 번째 요소가 출력의 첫 번째 요소와 동일하다는 것을 의미합니다.

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
    

    exclusive 인수를 true 로 설정함으로써 독점적 누적 제품이 대신 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
    

    reversetrue 로 설정함으로써 누적 제품은 반대 방향으로 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
        Tensor<Float>([a * b * c, a * b, a])
    

    이것은 결과 텐서를 별도로 역전시키는 것보다 더 효율적입니다.

    전제조건

    axis -rank..<rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func cumulativeProduct(
      alongAxis axis: Int,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    매개변수

    axis

    누적 제품 작동을 수행하는 축.

    exclusive

    독점적 누적 제품을 수행할지 여부를 나타냅니다.

    reverse

    누적 제품을 역 순서로 수행할지 여부를 나타냅니다.

    반환 값

    누적 제품 작동의 결과.

  • 지정된 축을 따라이 텐서의 누적 제품을 반환합니다. 기본적 으로이 함수는 포괄적 인 누적 제품을 수행합니다. 이는 입력의 첫 번째 요소가 출력의 첫 번째 요소와 동일하다는 것을 의미합니다.

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
    

    exclusive 인수를 true 로 설정함으로써 독점적 누적 제품이 대신 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
    

    reversetrue 로 설정함으로써 누적 제품은 반대 방향으로 수행됩니다.

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
        Tensor<Float>([a * b * c, a * b, a])
    

    이것은 결과 텐서를 별도로 역전시키는 것보다 더 효율적입니다.

    전제조건

    axis 순위 0 있어야합니다.

    전제조건

    axis -rank..<rank 에 있어야합니다.

    선언

    @differentiable(wrt: self)
    public func cumulativeProduct(
      alongAxis axis: Tensor<Int32>,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    매개변수

    axis

    누적 제품 작동을 수행하는 축.

    exclusive

    독점적 누적 제품을 수행할지 여부를 나타냅니다.

    reverse

    누적 제품을 역 순서로 수행할지 여부를 나타냅니다.

    반환 값

    누적 제품 작동의 결과.

`scalar ':`tensorflowfloatingpoint'에서 사용할 수 있습니다
  • 지정된 축을 따라 요소의 표준 편차를 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 요소의 표준 편차를 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 요소의 표준 편차를 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 이 텐서에서 모든 요소의 표준 편차를 반환합니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation() -> Tensor
  • 지정된 축을 따라 요소의 표준 편차를 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 요소의 표준 편차를 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라 요소의 표준 편차를 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다. Bessel의 수정을 적용하지 않습니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • log(exp(self).sum(squeezingAxes: axes)) 반환합니다. 감소 된 치수가 제거됩니다.

    이 기능은 컴퓨팅 log(exp(self).sum(squeezingAxes: axes)) 보다 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • log(exp(self).sum(squeezingAxes: axes)) 반환합니다. 감소 된 치수가 제거됩니다.

    이 기능은 컴퓨팅 log(exp(self).sum(squeezingAxes: axes)) 보다 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • log(exp(self).sum(squeezingAxes: axes)) 반환합니다. 감소 된 치수가 제거됩니다.

    이 기능은 컴퓨팅 log(exp(self).sum(squeezingAxes: axes)) 보다 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • log(exp(self).sum()) 반환합니다. 결과는 스칼라입니다.

    이 기능은 컴퓨팅 log(exp(self).sum()) 보다 직접 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    선언

    @differentiable(wrt: self)
    public func logSumExp() -> Tensor
  • log(exp(self).sum(alongAxes: axes)) . 감소 된 치수는 값 1 으로 유지됩니다.

    이 기능은 컴퓨팅 log(exp(self).sum(alongAxes: axes)) 보다 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • log(exp(self).sum(alongAxes: axes)) . 감소 된 치수는 값 1 으로 유지됩니다.

    이 기능은 컴퓨팅 log(exp(self).sum(alongAxes: axes)) 보다 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: [Int]) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • log(exp(self).sum(alongAxes: axes)) . 감소 된 치수는 값 1 으로 유지됩니다.

    이 기능은 컴퓨팅 log(exp(self).sum(alongAxes: axes)) 보다 수치 적으로 안정적입니다. 작은 입력의 log 계산하여 발생하는 큰 입력 및 언더 플로의 exp 계산하여 발생하는 오버 플로를 피합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: Int...) -> Tensor

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라이 텐서의 평균과 분산을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 순위 1 있어야합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라이 텐서의 평균과 분산을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라이 텐서의 평균과 분산을 반환합니다. 감소 된 치수가 제거됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

    매개변수

    axes

    줄일 치수입니다.

  • 이 텐서의 요소의 평균과 분산을 반환합니다.

    선언

    @differentiable(wrt: self)
    public func moments() -> Moments<Scalar>
  • 지정된 축을 따라이 텐서의 평균과 분산을 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다.

    전제조건

    axes 순위 1 있어야합니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라이 텐서의 평균과 분산을 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

    매개변수

    axes

    줄일 치수입니다.

  • 지정된 축을 따라이 텐서의 평균과 분산을 반환합니다. 감소 된 치수는 값 1 으로 유지됩니다.

    전제조건

    axes 각 값은 범위에 있어야합니다 -rank..<rank .

    선언

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Int...) -> Moments<Scalar>

    매개변수

    axes

    줄일 치수입니다.

`스칼라 ':`숫자'
  • 두 텐서 사이의 매트릭스 곱셈을 수행하고 결과를 생성합니다.

    선언

    @differentiable
    public static func  (lhs: Tensor, rhs: Tensor) -> Tensor
`scalar ':`tensorflowfloatingpoint'에서 사용할 수 있습니다
  • 선언

    static func vjpInitDeviceAndPrecisionLike(
      _ value: Scalar,
      deviceAndPrecisionLike tensor: Tensor
    ) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
  • 지정된 축을 따라 입력을 배치 정상화하여 계산 한 텐서를 반환합니다.

    구체적으로, 반환 (self - mu) / (var + epsilon) * gamma + beta 각각 muvar axis 따라 self 의 평균과 분산입니다.

    선언

    @differentiable(wrt: (self, offset, scale)
    public func batchNormalized(
      alongAxis axis: Int,
      offset: Tensor = Tensor(0),
      scale: Tensor = Tensor(1),
      epsilon: Scalar = 0.001
    ) -> Tensor

    매개변수

    axis

    배치 치수.

    offset

    베타라고도하는 오프셋.

    scale

    감마라고도하는 규모.

    epsilon

    수치 안정성을 위해 분모에 첨가 된 작은 값.

  • 마지막 축을 따라 두 개의 텐서를 연결합니다.

    선언

    @differentiable
    public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • 두 값을 추가하고 합계를 생성합니다.

    선언

    @differentiable
    public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • 평균 두 값.

    선언

    @differentiable
    public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • 두 값을 곱합니다.

    선언

    @differentiable
    public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • 두 값을 쌓습니다.

    선언

    @differentiable
    public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • 선언

    @derivative
    init(shape: scalars)
`scalar ':`Quaratable'에서 사용할 수 있습니다
  • 선언

    public static func == (lhs: Tensor, rhs: Tensor) -> Bool
  • 선언

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
`Scalar`: `Codable`에서 사용 가능
`스칼라 ':`숫자'
  • 스칼라 제로 텐서.

  • 선언

    public static var zero: Tensor { get }
  • 두 개의 텐서를 추가하고 합계를 생성합니다.

    메모

    + 방송을 지원합니다.

    선언

    @differentiable
    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
  • 한 텐서를 다른 텐서에서 빼고 차이를 만듭니다.

    메모

    - 방송을 지원합니다.

    선언

    @differentiable
    public static func - (lhs: Tensor, rhs: Tensor) -> Tensor
  • 스칼라 하나의 텐서.

    선언

    public static var one: Tensor { get }
  • self 의 요소 상호 상호를 반환합니다.

    선언

    public var reciprocal: Tensor { get }
  • 두 개의 텐서를 요소 단위로 곱하고 제품을 생산합니다.

    메모

    .* 방송을 지원합니다.

    선언

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
`scalar ':`tensorflowfloatingpoint'에서 사용할 수 있습니다
  • 선언

    public typealias TangentVector = Tensor
  • 선언

    public var zeroTangentVectorInitializer: () -> TangentVector { get }
  • 주석을 추가합니다.

    참고 : X10 만 지원됩니다. 다른 백엔드의 경우, umodified self 반환됩니다.

    선언

    @differentiable(wrt: self)
    public func annotate(_ annotation: String) -> Tensor<Scalar>

    매개변수

    annotation

    추가 할 주석.

    반환 값

    주석이 달린 텐서.

  • 선언

    @derivative
    func vjpAnnotate(_ annotation: String) -> (
      value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar>
    )