기능

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

  • 예측과 기대 사이의 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 divergence(KL divergence)를 반환합니다. 두 분포를 감안하면 pq , 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

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

  • 로짓과 레이블 간의 softmax 교차 엔트로피(범주형 교차 엔트로피)를 반환합니다.

    선언

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

    매개변수

    logits

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

    labels

    올바른 출력의 인덱스(제로 인덱스).

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

    선언

    @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

    nullary 클로저. 폐쇄는 반환 값이있는 경우, 그 값도의 반환 값으로 사용됩니다 withContext(_:_:) 기능.

    반환 값

    반환 값,의,있는 경우 body 폐쇄.

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

    선언

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

    매개변수

    learningPhase

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

    body

    nullary 클로저. 폐쇄는 반환 값이있는 경우, 그 값도의 반환 값으로 사용됩니다 withLearningPhase(_:_:) 기능.

    반환 값

    반환 값,의,있는 경우 body 폐쇄.

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

    선언

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

    매개변수

    randomSeed

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

    body

    nullary 클로저. 폐쇄는 반환 값이있는 경우, 그 값도의 반환 값으로 사용됩니다 withRandomSeedForTensorFlow(_:_:) 기능.

    반환 값

    반환 값,의,있는 경우 body 폐쇄.

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

    선언

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

    매개변수

    randomNumberGenerator

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

    body

    nullary 클로저. 폐쇄는 반환 값이있는 경우, 그 값도의 반환 값으로 사용됩니다 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
  • 주어진 폐쇄 적용 bodyx . 문맥에서 사용될 때, 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

    4-D Tensor 형상 [batch, height, width, channels] 3-D Tensor 형상 [height, width, channels] .

    size

    이미지의 새 크기입니다.

    method

    크기 조정 방법. 기본값은 .bilinear .

    antialias

    IFF true 이미지를 다운 샘플링 할 때, 안티 앨리어싱 필터를 사용합니다.

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

    전제조건

    이미지는 순위가 있어야합니다 3 또는 4 .

    전제조건

    크기는 양수여야 합니다.

    선언

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

    매개변수

    images

    4-D Tensor 형상 [batch, height, width, channels] 3-D Tensor 형상 [height, width, channels] .

    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 (자비)을 수행하여 텐서를 생성하는 기능 -limitlimit 제한은 기본 난수 발생기에 의해 생성, sqrt(6 / (fanIn + fanOut))fanIn / fanOut 입력의 수를 나타내고있는 경우 출력은 수용 필드 승산 기능.

    선언

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 반환 임의로 절단 정규 분포 스칼라 값을 샘플링 지정된 형상 정상적인 초기화 Glorot (자비)을 수행하여 텐서를 생성하는 기능을 중심으로 0 표준 편차와 sqrt(2 / (fanIn + fanOut)) , fanIn / fanOut 존재하는 경우 수용 필드 크기로 곱한 입력 및 출력 기능의 수를 나타냅니다.

    선언

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 반환 임의로 간의 균일 한 분포로부터 스칼라 값을 샘플링, 그는 (Kaiming) 지정된 형상 유니폼 초기화를 수행하여 텐서를 생성하는 기능 -limitlimit 제한은 기본 난수 발생기에 의해 생성, sqrt(6 / fanIn)fanIn 존재하는 경우 상기 수용 필드 곱한 입력 기능의 수를 나타낸다.

    선언

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 반환 임의로 절단 정규 분포 스칼라 값을 샘플링 지정된 형상 그가 께 (Kaiming) 정상적인 초기화를 수행하여 텐서를 생성하는 기능을 중심으로 0 표준 편차와 sqrt(2 / fanIn) , fanIn 입력 기능의 수를 나타낸다 존재하는 경우 수신 필드 크기를 곱합니다.

    선언

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 반환 임의로 간의 균일 한 분포로부터 스칼라 값을 샘플링 지정된 셰이프 LeCun 균일 초기화를 수행하여 텐서를 생성하는 기능 -limitlimit 제한은 기본 난수 발생기에 의해 생성, sqrt(3 / fanIn)fanIn 존재하는 경우 상기 수용 필드 곱한 입력 기능의 수를 나타낸다.

    선언

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 반환 임의로 절단 정규 분포 스칼라 값을 샘플링 지정된 셰이프 LeCun 정상적인 초기화를 수행하여 텐서를 생성하는 기능을 중심으로 0 표준 편차와 sqrt(1 / fanIn) , fanIn 에 의해 곱 기능 입력의 수를 나타낸다 존재하는 경우 수용 필드 크기.

    선언

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 잘린 정규 분포에서 모든 값을 무작위로 초기화하여 텐서를 생성하는 함수를 반환합니다. 생성 된 값은 평균이 정규 분포에 따라 mean 및 표준 편차 standardDeviation 크기 평균의 두 표준 편차가 떨어졌다 다시 샘플링보다 더입니다 값 제외를.

    선언

    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] .

  • 하나 이상의 정방 행렬의 촐레스키 분해를 반환합니다.

    입력이 형상의 텐서 [..., M, M] 그 가장 안쪽 사각형 2 차원 행렬을 형성한다.

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

    출력은 모든 입력 행렬에 대한 촐레 스키 분해를 포함하는 입력과 같은 형상의 텐서 [..., :, :] .

    선언

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

    매개변수

    input

    형상의 텐서 [..., M, M] .

  • 반환 용액 x 선형 연립 방정식에 의해 표현 Ax = b .

    전제조건

    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

    삼각 나타내는 입력 계수 행렬 AAx = b .

    rhs

    우변 값을 나타내는 bAx = b .

    lower

    여부의 matrix 낮은 삼각형이다 ( true ) 또는 상위 삼각 ( false ). 기본값은 true .

    adjoint

    경우 true 의 수반 행렬과 해결 matrix 대신 matrix . 기본값은 false .

    반환 값

    용액 x 선형 방정식의 시스템에 의해 표현 Ax = b . x 동일한 형상 가진다 b .

  • 사이의 L1 손실 계산 expectedpredicted . 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

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

  • 사이의 L2 손실 계산 expectedpredicted . 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

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

  • 사이의 평균 제곱 로그 오류를 계산 predictedexpected 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

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

  • 사이의 평균 절대 비율 오차 계산 predictedexpected . 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

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

  • 사이 힌지 손실 계산 predictedexpected . 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

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

  • 사이의 제곱 힌지 손실 계산 predictedexpected . 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

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

  • 사이의 범주 힌지 손실 계산 predictedexpected . 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

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

  • 사이 계산해 쿨백 - 라이 블러의 분기 손실이 expectedpredicted . 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

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

  • 로짓과 레이블 간의 희소 softmax 교차 엔트로피(범주형 교차 엔트로피)를 계산합니다. 두 개 이상의 레이블 클래스가 있는 경우 이 교차 엔트로피 손실 함수를 사용합니다. 레이블은 정수로 제공될 것으로 기대합니다. 이 있어야 # classes 에 대한 기능에 따라 부동 소수점 값 logits 과 기능 당 하나의 부동 소수점 값 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

    올바른 출력의 인덱스(제로 인덱스).

    reduction

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

  • 로짓과 레이블 간의 희소 softmax 교차 엔트로피(범주형 교차 엔트로피)를 계산합니다. 두 개 이상의 레이블 클래스가 있는 경우 이 교차 엔트로피 손실 함수를 사용합니다. 우리는 라벨이 제공 제공 될 것으로 예상 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

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

  • 사이의 후버 손실 계산 predictedexpected .

    각 값의 경우 xerror = expected - predicted :

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

    • 출처 : 위키 백과 문서 .

    선언

    @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)) 수치의 안정적인 접근 방식을 사용.

    메모

    다음의 접근법은 수학 식 7에 도시 https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

    선언

    @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
  • 지정된 텐서의 부호 표시를 요소별로 반환합니다. 구체적으로는, 계산 y = sign(x) = -1 의 경우 x < 0 ; 만약 0 x == 0 ; 1이면 x > 0 .

    선언

    @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
  • 마지막 축을 따라 지정된 텐서의 softmax를 반환합니다. 구체적으로 계산해 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
  • 지수 선형 단위를 적용하여 텐서를 반환합니다. 구체적으로 계산해 exp(x) - 1 <0 인 경우 x 그렇지. 참조 지수 선형 단위로 신속하고 정확한 깊은 네트워크 학습 (ELUs를)

    선언

    @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
  • 누출 ReLU 활성화 함수를 지정된 텐서에 요소별로 적용하여 텐서를 반환합니다. 즉, 계산 max(x, x * alpha) .

    선언

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • 되돌 SeLU 활성화 함수를 적용함으로써 텐서, 즉 scale * alpha * (exp(x) - 1) 하는 경우 x < 0 , 및 scale * x 그렇지.

    메모

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

    선언

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 반환 휙 활성화 기능, 즉 적용하여 텐서 x * sigmoid(x) .

    출처 : (. 라마 찬드 등 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 검색"(. 하워드 등 2019) https://arxiv.org/abs/1905.02244

    선언

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 반환 값, 즉 하드 휙 활성화 함수를 적용함으로써 텐서 x * Relu6(x+3)/6 .

    출처 : "MobileNetV3 검색"(. 하워드 등 2019) https://arxiv.org/abs/1905.02244

    선언

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 반환 뒤범벅 활성화 기능, 즉 적용하여 텐서 x * tanh(softplus(x)) .

    출처 : "뒤범벅 : 자기 정규화 비 모노 토닉 신경 활성화 기능" 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
  • 반환 값의 제곱 차이 xy .

    선언

    @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
  • 반환 사이의 코사인 유사도 xy .

    선언

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • 반환 사이의 코사인 거리 xy . 코사인 거리로 정의되는 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>
  • 지정된 입력, 필터, 보폭 및 패딩을 사용하여 1차원 컨볼루션을 반환합니다.

    전제조건

    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

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

  • 지정된 입력, 필터, 보폭, 패딩 및 팽창이 있는 3차원 컨볼루션을 반환합니다.

    전제조건

    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

    작업에 대한 패딩입니다.

  • 지정된 필터 크기, 보폭 및 패딩을 사용하여 3차원 최대 풀링을 반환합니다.

    선언

    @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

    텐서. 형상의 4-D [batch, height, width, channels] .

    poolingRatio

    목록 Doubles . 각 차원에 대한 비율을 풀링 input , 현재는 행 및 COL 사이즈 지원> = 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"와 _ 크기 = 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]]]]
    

    이 동작은 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"와 _ 크기 = 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]]]]
    

    이 동작은 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 .

    전제조건

    The width of the input must be divisible by b .

    선언

    @differentiable(wrt: input)
    public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Builds a per-weight optimizer for 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
  • Builds a SGD based per-weight optimizer.

    선언

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    선언

    public func makeAdam(
      learningRate: Float = 0.01,
      beta1: Float = 0.9,
      beta2: Float = 0.999,
      weightDecayRate: Float = 0.01,
      epsilon: Float = 1e-6
    ) -> ParameterGroupOptimizer
  • Generates a new random seed for TensorFlow.

    선언

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    선언

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    선언

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    선언

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    선언

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    선언

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

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    선언

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

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    선언

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