หน้านี้ได้รับการแปลโดย Cloud Translation API

ฟังก์ชั่น

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

l1Loss(คาดการณ์:คาดหวัง :)

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

ประกาศ

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

พารามิเตอร์

`predicted`	เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม
`expected`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

l2Loss(คาดการณ์:คาดหวัง :)

ส่งกลับค่าการสูญเสีย 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`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

squaredHingeLoss (คาดการณ์: คาดหวัง :)

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

ประกาศ

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

พารามิเตอร์

`predicted`	เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม
`expected`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

เด็ดขาดHingeLoss(คาดการณ์:คาดหวัง :)

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

ประกาศ

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

พารามิเตอร์

`predicted`	เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม
`expected`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

logCoshLoss(คาดการณ์:คาดหวัง :)

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

ประกาศ

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

พารามิเตอร์

`predicted`	เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม
`expected`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

poissonLoss(คาดการณ์:คาดหวัง :)

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

ประกาศ

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

พารามิเตอร์

`predicted`	เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม
`expected`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

kullbackLeiblerDivergence(คาดการณ์:คาดหวัง :)

ส่งคืน 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`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

softmaxCrossEntropy(บันทึก:ความน่าจะเป็น :)

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

ประกาศ

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

พารามิเตอร์

`logits`	เอาต์พุตที่เข้ารหัสแบบร้อนครั้งเดียวจากโครงข่ายประสาทเทียม
`labels`	ดัชนี (ดัชนีศูนย์) ของเอาต์พุตที่ถูกต้อง

sigmoidCrossEntropy (บันทึก: ป้ายกำกับ :)

ส่งคืน 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

ด้วย RandomSeedForTensorFlow(_:_:)

เรียกการปิดที่กำหนดภายในบริบทที่มีทุกอย่างเหมือนกับบริบทปัจจุบัน ยกเว้นเมล็ดพันธุ์สุ่มที่กำหนด

ประกาศ

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

พารามิเตอร์

`randomSeed`	เมล็ดพันธุ์สุ่มที่จะถูกตั้งค่าก่อนการปิดจะถูกเรียกและเรียกคืนหลังจากการปิดกลับคืนมา
`body`	การปิดเป็นโมฆะ หากปิดมีค่าตอบแทนเป็นค่าที่ยังใช้เป็นค่าตอบแทนของ `withRandomSeedForTensorFlow(_:_:)` ฟังก์ชั่น

คืนมูลค่า

ค่าตอบแทนถ้าใด ๆ ของ body ปิด

ด้วยRandomNumberGeneratorForTensorFlow(_:_:)

เรียกการปิดที่กำหนดภายในบริบทที่มีทุกอย่างเหมือนกับบริบทปัจจุบัน ยกเว้นตัวสร้างตัวเลขสุ่มที่กำหนด

ประกาศ

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

พารามิเตอร์

`randomNumberGenerator`	ตัวสร้างตัวเลขสุ่มที่จะถูกตั้งค่าก่อนการปิดจะถูกเรียกและเรียกคืนหลังจากการปิดกลับมา
`body`	การปิดเป็นโมฆะ หากปิดมีค่าตอบแทนเป็นค่าที่ยังใช้เป็นค่าตอบแทนของ `withRandomNumberGeneratorForTensorFlow(_:_:)` ฟังก์ชั่น

คืนมูลค่า

ค่าตอบแทนถ้าใด ๆ ของ body ปิด

zip(_:_:)

ประกาศ

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

LazyTensorBarrier(on:devices:รอ :)
LazyTensorBarrier ช่วยให้แน่ใจว่าเทนเซอร์แบบสดทั้งหมด (ในอุปกรณ์หากมี) มีกำหนดเวลาและทำงานอยู่ หากตั้งค่าการรอเป็น true การเรียกนี้จะบล็อกจนกว่าการคำนวณจะเสร็จสิ้น
ประกาศ
public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

valueWithGradient(at:in:)

ประกาศ

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

valueWithGradient(at:_:in:)

ประกาศ

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

valueWithGradient(at:_:_:in:)

ประกาศ

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

valueWithGradient(of :)

ประกาศ

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

valueWithGradient(of :)

ประกาศ

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

valueWithGradient(of :)

ประกาศ

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

การไล่ระดับสี (at:in :)

ประกาศ

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

การไล่ระดับสี (at:_:in :)

ประกาศ

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

ด้วยRecomputationInPullbacks(_:)
ทำให้ฟังก์ชันถูกคำนวณใหม่ในการดึงกลับ ซึ่งเรียกว่า "จุดตรวจ" ในการแยกความแตกต่างอัตโนมัติแบบเดิม
ประกาศ
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
differentiableFunction(จาก :)
สร้างฟังก์ชันดิฟเฟอเรนติเอเบิลจากฟังก์ชันผลิตภัณฑ์เวกเตอร์-จาโคเบียน
ประกาศ
public func differentiableFunction<T : Differentiable, R : Differentiable>( from vjp: @escaping (T) -> (value: R, pullback: (R.TangentVector) -> T.TangentVector) ) -> @differentiable (T) -> R

differentiableFunction(จาก :)

สร้างฟังก์ชันดิฟเฟอเรนติเอเบิลจากฟังก์ชันผลิตภัณฑ์เวกเตอร์-จาโคเบียน

ประกาศ

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

ไม่มีอนุพันธ์(at:)
ผลตอบแทน x เช่นฟังก์ชั่นตัวตน เมื่อนำมาใช้ในบริบทที่ x จะถูกแตกต่างที่เกี่ยวกับฟังก์ชั่นนี้จะไม่ผลิตอนุพันธ์ใด ๆ x
ประกาศ
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
ไม่มีอนุพันธ์(at:in:)
ใช้การปิดให้ 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 จะต้องดำเนินการบนอุปกรณ์ประเภทที่ระบุ

withDefaultDevice(ดำเนินการ :)

ดำเนินการปิด ทำให้ TensorFlow วางการทำงานของ TensorFlow บนอุปกรณ์ใดก็ได้ การดำเนินการนี้ควรคืนค่าการทำงานของตำแหน่งเริ่มต้น

ประกาศ

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

พารามิเตอร์

body

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

ปรับขนาด (images:size:method:antialias :)

ปรับขนาดภาพให้มีขนาดโดยใช้วิธีการที่ระบุ

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

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

resizeArea(รูปภาพ:ขนาด:จัดตำแหน่งมุม :)

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

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

ภาพจะต้องมียศ 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`	ขนาดใหม่ของภาพ

dilation2D(_:ตัวกรอง:ก้าว:อัตรา:ช่องว่างภายใน:)

ส่งกลับการขยาย 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`	อัตราการขยายสำหรับแต่ละมิติของอินพุต

erosion2D(_:ตัวกรอง:ก้าว:อัตรา:ช่องว่างภายใน:)

แสดงผลการกัดเซาะแบบ 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
ค่าคงที่Initializer(ค่า :)
ส่งกลับฟังก์ชันที่สร้างเทนเซอร์โดยกำหนดค่าเริ่มต้นทั้งหมดให้เป็นค่าที่ระบุ
ประกาศ
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
ค่าคงที่Initializer(ค่า :)
ส่งกลับฟังก์ชันที่สร้างเทนเซอร์โดยกำหนดค่าเริ่มต้นให้เป็นค่าที่ระบุ โปรดทราบว่าการออกอากาศของมูลค่าให้ไม่สนับสนุน
ประกาศ
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
glorotUniform(เมล็ด :)
ผลตอบแทนที่ได้ฟังก์ชั่นที่สร้างเมตริกซ์โดยการดำเนินการ Glorot (ซาเวียร์) เริ่มต้นเครื่องแบบสำหรับรูปร่างที่ระบุการสุ่มเก็บตัวอย่างค่าสเกลาจากเครื่องแบบกระจายระหว่าง -limit และ limit ที่สร้างโดยเครื่องกำเนิดไฟฟ้าจำนวนสุ่มค่าเริ่มต้นที่มีข้อ จำกัด คือ sqrt(6 / (fanIn + fanOut)) และ fanIn / fanOut แทนจำนวน input และ output คุณลักษณะคูณด้วยลานรับสัญญาณถ้าปัจจุบัน
ประกาศ
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
glorotNormal(เมล็ด :)
ผลตอบแทนที่ได้ฟังก์ชั่นที่สร้างเมตริกซ์โดยการดำเนินการ Glorot (ซาเวียร์) เริ่มต้นปกติสำหรับรูปร่างที่ระบุสุ่มเก็บตัวอย่างค่าสเกลาจากการกระจายปกติตัดทอนศูนย์กลางอยู่ที่ 0 กับส่วนเบี่ยงเบนมาตรฐาน sqrt(2 / (fanIn + fanOut)) ที่ fanIn / fanOut แสดงถึงจำนวนของคุณสมบัติอินพุตและเอาต์พุตคูณด้วยขนาดฟิลด์ที่เปิดกว้าง หากมี
ประกาศ
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
heUniform(เมล็ด :)
ผลตอบแทนที่ได้ฟังก์ชั่นที่สร้างเมตริกซ์โดยการดำเนินการเขา (Kaiming) เริ่มต้นเครื่องแบบสำหรับรูปร่างที่ระบุสุ่มเก็บตัวอย่างค่าสเกลาจากเครื่องแบบกระจายระหว่าง -limit และ limit ที่สร้างโดยเครื่องกำเนิดไฟฟ้าจำนวนสุ่มค่าเริ่มต้นที่มีข้อ จำกัด คือ sqrt(6 / fanIn) และ fanIn หมายถึงจำนวนของคุณสมบัติการป้อนข้อมูลคูณด้วยลานรับสัญญาณถ้าปัจจุบัน
ประกาศ
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
heNormal(เมล็ด :)
ผลตอบแทนที่ได้ฟังก์ชั่นที่สร้างเมตริกซ์โดยการดำเนินการเขา (Kaiming) เริ่มต้นปกติสำหรับรูปร่างที่ระบุการสุ่มเก็บตัวอย่างค่าสเกลาจากการกระจายปกติตัดทอนศูนย์กลางอยู่ที่ 0 มีค่าเบี่ยงเบนมาตรฐาน sqrt(2 / fanIn) ที่ fanIn หมายถึงจำนวนของคุณสมบัติการป้อนข้อมูล คูณด้วยขนาดช่องรับ หากมี
ประกาศ
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunUniform(เมล็ด :)
ผลตอบแทนที่ได้ฟังก์ชั่นที่สร้างเมตริกซ์โดยการดำเนินการเริ่มต้น LeCun เครื่องแบบสำหรับรูปร่างที่ระบุสุ่มเก็บตัวอย่างค่าสเกลาจากเครื่องแบบกระจายระหว่าง -limit และ limit ที่สร้างโดยเครื่องกำเนิดไฟฟ้าจำนวนสุ่มค่าเริ่มต้นที่มีข้อ จำกัด คือ sqrt(3 / fanIn) และ fanIn หมายถึงจำนวนของการป้อนข้อมูลคุณลักษณะคูณด้วยลานรับสัญญาณถ้าปัจจุบัน
ประกาศ
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunNormal(เมล็ด :)
ผลตอบแทนที่ได้ฟังก์ชั่นที่สร้างเมตริกซ์โดยการดำเนินการ LeCun เริ่มต้นปกติสำหรับรูปร่างที่ระบุสุ่มเก็บตัวอย่างค่าสเกลาจากการกระจายปกติตัดทอนศูนย์กลางอยู่ที่ 0 มีค่าเบี่ยงเบนมาตรฐาน sqrt(1 / fanIn) ที่ fanIn หมายถึงจำนวนของการป้อนข้อมูลคุณลักษณะคูณด้วย ขนาดฟิลด์ที่เปิดกว้าง หากมี
ประกาศ
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>

truncatedNormalInitializer(mean:standardDeviation:seed:) ที่ถูกตัดทอน

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

ตา(rowCount:columnCount:batchShape:on:)

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

ประกาศ

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]

สามเหลี่ยมแก้(เมทริกซ์:rhs:ล่าง:ติดกัน :)

ผลตอบแทนการแก้ปัญหา 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การสูญเสีย(คาดการณ์:คาดหวัง:ลดลง :)

คำนวณการสูญเสียระหว่าง 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

l2Loss(คาดการณ์:คาดหวัง:ลดลง :)

คำนวณการสูญเสียระหว่าง 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

meanAbsoluteError(คาดการณ์:คาดหวัง :)

คำนวณค่าเฉลี่ยความแตกต่างระหว่างป้ายกำกับและการคาดคะเน 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`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

meanSquaredError(คาดการณ์:คาดหวัง :)

คำนวณค่าเฉลี่ยของข้อผิดพลาดกำลังสองระหว่างป้ายกำกับและการคาดคะเน 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`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

meanSquaredLogarithmicError (คาดการณ์: คาดหวัง :)

คำนวณค่าเฉลี่ยข้อผิดพลาดเกี่ยวกับลอการิทึมแควร์ระหว่าง 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`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง

meanAbsolutePercentageError (คาดการณ์: คาดหวัง :)

คำนวณผิดพลาดร้อยละค่าเฉลี่ยระหว่างแน่นอน 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

squaredHingeLoss(คาดการณ์:คาดหวัง:ลดลง :)

คำนวณการสูญเสียบานพับสแควร์ระหว่าง 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

เด็ดขาดHingeLoss(คาดการณ์:คาดหวัง:ลดลง :)

คำนวณการสูญเสียบานพับเด็ดขาดระหว่าง 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

logCoshLoss(คาดการณ์:คาดหวัง:ลดลง :)

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

kullbackLeiblerDivergence(คาดการณ์:คาดหวัง:ลด :)

การสูญเสียความแตกต่างคำนวณ 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

softmaxCrossEntropy(บันทึก:ป้ายกำกับ:ลด :)

คำนวณเอนโทรปีครอสแบบเบาบางของ 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

softmaxCrossEntropy(บันทึก:ความน่าจะเป็น:ลด :)

คำนวณเอนโทรปีครอสแบบเบาบางของ 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

sigmoidCrossEntropy(บันทึก:ป้ายกำกับ:ลด :)

คำนวณ 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`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

huberLoss(คาดการณ์:คาดหวัง:เดลต้า:ลด :)

คำนวณการสูญเสียระหว่างฮิว predicted และ expected

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

0.5 * x^2 ถ้า |x| <= δ
0.5 * δ^2 + δ * (|x| - δ) มิฉะนั้น
ที่มา: บทความวิกิพีเดีย

ประกาศ

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

พารามิเตอร์

`predicted`	เอาต์พุตที่คาดการณ์จากโครงข่ายประสาทเทียม
`expected`	ค่าที่คาดหวัง เช่น เป้าหมาย ที่สอดคล้องกับผลลัพธ์ที่ถูกต้อง
`delta`	สเกลาร์จุดทศนิยมแทนจุดที่ฟังก์ชันการสูญเสียของฮูเบอร์เปลี่ยนจากกำลังสองเป็นเชิงเส้น
`reduction`	ลดการใช้กับค่าการสูญเสียที่คำนวณตามองค์ประกอบ

หน้าท้อง (_:)
ส่งกลับค่าสัมบูรณ์ของเทนเซอร์องค์ประกอบตามที่ระบุ
ประกาศ
@differentiable public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
บันทึก(_:)
ส่งกลับค่าลอการิทึมธรรมชาติขององค์ประกอบเทนเซอร์ที่ระบุ
ประกาศ
@differentiable public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
บันทึก2(_:)
ส่งกลับค่าลอการิทึมฐานสองของเทนเซอร์แบบอิงองค์ประกอบ
ประกาศ
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
บันทึก10(_:)
ส่งกลับค่าลอการิทึมฐานสิบของเทนเซอร์องค์ประกอบที่ระบุ
ประกาศ
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log1p(_:)
ส่งกลับลอการิทึมของ 1 + x องค์ประกอบที่ชาญฉลาด
ประกาศ
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log1mexp(_:)
ผลตอบแทนที่ได้ 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
cosh(_:)
ส่งกลับค่าไฮเปอร์โบลิกโคไซน์ขององค์ประกอบเทนเซอร์ที่ระบุ
ประกาศ
@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
acos(_:)
ส่งกลับค่าโคไซน์ผกผันขององค์ประกอบเทนเซอร์ที่ระบุ
ประกาศ
@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
sqrt(_:)
ส่งกลับค่ารากที่สองของเทนเซอร์องค์ประกอบตามที่ระบุ
ประกาศ
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
rsqrt(_:)
ส่งกลับค่าสแควร์รูทผกผันขององค์ประกอบเทนเซอร์ที่ระบุ
ประกาศ
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
ประสบการณ์(_:)
ส่งกลับค่าเลขชี้กำลังของเทนเซอร์องค์ประกอบที่ระบุ
ประกาศ
@differentiable public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
ประสบการณ์2(_:)
ส่งกลับค่าสองตัวที่ยกกำลังของเทนเซอร์องค์ประกอบที่ระบุ
ประกาศ
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
ประสบการณ์10(_:)
ส่งกลับค่าสิบยกกำลังของเทนเซอร์องค์ประกอบที่ระบุ
ประกาศ
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
expm1(_:)
ผลตอบแทนที่ได้ชี้แจงของ 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
logSigmoid(_:)
ส่งกลับค่า 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(_:ตามแกน :)
ส่งกลับค่า softmax ของเทนเซอร์ที่ระบุตามแกนที่ระบุ โดยเฉพาะการคำนวณ exp(x) / exp(x).sum(alongAxes: axis)
ประกาศ
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
logSoftmax(_:)
ส่งกลับค่า 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(_:)
ผลตอบแทนเมตริกซ์โดยใช้ฟังก์ชั่นการเปิดใช้งาน ReLU6 คือ min(max(0, x), 6)
ประกาศ
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
LeakyRelu(_:อัลฟ่า :)
ส่งกลับเทนเซอร์โดยใช้ฟังก์ชันการเปิดใช้งาน 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
hardSigmoid(_:)
ผลตอบแทนเมตริกซ์โดยใช้ฟังก์ชั่นอย่างหนัก 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
squaredDifference(_:_:)
ส่งกลับ 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>
cosineDistance(_:_:)
ผลตอบแทนระยะทางโคไซน์ระหว่าง x และ y ระยะโคไซน์ถูกกำหนดให้เป็น 1 - cosineSimilarity(x, y)
ประกาศ
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>

matmul(_:ย้าย:_:ย้าย:)

ทำการคูณเมทริกซ์กับเทนเซอร์อื่นและให้ผลลัพธ์

ประกาศ

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

conv1D(_:filter:stride:padding:dilation:)

ส่งกลับการบิดแบบ 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`	ปัจจัยการขยาย

conv2D(_:ตัวกรอง:ก้าว:ช่องว่างภายใน:ขยาย :)

ส่งกลับการบิดแบบ 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`	ปัจจัยการขยายสำหรับแต่ละมิติของอินพุต

transposedConv2D(_:รูปร่าง:ตัวกรอง:ก้าว:ช่องว่างภายใน:การขยาย :)

ส่งกลับการบิดแบบทรานสโพส 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`	ปัจจัยการขยายสำหรับแต่ละมิติของอินพุต

conv3D(_:ตัวกรอง:ก้าว:ช่องว่างภายใน:ขยาย :)

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

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

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`	ปัจจัยการขยายสำหรับแต่ละมิติของอินพุต

deepwiseConv2D(_:filter:strides:padding:)

ส่งกลับการบิดเชิงลึกแบบ 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`	แพดดิ้งสำหรับการดำเนินการ

maxPool2D(_:filterSize: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`	แพดดิ้งสำหรับการดำเนินการ

maxPool3D(_: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`	แพดดิ้งสำหรับการดำเนินการ

avgPool2D(_: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`	แพดดิ้งสำหรับการดำเนินการ

avgPool3D(_: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`	แพดดิ้งสำหรับการดำเนินการ

FractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)

ส่งกลับการรวมกลุ่มสูงสุดแบบเศษส่วน 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` เมล็ดที่สองเพื่อหลีกเลี่ยงการชนกันของเมล็ด

deepToSpace(_:blockSize:)
ส่งคืนสำเนาของ 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
spaceToDepth(_:blockSize:)
ส่งคืนสำเนาของ 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

makeLARS(learningRate:momentum:trustCoefficient:nesterov:epsilon:weightDecay:)

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

makeSGD(learningRate:momentum:weightDecay:nesterov:)

Builds a SGD based per-weight optimizer.

ประกาศ

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

makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)

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

randomSeedForTensorFlow(using:)

Generates a new random seed for TensorFlow.

ประกาศ

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

concatenate(_:_:)

Concatenates two values.

ประกาศ

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

sum(_:_:)

Adds two values and produces their sum.

ประกาศ

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

average(_:_:)

Averages two values.

ประกาศ

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

multiply(_:_:)

Multiplies two values.

ประกาศ

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

stack(_:_:)

Stack two values.

ประกาศ

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

PrintX10Metrics()
ประกาศ
public func PrintX10Metrics()

formatStatistics(_:)

Creates a string summary of a list of training and testing stats.

ประกาศ

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

formatStatistics(train:test:)

ประกาศ

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

runOnNThreads(_:_:)

Maps a function over n threads.

ประกาศ

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

`context`	บริบทที่จะถูกตั้งค่าก่อนที่จะมีการเรียกและเรียกคืนการปิดหลังจากการปิดกลับมา
`body`	การปิดเป็นโมฆะ หากปิดมีค่าตอบแทนเป็นค่าที่ยังใช้เป็นค่าตอบแทนของ `withContext(_:_:)` ฟังก์ชั่น

`learningPhase`	ขั้นตอนการเรียนรู้ที่จะถูกตั้งค่าก่อนที่จะมีการเรียกปิดและเรียกคืนหลังจากการปิดกลับคืนมา
`body`	การปิดเป็นโมฆะ หากปิดมีค่าตอบแทนเป็นค่าที่ยังใช้เป็นค่าตอบแทนของ `withLearningPhase(_:_:)` ฟังก์ชั่น