ฟังก์ชัน

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

  • ส่งกลับการสูญเสีย L1 ระหว่างการคาดการณ์และความคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับการสูญเสีย L2 ระหว่างการคาดการณ์และความคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับการสูญเสียบานพับระหว่างการคาดการณ์และความคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับการสูญเสียบานพับกำลังสองระหว่างการคาดการณ์และความคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับการสูญเสียบานพับตามหมวดหมู่ระหว่างการคาดการณ์และความคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับค่าลอการิทึมของโคไซน์ไฮเปอร์โบลิกของข้อผิดพลาดระหว่างการคาดการณ์และการคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับค่าการสูญเสียปัวซองระหว่างการคาดการณ์และความคาดหวัง

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับค่าความแตกต่างระหว่าง Kullback-Leibler (ความแตกต่าง KL) ระหว่างความคาดหวังและการคาดคะเน ด้วยการแจกแจงสองแบบ p และ q ความแตกต่างของ KL จะคำนวณ p * log(p / q)

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • ส่งกลับค่าเอนโทรปีข้าม 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

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

    คำประกาศ 

    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

    Tensor 4 มิติของรูปร่าง [batch, height, width, channels] หรือ Tensor 3 มิติของรูปร่าง [height, width, channels]

    size

    ขนาดใหม่ของภาพ

    method

    วิธีการปรับขนาด ค่าเริ่มต้นคือ .bilinear

    antialias

    หากเป็น true ให้ใช้ตัวกรองป้องกันนามแฝงเมื่อสุ่มตัวอย่างรูปภาพ

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

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

    รูปภาพจะต้องมีอันดับ 3 หรือ 4

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

    ขนาดจะต้องเป็นบวก

    คำประกาศ 

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

    พารามิเตอร์

    images

    Tensor 4 มิติของรูปร่าง [batch, height, width, channels] หรือ Tensor 3 มิติของรูปร่าง [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 (Xavier) สำหรับรูปร่างที่ระบุ โดยสุ่มสุ่มค่าสเกลาร์จากการแจกแจงแบบสม่ำเสมอระหว่าง -limit และ limit สร้างขึ้นโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ขีดจำกัดคือ sqrt(6 / (fanIn + fanOut)) และ fanIn / fanOut แสดงถึงจำนวนคุณลักษณะอินพุตและเอาต์พุตคูณด้วยฟิลด์รับสัญญาณ หากมี

    คำประกาศ 

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

  • ส่งกลับฟังก์ชันที่สร้างเทนเซอร์โดยดำเนินการกำหนดค่าเริ่มต้นตามปกติของ Glorot (Xavier) สำหรับรูปร่างที่ระบุ โดยสุ่มสุ่มตัวอย่างค่าสเกลาร์จากการแจกแจงแบบปกติที่ถูกตัดทอนโดยมีศูนย์กลางอยู่ที่ 0 โดยมีค่าเบี่ยงเบนมาตรฐาน sqrt(2 / (fanIn + fanOut)) โดยที่ fanIn / fanOut แสดงถึงจำนวนคุณลักษณะอินพุตและเอาต์พุตคูณด้วยขนาดฟิลด์รับสัญญาณ หากมี

    คำประกาศ 

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

  • ส่งกลับฟังก์ชันที่สร้างเมตริกซ์โดยดำเนินการกำหนดค่าเริ่มต้นแบบสม่ำเสมอของ He (Kaiming) สำหรับรูปร่างที่ระบุ โดยสุ่มสุ่มตัวอย่างค่าสเกลาร์จากการแจกแจงแบบสม่ำเสมอระหว่าง -limit และ limit สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ขีดจำกัดคือ sqrt(6 / fanIn) และ fanIn แสดงถึงจำนวนคุณลักษณะอินพุตคูณด้วยฟิลด์รับสัญญาณ หากมี

    คำประกาศ 

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

  • ส่งกลับฟังก์ชันที่สร้างเทนเซอร์โดยดำเนินการการกำหนดค่าเริ่มต้นตามปกติของ He (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 ยกเว้นค่าที่มีขนาดมากกว่าค่าเบี่ยงเบนมาตรฐานจากค่าเฉลี่ยมากกว่า 2 ค่าจะถูกละทิ้งและสุ่มตัวอย่างใหม่

    คำประกาศ 

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

    พารามิเตอร์

    mean

    ค่าเฉลี่ยของการแจกแจงแบบปกติ

    standardDeviation

    ค่าเบี่ยงเบนมาตรฐานของการแจกแจงแบบปกติ

    ค่าส่งคืน

    ฟังก์ชันตัวเริ่มต้นพารามิเตอร์ปกติที่ถูกตัดทอน

  • -

    คำประกาศ 

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

  • ส่งกลับเมทริกซ์เอกลักษณ์หรือชุดของเมทริกซ์

    คำประกาศ 

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

    พารามิเตอร์

    rowCount

    จำนวนแถวในแต่ละเมทริกซ์ชุดงาน

    columnCount

    จำนวนคอลัมน์ในแต่ละเมทริกซ์ชุดงาน

    batchShape

    ขนาดแบทช์ชั้นนำของเทนเซอร์ที่ส่งคืน

  • คำนวณการติดตามของเมทริกซ์แบบแบตช์ทางเลือก การติดตามคือผลรวมตามเส้นทแยงมุมหลักของเมทริกซ์ด้านในสุดแต่ละเมทริกซ์

    อินพุตเป็นเทนเซอร์ที่มีรูปร่าง [..., M, N] เอาต์พุตเป็นเทนเซอร์ที่มีรูปร่าง [...]

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

    matrix จะต้องเป็นเทนเซอร์ที่มีรูปร่าง [..., M, N]

    คำประกาศ 

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

    พารามิเตอร์

    matrix

    เทนเซอร์ของรูปร่าง [..., M, N] .

  • ส่งกลับการสลายตัวของ Cholesky ของเมทริกซ์จตุรัสตั้งแต่ 1 ตัวขึ้นไป

    ข้อมูลเข้าเป็นเทนเซอร์ของรูปร่าง [..., M, M] ซึ่ง 2 มิติด้านในสุดเป็นเมทริกซ์จตุรัส

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

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

    คำประกาศ 

    @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(_:) สำหรับจำนวนจริงที่เป็นลบ

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • คำนวณเปอร์เซ็นต์ความคลาดเคลื่อนสัมบูรณ์เฉลี่ยระหว่าง predicted และ expected loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

  • คำนวณการสูญเสียบานพับระหว่าง predicted และ expected loss = reduction(max(0, 1 - predicted * expected)) ค่า expected คาดว่าจะเป็น -1 หรือ 1

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

    reduction

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

  • คำนวณการสูญเสียบานพับกำลังสองระหว่าง predicted และ expected loss = reduction(square(max(0, 1 - predicted * expected))) ค่า expected คาดว่าจะเป็น -1 หรือ 1

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

    reduction

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

  • คำนวณการสูญเสียบานพับตามหมวดหมู่ระหว่าง predicted และ expected loss = maximum(negative - positive + 1, 0) โดยที่ negative = max((1 - expected) * predicted) และ positive = sum(predicted * expected)

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

    reduction

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

  • คำนวณลอการิทึมของโคไซน์ไฮเปอร์โบลิกของข้อผิดพลาดในการทำนาย logcosh = log((exp(x) + exp(-x))/2) โดยที่ x คือข้อผิดพลาด predicted - expected

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

    reduction

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

  • คำนวณการสูญเสียปัวซองระหว่างที่คาดการณ์ไว้และที่คาดไว้ การสูญเสียปัวซองคือค่าเฉลี่ยขององค์ประกอบของ Tensor predicted - expected * log(predicted)

    คำประกาศ 

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

    พารามิเตอร์

    predicted

    เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม

    expected

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

    reduction

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

  • คำนวณการสูญเสียความแตกต่างของ 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

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

  • คำนวณเอนโทรปีข้ามซิกมอยด์ (เอนโทรปีข้ามไบนารี) ระหว่างบันทึกและป้ายกำกับ ใช้การสูญเสียเอนโทรปีข้ามนี้เมื่อมีคลาสเลเบลเพียงสองคลาส (สมมติว่าเป็น 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

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

  • คำนวณการสูญเสียของ Huber ระหว่าง 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

  • ส่งกลับค่าซิกมอยด์ขององค์ประกอบเทนเซอร์ที่ระบุ โดยเฉพาะการคำนวณ 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

  • ส่งกลับสัญญาณอ่อนขององค์ประกอบเทนเซอร์ที่ระบุตาม โดยเฉพาะการคำนวณ features/ (abs(features) + 1)

    คำประกาศ 

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

  • ส่งกลับค่าซอฟต์แม็กซ์ของเทนเซอร์ที่ระบุตามแกนสุดท้าย โดยเฉพาะคำนวณ exp(x) / exp(x).sum(alongAxes: -1)

    คำประกาศ 

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

  • ส่งกลับค่าซอฟต์แม็กซ์ของเทนเซอร์ที่ระบุตามแนวแกนที่ระบุ โดยเฉพาะการคำนวณ exp(x) / exp(x).sum(alongAxes: axis)

    คำประกาศ 

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

  • ส่งกลับค่า log-softmax ขององค์ประกอบเทนเซอร์ที่ระบุ

    คำประกาศ 

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

  • ส่งกลับเทนเซอร์โดยใช้หน่วยเชิงเส้นแบบเอกซ์โปเนนเชียล โดยเฉพาะ คำนวณ exp(x) - 1 ถ้า < 0, x มิฉะนั้น ดู การเรียนรู้เครือข่ายเชิงลึกที่รวดเร็วและแม่นยำด้วย Exponential Linear Units (ELU)

    คำประกาศ 

    @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)])]

    ดู หน่วยเชิงเส้นข้อผิดพลาดแบบเกาส์

    คำประกาศ 

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

    บันทึก

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

    คำประกาศ 

    @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

  • ส่งกลับเทนเซอร์โดยใช้ฟังก์ชันการเปิดใช้งานฮาร์ดซิกมอยด์ ซึ่งก็คือ Relu6(x+3)/6

    ที่มา: “การค้นหา MobileNetV3” (Howard และคณะ 2019) https://arxiv.org/abs/1905.02244

    คำประกาศ 

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

  • ส่งกลับเทนเซอร์โดยใช้ฟังก์ชันการเปิดใช้งานแบบ hard swish ซึ่งก็คือ x * Relu6(x+3)/6

    ที่มา: “การค้นหา MobileNetV3” (Howard และคณะ 2019) https://arxiv.org/abs/1905.02244

    คำประกาศ 

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

  • ส่งกลับเทนเซอร์โดยใช้ฟังก์ชันการเปิดใช้งาน mish ซึ่งก็คือ x * tanh(softplus(x))

    ที่มา: “Mish: ฟังก์ชั่นการเปิดใช้งานระบบประสาทแบบไม่โมโนโทนิกแบบปรับตัวเองให้สม่ำเสมอ” https://arxiv.org/abs/1908.08681

    คำประกาศ 

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

  • ส่งกลับกำลังของเทนเซอร์ตัวแรกไปยังเทนเซอร์ตัวที่สอง

    คำประกาศ 

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

  • ส่งกำลังของสเกลาร์กลับคืนสู่เทนเซอร์ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งกำลังของเทนเซอร์กลับคืนสู่สเกลาร์ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งกำลังของเทนเซอร์กลับคืนสู่สเกลาร์ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งคืนค่ารากที่ n ของเทนเซอร์ตามองค์ประกอบ

    คำประกาศ 

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

  • ส่งกลับค่าความแตกต่างกำลังสองระหว่าง x และ y

    คำประกาศ 

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

    ค่าส่งคืน

    (x - y) ^ 2 .

  • ส่งกลับค่าสูงสุดของเทนเซอร์สองตัวตามองค์ประกอบ

    บันทึก

    max รองรับการออกอากาศ

    คำประกาศ 

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

  • ส่งกลับค่าสูงสุดของสเกลาร์และเทนเซอร์ตามองค์ประกอบ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งกลับค่าสูงสุดของสเกลาร์และเทนเซอร์ตามองค์ประกอบ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งกลับค่าเทนเซอร์ขั้นต่ำสองตัวตามองค์ประกอบ

    บันทึก

    min รองรับการออกอากาศ

    คำประกาศ 

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

  • ส่งกลับค่าต่ำสุดตามองค์ประกอบของสเกลาร์และเทนเซอร์ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งกลับค่าต่ำสุดตามองค์ประกอบของสเกลาร์และเทนเซอร์ โดยกระจายสเกลาร์

    คำประกาศ 

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

  • ส่งกลับความคล้ายคลึงโคไซน์ระหว่าง x และ y

    คำประกาศ 

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

  • ส่งกลับระยะห่างโคไซน์ระหว่าง x และ y ระยะทางโคไซน์ถูกกำหนดให้เป็น 1 - cosineSimilarity(x, y)

    คำประกาศ 

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

  • ทำการคูณเมทริกซ์ด้วยเมตริกซ์อื่นและสร้างผลลัพธ์

    คำประกาศ 

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

  • ส่งกลับการบิดแบบ 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

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

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

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

    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 ขณะนี้รองรับเฉพาะมิติแถวและคอลัมน์เท่านั้น และควรเป็น >= 1.0

    pseudoRandom

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

    overlapping

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

    deterministic

    Bool เสริม เมื่อตั้งค่าเป็น true ขอบเขตการรวมคงที่จะถูกใช้เมื่อวนซ้ำโหนดเศษส่วนMaxPool2Dในกราฟการคำนวณ

    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

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

    จำนวนจุดสนใจต้องหารด้วยกำลังสองของ b ลงตัว

    คำประกาศ 

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

  • ส่งกลับสำเนาของ input โดยที่ค่าจากมิติความสูงและความกว้างถูกย้ายไปยังมิติความลึก

    ตัวอย่างเช่น เมื่อป้อนข้อมูลรูปร่าง [1, 2, 2, 1] , data_format = “NHWC” และ block_size = 2:

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

    การดำเนินการนี้จะส่งออกเทนเซอร์ของรูปร่าง [1, 1, 1, 4] :

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

    ที่นี่อินพุตมีชุด 1 และแต่ละองค์ประกอบแบทช์มีรูปร่าง [2, 2, 1] เอาต์พุตที่สอดคล้องกันจะมีองค์ประกอบเดียว (เช่นความกว้างและความสูงคือ 1) และจะมีความลึก 4 ช่อง (1 * block_size * block_size) รูปร่างองค์ประกอบเอาต์พุตคือ [1, 1, 4]

    สำหรับเทนเซอร์อินพุตที่มีความลึกมากขึ้นที่นี่ของรูปร่าง [1, 2, 2, 3] เช่น

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

    การดำเนินการนี้สำหรับ block_size ของ 2 จะส่งคืนเทนเซอร์ของรูปร่างต่อไปนี้ [1, 1, 1, 12]

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

    ในทำนองเดียวกันสำหรับอินพุตของรูปร่าง [1 4 4 1] และขนาดบล็อก 2:

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

    ผู้ประกอบการจะส่งคืนเทนเซอร์ของรูปร่างต่อไปนี้ [1 2 2 4] :

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

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

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

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

    ความสูงของอินพุตจะต้องหารด้วย b

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

    ความกว้างของอินพุตจะต้องหารด้วย b

    การประกาศ 

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

  • สร้างเครื่องมือเพิ่มประสิทธิภาพต่อน้ำหนักสำหรับ LARS ( https://arxiv.org/pdf/1708.03888.pdf )

    การประกาศ 

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

  • สร้างเครื่องมือเพิ่มประสิทธิภาพต่อน้ำหนัก SGD

    การประกาศ 

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

  • สร้างเครื่องมือเพิ่มประสิทธิภาพต่อน้ำหนักสำหรับอดัมด้วยการสลายตัวของน้ำหนัก

    การอ้างอิง: “ อดัม - วิธีการเพิ่มประสิทธิภาพแบบสุ่ม”

    การประกาศ 

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

  • สร้างเมล็ดสุ่มใหม่สำหรับ tensorflow

    การประกาศ 

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

  • เชื่อมต่อสองค่า

    การประกาศ 

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

  • เพิ่มสองค่าและสร้างผลรวมของพวกเขา

    การประกาศ 

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

  • ค่าเฉลี่ยสองค่า

    การประกาศ 

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

  • ทวีคูณสองค่า

    การประกาศ 

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

  • สแต็คสองค่า

    การประกาศ 

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

  • การประกาศ 

    public func PrintX10Metrics()

  • สร้างบทสรุปสตริงของรายการการฝึกอบรมและการทดสอบสถิติ

    การประกาศ 

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

  • การประกาศ 

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

  • แมปฟังก์ชั่นมากกว่าเธรด n

    การประกาศ 

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