함수

다음 기능은 전역적으로 사용할 수 있습니다.

  • 예측과 기대 사이의 L1 손실을 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 예측과 기대 사이의 L2 손실을 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 예측과 기대 사이의 힌지 손실을 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 예측과 기대 사이의 제곱 힌지 손실을 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 예측과 기대 사이의 범주형 힌지 손실을 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 예측과 기대 사이의 오류에 대한 쌍곡선 코사인의 로그를 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 예측과 기대 사이의 포아송 손실을 반환합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 기대치와 예측 간의 Kullback-Leibler 발산(KL 발산)을 반환합니다. 두 개의 분포 p 와 q 주어지면 KL 발산은 p * log(p / q) 계산합니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 로짓과 레이블 사이의 소프트맥스 교차 엔트로피(범주형 교차 엔트로피)를 반환합니다.

    선언 

    @differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    logits

    신경망의 원-핫 인코딩된 출력입니다.

    labels

    올바른 출력의 인덱스(0 인덱스)입니다.

  • 로짓과 레이블 사이의 시그모이드 교차 엔트로피(이진 교차 엔트로피)를 반환합니다.

    선언 

    @differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    logits

    신경망의 크기 조정되지 않은 출력입니다.

    labels

    올바른 출력에 해당하는 정수 값입니다.

  • 지정된 텐서와 모양 및 스칼라가 동일한 텐서를 반환합니다.

    선언 

    @differentiable
public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • 주어진 학습 단계를 제외하고 현재 컨텍스트와 모든 것이 동일한 컨텍스트 내에서 지정된 클로저를 호출합니다.

    선언 

    public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R

    매개변수

    context

    클로저가 호출되기 전에 설정되고 클로저가 반환된 후 복원되는 컨텍스트입니다.

    body

    무효 폐쇄. 클로저에 반환 값이 있으면 해당 값은 withContext(_:_:) 함수의 반환 값으로도 사용됩니다.

    반환 값

    body 클로저의 반환 값(있는 경우)입니다.

  • 주어진 학습 단계를 제외하고 현재 컨텍스트와 모든 것이 동일한 컨텍스트 내에서 지정된 클로저를 호출합니다.

    선언 

    public func withLearningPhase<R>(
  _ learningPhase: LearningPhase,
  _ body: () throws -> R
) rethrows -> R

    매개변수

    learningPhase

    클로저가 호출되기 전에 설정되고 클로저가 반환된 후 복원되는 학습 단계입니다.

    body

    무효 폐쇄. 클로저에 반환 값이 있으면 해당 값은 withLearningPhase(_:_:) 함수의 반환 값으로도 사용됩니다.

    반환 값

    body 클로저의 반환 값(있는 경우)입니다.

  • 주어진 무작위 시드를 제외하고 현재 컨텍스트와 모든 것이 동일한 컨텍스트 내에서 주어진 클로저를 호출합니다.

    선언 

    public func withRandomSeedForTensorFlow<R>(
  _ randomSeed: TensorFlowSeed,
  _ body: () throws -> R
) rethrows -> R

    매개변수

    randomSeed

    클로저가 호출되기 전에 설정되고 클로저가 반환된 후에 복원되는 임의의 시드입니다.

    body

    무효 폐쇄. 클로저에 반환 값이 있으면 해당 값은 withRandomSeedForTensorFlow(_:_:) 함수의 반환 값으로도 사용됩니다.

    반환 값

    body 클로저의 반환 값(있는 경우)입니다.

  • 주어진 난수 생성기를 제외하고 현재 컨텍스트와 모든 것이 동일한 컨텍스트 내에서 주어진 클로저를 호출합니다.

    선언 

    public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
  _ randomNumberGenerator: inout G,
  _ body: () throws -> R
) rethrows -> R

    매개변수

    randomNumberGenerator

    클로저가 호출되기 전에 설정되고 클로저가 반환된 후에 복원되는 난수 생성기입니다.

    body

    무효 폐쇄. 클로저에 반환 값이 있으면 해당 값은 withRandomNumberGeneratorForTensorFlow(_:_:) 함수의 반환 값으로도 사용됩니다.

    반환 값

    body 클로저의 반환 값(있는 경우)입니다.

  • 선언 

    public func zip<T: TensorGroup, U: TensorGroup>(
  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
) -> Dataset<Zip2TensorGroup<T, U>>

  • LazyTensorBarrier는 모든 라이브 텐서(제공된 경우 장치에 있음)가 예약되고 실행되는지 확인합니다. wait가 true로 설정된 경우 이 호출은 계산이 완료될 때까지 차단됩니다.

    선언 

    public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

  • 선언 

    public func valueWithGradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func valueWithGradient<T, U, R>(
  at x: T,
  _ y: U,
  in f: @differentiable (T, U) -> Tensor<R>
) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func valueWithGradient<T, U, V, R>(
  at x: T,
  _ y: U,
  _ z: V,
  in f: @differentiable (T, U, V) -> Tensor<R>
) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func valueWithGradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func valueWithGradient<T, U, R>(
  of f: @escaping @differentiable (T, U) -> Tensor<R>
) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func valueWithGradient<T, U, V, R>(
  of f: @escaping @differentiable (T, U, V) -> Tensor<R>
) -> (T, U, V) -> (
  value: Tensor<R>,
  gradient: (T.TangentVector, U.TangentVector, V.TangentVector)
)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func gradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func gradient<T, U, R>(
  at x: T,
  _ y: U,
  in f: @differentiable (T, U) -> Tensor<R>
) -> (T.TangentVector, U.TangentVector)
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func gradient<T, U, V, R>(
  at x: T,
  _ y: U,
  _ z: V,
  in f: @differentiable (T, U, V) -> Tensor<R>
) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func gradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func gradient<T, U, R>(
  of f: @escaping @differentiable (T, U) -> Tensor<R>
) -> (T, U) -> (T.TangentVector, U.TangentVector)
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

  • 선언 

    public func gradient<T, U, V, R>(
  of f: @escaping @differentiable (T, U, V) -> Tensor<R>
) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

  • 기존 자동 미분에서는 "체크포인트"라고 알려진 풀백에서 함수를 다시 계산합니다.

    선언 

    public func withRecomputationInPullbacks<T, U>(
  _ body: @escaping @differentiable (T) -> U
) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

  • 벡터-야코비안 곱 함수에서 미분 가능 함수를 만듭니다.

    선언 

    public func differentiableFunction<T : Differentiable, R : Differentiable>(
  from vjp: @escaping (T)
           -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
) -> @differentiable (T) -> R

  • 벡터-야코비안 곱 함수에서 미분 가능 함수를 만듭니다.

    선언 

    public func differentiableFunction<T, U, R>(
  from vjp: @escaping (T, U)
           -> (value: R, pullback: (R.TangentVector)
             -> (T.TangentVector, U.TangentVector))
) -> @differentiable (T, U) -> R

  • 항등 함수처럼 x 반환합니다. x 미분되는 맥락에서 사용될 때 이 함수는 x 에서 어떤 도함수도 생성하지 않습니다.

    선언 

    @_semantics("autodiff.nonvarying")
public func withoutDerivative<T>(at x: T) -> T

  • 주어진 클로저 body x 에 적용합니다. x 미분되는 맥락에서 사용될 때 이 함수는 x 에서 어떤 도함수도 생성하지 않습니다.

    선언 

    @_semantics("autodiff.nonvarying")
public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R

  • 클로저를 실행하여 TensorFlow 작업이 특정 종류의 장치에서 실행되도록 합니다.

    선언 

    public func withDevice<R>(
  _ kind: DeviceKind,
  _ index: UInt = 0,
  perform body: () throws -> R
) rethrows -> R

    매개변수

    kind

    TensorFlow 작업을 실행하는 일종의 장치입니다.

    index

    작업을 실행할 장치입니다.

    body

    특정 종류의 장치에서 TensorFlow 작업이 실행되는 클로저입니다.

  • 특정 이름을 가진 장치에서 TensorFlow 작업이 실행되도록 클로저를 실행합니다.

    장치 이름의 몇 가지 예:

    • "/device:CPU:0": 컴퓨터의 CPU입니다.
    • "/GPU:0": TensorFlow에 표시되는 머신의 첫 번째 GPU에 대한 약칭 표기법
    • "/job:localhost/replica:0/task:0/device:GPU:1": TensorFlow에 표시되는 머신의 두 번째 GPU의 정규화된 이름입니다.

    선언 

    public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R

    매개변수

    name

    장치 이름.

    body

    특정 종류의 장치에서 TensorFlow 작업이 실행되는 클로저입니다.

  • 클로저를 실행하여 TensorFlow가 모든 장치에 TensorFlow 작업을 배치할 수 있도록 합니다. 이렇게 하면 기본 배치 동작이 복원됩니다.

    선언 

    public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R

    매개변수

    body

    특정 종류의 장치에서 TensorFlow 작업이 실행되는 클로저입니다.

  • 지정된 방법을 사용하여 이미지 크기를 조정합니다.

    전제조건

    이미지의 순위는 3 또는 4 여야 합니다.

    전제조건

    크기는 양수여야 합니다.

    선언 

    @differentiable(wrt: images)
public func resize(
  images: Tensor<Float>,
  size: (newHeight: Int, newWidth: Int),
  method: ResizeMethod = .bilinear,
  antialias: Bool = false
) -> Tensor<Float>

    매개변수

    images

    [batch, height, width, channels] 모양의 4차원 Tensor 또는 [height, width, channels] 모양의 3차원 Tensor .

    size

    이미지의 새로운 크기.

    method

    크기 조정 방법. 기본값은 .bilinear 입니다.

    antialias

    true 인 경우 이미지를 다운샘플링할 때 앤티앨리어싱 필터를 사용합니다.

  • 영역 보간을 사용하여 이미지 크기를 조정합니다.

    전제조건

    이미지의 순위는 3 또는 4 여야 합니다.

    전제조건

    크기는 양수여야 합니다.

    선언 

    public func resizeArea<Scalar: TensorFlowNumeric>(
  images: Tensor<Scalar>,
  size: (newHeight: Int, newWidth: Int),
  alignCorners: Bool = false
) -> Tensor<Float>

    매개변수

    images

    [batch, height, width, channels] 모양의 4차원 Tensor 또는 [height, width, channels] 모양의 3차원 Tensor .

    size

    이미지의 새로운 크기.

  • 지정된 입력, 필터, 보폭 및 패딩을 사용하여 2차원 팽창을 반환합니다.

    전제조건

    input 순위 4 여야 합니다.

    전제조건

    filter 순위 3 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func dilation2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filter

    팽창 필터.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩

    rates

    입력의 각 차원에 대한 팽창률입니다.

  • 지정된 입력, 필터, 보폭 및 패딩을 사용하여 2차원 침식을 반환합니다.

    전제조건

    input 순위 4 여야 합니다.

    전제조건

    filter 순위 3이 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func erosion2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filter

    침식 필터.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩

    rates

    입력의 각 차원에 대한 팽창률입니다.

  • 0()

    모든 값을 0으로 초기화하여 텐서를 생성하는 함수를 반환합니다.

    선언 

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint

  • 모든 값을 제공된 값으로 초기화하여 텐서를 생성하는 함수를 반환합니다.

    선언 

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
  value: Scalar
) -> ParameterInitializer<Scalar>

  • 제공된 값으로 초기화하여 텐서를 생성하는 함수를 반환합니다. 제공된 값의 브로드캐스팅은 지원되지 않습니다 .

    선언 

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
  value: Tensor<Scalar>
) -> ParameterInitializer<Scalar>

  • 지정된 모양에 대해 Glorot(Xavier) 균일 초기화를 수행하고 기본 난수 생성기에 의해 생성된 -limit 와 limit 사이의 균일 분포에서 스칼라 값을 무작위로 샘플링하여 텐서를 생성하는 함수를 반환합니다. 여기서 한계는 sqrt(6 / (fanIn + fanOut)) 및 fanIn / fanOut 입력 및 출력 기능의 수에 수용 필드(있는 경우)를 곱한 값을 나타냅니다.

    선언 

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 지정된 모양에 대해 Glorot(Xavier) 정규 초기화를 수행하고 표준 편차 sqrt(2 / (fanIn + fanOut)) 사용하여 0 중심으로 한 잘린 정규 분포에서 스칼라 값을 무작위로 샘플링하여 텐서를 생성하는 함수를 반환합니다. 여기서 fanIn / fanOut 존재하는 경우 입력 및 출력 기능의 수에 수용 필드 크기를 곱한 값을 나타냅니다.

    선언 

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 지정된 모양에 대해 He(Kaiming) 균일 초기화를 수행하고 기본 난수 생성기에 의해 생성된 -limit 와 limit 사이의 균일 분포에서 스칼라 값을 무작위로 샘플링하여 텐서를 생성하는 함수를 반환합니다. 여기서 한계는 sqrt(6 / fanIn) 입니다. sqrt(6 / fanIn) , fanIn 입력 특성의 수에 수용 필드(있는 경우)를 곱한 값을 나타냅니다.

    선언 

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 지정된 모양에 대해 He(Kaiming) 정규 초기화를 수행하고 표준 편차 sqrt(2 / fanIn) 사용하여 0 중심으로 하는 잘린 정규 분포에서 스칼라 값을 무작위로 샘플링하여 텐서를 생성하는 함수를 반환합니다. 여기서 fanIn 입력 특성의 수를 나타냅니다. 존재하는 경우 수용 필드 크기를 곱합니다.

    선언 

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 지정된 모양에 대해 LeCun 균일 초기화를 수행하고 기본 난수 생성기에 의해 생성된 -limit 와 limit 사이의 균일 분포에서 스칼라 값을 무작위로 샘플링하여 텐서를 생성하는 함수를 반환합니다. 여기서 한계는 sqrt(3 / fanIn) 입니다. fanIn 입력 기능의 수에 수용 필드(있는 경우)를 곱한 값을 나타냅니다.

    선언 

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 지정된 모양에 대해 LeCun 정규 초기화를 수행하고 표준 편차 sqrt(1 / fanIn) 사용하여 0 중심으로 하는 잘린 정규 분포에서 스칼라 값을 무작위로 샘플링하여 텐서를 생성하는 함수를 반환합니다. 여기서 fanIn 입력 특성의 수에 수용 필드 크기(있는 경우)

    선언 

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 잘린 정규 분포에서 모든 값을 무작위로 초기화하여 텐서를 생성하는 함수를 반환합니다. 생성된 값은 mean 과 표준편차 standardDeviation 갖는 정규 분포를 따릅니다. 단, 크기가 평균에서 2 표준편차를 초과하는 값은 삭제되고 다시 샘플링됩니다.

    선언 

    public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>(
  mean: Tensor<Scalar> = Tensor<Scalar>(0),
  standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1),
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

    매개변수

    mean

    정규 분포의 평균입니다.

    standardDeviation

    정규분포의 표준편차.

    반환 값

    잘린 일반 매개변수 초기화 함수입니다.

  • 선언 

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool

  • 단위 행렬 또는 행렬 배치를 반환합니다.

    선언 

    public func eye<Scalar: Numeric>(
  rowCount: Int,
  columnCount: Int? = nil,
  batchShape: [Int] = [],
  on device: Device = .default
) -> Tensor<Scalar>

    매개변수

    rowCount

    각 배치 행렬의 행 수입니다.

    columnCount

    각 배치 행렬의 열 수입니다.

    batchShape

    반환된 텐서의 주요 배치 차원입니다.

  • 선택적으로 일괄 처리된 행렬의 추적을 계산합니다. 추적은 가장 안쪽에 있는 각 행렬의 주대각선을 따른 합입니다.

    입력은 [..., M, N] 모양의 텐서입니다. 출력은 [...] 모양의 텐서입니다.

    전제조건

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

    선언 

    @differentiable(wrt: matrix)
public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    매개변수

    matrix

    [..., M, N] 모양의 텐서.

  • 하나 이상의 정사각 행렬에 대한 Cholesky 분해를 반환합니다.

    입력은 가장 안쪽의 2차원이 정사각형 행렬을 형성하는 [..., M, M] 모양의 텐서입니다.

    입력은 대칭적이고 양의 정부호여야 합니다. 이 작업에는 입력의 아래쪽 삼각형 부분만 사용됩니다. 위쪽 삼각형 부분은 읽혀지지 않습니다.

    출력은 모든 입력 하위 행렬 [..., :, :] 에 대한 Cholesky 분해를 포함하는 입력과 동일한 모양의 텐서입니다.

    선언 

    @differentiable
public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

    매개변수

    input

    [..., M, M] 모양의 텐서.

  • Ax = b 로 표현되는 선형 연립방정식의 해 x 반환합니다.

    전제조건

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

    전제조건

    rhs [..., M, K] 형태의 텐서여야 합니다.

    선언 

    @differentiable
public func triangularSolve<T: TensorFlowFloatingPoint>(
  matrix: Tensor<T>,
  rhs: Tensor<T>,
  lower: Bool = true,
  adjoint: Bool = false
) -> Tensor<T>

    매개변수

    matrix

    Ax = b 에서 A 나타내는 입력 삼각 계수 행렬.

    rhs

    Ax = b 에서 b 나타내는 우변 값입니다.

    lower

    matrix 하부 삼각 행렬( true )인지 상부 삼각 행렬( false )인지 여부입니다. 기본값은 true 입니다.

    adjoint

    true 인 경우 matrix 대신 matrix 수반을 사용하여 해결합니다. 기본값은 false 입니다.

    반환 값

    Ax = b 로 표현되는 선형 연립방정식의 해 x . x b 와 모양이 같습니다.

  • expected 과 predicted 사이의 L1 손실을 계산합니다. loss = reduction(abs(expected - predicted))

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • expected 과 predicted 사이의 L2 손실을 계산합니다. loss = reduction(square(expected - predicted))

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 라벨과 예측 간의 절대차의 평균을 계산합니다. loss = mean(abs(expected - predicted))

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • 라벨과 예측 간의 오차 제곱의 평균을 계산합니다. loss = mean(square(expected - predicted))

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanSquaredError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • predicted 손실과 expected loss = square(log(expected) - log(predicted))

    메모

    음수 텐서 항목은 정의되지 않은 로그 동작을 피하기 위해 0 으로 고정됩니다 log(_:) 음수 실수에 대해 정의되지 않기 때문입니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • predicted 과 expected 사이의 평균 절대 백분율 오차를 계산합니다. loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

  • predicted 및 expected 사이의 힌지 손실을 계산합니다. loss = reduction(max(0, 1 - predicted * expected)) expected 값은 -1 또는 1이 될 것으로 예상됩니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • predicted 및 expected 사이의 제곱 힌지 손실을 계산합니다. loss = reduction(square(max(0, 1 - predicted * expected))) expected 값은 -1 또는 1이 될 것으로 예상됩니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • predicted 및 expected 사이의 범주형 힌지 손실을 계산합니다. loss = maximum(negative - positive + 1, 0) 여기서 negative = max((1 - expected) * predicted) 및 positive = sum(predicted * expected)

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 예측 오차의 쌍곡선 코사인의 로그를 계산합니다. logcosh = log((exp(x) + exp(-x))/2) , 여기서 x는 predicted - expected 오류입니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 예측된 것과 예상된 것 사이의 포아송 손실을 계산합니다. 포아송 손실은 Tensor predicted - expected * log(predicted) 요소의 평균입니다.

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • expected 과 predicted 사이의 Kullback-Leibler 발산 손실을 계산합니다. loss = reduction(expected * log(expected / predicted))

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 로짓과 레이블 사이의 희소 소프트맥스 교차 엔트로피(범주형 교차 엔트로피)를 계산합니다. 두 개 이상의 레이블 클래스가 있는 경우 이 교차엔트로피 손실 함수를 사용하십시오. 라벨은 정수로 제공될 것으로 예상됩니다. logits 의 경우 기능당 # classes 부동 소수점 값이 있어야 하고 expected 의 경우 기능당 단일 부동 소수점 값이 있어야 합니다.

    선언 

    @differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Int32>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    logits

    신경망의 원-핫 인코딩된 출력입니다.

    labels

    올바른 출력의 인덱스(0 인덱스)입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 로짓과 레이블 사이의 희소 소프트맥스 교차 엔트로피(범주형 교차 엔트로피)를 계산합니다. 두 개 이상의 레이블 클래스가 있는 경우 이 교차엔트로피 손실 함수를 사용하십시오. 라벨은 one_hot 표현으로 제공될 것으로 예상됩니다. 기능당 # classes 부동 소수점 값이 있어야 합니다.

    선언 

    @differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    logits

    신경망의 크기 조정되지 않은 로그 확률입니다.

    probabilities

    올바른 출력에 해당하는 확률 값입니다. 각 행은 유효한 확률 분포여야 합니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 로짓과 레이블 사이의 시그모이드 교차 엔트로피(이진 교차 엔트로피)를 계산합니다. 레이블 클래스가 두 개만 있는 경우(0과 1로 가정) 이 교차 엔트로피 손실을 사용합니다. 각 예시에는 예측당 단일 부동 소수점 값이 있어야 합니다.

    선언 

    @differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    매개변수

    logits

    신경망의 크기 조정되지 않은 출력입니다.

    labels

    올바른 출력에 해당하는 정수 값입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • predicted 및 expected 사이의 Huber 손실을 계산합니다.

    각 값 x 에 대해 error = expected - predicted :

    • 0.5 * x^2 if |x| <= δ .

    • 0.5 * δ^2 + δ * (|x| - δ) 그렇지 않은 경우.

    • 출처: Wikipedia 기사 .

    선언 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func huberLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  delta: Scalar,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    매개변수

    predicted

    신경망의 예측 출력입니다.

    expected

    올바른 출력에 해당하는 예상 값, 즉 목표입니다.

    delta

    Huber 손실 함수가 2차에서 선형으로 변경되는 지점을 나타내는 부동 소수점 스칼라입니다.

    reduction

    계산된 요소별 손실 값에 적용할 감소입니다.

  • 지정된 텐서의 절대값을 요소별로 반환합니다.

    선언 

    @differentiable
public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar

  • 지정된 텐서 요소의 자연 로그를 반환합니다.

    선언 

    @differentiable
public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 밑이 2인 로그를 반환합니다.

    선언 

    @differentiable
public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 밑이 10인 로그를 반환합니다.

    선언 

    @differentiable
public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 1 + x 요소별 로그를 반환합니다.

    선언 

    @differentiable
public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 수치적으로 안정적인 접근 방식을 사용하여 log(1 - exp(x)) 반환합니다.

    메모

    접근 방식은 https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf 의 방정식 7에 나와 있습니다.

    선언 

    @differentiable
public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 코사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 탄젠트를 요소별로 반환합니다.

    선언 

    @differentiable
public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 쌍곡사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 쌍곡선 코사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 쌍곡선 탄젠트를 반환합니다.

    선언 

    @differentiable
public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 역코사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 역사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 역탄젠트를 반환합니다.

    선언 

    @differentiable
public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 역쌍곡선 코사인을 반환합니다.

    선언 

    @differentiable
public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 역쌍곡선 사인을 요소별로 반환합니다.

    선언 

    @differentiable
public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 역쌍곡선 탄젠트를 반환합니다.

    선언 

    @differentiable
public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 제곱근을 반환합니다.

    선언 

    @differentiable
public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 역제곱근을 반환합니다.

    선언 

    @differentiable
public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 지수를 요소별로 반환합니다.

    선언 

    @differentiable
public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소별로 거듭제곱한 2를 반환합니다.

    선언 

    @differentiable
public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소별로 거듭제곱한 10을 반환합니다.

    선언 

    @differentiable
public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • x - 1 요소의 지수를 반환합니다.

    선언 

    @differentiable
public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 요소별로 가장 가까운 정수로 반올림된 지정된 텐서의 값을 반환합니다.

    선언 

    @differentiable
public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 최대값을 요소별로 반환합니다.

    선언 

    @differentiable
public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 최소값을 요소별로 반환합니다.

    선언 

    @differentiable
public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 부호 표시를 요소별로 반환합니다. 구체적으로 x < 0 인 경우 y = sign(x) = -1 계산합니다. x == 0 이면 0; x > 0 이면 1입니다.

    선언 

    @differentiable
public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

  • 지정된 텐서의 시그모이드를 요소별로 반환합니다. 구체적으로 1 / (1 + exp(-x)) 계산합니다.

    선언 

    @differentiable
public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 로그 시그모이드를 반환합니다. 구체적으로는 log(1 / (1 + exp(-x))) . 수치적 안정성을 위해 -softplus(-x) 사용합니다.

    선언 

    @differentiable
public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 소프트플러스를 요소별로 반환합니다. 구체적으로 log(exp(features) + 1) 계산합니다.

    선언 

    @differentiable
public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서의 소프트부호를 요소별로 반환합니다. 구체적으로, features/ (abs(features) + 1) 계산합니다.

    선언 

    @differentiable
public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 마지막 축을 따라 지정된 텐서의 소프트맥스를 반환합니다. 구체적으로 exp(x) / exp(x).sum(alongAxes: -1) 계산합니다.

    선언 

    @differentiable
public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 축을 따라 지정된 텐서의 소프트맥스를 반환합니다. 구체적으로 exp(x) / exp(x).sum(alongAxes: axis) 계산합니다.

    선언 

    @differentiable
public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 log-softmax를 반환합니다.

    선언 

    @differentiable
public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지수 선형 단위를 적용하여 텐서를 반환합니다. 구체적으로, < 0이면 exp(x) - 1 계산하고, 그렇지 않으면 x 계산합니다. ELU(지수 선형 단위)를 통한 빠르고 정확한 심층 네트워크 학습을 확인하세요.

    선언 

    @differentiable
public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소의 GELU(Gaussian Error Linear Unit) 활성화를 반환합니다.

    구체적으로 gelu 다음을 계산하여 xP(X <= x) 근사화합니다. 여기서 P(X <= x) 는 표준 가우스 누적 분포입니다. x * [0.5 * (1 + tanh[√(2/π) * (x + 0.044715 * x^3)])].

    가우스 오차 선형 단위 를 참조하십시오.

    선언 

    @differentiable
public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 지정된 텐서 요소에 ReLU 활성화 함수를 적용하여 텐서를 반환합니다. 구체적으로 max(0, x) 계산합니다.

    선언 

    @differentiable
public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • ReLU6 활성화 함수, 즉 min(max(0, x), 6) 적용하여 텐서를 반환합니다.

    선언 

    @differentiable
public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Leaky ReLU 활성화 함수를 지정된 텐서 요소별로 적용하여 텐서를 반환합니다. 구체적으로 max(x, x * alpha) 계산합니다.

    선언 

    @differentiable(wrt: x)
public func leakyRelu<T: TensorFlowFloatingPoint>(
  _ x: Tensor<T>,
  alpha: Double = 0.2
) -> Tensor<T>

  • SeLU 활성화 함수, 즉 x < 0 이면 scale * alpha * (exp(x) - 1) , 그렇지 않으면 scale * x 적용하여 텐서를 반환합니다.

    메모

    이는 분산 스케일링 레이어 이니셜라이저와 함께 사용되도록 설계되었습니다. 자세한 내용은 자체 정규화 신경망을 참조하세요.

    선언 

    @differentiable
public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • swish 활성화 함수, 즉 x * sigmoid(x) 적용하여 텐서를 반환합니다.

    출처: "활성화 기능 검색"(Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

    선언 

    @differentiable
public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 하드 시그모이드 활성화 함수, 즉 Relu6(x+3)/6 적용하여 텐서를 반환합니다.

    출처: "MobileNetV3 검색"(Howard et al. 2019) https://arxiv.org/abs/1905.02244

    선언 

    @differentiable
public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • hard swish 활성화 함수, 즉 x * Relu6(x+3)/6 적용하여 텐서를 반환합니다.

    출처: "MobileNetV3 검색"(Howard et al. 2019) https://arxiv.org/abs/1905.02244

    선언 

    @differentiable
public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 잘못된 활성화 함수, 즉 x * tanh(softplus(x)) 적용하여 텐서를 반환합니다.

    출처: "Mish: 자체 정규화된 비단조 신경 활성화 함수" https://arxiv.org/abs/1908.08681

    선언 

    @differentiable
public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 첫 번째 텐서의 거듭제곱을 두 번째 텐서에 반환합니다.

    선언 

    @differentiable
public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 스칼라의 거듭제곱을 텐서에 반환하여 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable(wrt: rhs)
public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 텐서의 힘을 스칼라에 반환하여 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable(wrt: lhs)
public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 텐서의 힘을 스칼라에 반환하여 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable
public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 텐서의 요소별 n 번째 루트를 반환합니다.

    선언 

    @differentiable
public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

  • x 와 y 사이의 차이 제곱을 반환합니다.

    선언 

    @differentiable
public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    반환 값

    (x - y) ^ 2 .

  • 두 텐서의 요소별 최대값을 반환합니다.

    메모

    max 방송을 지원합니다.

    선언 

    @differentiable
public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

  • 스칼라와 텐서의 요소별 최대값을 반환하고 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable(wrt: rhs)
public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

  • 스칼라와 텐서의 요소별 최대값을 반환하고 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable(wrt: lhs)
public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

  • 두 텐서의 요소별 최소값을 반환합니다.

    메모

    min 방송을 지원합니다.

    선언 

    @differentiable
public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

  • 스칼라와 텐서의 요소별 최소값을 반환하고 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable(wrt: rhs)
public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

  • 스칼라와 텐서의 요소별 최소값을 반환하고 스칼라를 브로드캐스팅합니다.

    선언 

    @differentiable(wrt: lhs)
public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

  • x 와 y 사이의 코사인 유사성을 반환합니다.

    선언 

    @differentiable
public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

  • x 와 y 사이의 코사인 거리를 반환합니다. 코사인 거리는 1 - cosineSimilarity(x, y) 로 정의됩니다.

    선언 

    @differentiable
public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

  • 다른 텐서와 행렬 곱셈을 수행하고 결과를 생성합니다.

    선언 

    @differentiable
public func matmul<Scalar: Numeric>(
  _ lhs: Tensor<Scalar>,
  transposed transposeLhs: Bool = false,
  _ rhs: Tensor<Scalar>,
  transposed transposeRhs: Bool = false
) -> Tensor<Scalar>

  • 지정된 입력, 필터, 보폭 및 패딩을 사용하여 1D 컨볼루션을 반환합니다.

    전제조건

    input 순위 3 이어야 합니다.

    전제조건

    filter 순위 3이 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func conv1D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  stride: Int = 1,
  padding: Padding = .valid,
  dilation: Int = 1
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filter

    컨볼루션 필터.

    stride

    슬라이딩 필터의 보폭.

    padding

    작업을 위한 패딩입니다.

    dilation

    팽창 인자.

  • 지정된 입력, 필터, 스트라이드 및 패딩을 사용하여 2차원 컨볼루션을 반환합니다.

    전제 조건

    input 순위 4 여야 합니다.

    전제조건

    filter 순위 4가 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func conv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filter

    컨볼루션 필터.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩

    dilations

    입력의 각 차원에 대한 확장 인자입니다.

  • 지정된 입력, 필터, 스트라이드 및 패딩을 사용하여 2차원 전치 컨벌루션을 반환합니다.

    전제조건

    input 순위 4 여야 합니다.

    전제조건

    filter 순위 4가 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  shape: [Int64],
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    shape

    디컨벌루션 작업의 출력 형태입니다.

    filter

    컨볼루션 필터.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩

    dilations

    입력의 각 차원에 대한 확장 인자입니다.

  • 지정된 입력, 필터, 스트라이드, 패딩 및 팽창을 사용하여 3D 컨볼루션을 반환합니다.

    전제조건

    input 순위 5 여야 합니다.

    전제조건

    filter 순위 5가 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func conv3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filter

    컨볼루션 필터.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩입니다.

    dilations

    입력의 각 차원에 대한 확장 인자입니다.

  • 지정된 입력, 필터, 스트라이드 및 패딩을 사용하여 2차원 깊이별 컨볼루션을 반환합니다.

    전제조건

    input 순위 4가 있어야 합니다.

    전제조건

    filter 순위 4가 있어야 합니다.

    선언 

    @differentiable(wrt: (input, filter)
public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filter

    깊이별 컨볼루션 필터입니다.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩입니다.

  • 지정된 필터 크기, 스트라이드 및 패딩을 사용하여 2차원 최대 풀링을 반환합니다.

    선언 

    @differentiable(wrt: input)
public func maxPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int),
  strides: (Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filterSize

    풀링 커널의 차원입니다.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩입니다.

  • 지정된 필터 크기, 스트라이드 및 패딩을 사용하여 3D 최대 풀링을 반환합니다.

    선언 

    @differentiable(wrt: input)
public func maxPool3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int, Int),
  strides: (Int, Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filterSize

    풀링 커널의 차원입니다.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩입니다.

  • 지정된 필터 크기, 스트라이드 및 패딩을 사용하여 2차원 평균 풀링을 반환합니다.

    선언 

    @differentiable(wrt: input)
public func avgPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int),
  strides: (Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filterSize

    풀링 커널의 차원입니다.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩입니다.

  • 지정된 필터 크기, 스트라이드 및 패딩을 사용하여 3차원 평균 풀링을 반환합니다.

    선언 

    @differentiable(wrt: input)
public func avgPool3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int, Int),
  strides: (Int, Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

    매개변수

    input

    입력.

    filterSize

    풀링 커널의 차원입니다.

    strides

    입력의 각 차원에 대한 슬라이딩 필터의 보폭입니다.

    padding

    작업을 위한 패딩입니다.

  • 지정된 풀링 비율을 사용하여 2차원 분수 최대 풀링을 반환합니다.

    참고: fractionalMaxPool XLA 구현이 없으므로 성능에 영향을 미칠 수 있습니다.

    선언 

    @differentiable(wrt: input)
public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  poolingRatio: (Double, Double, Double, Double),
  pseudoRandom: Bool = false,
  overlapping: Bool = false,
  deterministic: Bool = false,
  seed: Int64 = 0,
  seed2: Int64 = 0
) -> Tensor<Scalar>

    매개변수

    input

    텐서. 모양이 [batch, height, width, channels] 인 4차원입니다.

    poolingRatio

    Doubles 목록입니다. input 의 각 차원에 대한 풀링 비율은 현재 행 및 열 차원만 지원하며 1.0보다 커야 합니다.

    pseudoRandom

    선택적 Bool . 기본값은 false 입니다. true 로 설정하면 의사 무작위 방식으로 풀링 시퀀스를 생성하고, 그렇지 않으면 무작위 방식으로 생성합니다.

    overlapping

    선택적 Bool . 기본값은 false 입니다. true 로 설정하면 풀링할 때 인접한 풀링 셀 경계의 값이 두 셀 모두에서 사용된다는 의미입니다.

    deterministic

    선택적 Bool . true 로 설정하면 계산 그래프에서 FractionalMaxPool2D 노드를 반복할 때 고정 풀링 영역이 사용됩니다.

    seed

    선택적 Int64 . 기본값은 0 입니다. 0이 아닌 값으로 설정되면 난수 생성기는 지정된 시드에 의해 시드됩니다.

    seed2

    선택적 Int64 . 기본값은 0 입니다. 시드 충돌을 피하기 위한 두 번째 시드입니다.

  • 깊이 차원의 값이 공간 블록에서 높이 및 너비 차원으로 이동되는 input 복사본을 반환합니다.

    예를 들어, [1, 2, 2, 1] 형태의 입력이 주어지면 data_format = "NHWC" 및 block_size = 2입니다.

    x = [[[[1], [2]],
      [[3], [4]]]]

    이 작업은 [1, 1, 1, 4] 모양의 텐서를 출력합니다.

    [[[[1, 2, 3, 4]]]]

    여기서 입력에는 1개의 배치가 있고 각 배치 요소의 모양은 [2, 2, 1] 이며 해당 출력은 단일 요소(예: 너비와 높이가 모두 1)를 가지며 깊이는 4개 채널(1)입니다. * 블록 크기 * 블록 크기). 출력 요소 모양은 [1, 1, 4] 입니다.

    더 큰 깊이를 가진 입력 텐서의 경우, 여기서는 [1, 2, 2, 3] 모양입니다. 예:

    x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]

    block_size가 2인 경우 이 작업은 [1, 1, 1, 12] 모양의 다음 텐서를 반환합니다.

    [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]

    마찬가지로 다음 입력의 경우 [1 4 4 1] 모양이고 블록 크기는 2입니다.

    x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]

    연산자는 [1 2 2 4] 모양의 다음 텐서를 반환합니다.

    x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]

    전제조건

    input.rank == 4 && b >= 2 .

    전제조건

    특징의 수는 b 의 제곱으로 나누어져야 합니다.

    선언 

    @differentiable(wrt: input)
public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • 높이 및 너비 차원의 값이 깊이 차원으로 이동된 input 복사본을 반환합니다.

    예를 들어, [1, 2, 2, 1] 형태의 입력이 주어지면 data_format = "NHWC" 및 block_size = 2입니다.

    x = [[[[1], [2]],
      [[3], [4]]]]

    이 작업은 [1, 1, 1, 4] 모양의 텐서를 출력합니다.

    [[[[1, 2, 3, 4]]]]

    여기서 입력은 배치가 1이고 각 배치 요소는 모양 [2, 2, 1] 을 가지며, 해당 출력은 단일 요소 (예 : 너비와 높이는 모두 1)를 가지며 깊이는 4 개의 채널을 갖습니다 (1 * block_size * block_size). 출력 요소 모양은 [1, 1, 4] 입니다.

    깊이가 큰 입력 텐서, 여기에서 [1, 2, 2, 3] , 예를 들어

    x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]

    2의 Block_size의 경우이 작업은 다음과 같은 모양의 텐서를 반환합니다 [1, 1, 1, 12]

    [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]

    마찬가지로, 다음과 같은 모양의 입력 [1 4 4 1] 및 블록 크기 2 :

    x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]

    연산자는 다음과 같은 모양의 텐서를 반환합니다 [1 2 2 4] :

    x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]

    전제 조건

    input.rank == 4 && b >= 2 .

    전제 조건

    입력의 높이는 b 로 나눌 수 있어야합니다.

    전제 조건

    입력의 너비는 b 로 나눌 수 있어야합니다.

    선언 

    @differentiable(wrt: input)
public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • LARS ( https://arxiv.org/pdf/1708.03888.pdf )에 대한 중량당 최적화기를 구축합니다.

    선언 

    public func makeLARS(
  learningRate: Float = 0.01,
  momentum: Float = 0.9,
  trustCoefficient: Float = 0.001,
  nesterov: Bool = false,
  epsilon: Float = 0.0,
  weightDecay: Float = 0.0
) -> ParameterGroupOptimizer

  • SGD 기반 가중 당 최적화기를 구축합니다.

    선언 

    public func makeSGD(
  learningRate: Float = 0.01,
  momentum: Float = 0,
  weightDecay: Float = 0,
  nesterov: Bool = false
) -> ParameterGroupOptimizer

  • 체중 부패로 Adam을위한 가중 당 최적화기를 구축합니다.

    참조 : “아담 - 확률 적 최적화를위한 방법”

    선언 

    public func makeAdam(
  learningRate: Float = 0.01,
  beta1: Float = 0.9,
  beta2: Float = 0.999,
  weightDecayRate: Float = 0.01,
  epsilon: Float = 1e-6
) -> ParameterGroupOptimizer

  • 텐서 플로우를위한 새로운 임의의 시드를 생성합니다.

    선언 

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

  • 두 값을 연결합니다.

    선언 

    @differentiable
public func concatenate<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • 두 값을 추가하고 합계를 생성합니다.

    선언 

    @differentiable
public func sum<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • 평균 두 값.

    선언 

    @differentiable
public func average<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • 두 값을 곱합니다.

    선언 

    @differentiable
public func multiply<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • 두 값을 쌓습니다.

    선언 

    @differentiable
public func stack<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • 선언 

    public func PrintX10Metrics()

  • 교육 및 테스트 통계 목록의 문자열 요약을 만듭니다.

    선언 

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

  • 선언 

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
  -> String

  • N 스레드 위에 함수를 매핑합니다.

    선언 

    public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]