Tensor

@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: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
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

Mảng đa chiều gồm các phần tử là sự tổng quát hóa của vectơ và ma trận thành các chiều có khả năng cao hơn.

Tham số chung Scalar mô tả loại đại số vô hướng trong tensor (chẳng hạn như Int32 , Float , v.v.).

  • TensorHandle cơ bản.

    Ghi chú

    handle là công khai để cho phép các hoạt động do người dùng xác định, nhưng thông thường không nên sử dụng.

    Tuyên ngôn

    public let handle: TensorHandle<Scalar>

  • Tuyên ngôn

    public init(handle: TensorHandle<Scalar>)

  • Giải nén kích thước đã cho của một tenxơ hạng R thành nhiều tenxơ hạng (R-1) . Giải nén N tensor khỏi tensor này bằng cách cắt nó dọc theo chiều axis , trong đó N được suy ra từ hình dạng của tensor này. Ví dụ: cho một tensor có hình dạng [A, B, C, D] :

    • Nếu axis == 0 thì tensor thứ i trong mảng được trả về là lát self[i, :, :, :] và mỗi tensor trong mảng đó sẽ có hình dạng [B, C, D] . (Lưu ý rằng kích thước được giải nén sẽ biến mất, không giống như Tensor.split(numSplits:alongAxis) hoặc Tensor.split(sizes:alongAxis) ).
    • Nếu axis == 1 thì tensor thứ i trong mảng được trả về là slice value[:, i, :, :] và mỗi tensor trong mảng đó sẽ có hình dạng [A, C, D] .
    • Vân vân.

    Điều này trái ngược với Tensor.init(stacking:alongAxis:) .

    điều kiện tiên quyết

    axis phải nằm trong phạm vi [-rank, rank) , trong đó rank là hạng của các tensor được cung cấp.

    Tuyên ngôn

    @differentiable
public func unstacked(alongAxis axis: Int = 0) -> [Tensor]

    Thông số

    axis

    Kích thước dọc theo đó để giải nén. Các giá trị âm bao bọc xung quanh.

    Giá trị trả về

    Mảng chứa các tensor chưa được xếp chồng lên nhau.

  • Tách một tensor thành nhiều tensor. Tensor được chia dọc theo axis kích thước thành các count nhỏ hơn. Điều này đòi hỏi count chia đều cho shape[axis] .

    Ví dụ:

    // '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]

    điều kiện tiên quyết

    count phải chia đều kích thước của axis kích thước.

    điều kiện tiên quyết

    axis phải nằm trong phạm vi [-rank, rank) , trong đó rank là hạng của các tensor được cung cấp.

    Tuyên ngôn

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

    Thông số

    count

    Số lượng phần tách để tạo.

    axis

    Kích thước để phân chia tensor này. Các giá trị âm bao bọc xung quanh.

    Giá trị trả về

    Một mảng chứa phần tensor.

  • Tách một tensor thành nhiều tensor. Tensor được chia thành các phần sizes.shape[0] . Hình dạng của mảnh thứ i có hình dạng giống như tensor này ngoại trừ dọc theo axis kích thước có kích thước sizes[i] .

    Ví dụ:

    // '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]

    điều kiện tiên quyết

    Các giá trị về sizes phải cộng lại bằng kích thước của axis thứ nguyên .

    điều kiện tiên quyết

    axis phải nằm trong phạm vi [-rank, rank) , trong đó rank là hạng của các tensor được cung cấp.

    Tuyên ngôn

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

    Thông số

    sizes

    Tenor 1-D chứa kích thước của mỗi phần phân chia.

    axis

    Kích thước dọc theo đó để phân chia tensor này. Các giá trị âm bao bọc xung quanh.

    Giá trị trả về

    Mảng chứa các phần tensor.

  • Tuyên ngôn

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

  • Trả về một tenxơ xếp kề, được xây dựng bằng cách xếp kề tenxơ này.

    Hàm tạo này tạo ra một tensor mới bằng cách sao chép tensor này multiples lần. Chiều thứ i của tensor được xây dựng có các phần tử self.shape[i] * multiples[i] và các giá trị của tensor này được sao chép multiples[i] lần dọc theo chiều i . Ví dụ: xếp [abcd] theo [2] sẽ tạo ra [abcdabcd] .

    điều kiện tiên quyết

    rank dự kiến ​​của bội số phải là 1 .

    điều kiện tiên quyết

    Hình dạng của multiples phải là [tensor.rank] .

    điều kiện tiên quyết

    Tất cả các số vô hướng trong multiples phải không âm.

    Tuyên ngôn

    @differentiable(wrt: self)
public func tiled(multiples: [Int]) -> Tensor

  • Trả về một tenxơ xếp kề, được xây dựng bằng cách xếp kề tenxơ này.

    Hàm tạo này tạo ra một tensor mới bằng cách sao chép tensor này multiples lần. Chiều thứ i của tensor được xây dựng có các phần tử self.shape[i] * multiples[i] và các giá trị của tensor này được sao chép multiples[i] lần dọc theo chiều i . Ví dụ: xếp [abcd] theo [2] sẽ tạo ra [abcdabcd] .

    điều kiện tiên quyết

    rank dự kiến ​​của bội số phải là 1 .

    điều kiện tiên quyết

    Hình dạng của multiples phải là [tensor.rank] .

    Tuyên ngôn

    @differentiable(wrt: self)
public func tiled(multiples: Tensor<Int32>) -> Tensor

  • Định hình lại hình dạng của Tensor đã chỉ định.

    điều kiện tiên quyết

    Số lượng vô hướng phù hợp với hình dạng mới.

    Tuyên ngôn

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

  • Định hình lại hình dạng đã chỉ định.

    điều kiện tiên quyết

    Số lượng vô hướng phù hợp với hình dạng mới.

    Tuyên ngôn

    @differentiable(wrt: self)
public func reshaped(to newShape: TensorShape) -> Tensor

  • Định hình lại Tensor được chỉ định đại diện cho một hình dạng.

    điều kiện tiên quyết

    Số lượng vô hướng phù hợp với hình dạng mới.

    Tuyên ngôn

    @differentiable(wrt: self)
public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor

  • Trả về một bản sao của tenxơ được thu gọn thành Tensor 1-D, theo thứ tự hàng lớn.

    Tuyên ngôn

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

  • Trả về một Tensor được mở rộng về hình dạng, với kích thước là 1 được chèn vào các chỉ số hình dạng đã chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func expandingShape(at axes: Int...) -> Tensor

  • Trả về một Tensor được mở rộng về hình dạng, với kích thước là 1 được chèn vào các chỉ số hình dạng đã chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func expandingShape(at axes: [Int]) -> Tensor

  • Trả về một Tensor được nâng cấp với thứ nguyên ở đầu là 1.

    Tuyên ngôn

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

  • Loại bỏ các kích thước được chỉ định có kích thước 1 khỏi hình dạng của tensor. Nếu không có thứ nguyên nào được chỉ định thì tất cả thứ nguyên có kích thước 1 sẽ bị xóa.

    Tuyên ngôn

    @differentiable(wrt: self)
public func squeezingShape(at axes: Int...) -> Tensor

  • Loại bỏ các kích thước được chỉ định có kích thước 1 khỏi hình dạng của tensor. Nếu không có thứ nguyên nào được chỉ định thì tất cả thứ nguyên có kích thước 1 sẽ bị xóa.

    Tuyên ngôn

    @differentiable(wrt: self)
public func squeezingShape(at axes: [Int]) -> Tensor

  • Trả về một tenxơ chuyển đổi, với các kích thước được hoán vị theo thứ tự đã chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func transposed(permutation: Tensor<Int32>) -> Tensor

  • Trả về một tenxơ chuyển đổi, với các kích thước được hoán vị theo thứ tự đã chỉ định.

    Tuyên ngôn

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor

  • Trả về một tenxơ chuyển đổi, với các kích thước được hoán vị theo thứ tự đã chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func transposed(permutation: [Int]) -> Tensor

  • Trả về một tenxơ chuyển đổi, với các kích thước được hoán vị theo thứ tự đã chỉ định.

    Tuyên ngôn

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: [Int]) -> Tensor

  • Trả về một tenxơ chuyển đổi, với các kích thước được hoán vị theo thứ tự đã chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func transposed(permutation: Int...) -> Tensor

  • Trả về một tenxơ chuyển đổi, với các kích thước được hoán vị theo thứ tự đã chỉ định.

    Tuyên ngôn

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Int...) -> Tensor

  • Trả về một tensor chuyển vị, với các kích thước được hoán vị theo thứ tự ngược lại.

    Tuyên ngôn

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

  • Trả về một tensor có kích thước được chỉ định bị đảo ngược.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    điều kiện tiên quyết

    Không được có sự trùng lặp trong axes .

    Tuyên ngôn

    @differentiable(wrt: self)
public func reversed(inAxes axes: Tensor<Int32>) -> Tensor

  • Trả về một tensor có kích thước được chỉ định bị đảo ngược.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    điều kiện tiên quyết

    Không được có sự trùng lặp trong axes .

    Tuyên ngôn

    @differentiable(wrt: self)
public func reversed(inAxes axes: [Int]) -> Tensor

  • Trả về một tensor có kích thước được chỉ định bị đảo ngược.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    điều kiện tiên quyết

    Không được có sự trùng lặp trong axes .

    Tuyên ngôn

    @differentiable(wrt: self)
public func reversed(inAxes axes: Int...) -> Tensor

  • Trả về một tenxơ được nối dọc theo trục đã chỉ định.

    điều kiện tiên quyết

    Các tensor phải có cùng kích thước, ngoại trừ trục được chỉ định.

    điều kiện tiên quyết

    Trục phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable
public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor

  • Điều hành nối.

    Ghi chú

    ++ là một toán tử tùy chỉnh không tồn tại trong Swift nhưng có trong Haskell/Scala. Sự bổ sung của nó không phải là một sự thay đổi ngôn ngữ không đáng kể và có thể gây tranh cãi. Sự tồn tại/đặt tên của ++ sẽ được thảo luận trong giai đoạn thiết kế API sau này.

    Tuyên ngôn

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

  • Trả về một tensor bằng cách tập hợp các lát cắt của đầu vào tại indices dọc theo kích thước axis

    Đối với indices 0-D (vô hướng):

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

    Đối với indices 1-D (vectơ):

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

    Trong trường hợp tổng quát, tạo ra một tensor kết quả trong đó:

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

    trong đó N = self.rank và M = indices.rank .

    Hình dạng của tenxơ thu được là: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

    Ghi chú

    Trên CPU, nếu tìm thấy chỉ mục ngoài phạm vi, sẽ xảy ra lỗi. Trên GPU, nếu tìm thấy chỉ mục ngoài phạm vi, số 0 sẽ được lưu trong các giá trị đầu ra tương ứng.

    điều kiện tiên quyết

    axis phải nằm trong phạm vi [-rank, rank) .

    Tuyên ngôn

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

    Thông số

    indices

    Chứa các chỉ số để thu thập tại.

    axis

    Kích thước dọc theo đó để thu thập. Các giá trị âm bao bọc xung quanh.

    Giá trị trả về

    Các tensor tập hợp.

  • Trả về các lát cắt của tenxơ này tại indices dọc theo kích thước axis , đồng thời bỏ qua các kích thước batchDimensionCount đầu tiên tương ứng với các kích thước lô. Việc thu thập được thực hiện dọc theo chiều không theo đợt đầu tiên.

    Thực hiện chức năng tương tự như gathering , ngoại trừ hình dạng tensor kết quả bây giờ là shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

    điều kiện tiên quyết

    axis phải nằm trong phạm vi -rank..<rank , đồng thời lớn hơn hoặc bằng batchDimensionCount .

    điều kiện tiên quyết

    batchDimensionCount phải nhỏ indices.rank .

    Tuyên ngôn

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

    Thông số

    indices

    Chứa các chỉ số để thu thập.

    axis

    Kích thước dọc theo đó để thu thập. Các giá trị âm bao bọc xung quanh.

    batchDimensionCount

    Số thứ nguyên lô hàng đầu cần bỏ qua.

    Giá trị trả về

    Các tensor tập hợp.

  • Trả về một tensor bằng cách thu thập các giá trị sau khi áp dụng mặt nạ boolean được cung cấp cho đầu vào.

    Ví dụ:

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

    Nói chung, 0 < mask.rank = K <= tensor.rank và hình dạng của mask phải khớp với K kích thước đầu tiên của hình dạng của tensor . Khi đó chúng ta có: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] [i1, ..., iK] là mục nhập true i của mask (thứ tự hàng chính).

    axis có thể được sử dụng với mask để chỉ ra trục cần che. Trong trường hợp đó, axis + mask.rank <= tensor.rank và 's shape must match the first mask phải khớp với dimensions of the hình dạng của tenxơ.

    điều kiện tiên quyết

    mask không thể là vô hướng: mask.rank != 0 .

    Tuyên ngôn

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

    Thông số

    mask

    Tenxơ boolean KD, trong đó K <= self.rank .

    axis

    Tenor số nguyên 0-D biểu thị trục self che giấu từ đó, trong đó K + axis <= self.rank .

    Giá trị trả về

    (self.rank - K + 1) tensor chiều được điền bởi các mục trong tensor này tương ứng với các giá trị true trong mask .

  • Trả về vị trí của các giá trị khác 0/đúng trong tensor này.

    Tọa độ được trả về trong một tenxơ 2-D trong đó chiều thứ nhất (hàng) biểu thị số phần tử khác 0 và chiều thứ hai (cột) biểu thị tọa độ của các phần tử khác 0. Hãy nhớ rằng hình dạng của tensor đầu ra có thể thay đổi tùy thuộc vào số lượng giá trị thực có trong tensor này. Các chỉ số được xuất theo thứ tự hàng lớn.

    Ví dụ:

    // '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]]

    Tuyên ngôn

    public func nonZeroIndices() -> Tensor<Int64>

    Giá trị trả về

    Một tensor có hình dạng (num_true, rank(condition)) .

  • Tuyên ngôn

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

  • Tuyên ngôn

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

  • Phát sóng theo hình dạng giống như Tensor được chỉ định.

    điều kiện tiên quyết

    Hình dạng được chỉ định phải tương thích để phát sóng.

    Tuyên ngôn

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

  • Tuyên ngôn

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

  • Trích xuất một lát cắt từ tensor được xác định bởi giới hạn dưới và giới hạn trên cho mỗi chiều.

    Tuyên ngôn

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

    Thông số

    lowerBounds

    Giới hạn dưới ở mỗi chiều.

    upperBounds

    Giới hạn trên ở mỗi chiều.

  • Tuyên ngôn

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

  • Tuyên ngôn

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

  • Tuyên ngôn

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

  • Kiểm tra xem mỗi phần tử của axes có biểu thị một trục của self hay không và dừng chương trình bằng chẩn đoán ngược lại.

    Tuyên ngôn

    func ensureValid(
  axes: Tensor<Int32>,
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • Kiểm tra xem mỗi phần tử của axes có biểu thị một trục của self hay không và dừng chương trình bằng chẩn đoán ngược lại.

    Tuyên ngôn

    func ensureValid(
  axes: [Int],
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • Kiểm tra xem k biểu thị một trục của self và dừng chương trình bằng chẩn đoán khác.

    Tuyên ngôn

    func ensureValid(
  axis k: Int,
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • Tuyên ngôn

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

  • Tạo một bản sao của other trên Device đã cho.

    Tuyên ngôn

    public init(copying other: Tensor, to device: Device)

  • Tạo một tensor có hình dạng xác định và một giá trị vô hướng lặp lại.

    Tuyên ngôn

    @available(*, deprecated, renamed: "init(repeating:shape:﹚")
public init(shape: TensorShape, repeating repeatedValue: Scalar)

    Thông số

    shape

    Kích thước của tensor

    repeatedValue

    Giá trị vô hướng cần lặp lại.

  • Tạo một tensor có hình dạng xác định và một giá trị vô hướng lặp lại.

    Tuyên ngôn

    @differentiable
public init(
  repeating repeatedValue: Scalar, shape: TensorShape,
  on device: Device = .default
)

    Thông số

    repeatedValue

    Giá trị vô hướng cần lặp lại.

    shape

    Kích thước của tensor

  • Tạo một tensor bằng cách truyền bá vô hướng đã cho đến một hạng nhất định với tất cả các chiều là 1.

    Tuyên ngôn

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)

  • Tạo một tensor từ một mảng tensor (mà bản thân chúng có thể là vô hướng).

    Tuyên ngôn

    @differentiable
public init(_ elements: [Tensor])

  • Xếp chồng tensors , dọc theo axis , thành một tensor mới có hạng cao hơn một tensor hiện tại và mỗi tensor trong tensors .

    Cho rằng tất cả tensors đều có hình dạng [A, B, C] và tensors.count = N , thì:

    • nếu axis == 0 thì tensor kết quả sẽ có hình dạng [N, A, B, C] .
    • nếu axis == 1 thì tensor kết quả sẽ có hình dạng [A, N, B, C] .
    • vân vân.

    Ví dụ:

    // '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]]

    Điều này trái ngược với Tensor.unstacked(alongAxis:) .

    điều kiện tiên quyết

    Tất cả các tensor phải có hình dạng giống nhau.

    điều kiện tiên quyết

    axis phải nằm trong phạm vi [-rank, rank) , trong đó rank là hạng của các tensor được cung cấp.

    Tuyên ngôn

    @differentiable
public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)

    Thông số

    tensors

    Tensor để xếp chồng lên nhau.

    axis

    Kích thước dọc theo để xếp chồng lên nhau. Các giá trị âm bao bọc xung quanh.

    Giá trị trả về

    Tenxơ xếp chồng lên nhau.

  • Nối tensors dọc theo kích thước axis .

    Cho rằng tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , thì kết quả được nối có hình dạng [D0, D1, ... Raxis, ...Dn] , trong đó Raxis = sum(Daxis(i)) . Nghĩa là, dữ liệu từ các tensor đầu vào được nối dọc theo kích thước axis .

    Ví dụ:

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

    Ghi chú

    Nếu bạn đang nối dọc theo một trục mới, hãy cân nhắc sử dụng Tensor.init(stacking:alongAxis:) .

    điều kiện tiên quyết

    Tất cả các tensor phải có cùng thứ hạng và tất cả các kích thước ngoại trừ axis phải bằng nhau.

    điều kiện tiên quyết

    axis phải nằm trong phạm vi [-rank, rank) , trong đó rank là hạng của các tensor được cung cấp.

    Tuyên ngôn

    @differentiable
public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)

    Thông số

    tensors

    Tensors để nối.

    axis

    Kích thước dọc theo để nối. Các giá trị âm bao bọc xung quanh.

    Giá trị trả về

    Tenxơ nối.

  • Thay thế các phần tử của tenxơ này bằng other trong các làn có mask true .

    điều kiện tiên quyết

    self và other phải có hình dạng giống nhau. Nếu self và other là vô hướng thì mask cũng phải là vô hướng. Nếu self và other có thứ hạng lớn hơn hoặc bằng 1 thì mask phải có hình dạng giống với self hoặc là Tensor 1-D sao cho mask.scalarCount == self.shape[0] .

    Tuyên ngôn

    @differentiable(wrt: (self, other)
) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor

  • Trả về true nếu loại vô hướng vật lý bị giảm độ chính xác.

    Hiện tại, các loại vô hướng vật lý có độ chính xác giảm chỉ bao gồm BFloat16 .

    Tuyên ngôn

    public var isReducedPrecision: Bool { get }

  • Tăng cường một đại lượng vô hướng thành một tenxơ có cùng thiết bị và độ chính xác như tenxơ đã cho.

    Tuyên ngôn

    @differentiable
public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)

  • Trả về một bản sao của self được chuyển đổi thành loại vô hướng vật lý BFloat16 .

    Tuyên ngôn

    public var toReducedPrecision: `Self` { get }

  • Trả về một bản sao của self được chuyển đổi thành kiểu vô hướng vật lý Scalar .

    Tuyên ngôn

    public var toFullPrecision: `Self` { get }

  • Số chiều của Tensor .

    Tuyên ngôn

    public var rank: Int { get }

  • Hình dạng của Tensor .

    Tuyên ngôn

    public var shape: TensorShape { get }

  • Số lượng vô hướng trong Tensor .

  • Tuyên ngôn

    public var scalarCount: Int { get }

  • Thứ hạng của tensor, được biểu thị dưới dạng Tensor<Int32> .

    Tuyên ngôn

    public var rankTensor: Tensor<Int32> { get }

  • Kích thước của tensor, được biểu thị dưới dạng Tensor<Int32> .

    Tuyên ngôn

    public var shapeTensor: Tensor<Int32> { get }

  • Số lượng vô hướng trong tensor, được biểu thị dưới dạng Tensor<Int32> .

    Tuyên ngôn

    public var scalarCountTensor: Tensor<Int32> { get }

  • Trả về true nếu rank bằng 0 và false nếu ngược lại.

    Tuyên ngôn

    public var isScalar: Bool { get }

  • Trả về phần tử vô hướng đơn nếu rank bằng 0 và nil nếu ngược lại.

    Tuyên ngôn

    public var scalar: Scalar? { get }

  • Định hình lại thành vô hướng.

    điều kiện tiên quyết

    Tensor có đúng một đại lượng vô hướng.

    Tuyên ngôn

    @differentiable
public func scalarized() -> Scalar

  • Tuyên ngôn

    public var array: ShapedArray<Scalar> { get }

  • Tuyên ngôn

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

  • Tạo một tensor 0-D từ một giá trị vô hướng.

    Tuyên ngôn

    @differentiable
public init(_ value: Scalar, on device: Device = .default)

  • Tạo một tensor 1D từ các đại lượng vô hướng.

    Tuyên ngôn

    @differentiable
public init(_ scalars: [Scalar], on device: Device = .default)

  • Tạo một tensor 1D từ các đại lượng vô hướng.

    Tuyên ngôn

    public init<C: Collection>(
  _ vector: C, on device: Device = .default
) where C.Element == Scalar

  • Tạo một tensor có hình dạng xác định và các đại lượng vô hướng liền kề theo thứ tự hàng lớn.

    điều kiện tiên quyết

    Tích các kích thước của hình phải bằng số vô hướng.

    Tuyên ngôn

    @differentiable
public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)

    Thông số

    shape

    Hình dạng của tensor.

    scalars

    Nội dung vô hướng của tensor.

  • Tạo một tensor có hình dạng xác định và các đại lượng vô hướng liền kề theo thứ tự hàng lớn.

    điều kiện tiên quyết

    Tích các kích thước của hình phải bằng số vô hướng.

    Tuyên ngôn

    public init(
  shape: TensorShape,
  scalars: UnsafeBufferPointer<Scalar>,
  on device: Device = .default
)

    Thông số

    shape

    Hình dạng của tensor.

    scalars

    Nội dung vô hướng của tensor.

  • Tạo một tensor có hình dạng xác định và các đại lượng vô hướng liền kề theo thứ tự hàng lớn.

    điều kiện tiên quyết

    Tích các kích thước của hình phải bằng số vô hướng.

  • Tạo một tensor có hình dạng xác định và các đại lượng vô hướng liền kề theo thứ tự hàng lớn.

    điều kiện tiên quyết

    Tích các kích thước của hình phải bằng số vô hướng.

    Tuyên ngôn

    public init<C: Collection>(
  shape: TensorShape, scalars: C, on device: Device = .default
) where C.Element == Scalar

    Thông số

    shape

    Hình dạng của tensor.

    scalars

    Nội dung vô hướng của tensor.

  • Kiểu của các phần tử của một mảng bằng chữ.

    Tuyên ngôn

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • Tạo một tensor được khởi tạo với các phần tử đã cho.

    Tuyên ngôn

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)

  • Một biểu diễn văn bản của tensor.

    Ghi chú

    sử dụng fullDescription cho mô tả không được in đẹp hiển thị tất cả các đại lượng vô hướng.

    Tuyên ngôn

    public var description: String { get }

  • Một biểu diễn văn bản của tensor. Trả về mô tả tóm tắt nếu summarize là đúng và số phần tử vượt quá hai lần edgeElementCount .

    Tuyên ngôn

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

    Thông số

    lineWidth

    Độ rộng dòng tối đa để in. Được sử dụng để xác định số lượng vô hướng cần in trên mỗi dòng.

    edgeElementCount

    Số phần tử tối đa cần in trước và sau khi tóm tắt thông qua dấu ba chấm ( ... ).

    summarizing

    Nếu đúng, hãy tóm tắt mô tả nếu số phần tử vượt quá hai lần edgeElementCount .

  • Một biểu diễn văn bản đầy đủ, không in đẹp của tensor, hiển thị tất cả các đại lượng vô hướng.

    Tuyên ngôn

    public var fullDescription: String { get }

  • Tuyên ngôn

    public var playgroundDescription: Any { get }

  • Tuyên ngôn

    public var customMirror: Mirror { get }

  • Các chú thích mô tả tensor này.

    Tuyên ngôn

    public var annotations: String { get }

  • Bí danh cho chú thích.

    Tuyên ngôn

    public var summary: String { get }

  • Tuyên ngôn

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)

  • Tuyên ngôn

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

  • Tuyên ngôn

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

  • Tuyên ngôn

    init(_xla: XLATensor)

  • Tuyên ngôn

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • Tuyên ngôn

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • Tuyên ngôn

    var xlaTensor: XLATensor { get }
Có sẵn ở nơi `Vô hướng`: `Số`

  • Tuyên ngôn

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

  • Tuyên ngôn

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

  • Tuyên ngôn

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

  • Một chế độ quy định cách đệm một tensor.

    Tuyên ngôn

    public enum PaddingMode

  • Trả về một tensor được đệm với hằng số theo kích thước đệm được chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
  -> Tensor

  • Trả về một tenxơ đệm theo kích thước và chế độ đệm đã chỉ định.

    Tuyên ngôn

    @differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
Có sẵn ở nơi `Vô hướng`: `Số` & `Có thể so sánh`

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs < rhs theo từng phần tử.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs <= rhs theo từng phần tử.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs > rhs theo từng phần tử.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs >= rhs theo từng phần tử.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs < rhs theo từng phần tử.

    Ghi chú

    .< hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs <= rhs theo từng phần tử.

    Ghi chú

    .<= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs > rhs theo từng phần tử.

    Ghi chú

    .> hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs >= rhs theo từng phần tử.

    Ghi chú

    .>= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs < rhs theo từng phần tử.

    Ghi chú

    .< hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs <= rhs theo từng phần tử.

    Ghi chú

    .<= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs > rhs theo từng phần tử.

    Ghi chú

    .> hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs >= rhs theo từng phần tử.

    Ghi chú

    .>= hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Có sẵn ở nơi `Scalar`: `Equatable`

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs == rhs theo từng phần tử.

    Ghi chú

    .== hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs != rhs theo từng phần tử.

    Ghi chú

    .!= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs == rhs theo từng phần tử.

    Ghi chú

    .== hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs != rhs theo từng phần tử.

    Ghi chú

    .!= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs == rhs theo từng phần tử.

    Ghi chú

    .== hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về một tenxơ của các đại lượng vô hướng Boolean bằng cách tính lhs != rhs theo từng phần tử.

    Ghi chú

    .!= hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Có sẵn ở `Scalar`: `TensorFlowFloatingPoint` & `Equatable`

  • Trả về một tenxơ chứa các giá trị Boolean cho biết các phần tử của self có xấp xỉ bằng các phần tử của phần other không.

    điều kiện tiên quyết

    self và other phải có hình dạng giống nhau.

    Tuyên ngôn

    public func elementsAlmostEqual(
  _ other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`

  • Trả về true nếu tất cả các phần tử của self xấp xỉ bằng các phần tử của phần other .

    điều kiện tiên quyết

    self và other phải có hình dạng giống nhau.

    Tuyên ngôn

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
Có sẵn ở nơi `Scalar`: `TensorFlowNumeric`

  • Chạy tổng bản sao chéo cho tensor này. Tổng số bản sao chéo tương tự phải xảy ra trên mỗi thiết bị khác tham gia vào tổng.

    Tuyên ngôn

    public mutating mutating func crossReplicaSum(_ scale: Double)
Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`
Có sẵn ở nơi `Vô hướng`: `Số`

  • Thực hiện chuyển đổi loại phần tử từ tenxơ Bool .

    Tuyên ngôn

    public init(_ other: Tensor<Bool>)

  • Thực hiện chuyển đổi theo từng phần tử từ một Tensor khác.

    Tuyên ngôn

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`
Có sẵn ở nơi `Vô hướng`: `Số`

  • Tạo một tensor với tất cả các đại lượng vô hướng được đặt bằng 0.

    Tuyên ngôn

    public init(zeros shape: TensorShape, on device: Device = .default)

    Thông số

    shape

    Hình dạng của tensor.

  • Tạo một tensor với tất cả các đại lượng vô hướng được đặt thành một.

    Tuyên ngôn

    public init(ones shape: TensorShape, on device: Device = .default)

    Thông số

    shape

    Hình dạng của tensor.

  • Tạo một tensor với tất cả các đại lượng vô hướng được đặt bằng 0, có hình dạng và kiểu giống như tensor được cung cấp.

    Tuyên ngôn

    public init(zerosLike other: Tensor)

    Thông số

    other

    Tensor có hình dạng và kiểu dữ liệu để sử dụng.

  • Tạo một tensor với tất cả các đại lượng vô hướng được đặt thành một tensor có hình dạng và kiểu giống như tensor được cung cấp.

    Tuyên ngôn

    public init(onesLike other: Tensor)

    Thông số

    other

    Tensor có hình dạng và kiểu dữ liệu để sử dụng.

  • Tạo một tenxơ 1-D biểu thị một chuỗi từ giá trị bắt đầu đến nhưng không bao gồm giá trị cuối, tăng dần theo số lượng được chỉ định.

    Tuyên ngôn

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

    Thông số

    start

    Giá trị bắt đầu được sử dụng cho chuỗi. Nếu chuỗi chứa bất kỳ giá trị nào thì giá trị đầu tiên là start .

    end

    Một giá trị cuối để giới hạn trình tự. end không bao giờ là một phần tử của chuỗi kết quả.

    stride

    Số lượng từng bước với mỗi lần lặp. stride phải dương.

  • Tạo một tenxơ 1-D biểu thị một chuỗi từ giá trị bắt đầu đến nhưng không bao gồm giá trị cuối, tăng dần theo số lượng được chỉ định.

    Tuyên ngôn

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

    Thông số

    start

    Giá trị bắt đầu được sử dụng cho chuỗi. Nếu chuỗi chứa bất kỳ giá trị nào thì giá trị đầu tiên là start .

    end

    Một giá trị cuối để giới hạn trình tự. end không bao giờ là một phần tử của chuỗi kết quả.

    stride

    Số lượng từng bước với mỗi lần lặp. stride phải dương.

  • Tạo một tensor nóng tại các chỉ số nhất định. Các vị trí được biểu thị bằng indices nhận giá trị onValue ( 1 theo mặc định), trong khi tất cả các vị trí khác lấy giá trị offValue ( 0 theo mặc định). Nếu indices đầu vào là hạng n thì tensor mới sẽ có hạng n+1 . Trục mới được tạo tại axis kích thước (theo mặc định, trục mới được thêm vào cuối).

    Nếu indices là vô hướng thì hình dạng của tenxơ mới sẽ là một vectơ có độ dài depth .

    Nếu indices là một vectơ có độ dài features , thì hình dạng đầu ra sẽ là: các đặc điểm x độ sâu, nếu trục == -1 độ sâu x các đặc điểm, nếu trục == 0

    Nếu indices là một ma trận (batch) có hình dạng [batch, features] thì hình dạng đầu ra sẽ là: batch x feature x deep, if axis == -1 batch x deep x feature, if axis == 1 chiều sâu x batch x feature , nếu trục == 0

    Tuyên ngôn

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

    Thông số

    indices

    Một Tensor của các chỉ số.

    depth

    Một đại lượng vô hướng xác định độ sâu của một chiều nóng.

    onValue

    Một đại lượng vô hướng xác định giá trị tại vị trí được tham chiếu bởi một số chỉ mục trong indices .

    offValue

    Một đại lượng vô hướng xác định giá trị tại một vị trí không được tham chiếu bởi bất kỳ chỉ mục nào trong indices .

    axis

    Trục cần điền. Giá trị mặc định là -1 , một trục trong cùng mới.

Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`

  • Tạo một tenxơ 1-D biểu thị một chuỗi từ giá trị bắt đầu, đến và bao gồm giá trị cuối, cách đều nhau để tạo ra số lượng giá trị được chỉ định.

    Tuyên ngôn

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

    Thông số

    start

    Giá trị bắt đầu được sử dụng cho chuỗi. Nếu chuỗi chứa bất kỳ giá trị nào thì giá trị đầu tiên là start .

    end

    Một giá trị cuối để giới hạn trình tự. end là phần tử cuối cùng của chuỗi kết quả.

    count

    Số lượng giá trị trong chuỗi kết quả. count đếm phải dương.

  • Tạo một tenxơ 1-D biểu thị một chuỗi từ giá trị bắt đầu, đến và bao gồm giá trị cuối, cách đều nhau để tạo ra số lượng giá trị được chỉ định.

    điều kiện tiên quyết

    start , to và count phải là Tensors chứa một giá trị vô hướng duy nhất.

    Tuyên ngôn

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

    Thông số

    start

    Giá trị bắt đầu được sử dụng cho chuỗi. Nếu chuỗi chứa bất kỳ giá trị nào thì giá trị đầu tiên là start .

    end

    Một giá trị cuối để giới hạn trình tự. end là phần tử cuối cùng của chuỗi kết quả.

    count

    Số lượng giá trị trong chuỗi kết quả. count đếm phải dương.

Có sẵn ở nơi `Scalar`: `TensorFlowIndex`

  • Tạo một tenxơ có hình dạng được chỉ định, lấy mẫu ngẫu nhiên các giá trị vô hướng từ sự phân bố đồng đều giữa lowerBound và upperBound .

    Tuyên ngôn

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

    Thông số

    shape

    Kích thước của tensor

    lowerBound

    Giới hạn dưới của phân phối.

    upperBound

    Giới hạn trên của phân phối.

    seed

    Giá trị hạt giống.

Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`

  • Tạo một tenxơ có hình dạng được chỉ định, lấy mẫu ngẫu nhiên các giá trị vô hướng từ sự phân bố đồng đều giữa lowerBound và upperBound .

    Tuyên ngôn

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

    Thông số

    shape

    Kích thước của tensor

    lowerBound

    Giới hạn dưới của phân phối.

    upperBound

    Giới hạn trên của phân phối.

    seed

    Giá trị hạt giống.

  • Tạo một tensor có hình dạng xác định, lấy mẫu ngẫu nhiên các giá trị vô hướng từ phân phối chuẩn.

    Tuyên ngôn

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

    Thông số

    shape

    Kích thước của tensor

    mean

    Giá trị trung bình của phân phối.

    standardDeviation

    Độ lệch chuẩn của phân phối.

    seed

    Giá trị hạt giống.

  • Tạo một tenxơ có hình dạng được chỉ định, lấy mẫu ngẫu nhiên các giá trị vô hướng từ phân phối chuẩn bị cắt cụt.

    Tuyên ngôn

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

    Thông số

    shape

    Kích thước của tensor

    mean

    Giá trị trung bình của phân phối.

    standardDeviation

    Độ lệch chuẩn của phân phối.

    seed

    Giá trị hạt giống.

Có sẵn ở nơi `Scalar`: `TensorFlowIndex`

  • Tạo một tensor bằng cách vẽ các mẫu từ phân bố phân loại.

    Tuyên ngôn

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

    Thông số

    randomCategorialLogits

    Tensor 2-D có hình dạng [batchSize, classCount] . Mỗi lát [i, :] biểu thị xác suất nhật ký không chuẩn hóa cho tất cả các lớp.

    sampleCount

    0-D. Số lượng mẫu độc lập cần vẽ cho mỗi lát hàng.

    seed

    Giá trị hạt giống.

    Giá trị trả về

    Tenor 2-D có hình dạng [batchSize, sampleCount] . Mỗi lát [i, :] chứa các nhãn lớp được vẽ với phạm vi [0, classCount) .

Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`

  • Tạo một tensor có hình dạng được chỉ định bằng cách thực hiện khởi tạo thống nhất Glorot (Xavier).

    Nó lấy các mẫu ngẫu nhiên từ sự phân bố đồng đều giữa -limit và limit được tạo bởi trình tạo số ngẫu nhiên mặc định, trong đó limit là sqrt(6 / (fanIn + fanOut)) và fanIn / fanOut biểu thị số lượng tính năng đầu vào và đầu ra nhân với khả năng tiếp nhận kích thước trường.

    Tham khảo: “Hiểu được khó khăn trong việc đào tạo mạng lưới thần kinh chuyển tiếp sâu”

    Tuyên ngôn

    public init(
  glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    Thông số

    shape

    Kích thước của tensor

    seed

    Giá trị hạt giống.

  • Tạo một tensor có hình dạng được chỉ định bằng cách thực hiện khởi tạo bình thường Glorot (Xavier).

    Nó lấy các mẫu ngẫu nhiên từ phân phối chuẩn bị cắt cụt tập trung vào 0 với độ lệch chuẩn sqrt(2 / (fanIn + fanOut)) được tạo bởi trình tạo số ngẫu nhiên mặc định, trong đó fanIn / fanOut biểu thị số lượng tính năng đầu vào và đầu ra nhân với trường tiếp nhận kích cỡ.

    Tham khảo: “Hiểu được khó khăn trong việc đào tạo mạng lưới thần kinh chuyển tiếp sâu”

    Tuyên ngôn

    public init(
  glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    Thông số

    shape

    Kích thước của tensor

    seed

    Giá trị hạt giống.

  • Tạo một tenxơ có hình dạng được chỉ định bằng cách thực hiện khởi tạo đồng nhất He (Kaiming).

    Nó lấy các mẫu ngẫu nhiên từ sự phân bố đồng đều giữa -limit và limit được tạo bởi trình tạo số ngẫu nhiên mặc định, trong đó limit là sqrt(6 / fanIn) và fanIn biểu thị số lượng tính năng đầu vào nhân với kích thước trường tiếp nhận.

    Tham khảo: “Đi sâu vào bộ chỉnh lưu: Hiệu suất vượt trội so với con người trên Phân loại ImageNet”

    Tuyên ngôn

    public init(
  heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    Thông số

    shape

    Kích thước của tensor

    seed

    Giá trị hạt giống.

  • Tạo một tensor có hình dạng được chỉ định bằng cách thực hiện khởi tạo bình thường He (Kaiming).

    Nó lấy các mẫu ngẫu nhiên từ phân phối chuẩn bị cắt cụt tập trung vào 0 với độ lệch chuẩn sqrt(2 / fanIn)) được tạo bởi trình tạo số ngẫu nhiên mặc định, trong đó fanIn biểu thị số lượng tính năng đầu vào nhân với kích thước trường tiếp nhận.

    Tham khảo: “Đi sâu vào bộ chỉnh lưu: Hiệu suất vượt trội so với con người trên Phân loại ImageNet”

    Tuyên ngôn

    public init(
  heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    Thông số

    shape

    Kích thước của tensor

    seed

    Giá trị hạt giống.

  • Tạo một tensor có hình dạng được chỉ định bằng cách thực hiện khởi tạo thống nhất LeCun.

    Nó lấy các mẫu ngẫu nhiên từ sự phân bố đồng đều giữa -limit và limit được tạo bởi trình tạo số ngẫu nhiên mặc định, trong đó limit là sqrt(3 / fanIn) và fanIn biểu thị số lượng tính năng đầu vào nhân với kích thước trường tiếp nhận.

    Tham khảo: “BackProp hiệu quả”

    Tuyên ngôn

    public init(
  leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    Thông số

    shape

    Kích thước của tensor

    seed

    Giá trị hạt giống.

  • Tạo một tensor có hình dạng được chỉ định bằng cách thực hiện khởi tạo thông thường LeCun.

    Nó lấy các mẫu ngẫu nhiên từ phân phối chuẩn bị cắt cụt tập trung vào 0 với độ lệch chuẩn sqrt(1 / fanIn) được tạo bởi trình tạo số ngẫu nhiên mặc định, trong đó fanIn biểu thị số lượng tính năng đầu vào nhân với kích thước trường tiếp nhận.

    Tham khảo: “BackProp hiệu quả”

    Tuyên ngôn

    public init(
  leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    Thông số

    shape

    Kích thước của tensor

    seed

    Giá trị hạt giống.

  • Tạo một ma trận trực giao hoặc tensor.

    Nếu hình dạng của tenxơ cần khởi tạo là hai chiều thì nó được khởi tạo bằng ma trận trực giao thu được từ phép phân tách QR của ma trận các số ngẫu nhiên được rút ra từ phân phối chuẩn. Nếu ma trận có ít hàng hơn cột thì kết quả sẽ có các hàng trực giao. Nếu không, đầu ra sẽ có các cột trực giao.

    Nếu hình dạng của tenxơ cần khởi tạo lớn hơn hai chiều, một ma trận có hình [shape[0] * ... * shape[rank - 2], shape[rank - 1]] sẽ được khởi tạo. Ma trận sau đó được định hình lại để tạo ra một tenxơ có hình dạng mong muốn.

    Tuyên ngôn

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

    Thông số

    shape

    Hình dạng của tensor.

    gain

    Một hệ số nhân để áp dụng cho tensor trực giao.

    seed

    Một bộ gồm hai số nguyên để tạo bộ tạo số ngẫu nhiên.

Có sẵn ở nơi `Scalar`: `TensorFlowNumeric`

  • Trả về phần đường chéo [batched] của tensor [batched]. Đối với thể hiện tenxơ của hình [..., M, N] , đầu ra là một tenxơ có hình [..., K] , trong đó K bằng min(N, M) .

    Ví dụ:

    // 't' is [[1, 0, 0, 0]
//         [0, 2, 0, 0]
//         [0, 0, 3, 0]
//         [0, 0, 0, 4]]
t.diagonalPart()
// [1, 2, 3, 4]

    Tuyên ngôn

    @differentiable
public func diagonalPart() -> Tensor

  • Xây dựng một mảng đường chéo [theo đợt]. Đối với thể hiện tenxơ của hình [..., M] , đầu ra là một tenxơ có hình [..., M, M] .

    Ví dụ:

    // 't' is [1, 2, 3, 4]

t.diagonal()
// [[1, 0, 0, 0]
//  [0, 2, 0, 0]
//  [0, 0, 3, 0]
//  [0, 0, 0, 4]]

    Tuyên ngôn

    @differentiable
public func diagonal() -> Tensor

  • Trả về self với các giá trị đường chéo mới, cho rằng self là một ma trận được bó tùy chọn.

    Tensor được trả về có hình dạng và giá trị giống như self , ngoại trừ các đường chéo được chỉ định của ma trận trong cùng bị ghi đè bởi các giá trị trong diagonal .

    Tham số đường chéo: Một tensor có thứ rank - 1 đại diện cho các giá trị đường chéo mới.

    Tuyên ngôn

    public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor

  • Tuyên ngôn

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

  • Trả về bản sao của tenxơ trong cùng được xác định bởi ranh giới dải trung tâm. Đầu ra là một tensor có hình dạng giống như thể hiện [..., :, :] .

    Ví dụ:

    // '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]]

    Tuyên ngôn

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

    Thông số

    subdiagonalCount

    Số lượng đường chéo phụ cần giữ. Nếu âm, giữ nguyên toàn bộ tam giác phía dưới.

    superdiagonalCount

    Số lượng đường chéo cần giữ. Nếu âm, giữ nguyên toàn bộ tam giác trên.

Có sẵn ở nơi `Scalar`: `TensorFlowFloatingPoint`

  • Trả về phân tách QR của từng ma trận bên trong trong tenxơ, một tenxơ có ma trận trực giao bên trong q và một tenxơ có ma trận tam giác trên bên trong r , sao cho tenxơ bằng matmul(q, r) .

    Tuyên ngôn

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

    Thông số

    fullMatrices

    Nếu true , hãy tính q và r có kích thước đầy đủ. Nếu không, chỉ tính toán các cột min(shape[rank - 1], shape[rank - 2]) hàng đầu của q .

  • Trả về sự phân tách giá trị số ít của self , với điều kiện self là một ma trận được bó tùy chọn.

    Phân tách giá trị số ít (SVD) của self ma trận được phân nhóm tùy chọn là các giá trị s , u và v , sao cho:

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

    self must be a tensor with shape […, M, N] . Let K = phút(M, N)`.

    điều kiện tiên quyết

    self phải là một tensor có hình dạng [..., M, N] .

    Tuyên ngôn

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

    Thông số

    computeUV

    Nếu true , các vectơ số ít bên trái và bên phải được tính toán và trả về tương ứng là u và v . Nếu false , giá trị nil được trả về là u và v .

    fullMatrices

    Nếu true , u và v tương ứng có hình dạng [..., M, M] và [..., N, N] . Nếu false , u và v lần lượt có hình dạng [..., M, K] và [..., K, N] . Bị bỏ qua khi computeUV sai.

    Giá trị trả về

    • s: Các giá trị số ít, có dạng [..., K] . Trong mỗi vectơ, các giá trị số ít được sắp xếp theo thứ tự giảm dần.
    • u: Các vectơ số ít bên trái.
    • v: Các vectơ số ít bên phải.

  • Căn bậc hai của x .

    Đối với loại thực, nếu x âm thì kết quả là .nan . Đối với các loại phức tạp, có một nhánh cắt trên trục thực âm.

    Tuyên ngôn

    @differentiable
public static func sqrt(_ x: `Self`) -> Tensor<Scalar>

  • Cosin của x , được hiểu là một góc tính bằng radian.

    Tuyên ngôn

    @differentiable
public static func cos(_ x: `Self`) -> Tensor<Scalar>

  • Sin của x , được hiểu là một góc tính bằng radian.

    Tuyên ngôn

    @differentiable
public static func sin(_ x: `Self`) -> Tensor<Scalar>

  • Tiếp tuyến của x , được hiểu là một góc tính bằng radian.

    Tuyên ngôn

    @differentiable
public static func tan(_ x: `Self`) -> Tensor<Scalar>

  • Cosin nghịch đảo của x tính bằng radian.

    Tuyên ngôn

    @differentiable
public static func acos(_ x: `Self`) -> Tensor<Scalar>

  • Sin nghịch đảo của x tính bằng radian.

    Tuyên ngôn

    @differentiable
public static func asin(_ x: `Self`) -> Tensor<Scalar>

  • Tang nghịch đảo của x tính bằng radian.

    Tuyên ngôn

    @differentiable
public static func atan(_ x: `Self`) -> Tensor<Scalar>

  • Cosin hyperbol của x .

    Tuyên ngôn

    @differentiable
public static func cosh(_ x: `Self`) -> Tensor<Scalar>

  • Sin hyperbol của x .

    Tuyên ngôn

    @differentiable
public static func sinh(_ x: `Self`) -> Tensor<Scalar>

  • Tiếp tuyến hyperbol của x .

    Tuyên ngôn

    @differentiable
public static func tanh(_ x: `Self`) -> Tensor<Scalar>

  • Cosin hyperbol nghịch đảo của x .

    Tuyên ngôn

    @differentiable
public static func acosh(_ x: `Self`) -> Tensor<Scalar>

  • Sin hyperbol nghịch đảo của x .

    Tuyên ngôn

    @differentiable
public static func asinh(_ x: `Self`) -> Tensor<Scalar>

  • Tang hyperbol nghịch đảo của x .

    Tuyên ngôn

    @differentiable
public static func atanh(_ x: `Self`) -> Tensor<Scalar>

  • Hàm số mũ được áp dụng cho x hoặc e**x .

    Tuyên ngôn

    @differentiable
public static func exp(_ x: `Self`) -> Tensor<Scalar>

  • Hai nâng lên lũy thừa x .

    Tuyên ngôn

    @differentiable
public static func exp2(_ x: `Self`) -> Tensor<Scalar>

  • Mười nâng lên lũy thừa x .

    Tuyên ngôn

    @differentiable
public static func exp10(_ x: `Self`) -> Tensor<Scalar>

  • exp(x) - 1 được đánh giá để duy trì độ chính xác gần bằng 0.

    Tuyên ngôn

    @differentiable
public static func expm1(_ x: `Self`) -> Tensor<Scalar>

  • Logarit tự nhiên của x .

    Tuyên ngôn

    @differentiable
public static func log(_ x: `Self`) -> Tensor<Scalar>

  • Logarit cơ số hai của x .

    Tuyên ngôn

    @differentiable
public static func log2(_ x: `Self`) -> Tensor<Scalar>

  • Logarit cơ số mười của x .

    Tuyên ngôn

    @differentiable
public static func log10(_ x: `Self`) -> Tensor<Scalar>

  • log(1 + x) được đánh giá để bảo tồn độ chính xác gần bằng không.

    Tuyên ngôn

    @differentiable
public static func log1p(_ x: `Self`) -> Tensor<Scalar>

  • exp(y log(x)) được tính toán mà không mất độ chính xác trung gian.

    Đối với các loại thực, nếu x là âm thì kết quả là nan, ngay cả khi y có giá trị tích phân. Đối với các loại phức tạp, có một nhánh cắt trên trục thực âm.

    Tuyên ngôn

    @differentiable
public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>

  • x nâng lên sức mạnh n .

    Sản phẩm của n bản sao của x .

    Tuyên ngôn

    @differentiable
public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>

  • n của x của x .

    Đối với các loại thực, nếu x là âm và n là chẵn, kết quả là nan. Đối với các loại phức tạp, có một nhánh cắt dọc theo trục thực âm.

    Tuyên ngôn

    @differentiable
public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>

  • Tuyên ngôn

    public typealias VectorSpaceScalar = Float

  • Tuyên ngôn

    public func scaled(by scale: Float) -> Tensor<Scalar>

  • Tuyên ngôn

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

  • Tuyên ngôn

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
Có sẵn trong đó `vô hướng ':` Numeric`

  • Thêm vô hướng vào mọi vô hướng của tenxơ và tạo ra tổng.

    Tuyên ngôn

    @differentiable
public static func + (lhs: Scalar, rhs: Tensor) -> Tensor

  • Thêm vô hướng vào mọi vô hướng của tenxơ và tạo ra tổng.

    Tuyên ngôn

    @differentiable
public static func + (lhs: Tensor, rhs: Scalar) -> Tensor

  • Trừ vô hướng từ mọi vô hướng của tenxơ và tạo ra sự khác biệt.

    Tuyên ngôn

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

  • Trừ vô hướng từ mọi vô hướng của tenxơ và tạo ra sự khác biệt

    Tuyên ngôn

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

  • Thêm hai tenxơ và lưu trữ kết quả trong biến bên trái.

    Ghi chú

    += hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Thêm vô hướng vào mọi vô hướng của tenxơ và lưu trữ kết quả trong biến bên trái.

    Tuyên ngôn

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

  • Trừ tenxơ thứ hai từ đầu thứ nhất và lưu trữ kết quả trong biến bên trái.

    Ghi chú

    -= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trừ vô hướng từ mọi vô hướng của tenxơ và lưu trữ kết quả trong biến bên trái.

    Tuyên ngôn

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

  • Trả về tenxơ được sản xuất bằng cách nhân hai tenxor.

    Ghi chú

    * Hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về tenxơ bằng cách nhân nó với mỗi vô hướng của tenxơ.

    Tuyên ngôn

    @differentiable
public static func * (lhs: Scalar, rhs: Tensor) -> Tensor

  • Nhân hóa vô hướng với mỗi vô hướng của tenxơ và tạo ra sản phẩm.

    Tuyên ngôn

    @differentiable
public static func * (lhs: Tensor, rhs: Scalar) -> Tensor

  • Nhân hai tenxơ và lưu trữ kết quả trong biến bên trái.

    Ghi chú

    *= hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Nhân các tenxơ với vô hướng, phát sóng vô hướng và lưu trữ kết quả trong biến phía bên trái.

    Tuyên ngôn

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

  • Trả về chỉ số của việc chia tenxor đầu tiên cho lần thứ hai.

    Ghi chú

    / hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về thương số chia vô hướng cho tenxơ, phát sóng vô hướng.

    Tuyên ngôn

    @differentiable
public static func / (lhs: Scalar, rhs: Tensor) -> Tensor

  • Trả về thương số chia tenor cho vô hướng, phát sóng vô hướng.

    Tuyên ngôn

    @differentiable
public static func / (lhs: Tensor, rhs: Scalar) -> Tensor

  • Chia tenxơ đầu tiên cho lần thứ hai và lưu trữ chỉ số trong biến bên trái.

    Tuyên ngôn

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

  • Chia tenxơ cho vô hướng, phát sóng vô hướng và lưu trữ chỉ số trong biến bên trái.

    Tuyên ngôn

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

  • Trả về phần còn lại của việc chia tenxơ đầu tiên cho lần thứ hai.

    Ghi chú

    % hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trả về phần còn lại của việc chia tenxơ cho vô hướng, phát sóng vô hướng.

    Tuyên ngôn

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor

  • Trả về phần còn lại của việc chia vô hướng cho tenxơ, phát sóng vô hướng.

    Tuyên ngôn

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor

  • Chia tenxơ đầu tiên cho phần thứ hai và lưu trữ phần còn lại trong biến bên trái.

    Tuyên ngôn

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

  • Chia tenxơ cho vô hướng và lưu trữ phần còn lại trong biến bên trái.

    Tuyên ngôn

    public static func %= (lhs: inout Tensor, rhs: Scalar)
Có sẵn trong đó `vô hướng '==` bool`

  • Trả lại !self yếu tố khôn ngoan.

    Tuyên ngôn

    public func elementsLogicalNot() -> Tensor

  • Trả về self && other khôn ngoan.

    Ghi chú

    && hỗ trợ phát sóng.

    Tuyên ngôn

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor

  • Trả về self && other , phát sóng other .

    Tuyên ngôn

    public func elementsLogicalAnd(_ other: Scalar) -> Tensor

  • Trả lại self || other yếu tố self || other khôn ngoan.

    Tuyên ngôn

    public func elementsLogicalOr(_ other: Tensor) -> Tensor

  • Trả lại self || other yếu tố self || other , phát sóng other .

    Tuyên ngôn

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
Có sẵn ở đâu

  • Trả về max(min(self, max), min) .

    Tuyên ngôn

    @differentiable
public func clipped(min: Tensor, max: Tensor) -> Tensor

  • Trả về max(min(self, max), min) .

    Tuyên ngôn

    @differentiable(wrt: (self, min)
) public func clipped(min: Tensor, max: Scalar) -> Tensor

  • Trả về max(min(self, max), min) .

    Tuyên ngôn

    @differentiable(wrt: (self, max)
) public func clipped(min: Scalar, max: Tensor) -> Tensor

  • Trả về max(min(self, max), min) .

    Tuyên ngôn

    @differentiable(wrt: self)
public func clipped(min: Scalar, max: Scalar) -> Tensor
Có sẵn trong đó `vô hướng`:` SignedNumeric`

  • Trả về sự phủ định của phần tử tenxơ được chỉ định.

    Tuyên ngôn

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
Có sẵn trong đó `vô hướng ':` Numeric`

  • Tuyên ngôn

    @differentiable(wrt: self)
public func squared() -> Tensor
Có sẵn trong đó `vô hướng ':` TensorFlowFloatingPoint`

  • Trả về một tenxơ boolean cho biết các yếu tố của x là hữu hạn.

    Tuyên ngôn

    public var isFinite: Tensor<Bool> { get }

  • Trả về một tenxơ boolean cho biết các yếu tố của x là vô hạn.

    Tuyên ngôn

    public var isInfinite: Tensor<Bool> { get }

  • Trả về một tenxơ boolean cho biết các yếu tố của x có giá trị nan.

    Tuyên ngôn

    public var isNaN: Tensor<Bool> { get }
Có sẵn trong đó `vô hướng '==` bool`

  • Trả về true nếu tất cả các vô hướng bằng với true . Ngược lại, trả về false .

    Tuyên ngôn

    public func all() -> Bool

  • Trả về true nếu bất kỳ vô hướng nào bằng true . Ngược lại, trả về false .

    Tuyên ngôn

    public func any() -> Bool

  • Thực hiện một hoạt động logic và hoạt động dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func all(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Thực hiện một hoạt động logic và hoạt động dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func any(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Thực hiện một hoạt động logic và hoạt động dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func all(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Thực hiện một hoạt động logic hoặc hoạt động dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func any(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

Có sẵn trong đó `vô hướng ':` numeric` & `so sánh`

  • Tuyên ngôn

    @differentiable
public func min() -> Tensor

  • Tuyên ngôn

    @differentiable
public func max() -> Tensor

  • Trả về các giá trị tối đa dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các giá trị tối đa dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func max(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các giá trị tối đa dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func max(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các giá trị tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các giá trị tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func min(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các giá trị tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func min(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các chỉ số của các giá trị tối đa dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về các chỉ số của các giá trị tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func min(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func min(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func min(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func max(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func max(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tối thiểu dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func max(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về chỉ số của giá trị tối đa của vô hướng phẳng.

    Tuyên ngôn

    public func argmax() -> Tensor<Int32>

  • Trả về chỉ số của giá trị tối thiểu của vô hướng phẳng.

    Tuyên ngôn

    public func argmin() -> Tensor<Int32>
Có sẵn trong đó `vô hướng ':` Numeric`

  • Trả về tổng dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tổng dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func sum(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tổng dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func sum(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Tuyên ngôn

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

  • Trả về tổng dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func sum(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tổng dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func sum(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về tổng dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func sum(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về sản phẩm dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về sản phẩm dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func product(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về sản phẩm dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func product(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Tuyên ngôn

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

  • Trả về sản phẩm dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func product(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về sản phẩm dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func product(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về sản phẩm dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    public func product(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về trung bình số học dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về trung bình số học dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func mean(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về trung bình số học dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank...rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func mean(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Tuyên ngôn

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

  • Trả về trung bình số học dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func mean(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về trung bình số học dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func mean(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về trung bình số học dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func mean(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về phương sai dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về phương sai dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func variance(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về phương sai dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func variance(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Tuyên ngôn

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

  • Trả về phương sai dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func variance(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về phương sai dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func variance(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về phương sai dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func variance(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • T.

    Trả về tổng tích lũy của tenxơ này dọc theo trục được chỉ định. Theo mặc định, hàm này thực hiện tổng tích lũy bao gồm, có nghĩa là phần tử đầu tiên của đầu vào giống hệt với phần tử đầu tiên của đầu ra:

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

    Bằng cách đặt đối số exclusive thành true , một tổng tích lũy độc quyền được thực hiện thay thế:

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

    Bằng cách đặt đối số reverse thành true , tổng tích lũy được thực hiện theo hướng ngược lại:

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

    Điều này hiệu quả hơn so với việc đảo ngược riêng biệt các tenxơ kết quả.

    điều kiện tiên quyết

    axis phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

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

    Thông số

    axis

    Trục dọc theo đó để thực hiện hoạt động tổng tích lũy.

    exclusive

    Cho biết có nên thực hiện một tổng tích lũy độc quyền hay không.

    reverse

    Cho biết có nên thực hiện tổng tích lũy theo thứ tự đảo ngược hay không.

    Giá trị trả lại

    Kết quả của hoạt động tổng tích lũy.

  • T.

    Trả về tổng tích lũy của tenxơ này dọc theo trục được chỉ định. Theo mặc định, hàm này thực hiện tổng tích lũy bao gồm, có nghĩa là phần tử đầu tiên của đầu vào giống hệt với phần tử đầu tiên của đầu ra:

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

    Bằng cách đặt đối số exclusive thành true , một tổng tích lũy độc quyền được thực hiện thay thế:

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

    Bằng cách đặt đối số reverse thành true , tổng tích lũy được thực hiện theo hướng ngược lại:

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

    Điều này hiệu quả hơn so với việc đảo ngược riêng biệt các tenxơ kết quả.

    điều kiện tiên quyết

    axis.rank phải là 0 .

    điều kiện tiên quyết

    axis phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

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

    Thông số

    axis

    Trục dọc theo đó để thực hiện hoạt động tổng tích lũy.

    exclusive

    Cho biết có nên thực hiện một tổng tích lũy độc quyền hay không.

    reverse

    Cho biết có nên thực hiện tổng tích lũy theo thứ tự đảo ngược hay không.

    Giá trị trả lại

    Kết quả của hoạt động tổng tích lũy.

  • Trả về sản phẩm tích lũy của tenxơ này dọc theo trục được chỉ định. Theo mặc định, chức năng này thực hiện một sản phẩm tích lũy bao gồm, điều đó có nghĩa là phần tử đầu tiên của đầu vào giống hệt với phần tử đầu tiên của đầu ra:

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

    Bằng cách đặt đối số exclusive thành true , một sản phẩm tích lũy độc quyền được thực hiện thay thế:

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

    Bằng cách đặt đối số reverse thành true , sản phẩm tích lũy được thực hiện theo hướng ngược lại:

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

    Điều này hiệu quả hơn so với việc đảo ngược riêng biệt các tenxơ kết quả.

    điều kiện tiên quyết

    axis phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

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

    Thông số

    axis

    Trục dọc theo đó để thực hiện hoạt động sản phẩm tích lũy.

    exclusive

    Cho biết có nên thực hiện một sản phẩm tích lũy độc quyền hay không.

    reverse

    Cho biết có nên thực hiện sản phẩm tích lũy theo thứ tự đảo ngược hay không.

    Giá trị trả lại

    Kết quả của hoạt động sản phẩm tích lũy.

  • Trả về sản phẩm tích lũy của tenxơ này dọc theo trục được chỉ định. Theo mặc định, chức năng này thực hiện một sản phẩm tích lũy bao gồm, điều đó có nghĩa là phần tử đầu tiên của đầu vào giống hệt với phần tử đầu tiên của đầu ra:

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

    Bằng cách đặt đối số exclusive thành true , một sản phẩm tích lũy độc quyền được thực hiện thay thế:

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

    Bằng cách đặt đối số reverse thành true , sản phẩm tích lũy được thực hiện theo hướng ngược lại:

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

    Điều này hiệu quả hơn so với việc đảo ngược riêng biệt các tenxơ kết quả.

    điều kiện tiên quyết

    axis phải có thứ hạng 0 .

    điều kiện tiên quyết

    axis phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

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

    Thông số

    axis

    Trục dọc theo đó để thực hiện hoạt động sản phẩm tích lũy.

    exclusive

    Cho biết có nên thực hiện một sản phẩm tích lũy độc quyền hay không.

    reverse

    Cho biết có nên thực hiện sản phẩm tích lũy theo thứ tự đảo ngược hay không.

    Giá trị trả lại

    Kết quả của hoạt động sản phẩm tích lũy.

Có sẵn trong đó `vô hướng ':` TensorFlowFloatingPoint`

  • Trả về độ lệch chuẩn của các phần tử dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 . Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về độ lệch chuẩn của các phần tử dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 . Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về độ lệch chuẩn của các phần tử dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 . Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về độ lệch chuẩn của tất cả các yếu tố trong tenxơ này. Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

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

  • Trả về độ lệch chuẩn của các phần tử dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 . Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về độ lệch chuẩn của các phần tử dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 . Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func standardDeviation(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về độ lệch chuẩn của các phần tử dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 . Không áp dụng hiệu chỉnh của Bessel.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func standardDeviation(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về log(exp(self).sum(squeezingAxes: axes)) . Các kích thước giảm được loại bỏ.

    Hàm này ổn định số hơn so với log(exp(self).sum(squeezingAxes: axes)) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về log(exp(self).sum(squeezingAxes: axes)) . Các kích thước giảm được loại bỏ.

    Hàm này ổn định số hơn so với log(exp(self).sum(squeezingAxes: axes)) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về log(exp(self).sum(squeezingAxes: axes)) . Các kích thước giảm được loại bỏ.

    Hàm này ổn định số hơn so với log(exp(self).sum(squeezingAxes: axes)) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về log(exp(self).sum()) . Kết quả là một vô hướng.

    Hàm này ổn định số hơn so với log(exp(self).sum()) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    Tuyên ngôn

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

  • Trả về log(exp(self).sum(alongAxes: axes)) . Các kích thước giảm được giữ lại với giá trị 1 .

    Hàm này ổn định số hơn so với log(exp(self).sum(alongAxes: axes)) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về log(exp(self).sum(alongAxes: axes)) . Các kích thước giảm được giữ lại với giá trị 1 .

    Hàm này ổn định số hơn so với log(exp(self).sum(alongAxes: axes)) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func logSumExp(alongAxes axes: [Int]) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về log(exp(self).sum(alongAxes: axes)) . Các kích thước giảm được giữ lại với giá trị 1 .

    Hàm này ổn định số hơn so với log(exp(self).sum(alongAxes: axes)) trực tiếp. Nó tránh tràn ra do tính toán exp của các đầu vào lớn và dòng chảy gây ra bằng cách tính toán log của các đầu vào nhỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func logSumExp(alongAxes axes: Int...) -> Tensor

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về giá trị trung bình và phương sai của tenxơ này dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    axes phải có thứ hạng 1 .

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về giá trị trung bình và phương sai của tenxơ này dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về giá trị trung bình và phương sai của tenxơ này dọc theo các trục được chỉ định. Các kích thước giảm được loại bỏ.

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về giá trị trung bình và phương sai của các yếu tố tenxơ này.

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments() -> Moments<Scalar>

  • Trả về giá trị trung bình và phương sai của tenxơ này dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 .

    điều kiện tiên quyết

    axes phải có thứ hạng 1 .

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về giá trị trung bình và phương sai của tenxơ này dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 .

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

    Thông số

    axes

    Các kích thước cần giảm.

  • Trả về giá trị trung bình và phương sai của tenxơ này dọc theo các trục được chỉ định. Các kích thước giảm được giữ lại với giá trị 1 .

    điều kiện tiên quyết

    Mỗi giá trị trong axes phải nằm trong phạm vi -rank..<rank .

    Tuyên ngôn

    @differentiable(wrt: self)
public func moments(alongAxes axes: Int...) -> Moments<Scalar>

    Thông số

    axes

    Các kích thước cần giảm.

Có sẵn trong đó `vô hướng ':` Numeric`

  • Thực hiện phép nhân ma trận giữa hai tenxor và tạo ra kết quả.

    Tuyên ngôn

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
Có sẵn trong đó `vô hướng ':` TensorFlowFloatingPoint`

  • Tuyên ngôn

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

  • Trả về một tenxơ được tính toán từ hàng loạt chuẩn hóa đầu vào dọc theo trục được chỉ định.

    Cụ thể, trả về (self - mu) / (var + epsilon) * gamma + beta trong đó mu và var tương ứng là trung bình và phương sai của self dọc theo axis .

    Tuyên ngôn

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

    Thông số

    axis

    Kích thước hàng loạt.

    offset

    Phần bù, còn được gọi là beta.

    scale

    Thang đo, còn được gọi là gamma.

    epsilon

    Một giá trị nhỏ được thêm vào mẫu số cho độ ổn định số.

  • Concatenates hai tenxor dọc theo trục cuối cùng.

    Tuyên ngôn

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

  • Thêm hai giá trị và tạo ra tổng của chúng.

    Tuyên ngôn

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

  • Trung bình hai giá trị.

    Tuyên ngôn

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

  • Nhân hai giá trị.

    Tuyên ngôn

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

  • Xếp hai giá trị.

    Tuyên ngôn

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

  • Tuyên ngôn

    @derivative
init(shape: scalars)
Có sẵn ở đâu

  • Tuyên ngôn

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

  • Tuyên ngôn

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
Có sẵn trong đó `vô hướng ':` có thể mã hóa'

  • Tuyên ngôn

    public func encode(to encoder: Encoder) throws

  • Tuyên ngôn

    public init(from decoder: Decoder) throws
Có sẵn trong đó `vô hướng ':` Numeric`

  • Các tenxơ vô hướng bằng không.

  • Tuyên ngôn

    public static var zero: Tensor { get }

  • Thêm hai tenxơ và tạo ra tổng của chúng.

    Ghi chú

    + hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Trừ một tenxơ từ một tenor khác và tạo ra sự khác biệt của chúng.

    Ghi chú

    - Hỗ trợ phát sóng.

    Tuyên ngôn

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

  • Vô hướng một tenor.

    Tuyên ngôn

    public static var one: Tensor { get }

  • Trả về đối ứng yếu tố khôn ngoan của self .

    Tuyên ngôn

    public var reciprocal: Tensor { get }

  • Nhân hai yếu tố Tensors khôn ngoan và sản xuất sản phẩm của họ.

    Ghi chú

    .* Hỗ trợ phát sóng.

    Tuyên ngôn

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
Có sẵn trong đó `vô hướng ':` TensorFlowFloatingPoint`

  • Tuyên ngôn

    public typealias TangentVector = Tensor

  • Tuyên ngôn

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

  • Thêm một chú thích.

    Lưu ý: Chỉ có X10 được hỗ trợ. Đối với các phụ trợ khác, self được trả lại.

    Tuyên ngôn

    @differentiable(wrt: self)
public func annotate(_ annotation: String) -> Tensor<Scalar>

    Thông số

    annotation

    Các chú thích sẽ được thêm vào.

    Giá trị trả lại

    Các tenxơ chú thích.

  • Tuyên ngôn

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