คำเตือน: โครงการนี้เลิกใช้แล้ว Swift สำหรับ TensorFlow เป็นการทดลองในแพลตฟอร์มรุ่นต่อไปสำหรับการเรียนรู้ของเครื่อง โดยรวมงานวิจัยล่าสุดเกี่ยวกับการเรียนรู้ของเครื่อง คอมไพเลอร์ การเขียนโปรแกรมสร้างความแตกต่าง การออกแบบระบบ และอื่นๆ ถูกเก็บถาวรในเดือนกุมภาพันธ์ 2564

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

เทนเซอร์

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar

extension Tensor: Collatable

extension Tensor: CopyableToDevice

extension Tensor: AnyTensor

extension Tensor: ExpressibleByArrayLiteral

extension Tensor: CustomStringConvertible

extension Tensor: CustomPlaygroundDisplayConvertible

extension Tensor: CustomReflectable

extension Tensor: TensorProtocol

extension Tensor: TensorGroup

extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint

extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint

extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint

l10n-

extension Tensor: Equatable where Scalar: Equatable

extension Tensor: Codable where Scalar: Codable

ตัวยึดตำแหน่ง15 l10n-ตัวยึดตำแหน่ง

extension Tensor: AdditiveArithmetic where Scalar: Numeric

extension Tensor: PointwiseMultiplicative where Scalar: Numeric

extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint

extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

อาร์เรย์หลายมิติขององค์ประกอบที่เป็นลักษณะทั่วไปของเวกเตอร์และเมทริกซ์ในมิติที่อาจสูงกว่า

พารามิเตอร์ทั่วไป Scalar อธิบายประเภทของสเกลาร์ในเมตริกซ์ (เช่น Int32 , Float ฯลฯ )

รับมือ
TensorHandle พื้นฐาน
บันทึก
handle เป็นแบบสาธารณะเพื่ออนุญาตให้ผู้ใช้กำหนด ops แต่ปกติไม่ควรใช้
คำประกาศ
public let handle: TensorHandle<Scalar>
เริ่มต้น (จัดการ :)
คำประกาศ
public init(handle: TensorHandle<Scalar>)
ไม่ซ้อนกัน (ตามแกน :)
คลายมิติที่กำหนดของเทนเซอร์อันดับ R ออกเป็นเทนเซอร์หลายอันดับ (R-1) แกะเทนเซอร์ N ออกจากเทนเซอร์นี้โดยการบิ่นตามขนาด axis โดยที่ N อนุมานจากรูปร่างของเทนเซอร์นี้ ตัวอย่างเช่น เมื่อกำหนดเทนเซอร์ที่มีรูปร่าง [A, B, C, D] :
- หาก axis == 0 ดังนั้นเทนเซอร์ i -th ในอาร์เรย์ที่ส่งคืนคือชิ้น self[i, :, :, :] และเทนเซอร์แต่ละตัวในอาร์เรย์นั้นจะมีรูปร่าง [B, C, D] (โปรดทราบว่ามิติข้อมูลที่ถูกคลายแพ็กหายไปแล้ว ไม่เหมือน Tensor.split(numSplits:alongAxis) หรือ Tensor.split(sizes:alongAxis) )
- หาก axis == 1 ดังนั้นเทนเซอร์ i -th ในอาร์เรย์ที่ส่งคืนคือ value[:, i, :, :] และเทนเซอร์แต่ละตัวในอาร์เรย์นั้นจะมีรูปร่าง [A, C, D]
- ฯลฯ
นี่คือสิ่งที่ตรงกันข้ามกับ Tensor.init(stacking:alongAxis:)
เงื่อนไขเบื้องต้น
axis ต้องอยู่ในช่วง [-rank, rank) โดยที่ rank คืออันดับของเทนเซอร์ที่ให้มา
คำประกาศ
@differentiable public func unstacked(alongAxis axis: Int = 0) -> [Tensor]
พารามิเตอร์
axis
มิติข้อมูลที่จะแยกออกจากกัน ค่าลบล้อมรอบ
ค่าส่งคืน
อาร์เรย์ที่มีเทนเซอร์ที่ไม่เรียงซ้อนกัน
แยก (นับ: ตามแกน :)
แยกเทนเซอร์ออกเป็นหลายเทนเซอร์ เทนเซอร์จะถูกแบ่งตาม axis มิติเป็น count นเซอร์ที่มีขนาดเล็กลง สิ่งนี้ต้องการให้ count แบ่ง shape[axis] เท่า ๆ กัน
ตัวอย่างเช่น:
```
// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors along dimension 1:
let parts = value.split(count: 3, alongAxis: 1)
parts[0] // has shape [5, 10]
parts[1] // has shape [5, 10]
parts[2] // has shape [5, 10]
```
เงื่อนไขเบื้องต้น
count จะต้องแบ่งขนาดของ axis มิติให้เท่ากัน
เงื่อนไขเบื้องต้น
axis ต้องอยู่ในช่วง [-rank, rank) โดยที่ rank คืออันดับของเทนเซอร์ที่ให้มา
คำประกาศ
@differentiable public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]
พารามิเตอร์
count
จำนวนการแยกที่จะสร้าง
axis
มิติที่ใช้แยกเทนเซอร์นี้ ค่าลบล้อมรอบ
ค่าส่งคืน
อาร์เรย์ที่มีส่วนเทนเซอร์

แยก (ขนาด: ตามแกน :)

แยกเทนเซอร์ออกเป็นหลายเทนเซอร์ เทนเซอร์แบ่งออกเป็น sizes.shape[0] ชิ้น รูปร่างของชิ้นที่ i มีรูปร่างเหมือนกับเทนเซอร์นี้ ยกเว้นตาม axis มิติที่มีขนาดเป็น sizes[i]

ตัวอย่างเช่น:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
parts[0] // has shape [5, 4]
parts[1] // has shape [5, 15]
parts[2] // has shape [5, 11]

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

ค่าใน sizes ต้องรวมกันจนเท่ากับขนาดของ axis มิติ

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

axis ต้องอยู่ในช่วง [-rank, rank) โดยที่ rank คืออันดับของเทนเซอร์ที่ให้มา

คำประกาศ

@differentiable(wrt: self)
public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]

พารามิเตอร์

`sizes`	เทนเซอร์ 1-D ที่มีขนาดของแต่ละการแยก
`axis`	มิติที่จะแยกเทนเซอร์นี้ ค่าลบล้อมรอบ

ค่าส่งคืน

อาร์เรย์ที่มีส่วนเทนเซอร์

แยก (ขนาด: ตามแกน :)

คำประกาศ

@differentiable(wrt: self)
public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]

ปูกระเบื้อง (หลายรายการ :)
ส่งกลับเทนเซอร์แบบเรียงต่อกัน ซึ่งสร้างโดยการเรียงเมตริกซ์นี้
ตัวสร้างนี้สร้างเทนเซอร์ใหม่โดยการจำลองเทนเซอร์นี้ multiples ครั้ง มิติที่ i ของเทนเซอร์ที่สร้างขึ้นมีองค์ประกอบ self.shape[i] * multiples[i] และค่าของเทนเซอร์นี้จะถูกจำลอง multiples[i] ครั้งตามมิติที่ i ตัวอย่างเช่น การเรียงต่อ [abcd] ด้วย [2] จะสร้าง [abcdabcd]
เงื่อนไขเบื้องต้น
rank ของทวีคูณที่คาดหวังต้องเป็น 1
เงื่อนไขเบื้องต้น
รูปร่างของ multiples จะต้องเป็น [tensor.rank]
เงื่อนไขเบื้องต้น
สเกลาร์ทั้งหมดใน multiples จะต้องไม่เป็นลบ
คำประกาศ
@differentiable(wrt: self) public func tiled(multiples: [Int]) -> Tensor
ปูกระเบื้อง (หลายรายการ :)
ส่งกลับเทนเซอร์แบบเรียงต่อกัน ซึ่งสร้างโดยการเรียงเมตริกซ์นี้
ตัวสร้างนี้สร้างเทนเซอร์ใหม่โดยการจำลองเทนเซอร์นี้ multiples ครั้ง มิติที่ i ของเทนเซอร์ที่สร้างขึ้นมีองค์ประกอบ self.shape[i] * multiples[i] และค่าของเทนเซอร์นี้จะถูกจำลอง multiples[i] ครั้งตามมิติที่ i ตัวอย่างเช่น การเรียงต่อ [abcd] ด้วย [2] จะสร้าง [abcdabcd]
เงื่อนไขเบื้องต้น
rank ของทวีคูณที่คาดหวังต้องเป็น 1
เงื่อนไขเบื้องต้น
รูปร่างของ multiples จะต้องเป็น [tensor.rank]
คำประกาศ
@differentiable(wrt: self) public func tiled(multiples: Tensor<Int32>) -> Tensor
เปลี่ยนรูปร่างใหม่ (เช่น :)
ปรับรูปร่างให้เป็นรูปร่างของ Tensor ที่ระบุ
เงื่อนไขเบื้องต้น
จำนวนสเกลาร์ตรงกับรูปร่างใหม่
คำประกาศ
@differentiable(wrt: self) public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
เปลี่ยนรูปร่างใหม่ (เป็น :)
ปรับรูปร่างให้เป็นรูปร่างที่กำหนด
เงื่อนไขเบื้องต้น
จำนวนสเกลาร์ตรงกับรูปร่างใหม่
คำประกาศ
@differentiable(wrt: self) public func reshaped(to newShape: TensorShape) -> Tensor
ปรับรูปร่างใหม่ (เป็นรูปร่าง :)
ปรับรูปร่างเป็น Tensor ที่ระบุซึ่งแสดงถึงรูปร่าง
เงื่อนไขเบื้องต้น
จำนวนสเกลาร์ตรงกับรูปร่างใหม่
คำประกาศ
@differentiable(wrt: self) public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
แบน()
ส่งกลับสำเนาของเทนเซอร์ที่ยุบลงใน Tensor 1-D ตามลำดับแถวหลัก
คำประกาศ
@differentiable(wrt: self) public func flattened() -> Tensor
ขยายรูปร่าง (ที่ :)
ส่งคืน Tensor ที่ขยายรูปร่าง โดยแทรกมิติ 1 ไว้ที่ดัชนีรูปร่างที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func expandingShape(at axes: Int...) -> Tensor
ขยายรูปร่าง (ที่ :)
ส่งคืน Tensor ที่ขยายรูปร่าง โดยแทรกมิติ 1 ไว้ที่ดัชนีรูปร่างที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func expandingShape(at axes: [Int]) -> Tensor
อันดับยก()
ส่งกลับ Tensor ที่ยกอันดับด้วยมิตินำหน้าเป็น 1
คำประกาศ
@differentiable(wrt: self) public func rankLifted() -> Tensor
บีบรูปร่าง(ที่ :)
ลบขนาดที่ระบุขนาด 1 ออกจากรูปร่างของเทนเซอร์ หากไม่มีการระบุมิติข้อมูล มิติข้อมูลขนาด 1 ทั้งหมดจะถูกลบออก
คำประกาศ
@differentiable(wrt: self) public func squeezingShape(at axes: Int...) -> Tensor
บีบรูปร่าง(ที่ :)
ลบขนาดที่ระบุขนาด 1 ออกจากรูปร่างของเทนเซอร์ หากไม่มีการระบุมิติข้อมูล มิติข้อมูลขนาด 1 ทั้งหมดจะถูกลบออก
คำประกาศ
@differentiable(wrt: self) public func squeezingShape(at axes: [Int]) -> Tensor
ย้าย (การเรียงสับเปลี่ยน :)
ส่งกลับเทนเซอร์ที่เปลี่ยนตำแหน่ง โดยมีมิติที่เรียงสับเปลี่ยนตามลำดับที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func transposed(permutation: Tensor<Int32>) -> Tensor
ย้าย (พร้อมพีชคณิต :)
ส่งกลับเทนเซอร์ที่เปลี่ยนตำแหน่ง โดยมีมิติที่เรียงสับเปลี่ยนตามลำดับที่ระบุ
คำประกาศ
@available(*, deprecated, renamed: "transposed(permutation:﹚") @differentiable(wrt: self) public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
ย้าย (การเรียงสับเปลี่ยน :)
ส่งกลับเทนเซอร์ที่เปลี่ยนตำแหน่ง โดยมีมิติที่เรียงสับเปลี่ยนตามลำดับที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func transposed(permutation: [Int]) -> Tensor
ย้าย (พร้อมพีชคณิต :)
ส่งกลับเทนเซอร์ที่เปลี่ยนตำแหน่ง โดยมีมิติที่เรียงสับเปลี่ยนตามลำดับที่ระบุ
คำประกาศ
@available(*, deprecated, renamed: "transposed(permutation:﹚") @differentiable(wrt: self) public func transposed(withPermutations permutations: [Int]) -> Tensor
ย้าย (การเรียงสับเปลี่ยน :)
ส่งกลับเทนเซอร์ที่เปลี่ยนตำแหน่ง โดยมีมิติที่เรียงสับเปลี่ยนตามลำดับที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func transposed(permutation: Int...) -> Tensor
ย้าย (พร้อมพีชคณิต :)
ส่งกลับเทนเซอร์ที่เปลี่ยนตำแหน่ง โดยมีมิติที่เรียงสับเปลี่ยนตามลำดับที่ระบุ
คำประกาศ
@available(*, deprecated, renamed: "transposed(permutation:﹚") @differentiable(wrt: self) public func transposed(withPermutations permutations: Int...) -> Tensor
ย้าย()
ส่งกลับเทนเซอร์แบบทรานสโพส โดยมีมิติที่เรียงสับเปลี่ยนในลำดับย้อนกลับ
คำประกาศ
@differentiable(wrt: self) public func transposed() -> Tensor
กลับด้าน (ในแกน :)
ส่งกลับเทนเซอร์โดยกลับด้านมิติที่ระบุ
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes ต้องอยู่ในช่วง -rank..<rank
เงื่อนไขเบื้องต้น
จะต้องไม่มีการทำซ้ำใน axes
คำประกาศ
@differentiable(wrt: self) public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
กลับด้าน (ในแกน :)
ส่งกลับเทนเซอร์โดยกลับด้านมิติที่ระบุ
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes ต้องอยู่ในช่วง -rank..<rank
เงื่อนไขเบื้องต้น
จะต้องไม่มีการทำซ้ำใน axes
คำประกาศ
@differentiable(wrt: self) public func reversed(inAxes axes: [Int]) -> Tensor
กลับด้าน (ในแกน :)
ส่งกลับเทนเซอร์โดยกลับด้านมิติที่ระบุ
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes ต้องอยู่ในช่วง -rank..<rank
เงื่อนไขเบื้องต้น
จะต้องไม่มีการทำซ้ำใน axes
คำประกาศ
@differentiable(wrt: self) public func reversed(inAxes axes: Int...) -> Tensor
ต่อกัน (ด้วย: ตามแกน :)
ส่งกลับเทนเซอร์ที่ต่อกันตามแกนที่ระบุ
เงื่อนไขเบื้องต้น
เทนเซอร์ต้องมีขนาดเท่ากัน ยกเว้นแกนที่ระบุ
เงื่อนไขเบื้องต้น
แกนต้องอยู่ในช่วง -rank..<rank
คำประกาศ
@differentiable public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
++(_:_:)
ตัวดำเนินการต่อข้อมูล
บันทึก
++ เป็นตัวดำเนินการแบบกำหนดเองที่ไม่มีอยู่ใน Swift แต่มีใน Haskell/Scala การเพิ่มนี้ไม่ใช่การเปลี่ยนแปลงภาษาเล็กน้อยและอาจก่อให้เกิดข้อโต้แย้งได้ การมีอยู่/การตั้งชื่อของ ++ จะมีการพูดคุยกันในระหว่างขั้นตอนการออกแบบ API ในภายหลัง
คำประกาศ
@differentiable public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
การรวบรวม (atIndices: alongAxis :)
ส่งกลับเทนเซอร์โดยการรวบรวมชิ้นส่วนของอินพุตที่ indices ตามแนว axis
สำหรับ indices 0-D (สเกลาร์) :
```
result[p_0,          ..., p_{axis-1},
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices,
     p_{axis + 1}, ..., p_{N-1}]
```
สำหรับ indices 1-D (เวกเตอร์):
```
result[p_0,          ..., p_{axis-1},
       i,
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices[i],
     p_{axis + 1}, ..., p_{N-1}]
```
ในกรณีทั่วไป จะสร้างผลลัพธ์เทนเซอร์โดยที่:
```
result[p_0,             ..., p_{axis-1},
       i_{batch\_dims}, ..., i_{M-1},
       p_{axis + 1},    ..., p_{N-1}] =
self[p_0,             ..., p_{axis-1},
     indices[i_0,     ..., i_{M-1}],
     p_{axis + 1},    ..., p_{N-1}]
```
โดยที่ N = self.rank และ M = indices.rank
รูปร่างของเทนเซอร์ที่ได้คือ: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...]
บันทึก
บน CPU หากพบดัชนีที่อยู่นอกช่วง ข้อผิดพลาดจะเกิดขึ้น บน GPU หากพบดัชนีที่อยู่นอกช่วง 0 จะถูกเก็บไว้ในค่าเอาต์พุตที่เกี่ยวข้อง
เงื่อนไขเบื้องต้น
axis ต้องอยู่ในช่วง [-rank, rank)
คำประกาศ
@differentiable(wrt: self) public func gathering<Index: TensorFlowIndex>( atIndices indices: Tensor<Index>, alongAxis axis: Int = 0 ) -> Tensor
พารามิเตอร์
indices
ประกอบด้วยดัชนีที่จะรวบรวมที่
axis
มิติที่จะรวบรวม ค่าลบล้อมรอบ
ค่าส่งคืน
เทนเซอร์ที่รวบรวม

การรวบรวมชุด (ที่ดัชนี: ตามแกน: ชุดมิตินับ :)

ส่งกลับส่วนของเมตริกซ์นี้ที่ indices ตามแนว axis โดยไม่สนใจมิติ batchDimensionCount ชุดแรกซึ่งสอดคล้องกับมิติข้อมูลชุดงาน การรวบรวมจะดำเนินการตามมิติที่ไม่ใช่ชุดงานแรก

ดำเนินการฟังก์ชันที่คล้ายกันเพื่อ gathering ยกเว้นว่ารูปร่างเทนเซอร์ที่ได้คือตอนนี้ shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...]

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

axis ต้องอยู่ batchDimensionCount ช่วง -rank..<rank ในขณะที่ต้องมากกว่าหรือเท่ากับ

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

batchDimensionCount ต้องน้อยกว่า indices.rank

คำประกาศ

@differentiable(wrt: self)
public func batchGathering<Index: TensorFlowIndex>(
  atIndices indices: Tensor<Index>,
  alongAxis axis: Int = 1,
  batchDimensionCount: Int = 1
) -> Tensor

พารามิเตอร์

`indices`	ประกอบด้วยดัชนีที่จะรวบรวม
`axis`	มิติที่จะรวบรวม ค่าลบล้อมรอบ
`batchDimensionCount`	จำนวนมิติแบทช์ชั้นนำที่จะละเว้น

ค่าส่งคืน

เทนเซอร์ที่รวบรวม

การรวบรวม (โดยที่: ตาม Axis :)

ส่งกลับเทนเซอร์โดยการรวบรวมค่าหลังจากใช้มาสก์บูลีนที่ให้มากับอินพุต

ตัวอย่างเช่น:

// 1-D example
// tensor is [0, 1, 2, 3]
// mask is [true, false, true, false]
tensor.gathering(where: mask) // is [0, 2]

// 2-D example
// tensor is [[1, 2], [3, 4], [5, 6]]
// mask is [true, false, true]
tensor.gathering(where: mask) // is [[1, 2], [5, 6]]

โดยทั่วไป 0 < mask.rank = K <= tensor.rank และรูปร่างของ mask จะต้องตรงกับมิติ K แรกของรูปร่างของ tensor จากนั้นเรามี: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] โดยที่ [i1, ..., iK] คือรายการ true ของ mask ที่ i (ลำดับหลักแถว)

axis สามารถใช้กับมา mask เพื่อระบุแกนที่จะมาสก์ได้ ในกรณีนั้น axis + mask.rank <= tensor.rank และ 's shape must match the first mask จะต้องตรงกับ dimensions of the รูปร่างของเทนเซอร์

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

mask ไม่สามารถเป็นสเกลาร์ได้: mask.rank != 0

คำประกาศ

@differentiable(wrt: self)
public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor

พารามิเตอร์

`mask`	KD บูลีนเทนเซอร์ โดยที่ `K <= self.rank`
`axis`	เทนเซอร์จำนวนเต็ม 0-D แทนแกนใน `self` เพื่อมาส์ก โดยที่ `K + axis <= self.rank`

ค่าส่งคืน

(self.rank - K + 1) -มิติเทนเซอร์ที่เติมโดยรายการในเทนเซอร์นี้ซึ่งสอดคล้องกับค่า true ใน mask

ดัชนีที่ไม่ใช่ศูนย์()
ส่งกลับตำแหน่งของค่าที่ไม่ใช่ศูนย์ / ค่าจริงในเทนเซอร์นี้
พิกัดจะถูกส่งกลับในเมตริกซ์ 2 มิติ โดยที่มิติแรก (แถว) แสดงถึงจำนวนขององค์ประกอบที่ไม่เป็นศูนย์ และมิติที่สอง (คอลัมน์) แสดงถึงพิกัดขององค์ประกอบที่ไม่เป็นศูนย์ โปรดทราบว่ารูปร่างของเทนเซอร์เอาท์พุตอาจแตกต่างกันไปขึ้นอยู่กับจำนวนค่าจริงที่มีอยู่ในเทนเซอร์นี้ ดัชนีจะถูกส่งออกตามลำดับแถวหลัก
ตัวอย่างเช่น:
```
// 'input' is [[true, false], [true, false]]
// 'input' has 2 true values and so the output has 2 rows.
// 'input' has rank of 2, and so the second dimension of the output has size 2.
input.nonZeroIndices() // is [[0, 0], [1, 0]]

// 'input' is [[[ true, false], [ true, false]],
//             [[false,  true], [false,  true]],
//             [[false, false], [false,  true]]]
// 'input' has 5 true values and so the output has 5 rows.
// 'input' has rank 3, and so the second dimension of the output has size 3.
input.nonZeroIndices() // is [[0, 0, 0],
                       //     [0, 1, 0],
                       //     [1, 0, 1],
                       //     [1, 1, 1],
                       //     [2, 1, 1]]
```
คำประกาศ
public func nonZeroIndices() -> Tensor<Int64>
ค่าส่งคืน
เทนเซอร์ที่มีรูปร่าง (num_true, rank(condition))

ออกอากาศ (ถึงรูปร่าง :)

คำประกาศ

@differentiable(wrt: self)
public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor

ออกอากาศ (ถึง :)

คำประกาศ

@differentiable(wrt: self)
public func broadcasted(to shape: TensorShape) -> Tensor

ออกอากาศ (ชอบ :)
ออกอากาศเป็นรูปร่างเดียวกับ Tensor ที่ระบุ
เงื่อนไขเบื้องต้น
รูปร่างที่กำหนดจะต้องเข้ากันได้สำหรับการออกอากาศ
คำประกาศ
@differentiable(wrt: self) public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar

.=(_:_:)

คำประกาศ

public static func .= (lhs: inout Tensor, rhs: Tensor)

ชิ้น (ขอบเขตล่าง: ขอบเขตบน :)
แยกชิ้นส่วนออกจากเมตริกซ์ที่กำหนดโดยขอบเขตล่างและบนสำหรับแต่ละมิติ
คำประกาศ
@differentiable(wrt: self) public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor
พารามิเตอร์
lowerBounds
ขอบเขตล่างของแต่ละมิติ
upperBounds
ขอบเขตบนของแต่ละมิติ

ชิ้น (ขอบเขตล่าง: ขนาด :)

คำประกาศ

@differentiable(wrt: self)
public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor

ชิ้น (ขอบเขตล่าง: ขนาด :)

คำประกาศ

@differentiable(wrt: self)
public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor

ตัวห้อย (_:)

คำประกาศ

@differentiable(wrt: self)
public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }

ตรวจสอบความถูกต้อง (แกน: ฟังก์ชั่น: ไฟล์: บรรทัด :)
ตรวจสอบว่าแต่ละองค์ประกอบของ axes แสดงถึงแกนของ self และหยุดโปรแกรมด้วยการวินิจฉัยอย่างอื่น
คำประกาศ
func ensureValid( axes: Tensor<Int32>, function: StaticString = #function, file: StaticString = #file, line: UInt = #line )
ตรวจสอบความถูกต้อง (แกน: ฟังก์ชั่น: ไฟล์: บรรทัด :)
ตรวจสอบว่าแต่ละองค์ประกอบของ axes แสดงถึงแกนของ self และหยุดโปรแกรมด้วยการวินิจฉัยอย่างอื่น
คำประกาศ
func ensureValid( axes: [Int], function: StaticString = #function, file: StaticString = #file, line: UInt = #line )
ตรวจสอบความถูกต้อง(แกน:ฟังก์ชัน:ไฟล์:บรรทัด:)
ตรวจสอบว่า k หมายถึงแกนของ self และหยุดโปรแกรมด้วยการวินิจฉัยอย่างอื่น
คำประกาศ
func ensureValid( axis k: Int, function: StaticString = #function, file: StaticString = #file, line: UInt = #line )

เริ่มต้น (การเรียง :)

คำประกาศ

public init<BatchSamples: Collection>(collating samples: BatchSamples)
where BatchSamples.Element == Self

init(คัดลอก:ถึง:)
สร้างสำเนา other บน Device ที่กำหนด
คำประกาศ
public init(copying other: Tensor, to device: Device)
init(รูปร่าง:การทำซ้ำ:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุและค่าสเกลาร์ค่าเดียวที่ซ้ำกัน
คำประกาศ
@available(*, deprecated, renamed: "init(repeating:shape:﹚") public init(shape: TensorShape, repeating repeatedValue: Scalar)
พารามิเตอร์
shape
ขนาดของเทนเซอร์
repeatedValue
ค่าสเกลาร์ที่จะทำซ้ำ
init(การทำซ้ำ:รูปร่าง:บน:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุและค่าสเกลาร์ค่าเดียวที่ซ้ำกัน
คำประกาศ
@differentiable public init( repeating repeatedValue: Scalar, shape: TensorShape, on device: Device = .default )
พารามิเตอร์
repeatedValue
ค่าสเกลาร์ที่จะทำซ้ำ
shape
ขนาดของเทนเซอร์
เริ่มต้น (การออกอากาศ: อันดับ: เปิด :)
สร้างเมตริกซ์โดยการถ่ายทอดสเกลาร์ที่กำหนดไปยังอันดับที่กำหนดโดยมิติทั้งหมดเป็น 1
คำประกาศ
public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
ในนั้น(_:)
สร้างเมตริกซ์จากอาร์เรย์เทนเซอร์ (ซึ่งอาจเป็นสเกลาร์)
คำประกาศ
@differentiable public init(_ elements: [Tensor])
เริ่มต้น (ซ้อน: ตามแกน :)
ซ้อน tensors ตามขนาด axis ให้เป็นเทนเซอร์ใหม่โดยมีอันดับสูงกว่าเทนเซอร์ปัจจุบันหนึ่งอันดับ และเทนเซอร์แต่ละตัวอยู่ใน tensors
เนื่องจาก tensors ทั้งหมดมีรูปร่าง [A, B, C] และ tensors.count = N ดังนั้น:
- ถ้า axis == 0 ดังนั้นเทนเซอร์ที่ได้จะมีรูปร่าง [N, A, B, C]
- ถ้า axis == 1 ดังนั้นเทนเซอร์ที่ได้จะมีรูปร่าง [A, N, B, C]
- ฯลฯ
ตัวอย่างเช่น:
```
// 'x' is [1, 4]
// 'y' is [2, 5]
// 'z' is [3, 6]
Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]
```
นี่คือสิ่งที่ตรงกันข้ามกับ Tensor.unstacked(alongAxis:)
เงื่อนไขเบื้องต้น
เทนเซอร์ทั้งหมดจะต้องมีรูปร่างเหมือนกัน
เงื่อนไขเบื้องต้น
axis ต้องอยู่ในช่วง [-rank, rank) โดยที่ rank คืออันดับของเทนเซอร์ที่ให้มา
คำประกาศ
@differentiable public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)
พารามิเตอร์
tensors
เทนเซอร์ที่จะกองซ้อน
axis
มิติตามที่จะกองซ้อน ค่าลบล้อมรอบ
ค่าส่งคืน
เทนเซอร์แบบเรียงซ้อน
init (เชื่อม: ตามแกน :)
เชื่อมต่อ tensors ตามมิติ axis
เมื่อพิจารณาว่า tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] ดังนั้นผลลัพธ์ที่ต่อกันจะมีรูปร่าง [D0, D1, ... Raxis, ...Dn] , โดยที่ Raxis = sum(Daxis(i)) . นั่นคือข้อมูลจากเทนเซอร์อินพุตจะถูกรวมเข้ากับมิติ axis
ตัวอย่างเช่น:
```
// t1 is [[1, 2, 3], [4, 5, 6]]
// t2 is [[7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

// t3 has shape [2, 3]
// t4 has shape [2, 3]
Tensor(concatenating: [t3, t4]) // has shape [4, 3]
Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]
```
บันทึก
หากคุณกำลังเชื่อมต่อไปตามแกนใหม่ให้พิจารณาใช้ Tensor.init(stacking:alongAxis:)
เงื่อนไขเบื้องต้น
เทนเซอร์ทั้งหมดต้องมีอันดับเดียวกันและมิติทั้งหมดยกเว้น axis จะต้องเท่ากัน
เงื่อนไขเบื้องต้น
axis ต้องอยู่ในช่วง [-rank, rank) โดยที่ rank คืออันดับของเทนเซอร์ที่ให้มา
คำประกาศ
@differentiable public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)
พารามิเตอร์
tensors
เทนเซอร์ที่จะเชื่อมต่อกัน
axis
มิติที่จะต่อกัน ค่าลบล้อมรอบ
ค่าส่งคืน
เทนเซอร์ที่ต่อกัน
แทนที่ (ด้วย: โดยที่ :)
แทนที่องค์ประกอบของเทนเซอร์นี้ด้วย other ในเลนที่ mask เป็น true
เงื่อนไขเบื้องต้น
self และ other ต้องมีรูปร่างเหมือนกัน ถ้า self และ other เป็นสเกลาร์ mask ก็ต้องเป็นสเกลาร์ด้วย หาก self และ other มีอันดับมากกว่าหรือเท่ากับ 1 ดังนั้น mask จะต้องมีรูปร่างเหมือนกับ self หรือเป็น 1-D Tensor โดยที่ mask.scalarCount == self.shape[0]
คำประกาศ
@differentiable(wrt: (self, other) ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
คือความแม่นยำลดลง
คืนค่าเป็นจริงหากประเภทสเกลาร์ทางกายภาพลดความแม่นยำลง
ในปัจจุบัน ประเภทสเกลาร์ทางกายภาพที่มีความแม่นยำลดลงจะรวมเฉพาะ BFloat16 เท่านั้น
คำประกาศ
public var isReducedPrecision: Bool { get }
เริ่มต้น (_: อุปกรณ์ AndPrecisionLike :)
เลื่อนระดับสเกลาร์ไปยังเทนเซอร์ด้วยอุปกรณ์และความแม่นยำเดียวกันกับเทนเซอร์ที่กำหนด
คำประกาศ
@differentiable public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
เพื่อลดความแม่นยำ
ส่งกลับสำเนาของการแปลง self เป็นประเภทสเกลาร์ฟิสิคัล BFloat16
คำประกาศ
public var toReducedPrecision: `Self` { get }
ถึงฟูลพรีซิชั่น
ส่งกลับสำเนาของประเภท Scalar ฟิสิคัลที่แปลง self เป็นสเกลาร์
คำประกาศ
public var toFullPrecision: `Self` { get }
อันดับ
จำนวนมิติของ Tensor
คำประกาศ
public var rank: Int { get }
รูปร่าง
รูปร่างของ Tensor
คำประกาศ
public var shape: TensorShape { get }
สเกลาร์นับ
จำนวนสเกลาร์ใน Tensor
สเกลาร์นับ
คำประกาศ
public var scalarCount: Int { get }
อันดับเทนเซอร์
อันดับของเทนเซอร์ ซึ่งแสดงเป็น Tensor<Int32>
คำประกาศ
public var rankTensor: Tensor<Int32> { get }
รูปร่างเทนเซอร์
ขนาดของเทนเซอร์ซึ่งแสดงเป็น Tensor<Int32>
คำประกาศ
public var shapeTensor: Tensor<Int32> { get }
สเกลาร์เคาท์เทนเซอร์
จำนวนสเกลาร์ในเทนเซอร์ ซึ่งแสดงเป็น Tensor<Int32>
คำประกาศ
public var scalarCountTensor: Tensor<Int32> { get }
เป็นสเกลาร์
คืนค่า true หาก rank เท่ากับ 0 และคืนค่าเป็น false
คำประกาศ
public var isScalar: Bool { get }
สเกลาร์
ส่งคืนองค์ประกอบสเกลาร์เดี่ยวหาก rank เท่ากับ 0 nil ฉะนั้นจะเป็นศูนย์
คำประกาศ
public var scalar: Scalar? { get }
ปรับขนาด()
ปรับรูปร่างให้เป็นสเกลาร์
เงื่อนไขเบื้องต้น
เทนเซอร์มีสเกลาร์หนึ่งตัวพอดี
คำประกาศ
@differentiable public func scalarized() -> Scalar

อาร์เรย์

คำประกาศ

public var array: ShapedArray<Scalar> { get }

สเกลาร์

คำประกาศ

@differentiable
public var scalars: [Scalar] { get }

เริ่มต้น(_:บน:)
สร้างเมตริกซ์ 0-D จากค่าสเกลาร์
คำประกาศ
@differentiable public init(_ value: Scalar, on device: Device = .default)
เริ่มต้น(_:บน:)
สร้างเทนเซอร์ 1 มิติจากสเกลาร์
คำประกาศ
@differentiable public init(_ scalars: [Scalar], on device: Device = .default)
เริ่มต้น(_:บน:)
สร้างเทนเซอร์ 1 มิติจากสเกลาร์
คำประกาศ
public init<C: Collection>( _ vector: C, on device: Device = .default ) where C.Element == Scalar
init(รูปร่าง:สเกลาร์:เปิด:)
สร้างเมตริกซ์ที่มีรูปร่างที่ระบุและสเกลาร์ที่อยู่ติดกันในลำดับหลักแถว
เงื่อนไขเบื้องต้น
ผลคูณของขนาดของรูปร่างต้องเท่ากับจำนวนสเกลาร์
คำประกาศ
@differentiable public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)
พารามิเตอร์
shape
รูปร่างของเทนเซอร์
scalars
เนื้อหาสเกลาร์ของเทนเซอร์
init(รูปร่าง:สเกลาร์:เปิด:)
สร้างเมตริกซ์ที่มีรูปร่างที่ระบุและสเกลาร์ที่อยู่ติดกันในลำดับหลักแถว
เงื่อนไขเบื้องต้น
ผลคูณของขนาดของรูปร่างต้องเท่ากับจำนวนสเกลาร์
คำประกาศ
public init( shape: TensorShape, scalars: UnsafeBufferPointer<Scalar>, on device: Device = .default )
พารามิเตอร์
shape
รูปร่างของเทนเซอร์
scalars
เนื้อหาสเกลาร์ของเทนเซอร์
init(รูปร่าง:สเกลาร์:toReducedPrecision:directlyOn:)
สร้างเมตริกซ์ที่มีรูปร่างที่ระบุและสเกลาร์ที่อยู่ติดกันในลำดับหลักแถว
เงื่อนไขเบื้องต้น
ผลคูณของขนาดของรูปร่างต้องเท่ากับจำนวนสเกลาร์
init(รูปร่าง:สเกลาร์:เปิด:)
สร้างเมตริกซ์ที่มีรูปร่างที่ระบุและสเกลาร์ที่อยู่ติดกันในลำดับหลักแถว
เงื่อนไขเบื้องต้น
ผลคูณของขนาดของรูปร่างต้องเท่ากับจำนวนสเกลาร์
คำประกาศ
public init<C: Collection>( shape: TensorShape, scalars: C, on device: Device = .default ) where C.Element == Scalar
พารามิเตอร์
shape
รูปร่างของเทนเซอร์
scalars
เนื้อหาสเกลาร์ของเทนเซอร์
ArrayLiteralElement
ประเภทขององค์ประกอบของอาร์เรย์ตามตัวอักษร
คำประกาศ
public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
init(อาร์เรย์ตัวอักษร :)
สร้างเทนเซอร์ที่เริ่มต้นด้วยองค์ประกอบที่กำหนด
คำประกาศ
public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
คำอธิบาย
การแสดงข้อความของเทนเซอร์
บันทึก
ใช้ fullDescription สำหรับคำอธิบายที่ไม่สวยงามซึ่งแสดงสเกลาร์ทั้งหมด
คำประกาศ
public var description: String { get }

คำอธิบาย (lineWidth:edgeElementCount:สรุป:)

การแสดงข้อความของเทนเซอร์ ส่งคืนคำอธิบายโดยสรุป หาก summarize เป็นจริงและจำนวนองค์ประกอบเกินสองเท่าของ edgeElementCount

คำประกาศ

public func description(
  lineWidth: Int = 80,
  edgeElementCount: Int = 3,
  summarizing: Bool = false
) -> String

พารามิเตอร์

`lineWidth`	ความกว้างบรรทัดสูงสุดสำหรับการพิมพ์ ใช้เพื่อกำหนดจำนวนสเกลาร์ที่จะพิมพ์ต่อบรรทัด
`edgeElementCount`	จำนวนองค์ประกอบสูงสุดที่จะพิมพ์ก่อนและหลังการสรุปโดยใช้จุดไข่ปลา ( `...` )
`summarizing`	หากเป็นจริง ให้สรุปคำอธิบายหากจำนวนองค์ประกอบเกิน 2 เท่า `edgeElementCount`

คำอธิบายแบบเต็ม
การแสดงข้อความเทนเซอร์แบบเต็มและพิมพ์ไม่สวยงาม โดยแสดงสเกลาร์ทั้งหมด
คำประกาศ
public var fullDescription: String { get }
irText
สนามเด็กเล่นคำอธิบาย
คำประกาศ
public var playgroundDescription: Any { get }
กระจกเงาแบบกำหนดเอง
คำประกาศ
public var customMirror: Mirror { get }
คำอธิบายประกอบ
คำอธิบายประกอบที่อธิบายเทนเซอร์นี้
คำประกาศ
public var annotations: String { get }
สรุป
นามแฝงสำหรับคำอธิบายประกอบ
คำประกาศ
public var summary: String { get }
เริ่มต้น(_เป็นเจ้าของ :)
คำประกาศ
public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)

เริ่มต้น(_จัดการ :)

คำประกาศ

public init<C: RandomAccessCollection>(
  _handles: C
) where C.Element: _AnyTensorHandle

เริ่มต้น(_:บน:)

คำประกาศ

public init(_ array: ShapedArray<Scalar>, on device: Device = .default)

เริ่มต้น(_xla :)
คำประกาศ
init(_xla: XLATensor)
เริ่มต้น(_xlaHandle:)
คำประกาศ
init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

xlaHandle

คำประกาศ

var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

xlaTensor
คำประกาศ
var xlaTensor: XLATensor { get }

มีจำหน่ายที่ "สเกลาร์": "ตัวเลข"

ไม่ออกอากาศ(toShape:)

คำประกาศ

@differentiable(wrt: self)
public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor

ยังไม่ออกอากาศ (ชอบ :)

คำประกาศ

@differentiable(wrt: self)
public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar

ยังไม่ออกอากาศ(ถึง :)

คำประกาศ

@differentiable(wrt: self)
public func unbroadcasted(to shape: TensorShape) -> Tensor

โหมดการขยาย
โหมดที่กำหนดวิธีการบุนวมเทนเซอร์
คำประกาศ
public enum PaddingMode
เบาะ(สำหรับขนาด:ด้วย:)
ส่งกลับเทนเซอร์ที่บุด้วยค่าคงที่ตามขนาดช่องว่างภายในที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0) -> Tensor
เบาะ (สำหรับขนาด: โหมด :)
ส่งกลับเทนเซอร์ที่บุนวมตามขนาดและโหมดการบุนวมที่ระบุ
คำประกาศ
@differentiable(wrt: self) public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor

มีให้โดยที่ `สเกลาร์`: `ตัวเลข` & `เปรียบเทียบได้`

.<(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์บูลีนโดยการคำนวณ lhs < rhs element-wise
คำประกาศ
public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
.<=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs <= rhs element-wise
คำประกาศ
public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
.>(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์บูลีนโดยการคำนวณ lhs > rhs element-wise
คำประกาศ
public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
.>=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs >= rhs element-wise
คำประกาศ
public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
.<(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์บูลีนโดยการคำนวณ lhs < rhs element-wise
บันทึก
.< รองรับการออกอากาศ
คำประกาศ
public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
.<=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs <= rhs element-wise
บันทึก
.<= รองรับการออกอากาศ
คำประกาศ
public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
.>(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์บูลีนโดยการคำนวณ lhs > rhs element-wise
บันทึก
.> รองรับการออกอากาศ
คำประกาศ
public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
.>=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs >= rhs element-wise
บันทึก
.>= รองรับการออกอากาศ
คำประกาศ
public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
.<(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์บูลีนโดยการคำนวณ lhs < rhs element-wise
บันทึก
.< รองรับการออกอากาศ
คำประกาศ
public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
.<=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs <= rhs element-wise
บันทึก
.<= รองรับการออกอากาศ
คำประกาศ
public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
.>(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์บูลีนโดยการคำนวณ lhs > rhs element-wise
บันทึก
.> รองรับการออกอากาศ
คำประกาศ
public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
.>=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs >= rhs element-wise
บันทึก
.>= รองรับการออกอากาศ
คำประกาศ
public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

มีจำหน่ายที่ 'สเกลาร์': 'เท่าเทียม'

.==(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs == rhs element-wise
บันทึก
.== รองรับการออกอากาศ
คำประกาศ
public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
.!=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs != rhs element-wise
บันทึก
.!= รองรับการออกอากาศ
คำประกาศ
public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
.==(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs == rhs element-wise
บันทึก
.== รองรับการออกอากาศ
คำประกาศ
public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
.!=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs != rhs element-wise
บันทึก
.!= รองรับการออกอากาศ
คำประกาศ
public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
.==(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs == rhs element-wise
บันทึก
.== รองรับการออกอากาศ
คำประกาศ
public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
.!=(_:_:)
ส่งกลับเทนเซอร์ของสเกลาร์แบบบูลีนโดยการคำนวณ lhs != rhs element-wise
บันทึก
.!= รองรับการออกอากาศ
คำประกาศ
public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

มีให้โดยที่ `Scalar`: `TensorFlowFloatingPoint` & `Equatable`

องค์ประกอบเกือบจะเท่ากัน (_: ความอดทน :)
ส่งกลับเทนเซอร์ของค่าบูลีนที่ระบุว่าองค์ประกอบของ self มีค่าเท่ากับองค์ประกอบ other โดยประมาณหรือไม่
เงื่อนไขเบื้องต้น
self และ other จะต้องมีรูปร่างเหมือนกัน
คำประกาศ
public func elementsAlmostEqual( _ other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Tensor<Bool>

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

เกือบจะเท่ากัน (ถึง: ความอดทน :)
คืนค่า true หากองค์ประกอบทั้งหมดของ self มีค่าเท่ากับองค์ประกอบ other โดยประมาณ
เงื่อนไขเบื้องต้น
self และ other จะต้องมีรูปร่างเหมือนกัน
คำประกาศ
public func isAlmostEqual( to other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Bool

มีจำหน่ายที่ `Scalar`: `TensorFlowNumeric`

ข้ามReplicaSum(_:)
เรียกใช้ผลรวมการจำลองแบบข้ามสำหรับเทนเซอร์นี้ ผลรวมการจำลองแบบเดียวกันจะต้องเกิดขึ้นบนอุปกรณ์แต่ละเครื่องที่เข้าร่วมในผลรวม
คำประกาศ
public mutating mutating func crossReplicaSum(_ scale: Double)

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

เริ่มต้น (ซ้ำ :)
คำประกาศ
@derivative init(repeating: shape)

มีจำหน่ายที่ "สเกลาร์": "ตัวเลข"

ในนั้น(_:)
ทำการแปลงประเภทองค์ประกอบจาก Bool tensor
คำประกาศ
public init(_ other: Tensor<Bool>)

ในนั้น(_:)

ทำการแปลงตามองค์ประกอบจาก Tensor อื่น

คำประกาศ

@differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

ในนั้น(_:)
คำประกาศ
@derivative init(_: <<error type>>)
เริ่มต้น (ซ้อน :)
คำประกาศ
@derivative init(stacking: alongAxis)
init (เชื่อม :)
คำประกาศ
@derivative init(concatenating: alongAxis)

มีจำหน่ายที่ "สเกลาร์": "ตัวเลข"

เริ่มต้น (ศูนย์: เปิด :)
สร้างเทนเซอร์โดยตั้งค่าสเกลาร์ทั้งหมดเป็นศูนย์
คำประกาศ
public init(zeros shape: TensorShape, on device: Device = .default)
พารามิเตอร์
shape
รูปร่างของเทนเซอร์
เริ่มต้น (คน: บน :)
สร้างเทนเซอร์โดยตั้งค่าสเกลาร์ทั้งหมดเป็นหนึ่ง
คำประกาศ
public init(ones shape: TensorShape, on device: Device = .default)
พารามิเตอร์
shape
รูปร่างของเทนเซอร์
เริ่มต้น (zerosLike :)
สร้างเทนเซอร์โดยตั้งค่าสเกลาร์ทั้งหมดเป็นศูนย์ซึ่งมีรูปร่างและประเภทเดียวกันกับเทนเซอร์ที่ให้มา
คำประกาศ
public init(zerosLike other: Tensor)
พารามิเตอร์
other
เทนเซอร์ที่มีรูปร่างและประเภทข้อมูลที่จะใช้
เริ่มต้น (onesLike :)
สร้างเทนเซอร์โดยตั้งค่าสเกลาร์ทั้งหมดให้เป็นเมตริกซ์ที่มีรูปร่างและประเภทเดียวกันกับเทนเซอร์ที่ให้มา
คำประกาศ
public init(onesLike other: Tensor)
พารามิเตอร์
other
เทนเซอร์ที่มีรูปร่างและประเภทข้อมูลที่จะใช้

init(ช่วงจาก:ถึง:ก้าวย่าง:บน:)

สร้างเมตริกซ์ 1-D แทนลำดับจากค่าเริ่มต้นถึงแต่ไม่รวมค่าสิ้นสุด โดยก้าวตามจำนวนที่ระบุ

คำประกาศ

public init(
  rangeFrom start: Scalar, to end: Scalar, stride: Scalar,
  on device: Device = .default
)

พารามิเตอร์

`start`	ค่าเริ่มต้นที่จะใช้สำหรับลำดับ หากลำดับมีค่าใดๆ ค่าแรกจะเป็น `start`
`end`	ค่าสิ้นสุดเพื่อจำกัดลำดับ `end` ไม่เคยเป็นส่วนหนึ่งของลำดับผลลัพธ์
`stride`	จำนวนที่ต้องดำเนินการในแต่ละการวนซ้ำ `stride` จะต้องเป็นบวก

init(ช่วงจาก:ถึง:ก้าวย่าง:)

คำประกาศ

public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)

พารามิเตอร์

`start`	ค่าเริ่มต้นที่จะใช้สำหรับลำดับ หากลำดับมีค่าใดๆ ค่าแรกจะเป็น `start`
`end`	ค่าสิ้นสุดเพื่อจำกัดลำดับ `end` ไม่เคยเป็นส่วนหนึ่งของลำดับผลลัพธ์
`stride`	จำนวนที่ต้องดำเนินการในแต่ละการวนซ้ำ `stride` จะต้องเป็นบวก

init(oneHotAtIndices:ความลึก:onValue:offValue:axis:)

สร้างเทนเซอร์แบบร้อนแรงที่ดัชนีที่กำหนด ตำแหน่งที่แสดงโดย indices จะใช้ค่า onValue ( 1 โดยค่าเริ่มต้น) ในขณะที่ตำแหน่งอื่นๆ ทั้งหมดจะใช้ค่า offValue ( 0 โดยค่าเริ่มต้น) หาก indices อินพุตอยู่ในอันดับ n เทนเซอร์ใหม่จะมีอันดับ n+1 แกนใหม่จะถูกสร้างขึ้นที่ axis มิติ (ตามค่าเริ่มต้น แกนใหม่จะถูกต่อท้ายที่ส่วนท้าย)

หาก indices เป็นสเกลาร์ รูปร่างของเทนเซอร์ใหม่จะเป็นเวกเตอร์ที่มีความยาว depth

หาก indices เป็นเวกเตอร์ของ features ความยาว รูปร่างผลลัพธ์จะเป็น: คุณลักษณะ x ความลึก ถ้าแกน == -1 ความลึก x คุณลักษณะ ถ้าแกน == 0

หาก indices เป็นเมทริกซ์ (แบทช์) ที่มีรูปร่าง [batch, features] รูปร่างผลลัพธ์จะเป็น: แบทช์ x คุณสมบัติ x ความลึก, ถ้าแกน == -1 แบทช์ x ความลึก x คุณสมบัติ, ถ้าแกน == 1 ความลึก x แบทช์ x คุณสมบัติ ถ้าแกน == 0

คำประกาศ

public init(
  oneHotAtIndices indices: Tensor<Int32>,
  depth: Int,
  onValue: Scalar = 1,
  offValue: Scalar = 0,
  axis: Int = -1
)

พารามิเตอร์

`indices`	`Tensor` ของดัชนี
`depth`	สเกลาร์ที่กำหนดความลึกของมิติร้อนหนึ่งมิติ
`onValue`	สเกลาร์ที่กำหนดค่า ณ ตำแหน่งที่อ้างอิงโดยดัชนีบางตัวใน `indices`
`offValue`	สเกลาร์ที่กำหนดค่า ณ ตำแหน่งที่ไม่ได้อ้างอิงโดยดัชนีใดๆ ใน `indices`
`axis`	แกนที่จะเติม ค่าเริ่มต้นคือ `-1` ซึ่งเป็นแกนในสุดใหม่

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

init(linearSpaceFrom:to:count:on:)

สร้างเมตริกซ์ 1-D ที่แสดงลำดับตั้งแต่ค่าเริ่มต้น จนถึงและรวมถึงค่าสิ้นสุด โดยเว้นระยะห่างเท่าๆ กันเพื่อสร้างจำนวนค่าที่ระบุ

คำประกาศ

public init(
  linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default
)

พารามิเตอร์

`start`	ค่าเริ่มต้นที่จะใช้สำหรับลำดับ หากลำดับมีค่าใดๆ ค่าแรกจะเป็น `start`
`end`	ค่าสิ้นสุดเพื่อจำกัดลำดับ `end` คือองค์ประกอบสุดท้ายของลำดับผลลัพธ์
`count`	จำนวนค่าในลำดับผลลัพธ์ `count` จะต้องเป็นบวก

init(linearSpaceFrom:to:count:)

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

start , to และ count ต้องเป็น Tensors ที่มีค่าสเกลาร์ค่าเดียว

คำประกาศ

public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)

พารามิเตอร์

`start`	ค่าเริ่มต้นที่จะใช้สำหรับลำดับ หากลำดับมีค่าใดๆ ค่าแรกจะเป็น `start`
`end`	ค่าสิ้นสุดเพื่อจำกัดลำดับ `end` คือองค์ประกอบสุดท้ายของลำดับผลลัพธ์
`count`	จำนวนค่าในลำดับผลลัพธ์ `count` จะต้องเป็นบวก

มีจำหน่ายที่ `Scalar`: `TensorFlowIndex`

init(สุ่มUniform:lowerBound:upperBound:seed:on:)

สร้างเมตริกซ์ที่มีรูปร่างที่ระบุ โดยสุ่มสุ่มตัวอย่างค่าสเกลาร์จากการกระจายแบบสม่ำเสมอระหว่าง lowerBound และ upperBound

คำประกาศ

public init(
  randomUniform shape: TensorShape,
  lowerBound: Tensor<Scalar>? = nil,
  upperBound: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

พารามิเตอร์

`shape`	ขนาดของเทนเซอร์
`lowerBound`	ขอบเขตล่างของการแจกแจง
`upperBound`	ขอบเขตบนของการแจกแจง
`seed`	มูลค่าเมล็ดพันธุ์

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

init(สุ่มUniform:lowerBound:upperBound:seed:on:)

คำประกาศ

public init(
  randomUniform shape: TensorShape,
  lowerBound: Tensor<Scalar>? = nil,
  upperBound: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

พารามิเตอร์

`shape`	ขนาดของเทนเซอร์
`lowerBound`	ขอบเขตล่างของการแจกแจง
`upperBound`	ขอบเขตบนของการแจกแจง
`seed`	มูลค่าเมล็ดพันธุ์

init(randomNormal:mean:standardDeviation:seed:on:)

สร้างเมตริกซ์ที่มีรูปร่างที่ระบุ โดยสุ่มตัวอย่างค่าสเกลาร์จากการแจกแจงแบบปกติ

คำประกาศ

public init(
  randomNormal shape: TensorShape,
  mean: Tensor<Scalar>? = nil,
  standardDeviation: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

พารามิเตอร์

`shape`	ขนาดของเทนเซอร์
`mean`	ค่าเฉลี่ยของการกระจายตัว
`standardDeviation`	ค่าเบี่ยงเบนมาตรฐานของการแจกแจง
`seed`	มูลค่าเมล็ดพันธุ์

init (สุ่มตัดทอนปกติ: ค่าเฉลี่ย: มาตรฐานส่วนเบี่ยงเบน: เมล็ด: บน :)

สร้างเมตริกซ์ที่มีรูปร่างที่ระบุ โดยสุ่มสุ่มตัวอย่างค่าสเกลาร์จากการแจกแจงแบบปกติที่ถูกตัดทอน

คำประกาศ

public init(
  randomTruncatedNormal shape: TensorShape,
  mean: Tensor<Scalar>? = nil,
  standardDeviation: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

พารามิเตอร์

`shape`	ขนาดของเทนเซอร์
`mean`	ค่าเฉลี่ยของการกระจายตัว
`standardDeviation`	ค่าเบี่ยงเบนมาตรฐานของการแจกแจง
`seed`	มูลค่าเมล็ดพันธุ์

มีจำหน่ายที่ `Scalar`: `TensorFlowIndex`

init (randomCategorialLogits:sampleCount:seed:)

สร้างเทนเซอร์โดยการวาดตัวอย่างจากการแจกแจงแบบหมวดหมู่

คำประกาศ

public init<T: TensorFlowFloatingPoint>(
  randomCategorialLogits: Tensor<T>,
  sampleCount: Int32,
  seed: TensorFlowSeed = Context.local.randomSeed
)

พารามิเตอร์

`randomCategorialLogits`	เทนเซอร์ 2 มิติที่มีรูปร่าง `[batchSize, classCount]` แต่ละชิ้น `[i, :]` แสดงถึงความน่าจะเป็นของบันทึกที่ไม่ปกติสำหรับทุกคลาส
`sampleCount`	0-D. จำนวนตัวอย่างอิสระที่จะวาดสำหรับแต่ละชิ้นแถว
`seed`	มูลค่าเมล็ดพันธุ์

ค่าส่งคืน

เทนเซอร์ 2 มิติที่มีรูปร่าง [batchSize, sampleCount] แต่ละชิ้น [i, :] มีป้ายกำกับคลาสที่วาดซึ่งมีช่วง [0, classCount)

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

เริ่มต้น (gloroUniform:seed:on:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุโดยดำเนินการกำหนดค่าเริ่มต้นแบบสม่ำเสมอของ Glorot (Xavier)
มันดึงตัวอย่างแบบสุ่มจากการแจกแจงแบบสม่ำเสมอระหว่าง -limit และ limit ที่สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ limit คือ sqrt(6 / (fanIn + fanOut)) และ fanIn / fanOut แสดงถึงจำนวนของคุณสมบัติอินพุตและเอาต์พุตคูณด้วยตัวรับ ขนาดสนาม
ข้อมูลอ้างอิง: “การทำความเข้าใจความยากลำบากในการฝึกโครงข่ายประสาทเทียมแบบป้อนลึก”
คำประกาศ
public init( glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
พารามิเตอร์
shape
ขนาดของเทนเซอร์
seed
มูลค่าเมล็ดพันธุ์
เริ่มต้น (gloroNormal:seed:on:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุโดยดำเนินการกำหนดค่าเริ่มต้นตามปกติของ Glorot (Xavier)
มันดึงตัวอย่างแบบสุ่มจากการแจกแจงแบบปกติที่ถูกตัดทอนซึ่งมีศูนย์กลางอยู่ที่ 0 โดยมีค่าเบี่ยงเบนมาตรฐาน sqrt(2 / (fanIn + fanOut)) ที่สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ fanIn / fanOut แทนจำนวนคุณลักษณะอินพุตและเอาต์พุตคูณด้วยฟิลด์ที่รับ ขนาด.
ข้อมูลอ้างอิง: “การทำความเข้าใจความยากลำบากในการฝึกโครงข่ายประสาทเทียมแบบป้อนลึก”
คำประกาศ
public init( glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
พารามิเตอร์
shape
ขนาดของเทนเซอร์
seed
มูลค่าเมล็ดพันธุ์
เริ่มต้น (heUniform:seed:on:)
สร้างเทนเซอร์ตามรูปร่างที่ระบุโดยดำเนินการกำหนดค่าเริ่มต้นแบบสม่ำเสมอของ He (Kaiming)
โดยดึงตัวอย่างแบบสุ่มจากการแจกแจงแบบสม่ำเสมอระหว่าง -limit และ limit ที่สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ limit คือ sqrt(6 / fanIn) และ fanIn แสดงถึงจำนวนคุณลักษณะอินพุตคูณด้วยขนาดฟิลด์ที่รับ
ข้อมูลอ้างอิง: “การเจาะลึกเข้าไปในวงจรเรียงกระแส: ประสิทธิภาพที่เหนือกว่าระดับมนุษย์ในการจำแนกประเภท ImageNet”
คำประกาศ
public init( heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
พารามิเตอร์
shape
ขนาดของเทนเซอร์
seed
มูลค่าเมล็ดพันธุ์
เริ่มต้น (heNormal:seed:on:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุโดยดำเนินการการกำหนดค่าเริ่มต้นตามปกติของ He (Kaiming)
โดยดึงตัวอย่างแบบสุ่มจากการแจกแจงแบบปกติที่ถูกตัดทอนโดยมีศูนย์กลางอยู่ที่ 0 โดยมีค่าเบี่ยงเบนมาตรฐาน sqrt(2 / fanIn)) ที่สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ fanIn แทนจำนวนคุณลักษณะอินพุตคูณด้วยขนาดฟิลด์ที่รับ
ข้อมูลอ้างอิง: “การเจาะลึกเข้าไปในวงจรเรียงกระแส: ประสิทธิภาพที่เหนือกว่าระดับมนุษย์ในการจำแนกประเภท ImageNet”
คำประกาศ
public init( heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
พารามิเตอร์
shape
ขนาดของเทนเซอร์
seed
มูลค่าเมล็ดพันธุ์
เริ่มต้น (leCunUniform:seed:on:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุโดยดำเนินการเริ่มต้นเครื่องแบบ LeCun
โดยดึงตัวอย่างแบบสุ่มจากการแจกแจงแบบสม่ำเสมอระหว่าง -limit และ limit ที่สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ limit คือ sqrt(3 / fanIn) และ fanIn แสดงถึงจำนวนคุณลักษณะอินพุตคูณด้วยขนาดฟิลด์ที่รับ
อ้างอิง: “BackProp ที่มีประสิทธิภาพ”
คำประกาศ
public init( leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
พารามิเตอร์
shape
ขนาดของเทนเซอร์
seed
มูลค่าเมล็ดพันธุ์
เริ่มต้น (leCunNormal:seed:on:)
สร้างเทนเซอร์ที่มีรูปร่างที่ระบุโดยดำเนินการเริ่มต้นตามปกติของ LeCun
โดยดึงตัวอย่างแบบสุ่มจากการแจกแจงแบบปกติที่ถูกตัดทอนซึ่งมีศูนย์กลางอยู่ที่ 0 โดยมีค่าเบี่ยงเบนมาตรฐาน sqrt(1 / fanIn) ที่สร้างโดยตัวสร้างตัวเลขสุ่มเริ่มต้น โดยที่ fanIn แทนจำนวนคุณลักษณะอินพุตคูณด้วยขนาดฟิลด์ที่เปิดกว้าง
อ้างอิง: “BackProp ที่มีประสิทธิภาพ”
คำประกาศ
public init( leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
พารามิเตอร์
shape
ขนาดของเทนเซอร์
seed
มูลค่าเมล็ดพันธุ์

เริ่มต้น (มุมฉาก: กำไร: เมล็ด :)

สร้างเมทริกซ์มุมฉากหรือเมตริกซ์

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

หากรูปร่างของเทนเซอร์ที่จะเริ่มต้นมีค่ามากกว่าสองมิติ เมทริกซ์ของรูปร่าง [shape[0] * ... * shape[rank - 2], shape[rank - 1]] จะถูกเตรียมใช้งาน เมทริกซ์จะถูกปรับรูปร่างใหม่ในภายหลังเพื่อให้มีเทนเซอร์ของรูปร่างที่ต้องการ

คำประกาศ

public init(
  orthogonal shape: TensorShape,
  gain: Tensor<Scalar> = Tensor<Scalar>(1),
  seed: TensorFlowSeed = Context.local.randomSeed
)

พารามิเตอร์

`shape`	รูปร่างของเทนเซอร์
`gain`	ตัวคูณคูณที่ใช้กับเทนเซอร์ตั้งฉาก
`seed`	สิ่งอันดับของจำนวนเต็มสองตัวเพื่อเริ่มต้นเครื่องกำเนิดตัวเลขสุ่ม

มีจำหน่ายที่ `Scalar`: `TensorFlowNumeric`

เส้นทแยงมุม()
ส่งกลับค่าส่วนเส้นทแยงมุม [batched] ของเทนเซอร์ [batched] สำหรับอินสแตนซ์เทนเซอร์ของรูปร่าง [..., M, N] เอาต์พุตคือเทนเซอร์ของรูปร่าง [..., K] โดยที่ K เท่ากับ min(N, M)
ตัวอย่างเช่น:
```
// 't' is [[1, 0, 0, 0]
//         [0, 2, 0, 0]
//         [0, 0, 3, 0]
//         [0, 0, 0, 4]]
t.diagonalPart()
// [1, 2, 3, 4]
```
คำประกาศ
@differentiable public func diagonalPart() -> Tensor
เส้นทแยงมุม()
สร้างอาร์เรย์แนวทแยง [เป็นชุด] สำหรับตัวอย่างเทนเซอร์ของรูปร่าง [..., M] ผลลัพธ์จะเป็นเทนเซอร์ของรูปร่าง [..., M, M]
ตัวอย่างเช่น:
```
// 't' is [1, 2, 3, 4]

t.diagonal()
// [[1, 0, 0, 0]
//  [0, 2, 0, 0]
//  [0, 0, 3, 0]
//  [0, 0, 0, 4]]
```
คำประกาศ
@differentiable public func diagonal() -> Tensor
ด้วยเส้นทแยงมุม(_:)
ส่งกลับค่า self ด้วยค่าเส้นทแยงมุมใหม่ โดยพิจารณาว่า self เป็นเมทริกซ์แบบชุดหรือไม่ก็ได้
เทนเซอร์ที่ส่งคืนจะมีรูปร่างและค่าเหมือนกับ self ยกเว้นเส้นทแยงมุมที่ระบุของเมทริกซ์ที่อยู่ด้านในสุดซึ่งจะถูกเขียนทับด้วยค่าใน diagonal
เส้นทแยงมุมของพารามิเตอร์: เทนเซอร์ที่มี rank - 1 แทนค่าเส้นทแยงมุมใหม่
คำประกาศ
public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor

วงดนตรี(_:_:)

คำประกาศ

@differentiable(wrt: self)
public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor

bandPart(จำนวนย่อย:superdiagonalCount:)

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

ตัวอย่างเช่น:

// 't' is [[ 0,  1,  2, 3]
//         [-1,  0,  1, 2]
//         [-2, -1,  0, 1]
//         [-3, -2, -1, 0]]

t.bandPart(1, -1)
// [[ 0,  1,  2, 3]
//  [-1,  0,  1, 2]
//  [ 0, -1,  0, 1]
//  [ 0,  0, -1, 0]]

t.bandPart(2, 1)
// [[ 0,  1,  0, 0]
//  [-1,  0,  1, 0]
//  [-2, -1,  0, 1]
//  [ 0, -2, -1, 0]]

คำประกาศ

@differentiable
public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor

พารามิเตอร์

`subdiagonalCount`	จำนวนเส้นทแยงมุมย่อยที่ต้องเก็บ หากเป็นลบ ให้คงรูปสามเหลี่ยมด้านล่างไว้ทั้งหมด
`superdiagonalCount`	จำนวนเส้นทแยงมุมเหนือที่ต้องเก็บ หากเป็นลบ ให้คงรูปสามเหลี่ยมด้านบนไว้ทั้งหมด

มีจำหน่ายโดยที่ `Scalar`: `TensorFlowFloatingPoint`

qrDecomposition (เมทริกซ์เต็ม :)

ส่งกลับการสลายตัวของ QR ของเมทริกซ์ด้านในแต่ละตัวในเทนเซอร์ เทนเซอร์ที่มีเมทริกซ์มุมฉากด้านใน q และเทนเซอร์ที่มีเมทริกซ์สามเหลี่ยมด้านบนด้านใน r โดยที่เทนเซอร์จะเท่ากับ matmul(q, r)

คำประกาศ

public func qrDecomposition(fullMatrices: Bool = false) -> (
  q: Tensor<Scalar>, r: Tensor<Scalar>
)

พารามิเตอร์

fullMatrices

ถ้า true ให้คำนวณขนาดเต็ม q และ r มิฉะนั้นคำนวณเฉพาะคอลัมน์ min(shape[rank - 1], shape[rank - 2]) นำหน้าของ q

svd (คำนวณ UV: เต็มเมทริกซ์ :)

ส่งกลับค่าเอกพจน์ของการแยกส่วน self โดยระบุว่า self เป็นเมทริกซ์แบบเลือกได้

การสลายตัวของค่าเอกพจน์ (SVD) ของ self ริกซ์ที่เป็นทางเลือกแบบแบทช์คือค่า s , u และ v เพื่อให้:

self[..., :, :] = u[..., :, :] • s[..., :, :].diagonal() • v[..., :, :].transposed()`

ตัวเอง must be a tensor with shape […, M, N] . Let K = นาที(M, N)`

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

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

คำประกาศ

public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> (
  s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>?
)

พารามิเตอร์

`computeUV`	หาก `true` เวกเตอร์เอกพจน์ด้านซ้ายและขวาจะถูกคำนวณและส่งกลับเป็น `u` และ `v` ตามลำดับ หากเป็น `false` ค่า `nil` จะถูกส่งกลับเป็น `u` และ `v`
`fullMatrices`	ถ้า `true` `u` และ `v` ตามลำดับจะมีรูปร่าง `[..., M, M]` และ `[..., N, N]` หาก `false` `u` และ `v` ตามลำดับจะมีรูปร่าง `[..., M, K]` และ `[..., K, N]` ถูกละเว้นเมื่อ `computeUV` เป็นเท็จ

ค่าส่งคืน

s: ค่าเอกพจน์ที่มีรูปร่าง [..., K] ภายในเวกเตอร์แต่ละตัว ค่าเอกพจน์จะถูกจัดเรียงจากมากไปน้อย
u: เวกเตอร์เอกพจน์ด้านซ้าย
v: เวกเตอร์เอกพจน์ที่ถูกต้อง

ตารางวา(_:)
รากที่สองของ x
สำหรับประเภทจริง ถ้า x เป็นลบ ผลลัพธ์จะเป็น .nan สำหรับประเภทที่ซับซ้อน จะมีการตัดกิ่งบนแกนจริงลบ
คำประกาศ
@differentiable public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
เพราะ(_:)
โคไซน์ของ x แปลเป็นมุมเป็นเรเดียน
คำประกาศ
@differentiable public static func cos(_ x: `Self`) -> Tensor<Scalar>
บาป(_:)
ไซน์ของ x แปลเป็นมุมเป็นเรเดียน
คำประกาศ
@differentiable public static func sin(_ x: `Self`) -> Tensor<Scalar>
สีแทน(_:)
ค่าแทนเจนต์ของ x แปลเป็นมุมเป็นเรเดียน
คำประกาศ
@differentiable public static func tan(_ x: `Self`) -> Tensor<Scalar>
เอคอส(_:)
โคไซน์ผกผันของ x เป็นเรเดียน
คำประกาศ
@differentiable public static func acos(_ x: `Self`) -> Tensor<Scalar>
บาป(_:)
ไซน์ผกผันของ x เป็นเรเดียน
คำประกาศ
@differentiable public static func asin(_ x: `Self`) -> Tensor<Scalar>
อาทัน(_:)
แทนเจนต์ผกผันของ x เป็นเรเดียน
คำประกาศ
@differentiable public static func atan(_ x: `Self`) -> Tensor<Scalar>
คอส(_:)
โคไซน์ไฮเปอร์โบลิกของ x
คำประกาศ
@differentiable public static func cosh(_ x: `Self`) -> Tensor<Scalar>
ซิน(_:)
ไซน์ไฮเปอร์โบลิกของ x
คำประกาศ
@differentiable public static func sinh(_ x: `Self`) -> Tensor<Scalar>
ทันห์(_:)
แทนเจนต์ไฮเปอร์โบลิกของ x
คำประกาศ
@differentiable public static func tanh(_ x: `Self`) -> Tensor<Scalar>
อะโคช(_:)
โคไซน์ไฮเปอร์โบลิกผกผันของ x
คำประกาศ
@differentiable public static func acosh(_ x: `Self`) -> Tensor<Scalar>
อาซิน(_:)
ไซน์ไฮเปอร์โบลิกผกผันของ x
คำประกาศ
@differentiable public static func asinh(_ x: `Self`) -> Tensor<Scalar>
อาทันห์(_:)
แทนเจนต์ไฮเปอร์โบลิกผกผันของ x
คำประกาศ
@differentiable public static func atanh(_ x: `Self`) -> Tensor<Scalar>
ประสบการณ์(_:)
ฟังก์ชันเลขชี้กำลังที่ใช้กับ x หรือ e**x
คำประกาศ
@differentiable public static func exp(_ x: `Self`) -> Tensor<Scalar>
ประสบการณ์2(_:)
สองยกกำลัง x
คำประกาศ
@differentiable public static func exp2(_ x: `Self`) -> Tensor<Scalar>
ประสบการณ์10(_:)
สิบยกกำลัง x
คำประกาศ
@differentiable public static func exp10(_ x: `Self`) -> Tensor<Scalar>
expm1(_:)
exp(x) - 1 ประเมินเพื่อรักษาความแม่นยำให้ใกล้เคียงกับศูนย์
คำประกาศ
@differentiable public static func expm1(_ x: `Self`) -> Tensor<Scalar>
บันทึก(_:)
ลอการิทึมธรรมชาติของ x
คำประกาศ
@differentiable public static func log(_ x: `Self`) -> Tensor<Scalar>
ล็อก2(_:)
ลอการิทึมฐานสองของ x
คำประกาศ
@differentiable public static func log2(_ x: `Self`) -> Tensor<Scalar>
log10(_:)
ลอการิทึมฐานสิบของ x
คำประกาศ
@differentiable public static func log10(_ x: `Self`) -> Tensor<Scalar>
log1p(_:)
log(1 + x) ประเมินเพื่อรักษาความแม่นยำให้ใกล้เคียงกับศูนย์
คำประกาศ
@differentiable public static func log1p(_ x: `Self`) -> Tensor<Scalar>
ว้าย(_:_:)
exp(y log(x)) คำนวณโดยไม่สูญเสียความแม่นยำระดับกลาง
สำหรับประเภทจริงถ้า x เป็นลบผลลัพธ์คือ NAN แม้ว่า y จะมีค่าอินทิกรัล สำหรับประเภทที่ซับซ้อนมีการตัดสาขาบนแกนจริงเชิงลบ
การประกาศ
@differentiable public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
POW (_: _ :)
x ยกขึ้นสู่พลัง n th
ผลิตภัณฑ์ของ n สำเนาของ x
การประกาศ
@differentiable public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
ราก(_:_:)
ราก n th ของ x
สำหรับประเภทจริงถ้า x เป็นลบและ n เป็นแม้ผลลัพธ์คือน่าน สำหรับประเภทที่ซับซ้อนมีสาขาตัดตามแกนจริงเชิงลบ
การประกาศ
@differentiable public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
เวกเตอร์สเปซสเกลาร์
การประกาศ
public typealias VectorSpaceScalar = Float
ปรับขนาด (โดย :)
การประกาศ
public func scaled(by scale: Float) -> Tensor<Scalar>

เพิ่ม(_:)

การประกาศ

public func adding(_ scalar: Float) -> Tensor<Scalar>

การลบ (_ :)

การประกาศ

public func subtracting(_ scalar: Float) -> Tensor<Scalar>

มีให้ที่ `scalar`:` numeric`

+(_: _ :)
เพิ่มสเกลาร์ให้กับสเกลาร์ทุกตัวของเทนเซอร์และสร้างผลรวม
การประกาศ
@differentiable public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
+(_: _ :)
เพิ่มสเกลาร์ให้กับสเกลาร์ทุกตัวของเทนเซอร์และสร้างผลรวม
การประกาศ
@differentiable public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
-(_: _ :)
ลบสเกลาร์จากสเกลาร์ทุกตัวของเทนเซอร์และสร้างความแตกต่าง
การประกาศ
@differentiable public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
-(_: _ :)
ลบสเกลาร์จากสเกลาร์ทุกตัวของเทนเซอร์และสร้างความแตกต่าง
การประกาศ
@differentiable public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
+= (_: _ :)
เพิ่มสองเทนเซอร์และเก็บผลลัพธ์ในตัวแปรด้านซ้ายมือ
บันทึก
+= รองรับการออกอากาศ
การประกาศ
public static func += (lhs: inout Tensor, rhs: Tensor)
+= (_: _ :)
เพิ่มสเกลาร์ให้กับสเกลาร์ทุกตัวของเทนเซอร์และเก็บผลลัพธ์ในตัวแปรด้านซ้ายมือ
การประกาศ
public static func += (lhs: inout Tensor, rhs: Scalar)
-= (_: _ :)
ลบเทนเซอร์ที่สองจากครั้งแรกและเก็บผลลัพธ์ในตัวแปรด้านซ้ายมือ
บันทึก
-= รองรับการออกอากาศ
การประกาศ
public static func -= (lhs: inout Tensor, rhs: Tensor)
-= (_: _ :)
ลบสเกลาร์จากสเกลาร์ทุกตัวของเทนเซอร์และเก็บผลลัพธ์ในตัวแปรด้านซ้ายมือ
คำประกาศ
public static func -= (lhs: inout Tensor, rhs: Scalar)
*(_: _ :)
ส่งคืนเทนเซอร์ที่ผลิตโดยการคูณสองเทนเซอร์
บันทึก
* รองรับการออกอากาศ
การประกาศ
@differentiable public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
*(_: _ :)
ส่งคืนเทนเซอร์โดยการคูณด้วยสเกลาร์ทุกตัวของเทนเซอร์
การประกาศ
@differentiable public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
*(_: _ :)
ทวีคูณสเกลาร์กับสเกลาร์ทุกตัวของเทนเซอร์และผลิตผลิตภัณฑ์
การประกาศ
@differentiable public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
*= (_: _ :)
ทวีคูณสองเทนเซอร์และเก็บผลลัพธ์ในตัวแปรด้านซ้ายมือ
บันทึก
*= รองรับการออกอากาศ
การประกาศ
public static func *= (lhs: inout Tensor, rhs: Tensor)
*= (_: _ :)
ทวีคูณเทนเซอร์ด้วยสเกลาร์ออกอากาศสเกลาร์และเก็บผลลัพธ์ในตัวแปรด้านซ้ายมือ
การประกาศ
public static func *= (lhs: inout Tensor, rhs: Scalar)
/(_: _ :)
ส่งกลับความฉลาดของการหารเทนเซอร์แรกโดยที่สอง
บันทึก
/ สนับสนุนการออกอากาศ
การประกาศ
@differentiable public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
/(_: _ :)
ส่งกลับความฉลาดของการหารสเกลาร์โดยเทนเซอร์ออกอากาศสเกลาร์
การประกาศ
@differentiable public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
/(_: _ :)
ส่งคืนความฉลาดของการหารเทนเซอร์โดยสเกลาร์ออกอากาศสเกลาร์
การประกาศ
@differentiable public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
/= (_: _ :)
แบ่งเทนเซอร์แรกโดยที่สองและเก็บความฉลาดในตัวแปรด้านซ้ายมือ
การประกาศ
public static func /= (lhs: inout Tensor, rhs: Tensor)
/= (_: _ :)
แบ่งเทนเซอร์ด้วยสเกลาร์ออกอากาศสเกลาร์และเก็บความฉลาดในตัวแปรด้านซ้ายมือ
การประกาศ
public static func /= (lhs: inout Tensor, rhs: Scalar)
%(_: _ :)
ส่งคืนส่วนที่เหลือของการหารเทนเซอร์แรกโดยที่สอง
บันทึก
% รองรับการออกอากาศ
การประกาศ
public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
%(_: _ :)
ส่งคืนส่วนที่เหลือของการหารเทนเซอร์โดยสเกลาร์ออกอากาศสเกลาร์
การประกาศ
public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
%(_: _ :)
ส่งคืนส่วนที่เหลือของการแบ่งสเกลาร์โดยเทนเซอร์ออกอากาศสเกลาร์
การประกาศ
public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
%= (_: _ :)
แบ่งเทนเซอร์แรกโดยที่สองและเก็บส่วนที่เหลือในตัวแปรด้านซ้ายมือ
การประกาศ
public static func %= (lhs: inout Tensor, rhs: Tensor)
%= (_: _ :)
แบ่งเทนเซอร์ด้วยสเกลาร์และเก็บส่วนที่เหลือในตัวแปรด้านซ้ายมือ
คำประกาศ
public static func %= (lhs: inout Tensor, rhs: Scalar)

พร้อมใช้งานที่ `scalar` ==` bool '

Elementslogicalnot ()
กลับมา !self ฉลาด
การประกาศ
public func elementsLogicalNot() -> Tensor
Elementslogicaland (_ :)
ส่งคืน self && other ที่ชาญฉลาด
บันทึก
&& สนับสนุนการออกอากาศ
การประกาศ
public func elementsLogicalAnd(_ other: Tensor) -> Tensor
Elementslogicaland (_ :)
ส่งคืน self && other ที่ฉลาดออกอากาศ other
การประกาศ
public func elementsLogicalAnd(_ other: Scalar) -> Tensor
Elementslogicalor (_ :)
ส่งคืน self || other องค์ประกอบ self || other ที่ชาญฉลาด
การประกาศ
public func elementsLogicalOr(_ other: Tensor) -> Tensor
Elementslogicalor (_ :)
ส่งคืน self || other องค์ประกอบ self || other ที่ชาญฉลาดออกอากาศ other
การประกาศ
public func elementsLogicalOr(_ other: Scalar) -> Tensor

มีจำหน่ายที่ `Scalar`: `TensorFlowNumeric`

ถูกตัด (ขั้นต่ำ: สูงสุด :)
ส่งคืน max(min(self, max), min)
การประกาศ
@differentiable public func clipped(min: Tensor, max: Tensor) -> Tensor
ถูกตัด (ขั้นต่ำ: สูงสุด :)
ส่งคืน max(min(self, max), min)
การประกาศ
@differentiable(wrt: (self, min) ) public func clipped(min: Tensor, max: Scalar) -> Tensor
ถูกตัด (ขั้นต่ำ: สูงสุด :)
ส่งคืน max(min(self, max), min)
การประกาศ
@differentiable(wrt: (self, max) ) public func clipped(min: Scalar, max: Tensor) -> Tensor
ถูกตัด (ขั้นต่ำ: สูงสุด :)
ส่งคืน max(min(self, max), min)
การประกาศ
@differentiable(wrt: self) public func clipped(min: Scalar, max: Scalar) -> Tensor

พร้อมใช้งานที่ `scalar`:` signednumeric`

-(_ :)
ส่งคืนการปฏิเสธขององค์ประกอบเทนเซอร์ที่ระบุ
การประกาศ
@differentiable public prefix static func - (rhs: Tensor) -> Tensor

มีให้ที่ `scalar`:` numeric`

กำลังสอง ()

การประกาศ

@differentiable(wrt: self)
public func squared() -> Tensor

มีให้ที่ `scalar`:` tensorflowfloatingpoint '

isfinite
ส่งคืนเทนเซอร์บูลีนที่ระบุว่าองค์ประกอบของ x มี จำกัด
การประกาศ
public var isFinite: Tensor<Bool> { get }
ไม่มีที่สิ้นสุด
ส่งคืนเทนเซอร์บูลีนที่ระบุว่าองค์ประกอบของ x ใดที่ไม่มีที่สิ้นสุด
การประกาศ
public var isInfinite: Tensor<Bool> { get }
คือNaN
ส่งคืนเทนเซอร์บูลีนที่ระบุว่าองค์ประกอบของ x ใดที่มีค่า NAN
การประกาศ
public var isNaN: Tensor<Bool> { get }

พร้อมใช้งานที่ `scalar` ==` bool '

ทั้งหมด()
ส่งคืน true ถ้าสเกลาร์ทั้งหมดเท่ากับ true มิฉะนั้นจะส่งคืน false
การประกาศ
public func all() -> Bool
ใดๆ()
ส่งคืน true ถ้าสเกลาร์ใด ๆ เท่ากับ true มิฉะนั้นจะส่งคืน false
การประกาศ
public func any() -> Bool
ทั้งหมด (Squeezingaxes :)
ดำเนินการตรรกะและการทำงานตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func all(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ใด ๆ (บีบบีบ :)
ดำเนินการตรรกะและการทำงานตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func any(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ทั้งหมด (onlowaxes :)
ดำเนินการตรรกะและการทำงานตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func all(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ใด ๆ (onlowaxes :)
ดำเนินการตรรกะหรือการทำงานตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func any(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.

มีให้ที่ `scalar`:` ตัวเลข '& `เทียบเท่า'

นาที()

การประกาศ

@differentiable
public func min() -> Tensor

สูงสุด ()

การประกาศ

@differentiable
public func max() -> Tensor

สูงสุด (บีบอัดตัว :)
ส่งคืนค่าสูงสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
สูงสุด (บีบอัดตัว :)
ส่งคืนค่าสูงสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
คำประกาศ
@differentiable(wrt: self) public func max(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
สูงสุด (บีบอัดตัว :)
ส่งคืนค่าสูงสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func max(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ขั้นต่ำ (บีบอัด :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ขั้นต่ำ (บีบอัด :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func min(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ขั้นต่ำ (บีบอัด :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func min(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
argmax (บีบบีบ :)
ส่งคืนดัชนีของค่าสูงสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
argmin (บีบบีบ :)
ส่งคืนดัชนีของค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ขั้นต่ำ (onlowaxes :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func min(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ขั้นต่ำ (onlowaxes :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func min(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ขั้นต่ำ (onlowaxes :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func min(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
สูงสุด (onlowaxes :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func max(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
สูงสุด (onlowaxes :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func max(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
สูงสุด (onlowaxes :)
ส่งคืนค่าต่ำสุดตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func max(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
argmax ()
ส่งคืนดัชนีของค่าสูงสุดของสเกลาร์แบน
การประกาศ
public func argmax() -> Tensor<Int32>
argmin ()
ส่งคืนดัชนีของค่าต่ำสุดของสเกลาร์แบน
การประกาศ
public func argmin() -> Tensor<Int32>

มีให้ที่ `scalar`:` numeric`

Sum (Squeezingaxes :)
ส่งคืนผลรวมตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
Sum (Squeezingaxes :)
ส่งคืนผลรวมตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func sum(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
Sum (Squeezingaxes :)
ส่งคืนผลรวมตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func sum(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.

ผลรวม ()

การประกาศ

@differentiable(wrt: self)
public func sum() -> Tensor

ผลรวม (onlyaxes :)
ส่งคืนผลรวมตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func sum(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลรวม (onlyaxes :)
ส่งคืนผลรวมตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func sum(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลรวม (onlyaxes :)
ส่งคืนผลรวมตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func sum(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลิตภัณฑ์ (บีบอัด :)
ส่งคืนผลิตภัณฑ์ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลิตภัณฑ์ (บีบอัด :)
ส่งคืนผลิตภัณฑ์ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func product(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลิตภัณฑ์ (บีบอัด :)
ส่งคืนผลิตภัณฑ์ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func product(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.

ผลิตภัณฑ์()

การประกาศ

@differentiable(wrt: self)
public func product() -> Tensor

ผลิตภัณฑ์ (ตามกฎหมาย :)
ส่งคืนผลิตภัณฑ์ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
คำประกาศ
public func product(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลิตภัณฑ์ (ตามกฎหมาย :)
ส่งคืนผลิตภัณฑ์ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func product(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ผลิตภัณฑ์ (ตามกฎหมาย :)
ส่งคืนผลิตภัณฑ์ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
public func product(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
หมายถึง (บีบอัด :)
ส่งคืนค่าเฉลี่ยเลขคณิตตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
หมายถึง (บีบอัด :)
ส่งคืนค่าเฉลี่ยเลขคณิตตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func mean(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
หมายถึง (บีบอัด :)
ส่งคืนค่าเฉลี่ยเลขคณิตตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank...rank
การประกาศ
@differentiable(wrt: self) public func mean(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.

หมายถึง()

การประกาศ

@differentiable(wrt: self)
public func mean() -> Tensor

หมายถึง (onlowaxes :)
ส่งคืนค่าเฉลี่ยเลขคณิตตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func mean(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
หมายถึง (onlowaxes :)
ส่งคืนค่าเฉลี่ยเลขคณิตตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func mean(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
หมายถึง (onlowaxes :)
ส่งคืนค่าเฉลี่ยเลขคณิตตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func mean(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ความแปรปรวน (Squeezingaxes :)
ส่งคืนความแปรปรวนตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ความแปรปรวน (Squeezingaxes :)
ส่งคืนความแปรปรวนตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func variance(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ความแปรปรวน (Squeezingaxes :)
ส่งคืนความแปรปรวนตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1. ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func variance(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.

ความแปรปรวน ()

การประกาศ

@differentiable(wrt: self)
public func variance() -> Tensor

ความแปรปรวน (onlowaxes :)
ส่งคืนความแปรปรวนตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1. ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func variance(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ความแปรปรวน (onlowaxes :)
ส่งคืนความแปรปรวนตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1. ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func variance(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ความแปรปรวน (onlowaxes :)
ส่งคืนความแปรปรวนตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1. ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
คำประกาศ
@differentiable(wrt: self) public func variance(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.

cumulativesum (onlyaxis: Exclusive: ย้อนกลับ :)

ส่งคืนผลรวมสะสมของเทนเซอร์นี้ตามแกนที่ระบุ โดยค่าเริ่มต้นฟังก์ชั่นนี้จะทำผลรวมสะสมแบบรวมซึ่งหมายความว่าองค์ประกอบแรกของอินพุตนั้นเหมือนกับองค์ประกอบแรกของเอาต์พุต:

Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])

โดยการตั้งค่าอาร์กิวเมนต์ exclusive เป็น true ผลรวมสะสมพิเศษจะดำเนินการแทน:

Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])

โดยการตั้งค่าอาร์กิวเมนต์ reverse เป็น true ผลรวมสะสมจะดำเนินการในทิศทางตรงกันข้าม:

Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
    Tensor<Float>([a + b + c, a + b, a])

สิ่งนี้มีประสิทธิภาพมากกว่าการแยกเทนเซอร์ที่เกิดขึ้นแยกต่างหาก

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

axis ต้องอยู่ในช่วง -rank..<rank

การประกาศ

@differentiable(wrt: self)
public func cumulativeSum(
  alongAxis axis: Int,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

พารามิเตอร์

`axis`	แกนตามการดำเนินการรวมสะสม
`exclusive`	ระบุว่าจะดำเนินการรวมสะสมพิเศษหรือไม่
`reverse`	ระบุว่าจะดำเนินการสะสมสะสมตามลำดับกลับกันหรือไม่

ค่าส่งคืน

ผลของการดำเนินการรวมสะสม

cumulativesum (onlyaxis: Exclusive: ย้อนกลับ :)

Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])

โดยการตั้งค่าอาร์กิวเมนต์ exclusive เป็น true ผลรวมสะสมพิเศษจะดำเนินการแทน:

Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])

Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
    Tensor<Float>([a + b + c, a + b, a])

สิ่งนี้มีประสิทธิภาพมากกว่าการแยกเทนเซอร์ที่เกิดขึ้นแยกต่างหาก

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

axis.rank ต้องเป็น 0

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

axis ต้องอยู่ในช่วง -rank..<rank

การประกาศ

@differentiable(wrt: self)
public func cumulativeSum(
  alongAxis axis: Tensor<Int32>,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

พารามิเตอร์

`axis`	แกนตามการดำเนินการรวมสะสม
`exclusive`	ระบุว่าจะดำเนินการรวมสะสมพิเศษหรือไม่
`reverse`	ระบุว่าจะดำเนินการสะสมสะสมตามลำดับกลับกันหรือไม่

ค่าส่งคืน

ผลของการดำเนินการรวมสะสม

cumulativeproduct (onlyaxis: exclusive: reverse :)

ส่งคืนผลิตภัณฑ์สะสมของเทนเซอร์นี้ตามแกนที่ระบุ โดยค่าเริ่มต้นฟังก์ชั่นนี้ดำเนินการผลิตภัณฑ์สะสมแบบรวมซึ่งหมายความว่าองค์ประกอบแรกของอินพุตนั้นเหมือนกับองค์ประกอบแรกของเอาต์พุต:

Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])

โดยการตั้งค่าอาร์กิวเมนต์ exclusive เป็น true ผลิตภัณฑ์สะสมพิเศษจะดำเนินการแทน:

Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])

โดยการตั้งค่าอาร์กิวเมนต์ reverse เป็น true ผลิตภัณฑ์สะสมจะดำเนินการในทิศทางตรงกันข้าม:

Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
    Tensor<Float>([a * b * c, a * b, a])

สิ่งนี้มีประสิทธิภาพมากกว่าการแยกเทนเซอร์ที่เกิดขึ้นแยกต่างหาก

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

axis ต้องอยู่ในช่วง -rank..<rank

การประกาศ

@differentiable(wrt: self)
public func cumulativeProduct(
  alongAxis axis: Int,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

พารามิเตอร์

`axis`	แกนตามการดำเนินการผลิตภัณฑ์สะสม
`exclusive`	ระบุว่าจะดำเนินการผลิตภัณฑ์สะสมพิเศษหรือไม่
`reverse`	ระบุว่าจะดำเนินการผลิตภัณฑ์สะสมตามลำดับกลับ

ค่าส่งคืน

ผลของการดำเนินการผลิตภัณฑ์สะสม

cumulativeproduct (onlyaxis: exclusive: reverse :)

Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])

Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])

Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
    Tensor<Float>([a * b * c, a * b, a])

สิ่งนี้มีประสิทธิภาพมากกว่าการแยกเทนเซอร์ที่เกิดขึ้นแยกต่างหาก

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

axis ต้องมีอันดับ 0

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

axis ต้องอยู่ในช่วง -rank..<rank

การประกาศ

@differentiable(wrt: self)
public func cumulativeProduct(
  alongAxis axis: Tensor<Int32>,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

พารามิเตอร์

`axis`	แกนตามการดำเนินการผลิตภัณฑ์สะสม
`exclusive`	ระบุว่าจะดำเนินการผลิตภัณฑ์สะสมพิเศษหรือไม่
`reverse`	ระบุว่าจะดำเนินการผลิตภัณฑ์สะสมตามลำดับกลับ

ค่าส่งคืน

ผลของการดำเนินการผลิตภัณฑ์สะสม

มีให้ที่ `scalar`:` tensorflowfloatingpoint '

StandardDeviation (Squeezingaxes :)
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1 ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
StandardDeviation (Squeezingaxes :)
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1 ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
StandardDeviation (Squeezingaxes :)
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1 ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ส่วนเบี่ยงเบนมาตรฐาน()
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบทั้งหมดในเทนเซอร์นี้ ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func standardDeviation() -> Tensor
StandardDeviation (ตามกฎหมาย :)
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1 ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
StandardDeviation (ตามกฎหมาย :)
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1 ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
คำประกาศ
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
StandardDeviation (ตามกฎหมาย :)
ส่งคืนค่าเบี่ยงเบนมาตรฐานขององค์ประกอบตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1 ไม่ได้ใช้การแก้ไขของ Bessel
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
LogSumexp (บีบอัด :)
ส่งคืน log(exp(self).sum(squeezingAxes: axes)) ขนาดที่ลดลงจะถูกลบออก
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum(squeezingAxes: axes)) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
LogSumexp (บีบอัด :)
ส่งคืน log(exp(self).sum(squeezingAxes: axes)) ขนาดที่ลดลงจะถูกลบออก
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum(squeezingAxes: axes)) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
LogSumexp (บีบอัด :)
ส่งคืน log(exp(self).sum(squeezingAxes: axes)) ขนาดที่ลดลงจะถูกลบออก
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum(squeezingAxes: axes)) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
logsumexp ()
ส่งคืน log(exp(self).sum()) ผลที่ได้คือสเกลาร์
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum()) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
การประกาศ
@differentiable(wrt: self) public func logSumExp() -> Tensor
LogSumexp (ตามกฎหมาย :)
ส่งคืน log(exp(self).sum(alongAxes: axes)) ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum(alongAxes: axes)) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
LogSumexp (ตามกฎหมาย :)
ส่งคืน log(exp(self).sum(alongAxes: axes)) ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum(alongAxes: axes)) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func logSumExp(alongAxes axes: [Int]) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
LogSumexp (ตามกฎหมาย :)
ส่งคืน log(exp(self).sum(alongAxes: axes)) ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
ฟังก์ชั่นนี้มีความเสถียรเชิงตัวเลขมากกว่า log(exp(self).sum(alongAxes: axes)) โดยตรง มันหลีกเลี่ยงการล้นที่เกิดจากการคำนวณ exp ของอินพุตขนาดใหญ่และ underflows ที่เกิดจากการคำนวณ log ของอินพุตขนาดเล็ก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func logSumExp(alongAxes axes: Int...) -> Tensor
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ช่วงเวลา (บีบบีบ :)
ส่งคืนค่าเฉลี่ยและความแปรปรวนของเทนเซอร์นี้ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
axes ต้องมีอันดับ 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ช่วงเวลา (บีบบีบ :)
ส่งคืนค่าเฉลี่ยและความแปรปรวนของเทนเซอร์นี้ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ช่วงเวลา (บีบบีบ :)
ส่งคืนค่าเฉลี่ยและความแปรปรวนของเทนเซอร์นี้ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกลบออก
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ช่วงเวลา ()
ส่งคืนค่าเฉลี่ยและความแปรปรวนขององค์ประกอบของเทนเซอร์นี้
การประกาศ
@differentiable(wrt: self) public func moments() -> Moments<Scalar>
ช่วงเวลา (onlowaxes :)
ส่งคืนค่าเฉลี่ยและความแปรปรวนของเทนเซอร์นี้ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
axes ต้องมีอันดับ 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ช่วงเวลา (onlowaxes :)
ส่งคืนค่าเฉลี่ยและความแปรปรวนของเทนเซอร์นี้ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func moments(alongAxes axes: [Int]) -> Moments<Scalar>
พารามิเตอร์
axes
ขนาดที่ต้องลด.
ช่วงเวลา (onlowaxes :)
ส่งคืนค่าเฉลี่ยและความแปรปรวนของเทนเซอร์นี้ตามแกนที่ระบุ ขนาดที่ลดลงจะถูกเก็บไว้ด้วยค่า 1
เงื่อนไขเบื้องต้น
แต่ละค่าใน axes จะต้องอยู่ในช่วง -rank..<rank
การประกาศ
@differentiable(wrt: self) public func moments(alongAxes axes: Int...) -> Moments<Scalar>
พารามิเตอร์
axes
ขนาดที่ต้องลด.

มีให้ที่ `scalar`:` numeric`

• (_: _ :)
ทำการคูณเมทริกซ์ระหว่างสองเทนเซอร์และสร้างผลลัพธ์
การประกาศ
@differentiable public static func • (lhs: Tensor, rhs: Tensor) -> Tensor

มีให้ที่ `scalar`:` tensorflowfloatingpoint '

VJPinitDeviceAndPrecisionlike (_: deviceAndprecisionlike :)

การประกาศ

static func vjpInitDeviceAndPrecisionLike(
  _ value: Scalar,
  deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))

batchnormalized (ตามแนว: ออฟเซ็ต: สเกล: epsilon :)

ส่งคืนเทนเซอร์ที่คำนวณจากการกำหนดอินพุตแบบเป็นแบทช์ตามแนวแกนที่ระบุ

โดยเฉพาะผลตอบแทน (self - mu) / (var + epsilon) * gamma + beta โดยที่ mu และ var เป็นตามลำดับความแปรปรวนและความแปรปรวนของ self ตาม axis

การประกาศ

@differentiable(wrt: (self, offset, scale)
public func batchNormalized(
  alongAxis axis: Int,
  offset: Tensor = Tensor(0),
  scale: Tensor = Tensor(1),
  epsilon: Scalar = 0.001
) -> Tensor

พารามิเตอร์

`axis`	มิติชุด
`offset`	ออฟเซ็ตหรือที่รู้จักกันในชื่อเบต้า
`scale`	สเกลหรือที่รู้จักกันในชื่อแกมม่า
`epsilon`	ค่าเล็ก ๆ ที่เพิ่มเข้ามาในตัวส่วนเพื่อความมั่นคงเชิงตัวเลข

concatenate (_: _ :)
เชื่อมต่อสองเทนเซอร์ตามแกนสุดท้าย
การประกาศ
@differentiable public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
ผลรวม (_: _ :)
เพิ่มสองค่าและสร้างผลรวมของพวกเขา
การประกาศ
@differentiable public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
เฉลี่ย(_:_:)
ค่าเฉลี่ยสองค่า
การประกาศ
@differentiable public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

คูณ(_:_:)

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

การประกาศ

@differentiable
public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

ซ้อนกัน(_:_:)

สแต็คสองค่า

การประกาศ

@differentiable
public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

init (รูปร่าง :)
การประกาศ
@derivative init(shape: scalars)

มีให้ที่ `scalar`:` equatable '

== (_: _ :)

การประกาศ

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

! = (_: _ :)

การประกาศ

public static func != (lhs: Tensor, rhs: Tensor) -> Bool

พร้อมใช้งานที่ `scalar`:` codable '

เข้ารหัส (ถึง :)
การประกาศ
public func encode(to encoder: Encoder) throws

init (จาก :)

การประกาศ

public init(from decoder: Decoder) throws

มีให้ที่ `scalar`:` numeric`

ศูนย์
เทนเซอร์ศูนย์สเกลาร์
ศูนย์
การประกาศ
public static var zero: Tensor { get }
+(_: _ :)
เพิ่มสองเทนเซอร์และสร้างผลรวมของพวกเขา
บันทึก
+ รองรับการออกอากาศ
การประกาศ
@differentiable public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
-(_: _ :)
ลบหนึ่งเทนเซอร์จากอีกตัวหนึ่งและสร้างความแตกต่าง
บันทึก
- รองรับการออกอากาศ
การประกาศ
@differentiable public static func - (lhs: Tensor, rhs: Tensor) -> Tensor
หนึ่ง
สเกลาร์หนึ่งเทนเซอร์
การประกาศ
public static var one: Tensor { get }
ซึ่งกันและกัน
ส่งคืนค่าซึ่งกันและกันของ self
การประกาศ
public var reciprocal: Tensor { get }
.*(_: _ :)
ทวีคูณสองเทนเซอร์องค์ประกอบที่ชาญฉลาดและผลิตผลิตภัณฑ์ของพวกเขา
บันทึก
.* รองรับการออกอากาศ
การประกาศ
public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor

มีให้ที่ `scalar`:` tensorflowfloatingpoint '

แทนเจนต์เวกเตอร์
การประกาศ
public typealias TangentVector = Tensor

ZeroTangentVectorInitializer

การประกาศ

public var zeroTangentVectorInitializer: () -> TangentVector { get }

ใส่คำอธิบายประกอบ(_:)
เพิ่มคำอธิบายประกอบ
หมายเหตุ: รองรับ X10 เท่านั้น สำหรับแบ็กเอนด์อื่น ๆ self ของ Umodified จะถูกส่งคืน
คำประกาศ
@differentiable(wrt: self) public func annotate(_ annotation: String) -> Tensor<Scalar>
พารามิเตอร์
annotation
คำอธิบายประกอบที่จะเพิ่ม
ค่าส่งคืน
เทนเซอร์หมายเหตุประกอบ

vjpannotate (_ :)

การประกาศ

@derivative
func vjpAnnotate(_ annotation: String) -> (
  value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar>
)

`count`	จำนวนการแยกที่จะสร้าง
`axis`	มิติที่ใช้แยกเทนเซอร์นี้ ค่าลบล้อมรอบ

`indices`	ประกอบด้วยดัชนีที่จะรวบรวมที่
`axis`	มิติที่จะรวบรวม ค่าลบล้อมรอบ

`lowerBounds`	ขอบเขตล่างของแต่ละมิติ
`upperBounds`	ขอบเขตบนของแต่ละมิติ

`shape`	ขนาดของเทนเซอร์
`repeatedValue`	ค่าสเกลาร์ที่จะทำซ้ำ

`tensors`	เทนเซอร์ที่จะกองซ้อน
`axis`	มิติตามที่จะกองซ้อน ค่าลบล้อมรอบ

`tensors`	เทนเซอร์ที่จะเชื่อมต่อกัน
`axis`	มิติที่จะต่อกัน ค่าลบล้อมรอบ

`shape`	รูปร่างของเทนเซอร์
`scalars`	เนื้อหาสเกลาร์ของเทนเซอร์