เข้าร่วม Women in ML Symposium ในวันที่ 7 ธันวาคม ลงทะเบียนตอนนี้

ฟังก์ชั่น

ฟังก์ชันต่อไปนี้สามารถใช้ได้ทั่วโลก

  • ส่งกลับค่าการสูญเสีย 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) ระหว่างความคาดหวังและการคาดคะเน ได้รับสองกระจาย 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

    ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

  • ส่งกลับเอนโทรปีแบบไขว้ softmax (เอนโทรปีแบบแยกหมวดหมู่) ระหว่างบันทึกและป้ายกำกับ

    ประกาศ

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

    พารามิเตอร์

    logits

    เอาต์พุตที่เข้ารหัสแบบร้อนครั้งเดียวจากโครงข่ายประสาทเทียม

    labels

    ดัชนี (ดัชนีศูนย์) ของเอาต์พุตที่ถูกต้อง

  • ส่งคืน sigmoid cross entropy (binary cross entropy) ระหว่าง logits และ label

    ประกาศ

    @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 ช่วยให้แน่ใจว่าเทนเซอร์แบบสดทั้งหมด (ในอุปกรณ์หากมี) มีกำหนดเวลาและทำงานอยู่ หากตั้งค่าการรอเป็น 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

    อุปกรณ์ที่จะเรียกใช้ ops บน

    body

    การปิดซึ่งการดำเนินการของ TensorFlow จะต้องดำเนินการบนอุปกรณ์ประเภทที่ระบุ

  • ดำเนินการปิด ทำให้การทำงานของ TensorFlow ทำงานบนอุปกรณ์ที่มีชื่อเฉพาะ

    ตัวอย่างชื่ออุปกรณ์บางส่วน:

    • “/device:CPU:0”: CPU ของเครื่องของคุณ
    • “/GPU:0”: สัญกรณ์แบบสั้นสำหรับ GPU ตัวแรกของเครื่องของคุณที่ TensorFlow มองเห็น
    • “/job:localhost/replica:0/task:0/device:GPU:1”: ชื่อแบบเต็มของ GPU ตัวที่สองในเครื่องของคุณที่ TensorFlow มองเห็นได้

    ประกาศ

    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 , ใช้ตัวกรองป้องกันนามแฝงเมื่อ downsampling ภาพ

  • ปรับขนาดภาพให้มีขนาดโดยใช้การแก้ไขพื้นที่

    เงื่อนไขเบื้องต้น

    ภาพจะต้องมียศ 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

    อัตราการขยายสำหรับแต่ละมิติของอินพุต

  • ส่งกลับฟังก์ชันที่สร้างเทนเซอร์โดยกำหนดค่าเริ่มต้นทั้งหมดให้เป็นศูนย์

    ประกาศ

    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 (ซาเวียร์) เริ่มต้นเครื่องแบบสำหรับรูปร่างที่ระบุการสุ่มเก็บตัวอย่างค่าสเกลาจากเครื่องแบบกระจายระหว่าง -limit และ limit ที่สร้างโดยเครื่องกำเนิดไฟฟ้าจำนวนสุ่มค่าเริ่มต้นที่มีข้อ จำกัด คือ sqrt(6 / (fanIn + fanOut)) และ fanIn / fanOut แทนจำนวน input และ output คุณลักษณะคูณด้วยลานรับสัญญาณถ้าปัจจุบัน

    ประกาศ

    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) เริ่มต้นเครื่องแบบสำหรับรูปร่างที่ระบุสุ่มเก็บตัวอย่างค่าสเกลาจากเครื่องแบบกระจายระหว่าง -limit และ limit ที่สร้างโดยเครื่องกำเนิดไฟฟ้าจำนวนสุ่มค่าเริ่มต้นที่มีข้อ จำกัด คือ 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 เครื่องแบบสำหรับรูปร่างที่ระบุสุ่มเก็บตัวอย่างค่าสเกลาจากเครื่องแบบกระจายระหว่าง -limit และ limit ที่สร้างโดยเครื่องกำเนิดไฟฟ้าจำนวนสุ่มค่าเริ่มต้นที่มีข้อ จำกัด คือ 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 ยกเว้นค่าที่มีความสำคัญมากขึ้นกว่าสองส่วนเบี่ยงเบนมาตรฐานจากค่าเฉลี่ยจะลดลงและ resampled

    ประกาศ

    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 ของเมทริกซ์สี่เหลี่ยมตั้งแต่หนึ่งตัวขึ้นไป

    การป้อนข้อมูลที่เป็นเมตริกซ์ของรูปร่าง [..., M, M] ซึ่งภายในได้สูงสุด 2 มิติในรูปแบบตารางการฝึกอบรม

    ข้อมูลที่ป้อนจะต้องมีความสมมาตรและแน่นอนในเชิงบวก เฉพาะส่วนสามเหลี่ยมล่างของอินพุตเท่านั้นที่จะใช้สำหรับการดำเนินการนี้ ส่วนสามเหลี่ยมบนจะไม่ถูกอ่าน

    เอาท์พุทเป็นเมตริกซ์ของรูปร่างเช่นเดียวกับการป้อนข้อมูลที่มีการสลายตัว Cholesky สำหรับทุก submatrices อินพุต [..., :, :]

    ประกาศ

    @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

    อินพุตสามเหลี่ยมค่าสัมประสิทธิ์เมทริกซ์เป็นตัวแทน ใน A Ax = b

    rhs

    ค่าด้านขวามือเป็นตัวแทน b ใน Ax = b

    lower

    ไม่ว่าจะเป็น matrix เป็นรูปสามเหลี่ยมที่ต่ำกว่า ( true ) หรือสามเหลี่ยมบน ( false ) ค่าเริ่มต้นคือ true

    adjoint

    ถ้า true แก้ด้วย adjoint ของ matrix แทน matrix ค่าเริ่มต้นคือ false

    คืนมูลค่า

    วิธีการแก้ปัญหา x ของระบบสมการเชิงเส้นที่แสดงโดย Ax = b x มีรูปร่างเช่นเดียวกับ b

  • คำนวณการสูญเสียระหว่าง L1 expected และ predicted 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 expected และ predicted 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(_:) จะไม่ได้กำหนดสำหรับ reals เชิงลบ

    ประกาศ

    @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

    ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

  • คำนวณการสูญเสียระหว่าง Poisson คาดการณ์และคาดว่าการสูญเสีย Poisson เป็นค่าเฉลี่ยขององค์ประกอบของ 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

    ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

  • การสูญเสียความแตกต่างคำนวณ Kullback-Leibler ระหว่าง expected และ predicted 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

    ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

  • คำนวณ sigmoid cross entropy (binary cross entropy) ระหว่าง logits และ label ใช้ cross-entropy loss เมื่อมีเพียงสองคลาสเลเบล (สมมติว่าเป็น 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

    สำหรับค่าแต่ละ x ใน error = expected - predicted :

    ประกาศ

    @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

    สเกลาร์จุดทศนิยมแทนจุดที่ฟังก์ชันการสูญเสียของฮูเบอร์เปลี่ยนจากกำลังสองเป็นเชิงเส้น

    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
  • ส่งกลับค่าลอการิทึมฐานสองของเทนเซอร์แบบอิงองค์ประกอบ

    ประกาศ

    @differentiable
    public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ส่งกลับค่าลอการิทึมฐานสิบของเทนเซอร์องค์ประกอบที่ระบุ

    ประกาศ

    @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
  • ส่งกลับค่าสองตัวที่ยกกำลังของเทนเซอร์องค์ประกอบที่ระบุ

    ประกาศ

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ส่งกลับค่าสิบยกกำลังของเทนเซอร์องค์ประกอบที่ระบุ

    ประกาศ

    @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
  • ส่งกลับค่า sigmoid ขององค์ประกอบเทนเซอร์ที่ระบุ โดยเฉพาะการคำนวณ 1 / (1 + exp(-x))

    ประกาศ

    @differentiable
    public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ส่งกลับค่า log-sigmoid ขององค์ประกอบเทนเซอร์ที่ระบุ โดยเฉพาะการ 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
  • ส่งกลับ softsign ของเทนเซอร์ที่ชาญฉลาดตามองค์ประกอบที่ระบุ โดยเฉพาะการคำนวณ 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
  • ส่งกลับค่า softmax ของเทนเซอร์ที่ระบุตามแกนที่ระบุ โดยเฉพาะการคำนวณ 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
  • ส่งกลับการเปิดใช้งาน Gaussian Error Linear Unit (GELU) ขององค์ประกอบเทนเซอร์ที่ระบุ

    โดยเฉพาะ gelu ใกล้เคียง xP(X <= x) ที่ P(X <= x) คือการกระจายสะสมมาตรฐานเสียนโดยการคำนวณ: x * [0.5 * (1 + tanh [√ (2 / π) * (x + 0.044715 * x^3)])].

    ดู ข้อผิดพลาดเสียนเป็น Linear หน่วย

    ประกาศ

    @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 มิฉะนั้น

    บันทึก

    ซึ่งได้รับการออกแบบมาให้ใช้ร่วมกับตัวกำหนดค่าเริ่มต้นของเลเยอร์การปรับขนาดความแปรปรวน โปรดดูที่ ตัวเอง Normalizing โครงข่ายประสาทเทียม สำหรับข้อมูลเพิ่มเติม

    ประกาศ

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ผลตอบแทนเมตริกซ์โดยใช้ฟังก์ชั่นการเปิดใช้งานหวดคือ 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
  • ผลตอบแทนเมตริกซ์โดยใช้ฟังก์ชั่นอย่างหนัก sigmoid เปิดใช้งานคือ Relu6(x+3)/6 6

    ที่มา:“ที่ไหนมี MobileNetV3” (. โฮเวิร์ด et al, 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 6

    ที่มา:“ที่ไหนมี MobileNetV3” (. โฮเวิร์ด 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: ฟังก์ชั่นด้วยตัวเอง Regularized ไม่ต่อเนื่องประสาทการเปิดใช้งาน” 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
  • ส่งกลับ squared ความแตกต่างระหว่าง 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>
  • ส่งกลับการบิดแบบ 1-D ด้วยอินพุต ตัวกรอง การก้าว และช่องว่างภายในที่ระบุ

    เงื่อนไขเบื้องต้น

    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

    ปัจจัยการขยายสำหรับแต่ละมิติของอินพุต

  • ส่งกลับการบิดสามมิติด้วยอินพุต ตัวกรอง การก้าว การขยาย และการขยายที่ระบุ

    เงื่อนไขเบื้องต้น

    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-D ด้วยขนาดตัวกรอง การก้าว และช่องว่างภายใน

    ประกาศ

    @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 , ขณะนี้สนับสนุนเฉพาะแถวและคอลัมน์มิติและควรจะ> = 1.0

    pseudoRandom

    ตัวเลือก Bool เริ่มต้นที่ false เมื่อตั้งค่าเป็น true สร้างลำดับร่วมกันในแฟชั่น pseudorandom มิฉะนั้นในแฟชั่นแบบสุ่ม

    overlapping

    ตัวเลือก Bool เริ่มต้นที่ false เมื่อตั้งค่าเป็น true ก็หมายความว่าเมื่อรวมกำไรค่าที่ขอบเขตของเซลล์ร่วมกันที่อยู่ติดกันจะถูกใช้โดยทั้งสองเซลล์

    deterministic

    ตัวเลือก Bool เมื่อตั้งค่า true ภูมิภาคร่วมกันคงที่จะใช้เมื่อ iterating กว่าโหนด fractionalMaxPool2D ในกราฟการคำนวณ

    seed

    ตัวเลือก Int64 เริ่มต้นที่ 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 * block_size * block_size) รูปร่างองค์ประกอบผลผลิตที่ [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 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]]]]
    

    Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

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

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

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

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

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

    the operator will return the following tensor of shape [1 2 2 4] :

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

    Precondition

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

    Precondition

    The height of the input must be divisible by b .

    Precondition

    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]