Trang này được dịch bởi Cloud Translation API.

Tiếng 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: VectorProtocol where Scalar: TensorFlowFloatingPoint

extension Tensor: Mergeable 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.).

xử lý
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>

init(xử lý :)

Tuyên ngôn

public init(handle: TensorHandle<Scalar>)

không được xếp chồng lên nhau(dọc theo trục :)
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 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ẽ không còn nữa, không giống như Tensor.split(numSplits:alongAxis) hoặc Tensor.split(sizes:alongAxis) ).
- Nếu axis == 1 thì tensor 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.
chia (đếm: dọcAxis :)
Tách một tensor thành nhiều tensor. Tensor được chia dọc theo axis kích thước count các tensor 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.
chia (kích thước: dọcAxis :)
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 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.

chia (kích thước: dọcAxis :)

Tuyên ngôn

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

lát gạch(bội số :)
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 thứ 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
lát gạch(bội số :)
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 thứ 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 (như :)
Đị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
được định hình lại (thành :)
Đị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
được định hình lại(toShape:)
Đị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
làm phẳng()
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
mở rộngShape(at:)
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
mở rộngShape(at:)
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
thứ hạngLifted()
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
épShape(at:)
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
épShape(at:)
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
chuyển đổi (hoán vị :)
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

chuyển đổi(withPermutations:)

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

chuyển đổi (hoán vị :)
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

chuyển đổi(withPermutations:)

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

chuyển đổi (hoán vị :)
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

chuyển đổi(withPermutations:)

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

chuyển đổi()
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
đảo ngược(inAxes:)
Trả về một tenxơ 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
đảo ngược(inAxes:)
Trả về một tenxơ 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
đảo ngược(inAxes:)
Trả về một tenxơ 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
được nối (với:alongAxis:)
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
++(_:_:)
Toán tử nối.
Ghi chú
++ là 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
tập hợp(atIndices:alongAxis:)
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.

batchGathering(atIndices:alongAxis:batchDimensionCount:)

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.

tập hợp (trong đó: dọcAxis :)
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] , trong đó [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 dấ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 .

nonZeroIndices()

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)) .

được phát sóng(toShape:)

Tuyên ngôn

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

được phát sóng (đến :)

Tuyên ngôn

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

được phát sóng (như :)
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)

lát(lowBounds:upperBounds:)
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.

lát (lowBounds: kích thước :)

Tuyên ngôn

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

lát (lowBounds: kích thước :)

Tuyên ngôn

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

chỉ số dưới(_:)

Tuyên ngôn

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

đảmValid(axes:function:file: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: Tensor<Int32>, function: StaticString = #function, file: StaticString = #file, line: UInt = #line )
đảmValid(axes:function:file: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 )
đảmValid(trục:hàm:tập tin:dòng:)
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 )

init(đối chiếu :)

Tuyên ngôn

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

init(đang sao chép:đến:)
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)
init(hình dạng: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
@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.
init(lặp lại:hình dạng:on :)
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
init(phát sóng:thứ hạng:on :)
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)
init(_:)
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])
init(xếp chồng:longAxis:)
Xếp chồng tensors , dọc theo chiều 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.
init(nối:alongAxis:)
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ế (bằng: ở đâu :)
Thay thế các phần tử của tenxơ này bằng các phần 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
isReducedPrecision
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 }
init(_:deviceAndPrecisionLike:)
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)
toReducedPrecision
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 }
toFullPrecision
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 }
thứ hạng
Số chiều của Tensor .
Tuyên ngôn
public var rank: Int { get }
hình dạng
Hình dạng của Tensor .
Tuyên ngôn
public var shape: TensorShape { get }
số vô hướng
Số lượng vô hướng trong Tensor .
số vô hướng
Tuyên ngôn
public var scalarCount: Int { get }
xếp hạng Tensor
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 }
hình dạng Tensor
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 }
vô hướngĐếmTensor
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 }
là vô hướng
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 }
vô hướng
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 }
vô hướng()
Đị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

mảng

Tuyên ngôn

public var array: ShapedArray<Scalar> { get }

vô hướng

Tuyên ngôn

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

init(_:on:)

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)

init(_:on:)

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)

init(_:on:)

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

init(hình dạng:vô hướng:on:)
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.
init(hình dạng:vô hướng:on:)
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.
init(hình dạng:vô hướng:toReducedPrecision:directOn:)
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.
init(hình dạng:vô hướng:on:)
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.
Phần tử mảng chữ
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>
init(arrayLiteral:)
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>...)
Sự miêu tả
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 }

description(lineWidth:edgeElementCount:summarizing:)

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ả đầy đủ
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 }
irText

sân chơiMô tả

Tuyên ngôn

public var playgroundDescription: Any { get }

tùy chỉnhMirror
Tuyên ngôn
public var customMirror: Mirror { get }
chú thích
Các chú thích mô tả tensor này.
Tuyên ngôn
public var annotations: String { get }
bản tóm tắt
Bí danh cho chú thích.
Tuyên ngôn
public var summary: String { get }

init(_sở hữu:)

Tuyên ngôn

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

init(_handles:)

Tuyên ngôn

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

init(_:on:)

Tuyên ngôn

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

init(_xla:)
Tuyên ngôn
init(_xla: XLATensor)

init(_xlaHandle:)

Tuyên ngôn

init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

xlaHandle

Tuyên ngôn

var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

xlaTensor
Tuyên ngôn
var xlaTensor: XLATensor { get }

Có sẵn ở nơi `Vô hướng`: `Số`

không được phát sóng(toShape:)

Tuyên ngôn

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

không được phát sóng (như :)

Tuyên ngôn

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

không được phát sóng(đến :)

Tuyên ngôn

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

Chế độ đệm
Một chế độ quy định cách đệm một tensor.
Tuyên ngôn
public enum PaddingMode

đệm(forSizes:with:)

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

đệm(forSizes:mode:)

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`

phần tửAlmostEqual(_:tolerance:)
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 other hay 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`

isAlmostEqual(to:tolerance:)
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 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`

crossReplicaSum(_:)
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`

init(lặp lại :)
Tuyên ngôn
@derivative init(repeating: shape)

Có sẵn ở nơi `Vô hướng`: `Số`

init(_:)
Thực hiện chuyển đổi loại phần tử từ tenxơ Bool .
Tuyên ngôn
public init(_ other: Tensor<Bool>)

init(_:)

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`

init(_:)
Tuyên ngôn
@derivative init(_: <<error type>>)
init(xếp chồng :)
Tuyên ngôn
@derivative init(stacking: alongAxis)

init(nối :)

Tuyên ngôn

@derivative
init(concatenating: alongAxis)

Có sẵn ở nơi `Vô hướng`: `Số`

init(số không:bật :)
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.
init(những cái:on:)
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.
init(zerosLike:)
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.
init(onesLike:)
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.

init(rangeFrom:to:sải bước:on:)

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.

init(rangeFrom:to:sải bước:)

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.

init(oneHotAtIndices:deep:onValue:offValue:axis:)

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 tensor mới sẽ là một vectơ có depth dài .

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`

init(tuyến tínhSpaceFrom:to:count:on:)

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` phải dương.

init(tuyến tínhSpaceFrom:to:count:)

đ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` phải dương.

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

init(randomUniform:lowBound:upperBound:seed:on:)
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`

init(randomUniform:lowBound:upperBound:seed:on:)
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.
init(randomNormal:mean:standardDeviation:seed:on:)
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.
init(randomTruncatedNormal:mean:standardDeviation:seed:on:)
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`

init(randomCategorialLogits:sampleCount:seed:)

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`	Tenor 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`

init(glorotUniform:seed:on:)
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.
init(glorotNormal:seed:on:)
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.
init(heUniform:seed:on:)
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.
init(heNormal:seed:on:)
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.
init(leCunUniform:seed:on:)
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.
init(leCunNormal:seed:on:)
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.
init(trực giao:gain:seed:)
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 dạng [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`

đường chéoPart()
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
đường chéo()
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
withDiagonal(_:)
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ứ hạng 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

bandPart(_:_:)

Tuyên ngôn

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

bandPart(subdiagonalCount:superdiagonalCount:)

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`

qrDecomposition(fullMatrices:)
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 .

svd(computeUV:fullMatrices:)

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 rã giá trị số ít (SVD) của self ma trận được bó 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` lần lượt 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ó hình 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.

mét vuông(_:)
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>
cos(_:)
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>
tội lỗi(_:)
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>
tan(_:)
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>

acos(_:)

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>

asin(_:)

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>

atan(_:)

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>

cosh(_:)

Cosin hyperbol của x .

Tuyên ngôn

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

sinh(_:)

Sin hyperbol của x .

Tuyên ngôn

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

tính(_:)

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

Tuyên ngôn

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

acosh(_:)

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

Tuyên ngôn

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

asinh(_:)

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

Tuyên ngôn

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

atanh(_:)

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

Tuyên ngôn

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

điểm kinh nghiệm(_:)
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>

exp2(_:)

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

Tuyên ngôn

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

exp10(_:)

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

Tuyên ngôn

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

expm1(_:)
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>

nhật ký(_:)

Logarit tự nhiên của x .

Tuyên ngôn

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

log2(_:)

Logarit cơ số hai của x .

Tuyên ngôn

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

log10(_:)

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

Tuyên ngôn

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

log1p(_:)
log(1 + x) được đánh giá để duy trì độ chính xác gần bằng 0.
Tuyên ngôn
@differentiable public static func log1p(_ x: `Self`) -> Tensor<Scalar>
ôi(_:_:)
exp(y log(x)) được tính toán mà không làm mất độ chính xác trung gian.
Đối với kiểu thực, nếu x âm thì kết quả là NaN, ngay cả khi y có giá trị nguyên. Đối với các kiểu phức, 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>

ôi(_:_:)

x được nâng lên lũy thừa n .

Tích của n bản sao của x .

Tuyên ngôn

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

gốc(_:_:)
Căn bậc n của x .
Đối với kiểu thực, nếu x âm và n chẵn thì kết quả là NaN. Đối với các kiểu phức, 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>

VectorKhông GianVô Hướng

Tuyên ngôn

public typealias VectorSpaceScalar = Float

được chia tỷ lệ (bởi :)

Tuyên ngôn

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

thêm(_:)

Tuyên ngôn

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

trừ(_:)

Tuyên ngôn

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

Có sẵn ở nơi `Vô hướng`: `Số`

+(_:_:)
Cộng đại lượng vô hướng vào mỗi đại lượng vô hướng của tensor và tạo ra tổng.
Tuyên ngôn
@differentiable public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
+(_:_:)
Cộng đại lượng vô hướng vào mỗi đại lượng vô hướng của tensor và tạo ra tổng.
Tuyên ngôn
@differentiable public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
-(_:_:)
Trừ đại lượng vô hướng khỏi mọi đại lượng vô hướng của tenxơ và tạo ra hiệu.
Tuyên ngôn
@differentiable public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
-(_:_:)
Trừ đại lượng vô hướng khỏi mọi đại lượng vô hướng của tenxơ và tạo ra hiệu
Tuyên ngôn
@differentiable public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
+=(_:_:)
Cộng hai tensor và lưu kết quả vào 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`

ElementsLogicalNot ()
Trả lại !self yếu tố khôn ngoan.
Tuyên ngôn
public func elementsLogicalNot() -> Tensor
ElementsLogicaland (_ :)
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
ElementsLogicaland (_ :)
Trả về self && other , phát sóng other .
Tuyên ngôn
public func elementsLogicalAnd(_ other: Scalar) -> Tensor
ElementsLogicalor (_ :)
Trả lại self || other yếu tố self || other khôn ngoan.
Tuyên ngôn
public func elementsLogicalOr(_ other: Tensor) -> Tensor
ElementsLogicalor (_ :)
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

Cắt (tối thiểu: tối đa :)
Trả về max(min(self, max), min) .
Tuyên ngôn
@differentiable public func clipped(min: Tensor, max: Tensor) -> Tensor

Cắt (tối thiểu: tối đa :)

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

Tuyên ngôn

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

Cắt (tối thiểu: tối đa :)

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

Tuyên ngôn

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

Cắt (tối thiểu: tối đa :)

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`

bình phương ()

Tuyên ngôn

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

Có sẵn trong đó `vô hướng ':` TensorFlowFloatingPoint`

isfinite
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 }
isinfinite
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 }
isnan
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`

tất cả()
Trả về true nếu tất cả các vô hướng bằng với true . Nếu không, trả về false .
Tuyên ngôn
public func all() -> Bool
bất kì()
Trả về true nếu bất kỳ vô hướng nào bằng true . Nếu không, trả về false .
Tuyên ngôn
public func any() -> Bool
Tất cả (Squeezingaxes :)
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 để giảm.
Bất kỳ (Squeezingaxes :)
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 để giảm.
Tất cả (cùng với các vấn đề :)
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 để giảm.
bất kỳ (cùng với các bạn :)
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 để giảm.

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

tối thiểu ()

Tuyên ngôn

@differentiable
public func min() -> Tensor

Max ()

Tuyên ngôn

@differentiable
public func max() -> Tensor

Max (Squeezingaxes :)
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 để giảm.
Max (Squeezingaxes :)
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 để giảm.
Max (Squeezingaxes :)
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 để giảm.
Min (Squeezingaxes :)
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 để giảm.
Min (Squeezingaxes :)
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 để giảm.
Min (Squeezingaxes :)
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 để giảm.
Argmax (Squeezingaxis :)
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 để giảm.
Argmin (Squeezingaxis :)
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 để giảm.
Tối thiểu (cùng với những người :)
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 để giảm.
Tối thiểu (cùng với những người :)
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 để giảm.
Tối thiểu (cùng với những người :)
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 để giảm.
tối đa (cùng với các vấn đề :)
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 để giảm.
tối đa (cùng với các vấn đề :)
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 để giảm.
tối đa (cùng với các vấn đề :)
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 để giảm.
argmax ()
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>
Argmin ()
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`

Sum (Squeezingaxes :)
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 để giảm.
Sum (Squeezingaxes :)
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 để giảm.
Sum (Squeezingaxes :)
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 để giảm.

tổng()

Tuyên ngôn

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

Sum (cùng với các vấn đề :)
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 để giảm.
Sum (cùng với các vấn đề :)
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 để giảm.
Sum (cùng với các vấn đề :)
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 để giảm.
Sản phẩm (Squeezingaxes :)
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 để giảm.
Sản phẩm (Squeezingaxes :)
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 để giảm.
Sản phẩm (Squeezingaxes :)
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 để giảm.

sản phẩm()

Tuyên ngôn

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

Sản phẩm (cùng với trục :)
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 để giảm.
Sản phẩm (cùng với trục :)
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 để giảm.
Sản phẩm (cùng với trục :)
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 để giảm.
có nghĩa là (Squeezingaxes :)
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 để giảm.
có nghĩa là (Squeezingaxes :)
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 để giảm.
có nghĩa là (Squeezingaxes :)
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 để giảm.

nghĩa là()

Tuyên ngôn

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

có nghĩa là (cùng với trục :)
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 để giảm.
có nghĩa là (cùng với trục :)
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 để giảm.
có nghĩa là (cùng với trục :)
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 để giảm.
Phương sai (Squeezingaxes :)
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 để giảm.
Phương sai (Squeezingaxes :)
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 để giảm.
Phương sai (Squeezingaxes :)
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 để giảm.

phương sai ()

Tuyên ngôn

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

Phương sai (cùng với trục :)
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 để giảm.
Phương sai (cùng với trục :)
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 để giảm.
Phương sai (cùng với trục :)
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 để giảm.

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ả về

Kết quả của hoạt động tổng tích lũy.

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ả về

Kết quả của hoạt động tổng tích lũy.

Sản phẩm tích lũy (cùng với trục: Độc quyền: Đảo ngược :)

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ả về

Kết quả của hoạt động sản phẩm tích lũy.

Sản phẩm tích lũy (cùng với trục: Độc quyền: Đảo ngược :)

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ả về

Kết quả của hoạt động sản phẩm tích lũy.

Có sẵn trong đó `vô hướng ':` TensorFlowFloatingPoint`

StandardDeviation (Squeezingaxes :)
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 để giảm.
StandardDeviation (Squeezingaxes :)
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 để giảm.
StandardDeviation (Squeezingaxes :)
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 để giảm.
StandardDeviation ()
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
StandardDeviation (cùng trục :)
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 để giảm.
StandardDeviation (cùng trục :)
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 để giảm.
StandardDeviation (cùng trục :)
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 để giảm.
LogSumExp (Squeezingaxes :)
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 để giảm.
LogSumExp (Squeezingaxes :)
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 để giảm.
LogSumExp (Squeezingaxes :)
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 để giảm.
logSumExp ()
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
LogSumExp (cùng với các vấn đề :)
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 để giảm.
LogSumExp (cùng với các vấn đề :)
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 để giảm.
LogSumExp (cùng với các vấn đề :)
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 để giảm.
Khoảnh khắc (Squeezingaxes :)
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 để giảm.
Khoảnh khắc (Squeezingaxes :)
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 để giảm.
Khoảnh khắc (Squeezingaxes :)
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 để giảm.
Khoảnh khắc ()
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>
Khoảnh khắc (cùng với trục :)
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 để giảm.
Khoảnh khắc (cùng với trục :)
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 để giảm.
Khoảnh khắc (cùng với trục :)
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 để 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`

VjpinitDeviceAndprecision Like (_: DeviceAndPrecision Like :)

Tuyên ngôn

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

Batchnqualized (cùng với trục: Offset: Scale: Epsilon :)

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ố.

Concatenate (_: _ :)

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

Sum (_: _ :)

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(_:_:)

Trung bình hai giá trị.

Tuyên ngôn

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

Nhân (_: _ :)

Nhân hai giá trị.

Tuyên ngôn

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

Stack (_: _ :)

Xếp hai giá trị.

Tuyên ngôn

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

init (hình dạng :)
Tuyên ngôn
@derivative init(shape: scalars)

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

==(_:_:)

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 ở nơi `Scalar`: `Codable`

mã hóa(sang :)

Tuyên ngôn

public func encode(to encoder: Encoder) throws

init(từ :)

Tuyên ngôn

public init(from decoder: Decoder) throws

Có sẵn trong đó `vô hướng ':` Numeric`

không
Các tenxơ vô hướng bằng khô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
một
Vô hướng một tenor.
Tuyên ngôn
public static var one: Tensor { get }
đối ứng
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`

Tiếp tuyếnVector
Tuyên ngôn
public typealias TangentVector = Tensor

zeroTangentVectorInitializer

Tuyên ngôn

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

chú thích (_ :)
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ả về
Các tenxơ chú thích.

vjpannotate (_ :)

Tuyên ngôn

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

`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.

`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.

`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.

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

`lowerBounds`	Giới hạn dưới ở mỗi chiều.
`upperBounds`	Giới hạn trên ở mỗi chiều.

`shape`	Kích thước của tensor
`repeatedValue`	Giá trị vô hướng cần lặp lại.

`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.

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

`shape`	Hình dạng của tensor.
`scalars`	Nội dung vô hướng của tensor.

`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.

`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.

`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.