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

Array elemen multidimensi yang merupakan generalisasi vektor dan matriks ke dimensi yang berpotensi lebih tinggi.

Parameter generik Scalar menjelaskan jenis skalar di tensor (seperti Int32 , Float , dll).

• menangani
  TensorHandle yang mendasarinya.

  Catatan

  handle bersifat publik untuk mengizinkan operasi yang ditentukan pengguna, tetapi biasanya tidak digunakan.

  Pernyataan

  public let handle: TensorHandle<Scalar>

• init(menangani :)
  Pernyataan

  public init(handle: TensorHandle<Scalar>)

• tidak ditumpuk (sepanjang Axis :)
  Membongkar dimensi tertentu dari tensor peringkat- R menjadi beberapa tensor peringkat- (R-1) . Membongkar N tensor dari tensor ini dengan memotongnya sepanjang dimensi axis , dengan N disimpulkan dari bentuk tensor ini. Misalnya diberikan tensor dengan bentuk [A, B, C, D] :

  • Jika axis == 0 maka tensor ke- i dalam larik yang dikembalikan adalah potongan self[i, :, :, :] dan setiap tensor dalam larik tersebut akan berbentuk [B, C, D] . (Perhatikan bahwa dimensi yang dibongkar akan hilang, tidak seperti Tensor.split(numSplits:alongAxis) , atau Tensor.split(sizes:alongAxis) ).
  • Jika axis == 1 maka tensor ke- i dalam larik yang dikembalikan adalah value[:, i, :, :] dan setiap tensor dalam larik tersebut akan berbentuk [A, C, D] .
  • Dll.

  Ini kebalikan dari Tensor.init(stacking:alongAxis:) .

  Prasyarat

  axis harus berada dalam rentang [-rank, rank) , dengan rank adalah peringkat tensor yang disediakan.

  Pernyataan

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

  Parameter

  axis	Dimensi untuk melepaskan tumpukannya. Nilai-nilai negatif menyelimuti.

  Nilai Pengembalian

  Array berisi tensor yang tidak ditumpuk.

• split (hitungan: sepanjang Sumbu :)
  Membagi tensor menjadi beberapa tensor. Tensor dibagi sepanjang axis dimensi menjadi count tensor yang lebih kecil. Hal ini mengharuskan count membagi shape[axis] secara merata.

  Misalnya:

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

  Prasyarat

  count harus membagi ukuran axis dimensi secara merata.

  Prasyarat

  axis harus berada dalam rentang [-rank, rank) , dengan rank adalah peringkat tensor yang disediakan.

  Pernyataan

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

  Parameter

  count	Jumlah pemisahan yang akan dibuat.
  axis	Dimensi yang digunakan untuk membagi tensor ini. Nilai-nilai negatif menyelimuti.

  Nilai Pengembalian

  Array yang berisi bagian tensor.

• split(ukuran: sepanjangAxis :)
  Membagi tensor menjadi beberapa tensor. Tensor dibagi menjadi beberapa bagian sizes.shape[0] . Bentuk potongan i -i sama dengan tensor ini, kecuali pada axis dimensi yang ukurannya sizes[i] .

  Misalnya:

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

  Prasyarat

  Nilai dalam sizes harus berjumlah hingga ukuran axis dimensi.

  Prasyarat

  axis harus berada dalam rentang [-rank, rank) , dengan rank adalah peringkat tensor yang disediakan.

  Pernyataan

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

  Parameter

  sizes	Tensor 1-D berisi ukuran setiap pemisahan.
  axis	Dimensi untuk membagi tensor ini. Nilai-nilai negatif menyelimuti.

  Nilai Pengembalian

  Array yang berisi bagian tensor.

• split(ukuran: sepanjangAxis :)
  Pernyataan

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

• ubin(kelipatan :)
  Mengembalikan tensor bersusun, yang dibuat dengan menyusun tensor ini.

  Konstruktor ini membuat tensor baru dengan mereplikasi tensor ini multiples kali. Dimensi ke- i tensor yang dibangun memiliki elemen self.shape[i] * multiples[i] , dan nilai tensor ini direplikasi multiples[i] kali sepanjang dimensi i . Misalnya, ubin [abcd] oleh [2] menghasilkan [abcdabcd] .

  Prasyarat

  rank kelipatan yang diharapkan haruslah 1 .

  Prasyarat

  Bentuk multiples harus [tensor.rank] .

  Prasyarat

  Semua skalar dalam multiples harus non-negatif.

  Pernyataan

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

• ubin(kelipatan :)
  Mengembalikan tensor bersusun, yang dibuat dengan menyusun tensor ini.

  Konstruktor ini membuat tensor baru dengan mereplikasi tensor ini multiples kali. Dimensi ke- i tensor yang dibangun memiliki elemen self.shape[i] * multiples[i] , dan nilai tensor ini direplikasi multiples[i] kali sepanjang dimensi i . Misalnya, ubin [abcd] oleh [2] menghasilkan [abcdabcd] .

  Prasyarat

  rank kelipatan yang diharapkan haruslah 1 .

  Prasyarat

  Bentuk multiples harus [tensor.rank] .

  Pernyataan

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

• dibentuk kembali (seperti :)
  Bentuk ulang menjadi bentuk Tensor yang ditentukan.

  Prasyarat

  Jumlah skalar sesuai dengan bentuk baru.

  Pernyataan

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

• dibentuk kembali (ke :)
  Bentuk kembali ke bentuk yang ditentukan.

  Prasyarat

  Jumlah skalar sesuai dengan bentuk baru.

  Pernyataan

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

• dibentuk kembali (menjadi Bentuk :)
  Bentuk ulang menjadi Tensor tertentu yang mewakili suatu bentuk.

  Prasyarat

  Jumlah skalar sesuai dengan bentuk baru.

  Pernyataan

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

• diratakan()
  Mengembalikan salinan tensor yang diciutkan menjadi Tensor 1-D, dalam urutan baris-utama.

  Pernyataan

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

• memperluasBentuk(di:)
  Mengembalikan Tensor yang diperluas bentuknya, dengan dimensi 1 yang disisipkan pada indeks bentuk yang ditentukan.

  Pernyataan

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

• memperluasBentuk(di:)
  Mengembalikan Tensor yang diperluas bentuknya, dengan dimensi 1 yang disisipkan pada indeks bentuk yang ditentukan.

  Pernyataan

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

• peringkat terangkat()
  Mengembalikan Tensor yang dinaikkan peringkatnya dengan dimensi terdepan 1.

  Pernyataan

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

• meremasBentuk(di:)
  Menghapus dimensi ukuran 1 yang ditentukan dari bentuk tensor. Jika tidak ada dimensi yang ditentukan, maka semua dimensi ukuran 1 akan dihapus.

  Pernyataan

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

• meremasBentuk(di:)
  Menghapus dimensi ukuran 1 yang ditentukan dari bentuk tensor. Jika tidak ada dimensi yang ditentukan, maka semua dimensi ukuran 1 akan dihapus.

  Pernyataan

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

• dialihkan (permutasi :)
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan yang ditentukan.

  Pernyataan

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

• dialihkan(denganPermutasi :)
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan yang ditentukan.

  Pernyataan

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

• dialihkan (permutasi :)
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan yang ditentukan.

  Pernyataan

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

• dialihkan(denganPermutasi :)
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan yang ditentukan.

  Pernyataan

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

• dialihkan (permutasi :)
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan yang ditentukan.

  Pernyataan

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

• dialihkan(denganPermutasi :)
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan yang ditentukan.

  Pernyataan

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

• dialihkan()
  Mengembalikan tensor yang dialihkan, dengan dimensi yang diubah dalam urutan terbalik.

  Pernyataan

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

• terbalik (dalam Sumbu :)
  Mengembalikan tensor dengan dimensi tertentu yang dibalik.

  Prasyarat

  Setiap nilai dalam axes harus berada dalam rentang -rank..<rank .

  Prasyarat

  Tidak boleh ada duplikasi pada axes .

  Pernyataan

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

• terbalik (dalam Sumbu :)
  Mengembalikan tensor dengan dimensi tertentu yang dibalik.

  Prasyarat

  Setiap nilai dalam axes harus berada dalam rentang -rank..<rank .

  Prasyarat

  Tidak boleh ada duplikasi pada axes .

  Pernyataan

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

• terbalik (dalam Sumbu :)
  Mengembalikan tensor dengan dimensi tertentu yang dibalik.

  Prasyarat

  Setiap nilai dalam axes harus berada dalam rentang -rank..<rank .

  Prasyarat

  Tidak boleh ada duplikasi pada axes .

  Pernyataan

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

• digabungkan (dengan: sepanjang Axis :)
  Mengembalikan tensor gabungan sepanjang sumbu yang ditentukan.

  Prasyarat

  Tensor harus memiliki dimensi yang sama, kecuali sumbu yang ditentukan.

  Prasyarat

  Sumbu harus berada dalam kisaran -rank..<rank .

  Pernyataan

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

• ++(_:_:)
  Operator penggabungan.

  Catatan

  ++ adalah operator khusus yang tidak ada di Swift, tetapi ada di Haskell/Scala. Penambahannya bukanlah perubahan bahasa yang signifikan dan mungkin kontroversial. Keberadaan/penamaan ++ akan dibahas pada tahap desain API selanjutnya.

  Pernyataan

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

• pengumpulan (di Indeks: sepanjang Sumbu :)
  Mengembalikan tensor dengan mengumpulkan potongan masukan pada indices sepanjang dimensi axis

  Untuk indices 0-D (skalar):

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

  Untuk indices 1-D (vektor):

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

  Dalam kasus umum, menghasilkan tensor yang dihasilkan dimana:

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

  dimana N = self.rank dan M = indices.rank .

  Bentuk tensor yang dihasilkan adalah: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

  Catatan

  Pada CPU, jika ditemukan indeks di luar jangkauan, kesalahan akan terjadi. Pada GPU, jika ditemukan indeks di luar jangkauan, angka 0 disimpan dalam nilai keluaran yang sesuai.

  Prasyarat

  axis harus berada dalam kisaran [-rank, rank) .

  Pernyataan

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

  Parameter

  indices	Berisi indeks untuk dikumpulkan.
  axis	Dimensi tempat berkumpulnya. Nilai-nilai negatif menyelimuti.

  Nilai Pengembalian

  Tensor yang berkumpul.

• batchGathering(diIndices:alongAxis:batchDimensionCount:)
  Mengembalikan irisan tensor ini pada indices sepanjang dimensi axis , sambil mengabaikan dimensi batchDimensionCount pertama yang sesuai dengan dimensi batch. Pengumpulan dilakukan sepanjang dimensi non-batch pertama.

  Melakukan fungsi serupa dengan gathering , kecuali bentuk tensor yang dihasilkan sekarang menjadi shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

  Prasyarat

  axis harus berada dalam rentang -rank..<rank , dan juga lebih besar dari atau sama dengan batchDimensionCount .

  Prasyarat

  batchDimensionCount harus kurang dari indices.rank .

  Pernyataan

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

  Parameter

  indices	Berisi indeks yang akan dikumpulkan.
  axis	Dimensi tempat berkumpulnya. Nilai-nilai negatif menyelimuti.
  batchDimensionCount	Jumlah dimensi batch terdepan yang harus diabaikan.

  Nilai Pengembalian

  Tensor yang berkumpul.

• berkumpul (di mana: sepanjang Axis :)
  Mengembalikan tensor dengan mengumpulkan nilai setelah menerapkan masker boolean yang disediakan ke masukan.

  Misalnya:

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

  Secara umum, 0 < mask.rank = K <= tensor.rank , dan bentuk mask harus sesuai dengan dimensi K pertama dari bentuk tensor . Kita kemudian memiliki: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , di mana [i1, ..., iK] adalah entri mask i true (urutan baris-utama).

  axis dapat digunakan dengan mask untuk menunjukkan sumbu yang akan dijadikan mask. Dalam hal ini, axis + mask.rank <= tensor.rank dan bentuk mask 's shape must match the first dimensions of the bentuk tensor.

  Prasyarat

  mask tidak boleh berupa skalar: mask.rank != 0 .

  Pernyataan

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

  Parameter

  mask	Tensor boolean KD, dengan K <= self.rank .
  axis	Tensor bilangan bulat 0-D yang mewakili sumbu self yang akan disamarkan, dengan K + axis <= self.rank .

  Nilai Pengembalian

  (self.rank - K + 1) -tensor dimensi diisi oleh entri dalam tensor ini yang sesuai dengan nilai true dalam mask .

• bukanZeroIndeks()
  Mengembalikan lokasi nilai bukan nol/benar di tensor ini.

  Koordinat dikembalikan dalam tensor 2D dengan dimensi pertama (baris) mewakili jumlah elemen bukan nol, dan dimensi kedua (kolom) mewakili koordinat elemen bukan nol. Perlu diingat bahwa bentuk tensor keluaran dapat bervariasi bergantung pada berapa banyak nilai sebenarnya yang ada dalam tensor tersebut. Indeks dikeluarkan dalam urutan baris-utama.

  Misalnya:

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

  Pernyataan

  public func nonZeroIndices() -> Tensor<Int64>

  Nilai Pengembalian

  Tensor dengan bentuk (num_true, rank(condition)) .

• disiarkan (keBentuk :)
  Pernyataan

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

• disiarkan (ke :)
  Pernyataan

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

• disiarkan (seperti :)
  Disiarkan ke bentuk yang sama dengan Tensor yang ditentukan.

  Prasyarat

  Bentuk yang ditentukan harus kompatibel untuk penyiaran.

  Pernyataan

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

• .=(_:_:)
  Pernyataan

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

• irisan(Batas Bawah:Batas Atas :)
  Mengekstrak potongan dari tensor yang ditentukan oleh batas bawah dan atas untuk setiap dimensi.

  Pernyataan

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

  Parameter

  lowerBounds	Batas bawah di setiap dimensi.
  upperBounds	Batas atas di setiap dimensi.

• irisan(batas bawah:ukuran :)
  Pernyataan

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

• irisan(batas bawah:ukuran :)
  Pernyataan

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

• subskrip(_:)
  Pernyataan

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

• pastikanValid(sumbu:fungsi:file:baris :)
  Memeriksa apakah setiap elemen axes menunjukkan sumbu self , dan menghentikan program dengan diagnostik sebaliknya.

  Pernyataan

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

• pastikanValid(sumbu:fungsi:file:baris :)
  Memeriksa apakah setiap elemen axes menunjukkan sumbu self , dan menghentikan program dengan diagnostik sebaliknya.

  Pernyataan

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

• pastikanValid(sumbu:fungsi:file:garis :)
  Memeriksa apakah k menunjukkan sumbu self , dan menghentikan program dengan diagnostik sebaliknya.

  Pernyataan

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

• init(menyusun :)
  Pernyataan

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

• init(menyalin:ke :)
  Membuat salinan other pada Device yang diberikan.

  Pernyataan

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

• init(bentuk:berulang :)
  Membuat tensor dengan bentuk tertentu dan nilai skalar tunggal yang berulang.

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  repeatedValue	Nilai skalar yang akan diulang.

• init(berulang:bentuk:aktif :)
  Membuat tensor dengan bentuk tertentu dan nilai skalar tunggal yang berulang.

  Pernyataan

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

  Parameter

  repeatedValue	Nilai skalar yang akan diulang.
  shape	Dimensi tensor.

• init(penyiaran:peringkat:aktif :)
  Membuat tensor dengan menyiarkan skalar tertentu ke peringkat tertentu dengan semua dimensi menjadi 1.

  Pernyataan

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

• init(_:)
  Membuat tensor dari array tensor (yang mungkin merupakan skalar).

  Pernyataan

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

• init(menumpuk:sepanjangAxis:)
  Menumpuk tensors , sepanjang dimensi axis , menjadi tensor baru dengan peringkat satu lebih tinggi dari tensor saat ini dan setiap tensor dalam tensors .

  Mengingat semua tensors mempunyai bentuk [A, B, C] , dan tensors.count = N , maka:

  • jika axis == 0 maka tensor yang dihasilkan akan berbentuk [N, A, B, C] .
  • jika axis == 1 maka tensor yang dihasilkan akan berbentuk [A, N, B, C] .
  • dll.

  Misalnya:

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

  Ini kebalikan dari Tensor.unstacked(alongAxis:) .

  Prasyarat

  Semua tensor harus mempunyai bentuk yang sama.

  Prasyarat

  axis harus berada dalam rentang [-rank, rank) , dengan rank adalah peringkat tensor yang disediakan.

  Pernyataan

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

  Parameter

  tensors	Tensor untuk ditumpuk.
  axis	Dimensi yang akan ditumpuk. Nilai-nilai negatif menyelimuti.

  Nilai Pengembalian

  Tensor bertumpuk.

• init(penggabungan: sepanjangAxis :)
  Menggabungkan tensors sepanjang dimensi axis .

  Mengingat tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , maka hasil gabungannya berbentuk [D0, D1, ... Raxis, ...Dn] , dimana Raxis = sum(Daxis(i)) . Artinya, data dari tensor masukan digabungkan sepanjang dimensi axis .

  Misalnya:

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

  Catatan

  Jika Anda menggabungkan sepanjang sumbu baru, pertimbangkan untuk menggunakan Tensor.init(stacking:alongAxis:) .

  Prasyarat

  Semua tensor harus mempunyai rank yang sama dan semua dimensi kecuali axis harus sama.

  Prasyarat

  axis harus berada dalam rentang [-rank, rank) , dengan rank adalah peringkat tensor yang disediakan.

  Pernyataan

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

  Parameter

  tensors	Tensor untuk digabungkan.
  axis	Dimensi yang akan digabungkan. Nilai-nilai negatif menyelimuti.

  Nilai Pengembalian

  Tensor gabungan.

• mengganti (dengan: di mana :)
  Menggantikan elemen tensor ini dengan other di jalur yang mask true .

  Prasyarat

  self dan other harus mempunyai bentuk yang sama. Jika self dan other adalah skalar, maka mask juga harus berupa skalar. Jika self dan other memiliki peringkat lebih besar atau sama dengan 1 , maka mask harus memiliki bentuk yang sama dengan self atau berupa Tensor 1-D sehingga mask.scalarCount == self.shape[0] .

  Pernyataan

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

• adalahReduksiPresisi
  Mengembalikan nilai benar jika tipe skalar fisik dikurangi presisinya.

  Saat ini, jenis skalar fisik presisi rendah hanya mencakup BFloat16 .

  Pernyataan

  public var isReducedPrecision: Bool { get }

• init(_:deviceAndPrecisionLike:)
  Mempromosikan skalar menjadi tensor dengan perangkat dan presisi yang sama dengan tensor yang diberikan.

  Pernyataan

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

• untuk Mengurangi Presisi
  Mengembalikan salinan self yang dikonversi ke tipe skalar fisik BFloat16 .

  Pernyataan

  public var toReducedPrecision: `Self` { get }

• ke Presisi Penuh
  Mengembalikan salinan self yang dikonversi ke tipe skalar fisik Scalar .

  Pernyataan

  public var toFullPrecision: `Self` { get }

• pangkat
  Jumlah dimensi Tensor .

  Pernyataan

  public var rank: Int { get }

• membentuk
  Bentuk Tensor .

  Pernyataan

  public var shape: TensorShape { get }

• jumlah skalar
  Jumlah skalar di Tensor .

• jumlah skalar
  Pernyataan

  public var scalarCount: Int { get }

• peringkatTensor
  Pangkat tensor, direpresentasikan sebagai Tensor<Int32> .

  Pernyataan

  public var rankTensor: Tensor<Int32> { get }

• bentukTensor
  Dimensi tensor, direpresentasikan sebagai Tensor<Int32> .

  Pernyataan

  public var shapeTensor: Tensor<Int32> { get }

• scalarCountTensor
  Jumlah skalar dalam tensor, direpresentasikan sebagai Tensor<Int32> .

  Pernyataan

  public var scalarCountTensor: Tensor<Int32> { get }

• adalah Skalar
  Mengembalikan true jika rank sama dengan 0 dan false jika sebaliknya.

  Pernyataan

  public var isScalar: Bool { get }

• skalar
  Mengembalikan elemen skalar tunggal jika rank sama dengan 0 dan nil sebaliknya.

  Pernyataan

  public var scalar: Scalar? { get }

• terskalakan()
  Bentuk ulang menjadi skalar.

  Prasyarat

  Tensor mempunyai tepat satu skalar.

  Pernyataan

  @differentiable
  public func scalarized() -> Scalar

• susunan
  Pernyataan

  public var array: ShapedArray<Scalar> { get }

• skalar
  Pernyataan

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

• init(_:pada:)
  Membuat tensor 0-D dari nilai skalar.

  Pernyataan

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

• init(_:pada:)
  Membuat tensor 1D dari skalar.

  Pernyataan

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

• init(_:pada:)
  Membuat tensor 1D dari skalar.

  Pernyataan

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

• init(bentuk:skalar:on:)
  Membuat tensor dengan bentuk tertentu dan skalar yang berdekatan dalam urutan baris-utama.

  Prasyarat

  Hasil kali dimensi bangun harus sama dengan jumlah skalar.

  Pernyataan

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

  Parameter

  shape	Bentuk tensornya.
  scalars	Isi skalar tensor.

• init(bentuk:skalar:on:)
  Membuat tensor dengan bentuk tertentu dan skalar yang berdekatan dalam urutan baris-utama.

  Prasyarat

  Hasil kali dimensi bangun harus sama dengan jumlah skalar.

  Pernyataan

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

  Parameter

  shape	Bentuk tensornya.
  scalars	Isi skalar tensor.

• init(bentuk:skalar:toReductionPrecision:directlyOn:)
  Membuat tensor dengan bentuk tertentu dan skalar yang berdekatan dalam urutan baris-utama.

  Prasyarat

  Hasil kali dimensi bangun harus sama dengan jumlah skalar.
• init(bentuk:skalar:on:)
  Membuat tensor dengan bentuk tertentu dan skalar yang berdekatan dalam urutan baris-utama.

  Prasyarat

  Hasil kali dimensi bangun harus sama dengan jumlah skalar.

  Pernyataan

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

  Parameter

  shape	Bentuk tensornya.
  scalars	Isi skalar tensor.

• ArrayLiteralElement
  Tipe elemen array literal.

  Pernyataan

  public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

• init(arrayLiteral :)
  Membuat tensor yang diinisialisasi dengan elemen tertentu.

  Pernyataan

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

• keterangan
  Representasi tekstual tensor.

  Catatan

  gunakan fullDescription untuk deskripsi yang tidak dicetak cantik yang menampilkan semua skalar.

  Pernyataan

  public var description: String { get }

• deskripsi(Lebar Garis:EdgeElementCount:meringkas:)
  Representasi tekstual tensor. Mengembalikan deskripsi ringkasan jika summarize benar dan jumlah elemen melebihi dua kali edgeElementCount .

  Pernyataan

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

  Parameter

  lineWidth	Lebar garis maksimal untuk pencetakan. Digunakan untuk menentukan jumlah skalar yang akan dicetak per baris.
  edgeElementCount	Jumlah maksimum elemen yang akan dicetak sebelum dan sesudah peringkasan melalui elips ( ... ).
  summarizing	Jika benar, rangkum deskripsi jika jumlah elemen melebihi dua kali edgeElementCount .

• Deskripsi lengkap
  Representasi tekstual tensor yang lengkap dan tidak dicetak dengan indah, menampilkan semua skalar.

  Pernyataan

  public var fullDescription: String { get }

• teks ir
• Deskripsi taman bermain
  Pernyataan

  public var playgroundDescription: Any { get }

• cermin khusus
  Pernyataan

  public var customMirror: Mirror { get }

• anotasi
  Anotasi yang menjelaskan tensor ini.

  Pernyataan

  public var annotations: String { get }

• ringkasan
  Alias ​​untuk anotasi.

  Pernyataan

  public var summary: String { get }

• init(_memiliki:)
  Pernyataan

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

• init(_menangani:)
  Pernyataan

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

• init(_:pada:)
  Pernyataan

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

• init(_xla:)
  Pernyataan

  init(_xla: XLATensor)

• init(_xlaHandle:)
  Pernyataan

  init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

• xlaHandle
  Pernyataan

  var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

• xlaTensor
  Pernyataan

  var xlaTensor: XLATensor { get }

Tersedia di mana `Skalar`: `Numerik`

• tidak disiarkan (ke Bentuk :)
  Pernyataan

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

• tidak disiarkan (seperti :)
  Pernyataan

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

• tidak disiarkan (ke :)
  Pernyataan

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

• Mode Padding
  Mode yang menentukan bagaimana tensor diberi bantalan.

  Pernyataan

  public enum PaddingMode

• empuk (untuk Ukuran: dengan :)
  Mengembalikan tensor yang diisi dengan konstan sesuai dengan ukuran bantalan yang ditentukan.

  Pernyataan

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

• empuk (untuk Ukuran: mode :)
  Mengembalikan tensor empuk sesuai dengan ukuran dan mode padding yang ditentukan.

  Pernyataan

  @differentiable(wrt: self)
  public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor

Tersedia di mana `Skalar`: `Numerik` & `Sebanding`

• .<(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs < rhs berdasarkan elemen.

  Pernyataan

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

• .<=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs <= rhs berdasarkan elemen.

  Pernyataan

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

• .>(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs > rhs berdasarkan elemen.

  Pernyataan

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

• .>=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs >= rhs berdasarkan elemen.

  Pernyataan

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

• .<(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs < rhs berdasarkan elemen.

  Catatan

  .< mendukung penyiaran.

  Pernyataan

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

• .<=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs <= rhs berdasarkan elemen.

  Catatan

  .<= mendukung penyiaran.

  Pernyataan

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

• .>(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs > rhs berdasarkan elemen.

  Catatan

  .> mendukung penyiaran.

  Pernyataan

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

• .>=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs >= rhs berdasarkan elemen.

  Catatan

  .>= mendukung penyiaran.

  Pernyataan

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

• .<(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs < rhs berdasarkan elemen.

  Catatan

  .< mendukung penyiaran.

  Pernyataan

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

• .<=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs <= rhs berdasarkan elemen.

  Catatan

  .<= mendukung penyiaran.

  Pernyataan

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

• .>(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs > rhs berdasarkan elemen.

  Catatan

  .> mendukung penyiaran.

  Pernyataan

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

• .>=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs >= rhs berdasarkan elemen.

  Catatan

  .>= mendukung penyiaran.

  Pernyataan

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

Tersedia di mana `Skalar`: `Equatable`

• .==(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs == rhs berdasarkan elemen.

  Catatan

  .== mendukung penyiaran.

  Pernyataan

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

• .!=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs != rhs berdasarkan elemen.

  Catatan

  .!= mendukung penyiaran.

  Pernyataan

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

• .==(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs == rhs berdasarkan elemen.

  Catatan

  .== mendukung penyiaran.

  Pernyataan

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

• .!=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs != rhs berdasarkan elemen.

  Catatan

  .!= mendukung penyiaran.

  Pernyataan

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

• .==(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs == rhs berdasarkan elemen.

  Catatan

  .== mendukung penyiaran.

  Pernyataan

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

• .!=(_:_:)
  Mengembalikan tensor skalar Boolean dengan menghitung lhs != rhs berdasarkan elemen.

  Catatan

  .!= mendukung penyiaran.

  Pernyataan

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

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint` & `Equatable`

• elemenAlmostEqual(_:toleransi:)
  Mengembalikan tensor nilai Boolean yang menunjukkan apakah elemen self kira-kira sama dengan elemen other .

  Prasyarat

  self dan other harus memiliki bentuk yang sama.

  Pernyataan

  public func elementsAlmostEqual(
    _ other: Tensor,
    tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
  ) -> Tensor<Bool>

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• isAlmostEqual(untuk:toleransi :)
  Mengembalikan true jika semua elemen self kira-kira sama dengan elemen other .

  Prasyarat

  self dan other harus memiliki bentuk yang sama.

  Pernyataan

  public func isAlmostEqual(
    to other: Tensor,
    tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
  ) -> Bool

Tersedia di mana `Skalar`: `TensorFlowNumeric`

• crossReplicaSum(_:)
  Menjalankan jumlah replika silang untuk tensor ini. Penjumlahan replika silang yang sama harus terjadi pada setiap perangkat lain yang berpartisipasi dalam penjumlahan tersebut.

  Pernyataan

  public mutating mutating func crossReplicaSum(_ scale: Double)

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• init(berulang :)
  Pernyataan

  @derivative
  init(repeating: shape)

Tersedia di mana `Skalar`: `Numerik`

• init(_:)
  Lakukan konversi tipe berdasarkan elemen dari tensor Bool .

  Pernyataan

  public init(_ other: Tensor<Bool>)

• init(_:)
  Lakukan konversi berdasarkan elemen dari Tensor lain.

  Pernyataan

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

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• init(_:)
  Pernyataan

  @derivative
  init(_: <<error type>>)

• init(menumpuk :)
  Pernyataan

  @derivative
  init(stacking: alongAxis)

• init(menggabungkan :)
  Pernyataan

  @derivative
  init(concatenating: alongAxis)

Tersedia di mana `Skalar`: `Numerik`

• init(nol:on:)
  Membuat tensor dengan semua skalar disetel ke nol.

  Pernyataan

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

  Parameter

  shape

  Bentuk tensornya.

• init(yang:on :)
  Membuat tensor dengan semua skalar disetel ke satu.

  Pernyataan

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

  Parameter

  shape

  Bentuk tensornya.

• init(nolSuka :)
  Membuat tensor dengan semua skalar disetel ke nol yang memiliki bentuk dan jenis yang sama dengan tensor yang disediakan.

  Pernyataan

  public init(zerosLike other: Tensor)

  Parameter

  other

  Tensor yang bentuk dan tipe datanya akan digunakan.

• init(yang Suka :)
  Membuat tensor dengan semua skalar disetel ke bentuk dan jenis yang sama dengan tensor yang disediakan.

  Pernyataan

  public init(onesLike other: Tensor)

  Parameter

  other

  Tensor yang bentuk dan tipe datanya akan digunakan.

• init(rentangDari:ke:langkah:on:)
  Membuat tensor 1-D yang mewakili urutan dari nilai awal hingga, namun tidak termasuk, nilai akhir, dengan jumlah yang ditentukan.

  Pernyataan

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

  Parameter

  start	Nilai awal yang digunakan untuk urutan. Jika urutannya berisi nilai apa pun, yang pertama adalah start .
  end	Nilai akhir untuk membatasi urutan. end tidak pernah menjadi elemen dari barisan yang dihasilkan.
  stride	Jumlah yang harus diambil pada setiap iterasi. stride harus positif.

• init(rentangDari:ke:langkah :)
  Membuat tensor 1-D yang mewakili urutan dari nilai awal hingga, namun tidak termasuk, nilai akhir, dengan jumlah yang ditentukan.

  Pernyataan

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

  Parameter

  start	Nilai awal yang digunakan untuk urutan. Jika urutan berisi nilai apa pun, yang pertama adalah start .
  end	Nilai akhir untuk membatasi urutan. end tidak pernah menjadi elemen dari barisan yang dihasilkan.
  stride	Jumlah yang harus diambil pada setiap iterasi. stride harus positif.

• init(oneHotAtIndices:kedalaman:onValue:offValue:axis :)
  Membuat tensor one-hot pada indeks tertentu. Lokasi yang diwakili oleh indices mengambil nilai onValue ( 1 secara default), sedangkan semua lokasi lainnya mengambil nilai offValue ( 0 secara default). Jika indices masukannya adalah peringkat n , tensor baru akan memiliki peringkat n+1 . Sumbu baru dibuat pada axis dimensi (secara default, sumbu baru ditambahkan di akhir).

  Jika indices berupa skalar, bentuk tensor baru akan berupa vektor panjang depth .

  Jika indices adalah vektor features panjang, bentuk keluarannya adalah: fitur x kedalaman, jika sumbu == -1 kedalaman x fitur, jika sumbu == 0

  Jika indices adalah matriks (batch) dengan bentuk [batch, features] , bentuk keluarannya adalah: batch x fitur x kedalaman, jika sumbu == -1 kumpulan x kedalaman x fitur, jika sumbu == 1 kedalaman x kumpulan x fitur , jika sumbu == 0

  Pernyataan

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

  Parameter

  indices	Tensor indeks.
  depth	Skalar yang menentukan kedalaman satu dimensi panas.
  onValue	Skalar yang menentukan nilai pada lokasi yang dirujuk oleh beberapa indeks dalam indices .
  offValue	Skalar yang menentukan nilai di lokasi yang tidak dirujuk oleh indeks mana pun dalam indices .
  axis	Sumbu untuk diisi. Standarnya adalah -1 , sumbu paling dalam yang baru.

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• init(linearSpaceFrom:ke:count:on:)
  Membuat tensor 1-D yang mewakili urutan dari nilai awal, hingga dan termasuk nilai akhir, dengan jarak yang merata untuk menghasilkan jumlah nilai yang ditentukan.

  Pernyataan

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

  Parameter

  start	Nilai awal yang digunakan untuk urutan. Jika urutan berisi nilai apa pun, yang pertama adalah start .
  end	Nilai akhir untuk membatasi urutan. end adalah elemen terakhir dari urutan yang dihasilkan.
  count	Jumlah nilai dalam urutan yang dihasilkan. count harus positif.

• init(linearSpaceFrom:ke:hitungan :)
  Membuat tensor 1-D yang mewakili urutan dari nilai awal, hingga dan termasuk nilai akhir, dengan jarak yang merata untuk menghasilkan jumlah nilai yang ditentukan.

  Prasyarat

  start , to , dan count harus berupa Tensor yang berisi satu nilai Skalar.

  Pernyataan

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

  Parameter

  start	Nilai awal yang digunakan untuk urutan. Jika urutan berisi nilai apa pun, yang pertama adalah start .
  end	Nilai akhir untuk membatasi urutan. end adalah elemen terakhir dari urutan yang dihasilkan.
  count	Jumlah nilai dalam urutan yang dihasilkan. count harus positif.

Tersedia di mana `Scalar`: `TensorFlowIndex`

• init(randomUniform:lowerBound:upperBound:seed:on :)
  Membuat tensor dengan bentuk tertentu, mengambil sampel nilai skalar secara acak dari distribusi seragam antara lowerBound dan upperBound .

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  lowerBound	Batas bawah distribusi.
  upperBound	Batas atas distribusi.
  seed	Nilai benih.

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• init(randomUniform:lowerBound:upperBound:seed:on :)
  Membuat tensor dengan bentuk tertentu, mengambil sampel nilai skalar secara acak dari distribusi seragam antara lowerBound dan upperBound .

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  lowerBound	Batas bawah distribusi.
  upperBound	Batas atas distribusi.
  seed	Nilai benih.

• init(randomNormal:mean:standardDeviation:seed:on :)
  Membuat tensor dengan bentuk tertentu, mengambil sampel nilai skalar secara acak dari distribusi normal.

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  mean	Arti dari distribusi.
  standardDeviation	Simpangan baku distribusi.
  seed	Nilai benih.

• init(randomTruncatedNormal:mean:standardDeviation:seed:on:)
  Membuat tensor dengan bentuk tertentu, mengambil sampel nilai skalar secara acak dari distribusi Normal yang terpotong.

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  mean	Arti dari distribusi.
  standardDeviation	Simpangan baku distribusi.
  seed	Nilai benih.

Tersedia di mana `Scalar`: `TensorFlowIndex`

• init(randomCategorialLogits:sampleCount:seed :)
  Membuat tensor dengan mengambil sampel dari distribusi kategorikal.

  Pernyataan

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

  Parameter

  randomCategorialLogits	Tensor 2-D dengan bentuk [batchSize, classCount] . Setiap irisan [i, :] mewakili probabilitas log yang tidak dinormalisasi untuk semua kelas.
  sampleCount	0-D. Jumlah sampel independen yang diambil untuk setiap irisan baris.
  seed	Nilai benih.

  Nilai Pengembalian

  Tensor 2-D dengan bentuk [batchSize, sampleCount] . Setiap irisan [i, :] berisi label kelas yang digambar dengan rentang [0, classCount) .

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• init(glorotUniform:seed:on :)
  Membuat tensor dengan bentuk yang ditentukan dengan melakukan inisialisasi seragam Glorot (Xavier).

  Ini mengambil sampel acak dari distribusi seragam antara -limit dan limit yang dihasilkan oleh generator bilangan acak default, dengan limit adalah sqrt(6 / (fanIn + fanOut)) dan fanIn / fanOut mewakili jumlah fitur masukan dan keluaran dikalikan dengan fitur reseptif ukuran lapangan.

  Referensi: “Memahami kesulitan melatih jaringan saraf feedforward yang dalam”

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  seed	Nilai benih.

• init(glorotNormal:seed:on:)
  Membuat tensor dengan bentuk yang ditentukan dengan melakukan inisialisasi normal Glorot (Xavier).

  Ini mengambil sampel acak dari distribusi normal terpotong yang berpusat pada 0 dengan deviasi standar sqrt(2 / (fanIn + fanOut)) yang dihasilkan oleh generator angka acak default, di mana fanIn / fanOut mewakili jumlah fitur input dan output dikalikan dengan bidang reseptif ukuran.

  Referensi: “Memahami kesulitan melatih jaringan saraf feedforward yang dalam”

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  seed	Nilai benih.

• init(heUniform:seed:on :)
  Membuat tensor dengan bentuk yang ditentukan dengan melakukan inisialisasi seragam He (Kaiming).

  Ini mengambil sampel acak dari distribusi seragam antara -limit dan limit yang dihasilkan oleh generator angka acak default, dengan limit adalah sqrt(6 / fanIn) dan fanIn mewakili jumlah fitur input dikalikan dengan ukuran bidang reseptif.

  Referensi: “Mendalami Penyearah: Melampaui Kinerja Tingkat Manusia pada Klasifikasi ImageNet”

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  seed	Nilai benih.

• init(heNormal:seed:on :)
  Membuat tensor dengan bentuk yang ditentukan dengan melakukan inisialisasi normal He (Kaiming).

  Ini mengambil sampel acak dari distribusi normal terpotong yang berpusat pada 0 dengan deviasi standar sqrt(2 / fanIn)) yang dihasilkan oleh generator angka acak default, di mana fanIn mewakili jumlah fitur input dikalikan dengan ukuran bidang reseptif.

  Referensi: “Mendalami Penyearah: Melampaui Kinerja Tingkat Manusia pada Klasifikasi ImageNet”

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  seed	Nilai benih.

• init(leCunUniform:seed:on:)
  Membuat tensor dengan bentuk tertentu dengan melakukan inisialisasi seragam LeCun.

  Ini mengambil sampel acak dari distribusi seragam antara -limit dan limit yang dihasilkan oleh generator angka acak default, dengan limit adalah sqrt(3 / fanIn) dan fanIn mewakili jumlah fitur input dikalikan dengan ukuran bidang reseptif.

  Referensi: “BackProp Efisien”

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  seed	Nilai benih.

• init(leCunNormal:seed:on:)
  Membuat tensor dengan bentuk yang ditentukan dengan melakukan inisialisasi normal LeCun.

  Ini mengambil sampel acak dari distribusi normal terpotong yang berpusat pada 0 dengan deviasi standar sqrt(1 / fanIn) yang dihasilkan oleh generator angka acak default, di mana fanIn mewakili jumlah fitur input dikalikan dengan ukuran bidang reseptif.

  Referensi: “BackProp Efisien”

  Pernyataan

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

  Parameter

  shape	Dimensi tensor.
  seed	Nilai benih.

• init(ortogonal: keuntungan: benih :)
  Membuat matriks atau tensor ortogonal.

  Jika bentuk tensor yang akan diinisialisasi adalah dua dimensi, maka diinisialisasi dengan matriks ortogonal yang diperoleh dari dekomposisi QR matriks bilangan acak yang diambil dari distribusi normal. Jika matriks memiliki lebih sedikit baris daripada kolom maka keluarannya akan memiliki baris ortogonal. Jika tidak, keluarannya akan memiliki kolom ortogonal.

  Jika bentuk tensor yang akan diinisialisasi lebih dari dua dimensi, matriks berbentuk [shape[0] * ... * shape[rank - 2], shape[rank - 1]] diinisialisasi. Matriks tersebut kemudian dibentuk ulang untuk memberikan tensor bentuk yang diinginkan.

  Pernyataan

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

  Parameter

  shape	Bentuk tensornya.
  gain	Faktor perkalian yang diterapkan pada tensor ortogonal.
  seed	Tuple dua bilangan bulat untuk menyemai generator nomor acak.

Tersedia di mana `Skalar`: `TensorFlowNumeric`

• bagian diagonal()
  Mengembalikan bagian diagonal [batched] dari tensor [batched]. Untuk instance tensor berbentuk [..., M, N] , keluarannya adalah tensor berbentuk [..., K] , dengan K sama dengan min(N, M) .

  Misalnya:

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

  Pernyataan

  @differentiable
  public func diagonalPart() -> Tensor

• diagonal()
  Membangun array diagonal [batch]. Untuk instance tensor berbentuk [..., M] , keluarannya adalah tensor berbentuk [..., M, M] .

  Misalnya:

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

  Pernyataan

  @differentiable
  public func diagonal() -> Tensor

• denganDiagonal(_:)
  Mengembalikan self dengan nilai diagonal baru, mengingat self adalah matriks batch opsional.

  Tensor yang dikembalikan memiliki bentuk dan nilai yang sama dengan self , kecuali untuk diagonal tertentu dari matriks terdalam yang ditimpa oleh nilai dalam diagonal .

  Parameter diagonal: Tensor dengan rank - 1 mewakili nilai diagonal baru.

  Pernyataan

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

• bagian band(_:_:)
  Pernyataan

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

• bandPart(Jumlah subdiagonal:Jumlah superdiagonal :)
  Mengembalikan salinan tensor terdalam yang ditentukan oleh batas pita pusat. Outputnya adalah tensor dengan bentuk yang sama dengan instance [..., :, :] .

  Misalnya:

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

  Pernyataan

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

  Parameter

  subdiagonalCount	Jumlah subdiagonal yang harus dipertahankan. Jika negatif, pertahankan seluruh segitiga bawah.
  superdiagonalCount	Jumlah superdiagonal yang harus dipertahankan. Jika negatif, pertahankan seluruh segitiga atas.

Tersedia di mana `Scalar`: `TensorFlowFloatingPoint`

• qrDekomposisi(Matriks penuh :)
  Mengembalikan dekomposisi QR setiap matriks bagian dalam di tensor, tensor dengan matriks ortogonal dalam q dan tensor dengan matriks segitiga atas bagian dalam r , sehingga tensornya sama dengan matmul(q, r) .

  Pernyataan

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

  Parameter

  fullMatrices

  Jika true , hitung q dan r berukuran penuh. Jika tidak, hitung hanya kolom min(shape[rank - 1], shape[rank - 2]) terdepan dari q .

• svd(menghitungUV:matriks penuh :)
  Mengembalikan dekomposisi nilai tunggal self , mengingat self merupakan matriks batch opsional.

  Dekomposisi nilai tunggal (SVD) dari matriks yang self secara opsional adalah nilai s , u , dan v , sehingga:

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

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

  Prasyarat

  self harus berupa tensor dengan bentuk [..., M, N] .

  Pernyataan

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

  Parameter

  computeUV	Jika true , vektor tunggal kiri dan kanan dihitung dan dikembalikan masing-masing sebagai u dan v . Jika false , nilai nil dikembalikan sebagai u dan v .
  fullMatrices	Jika true , u dan v masing-masing memiliki bentuk [..., M, M] dan [..., N, N] . Jika false , u dan v masing-masing memiliki bentuk [..., M, K] dan [..., K, N] . Diabaikan ketika computeUV salah.

  Nilai Pengembalian

  • s: Nilai tunggal, dengan bentuk [..., K] . Dalam setiap vektor, nilai singular diurutkan dalam urutan menurun.
  • u : Vektor tunggal kiri.
  • v : Vektor tunggal siku-siku.
• persegi(_:)
  Akar kuadrat dari x .

  Untuk tipe sebenarnya, jika x negatif hasilnya adalah .nan . Untuk tipe kompleks terdapat potongan cabang pada sumbu nyata negatif.

  Pernyataan

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

• karena(_:)
  Kosinus x , diartikan sebagai sudut dalam radian.

  Pernyataan

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

• dosa(_:)
  Sinus x , diartikan sebagai sudut dalam radian.

  Pernyataan

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

• berjemur(_:)
  Garis singgung x , diartikan sebagai sudut dalam radian.

  Pernyataan

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

• karena(_:)
  Kosinus terbalik dari x dalam radian.

  Pernyataan

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

• asin(_:)
  Sinus kebalikan dari x dalam radian.

  Pernyataan

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

• atan(_:)
  Kebalikan tangen x dalam radian.

  Pernyataan

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

• tongkat pendek(_:)
  Kosinus hiperbolik dari x .

  Pernyataan

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

• sinh(_:)
  Sinus hiperbolik dari x .

  Pernyataan

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

• tanh(_:)
  Garis singgung hiperbolik dari x .

  Pernyataan

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

• acosh(_:)
  Kosinus hiperbolik terbalik dari x .

  Pernyataan

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

• sayang(_:)
  Sinus hiperbolik terbalik dari x .

  Pernyataan

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

• atanh(_:)
  Garis singgung hiperbolik terbalik dari x .

  Pernyataan

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

• pengalaman(_:)
  Fungsi eksponensial diterapkan pada x , atau e**x .

  Pernyataan

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

• exp2(_:)
  Dua diangkat ke pangkat x .

  Pernyataan

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

• exp10(_:)
  Sepuluh dinaikkan ke pangkat x .

  Pernyataan

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

• contoh1(_:)
  exp(x) - 1 dievaluasi untuk menjaga akurasi mendekati nol.

  Pernyataan

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

• catatan(_:)
  Logaritma natural dari x .

  Pernyataan

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

• catatan2(_:)
  Logaritma basis dua dari x .

  Pernyataan

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

• catatan10(_:)
  Logaritma basis sepuluh dari x .

  Pernyataan

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

• log1p(_:)
  log(1 + x) dievaluasi untuk menjaga akurasi mendekati nol.

  Pernyataan

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

• kekuatan(_:_:)
  exp(y log(x)) dihitung tanpa kehilangan presisi menengah.

  Untuk tipe riil, jika x negatif, hasilnya adalah NaN, meskipun y mempunyai nilai integral. Untuk tipe kompleks, terdapat potongan cabang pada sumbu nyata negatif.

  Pernyataan

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

• kekuatan(_:_:)
  x dipangkatkan ke n .

  Produk dari n salinan x .

  Pernyataan

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

• akar(_:_:)
  Akar n dari x .

  Untuk tipe riil, jika x negatif dan n genap, hasilnya adalah NaN. Untuk tipe kompleks, ada cabang yang dipotong sepanjang sumbu nyata negatif.

  Pernyataan

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

• VektorRuangSkalar
  Pernyataan

  public typealias VectorSpaceScalar = Float

• diskalakan (oleh :)
  Pernyataan

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

• menambahkan(_:)
  Pernyataan

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

• pengurangan(_:)
  Pernyataan

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

Tersedia di mana `Skalar`: `Numerik`

• +(_:_:)
  Menambahkan skalar ke setiap skalar tensor dan menghasilkan jumlahnya.

  Pernyataan

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

• +(_:_:)
  Menambahkan skalar ke setiap skalar tensor dan menghasilkan jumlahnya.

  Pernyataan

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

• -(_:_:)
  Kurangi skalar dari setiap skalar tensor dan hasilkan selisihnya.

  Pernyataan

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

• -(_:_:)
  Kurangi skalar dari setiap skalar tensor dan hasilkan perbedaannya

  Pernyataan

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

• +=(_:_:)
  Menambahkan dua tensor dan menyimpan hasilnya di variabel sisi kiri.

  Catatan

  += mendukung penyiaran.

  Pernyataan

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

• +=(_:_:)
  Menambahkan skalar ke setiap skalar tensor dan menyimpan hasilnya di variabel sisi kiri.

  Pernyataan

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

• -=(_:_:)
  Kurangi tensor kedua dari tensor pertama dan simpan hasilnya di variabel sisi kiri.

  Catatan

  -= mendukung penyiaran.

  Pernyataan

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

• -=(_:_:)
  Kurangi skalar dari setiap skalar tensor dan simpan hasilnya di variabel sisi kiri.

  Pernyataan

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

• *(_:_:)
  Mengembalikan tensor yang dihasilkan dengan mengalikan dua tensor.

  Catatan

  * mendukung penyiaran.

  Pernyataan

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

• *(_:_:)
  Mengembalikan tensor dengan mengalikannya dengan setiap skalar tensor.

  Pernyataan

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

• *(_:_:)
  Kalikan skalar dengan setiap skalar tensor dan hasilkan produknya.

  Pernyataan

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

• *=(_:_:)
  Mengalikan dua tensor dan menyimpan hasilnya dalam variabel sisi kiri.

  Catatan

  *= mendukung penyiaran.

  Pernyataan

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

• *= (_: _ :)
  Mengalikan tensor dengan skalar, menyiarkan skalar, dan menyimpan hasilnya dalam variabel sisi kiri.

  Pernyataan

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

• /(_: _ :)
  Mengembalikan hasil bagi membagi tensor pertama dengan yang kedua.

  Catatan

  / mendukung penyiaran.

  Pernyataan

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

• /(_: _ :)
  Mengembalikan hasil bagi membagi skalar dengan tensor, menyiarkan skalar.

  Pernyataan

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

• /(_: _ :)
  Mengembalikan hasil bagi membagi tensor dengan skalar, menyiarkan skalar.

  Pernyataan

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

• /= (_: _ :)
  Membagi tensor pertama dengan yang kedua dan menyimpan hasil bagi dalam variabel sisi kiri.

  Pernyataan

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

• /= (_: _ :)
  Membagi tensor dengan skalar, menyiarkan skalar, dan menyimpan hasil bagi dalam variabel sisi kiri.

  Pernyataan

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

• %(_: _ :)
  Mengembalikan sisa membagi tensor pertama dengan yang kedua.

  Catatan

  % mendukung penyiaran.

  Pernyataan

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

• %(_: _ :)
  Mengembalikan sisa membagi tensor dengan skalar, menyiarkan skalar.

  Pernyataan

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

• %(_: _ :)
  Mengembalikan sisa membagi skalar dengan tensor, menyiarkan skalar.

  Pernyataan

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

• %= (_: _ :)
  Membagi tensor pertama dengan yang kedua dan menyimpan sisanya dalam variabel sisi kiri.

  Pernyataan

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

• %= (_: _ :)
  Membagi tensor dengan skalar dan menyimpan sisanya dalam variabel sisi kiri.

  Pernyataan

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

Tersedia di mana `scalar` ==` bool`

• elementslogicalnot ()
  Kembali !self Elemen-bijaksana.

  Pernyataan

  public func elementsLogicalNot() -> Tensor

• ElementsLoGical dan (_ :)
  Mengembalikan self && other .

  Catatan

  && mendukung penyiaran.

  Pernyataan

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

• ElementsLoGical dan (_ :)
  Mengembalikan self && other , menyiarkan other .

  Pernyataan

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

• ElementsLogicalor (_ :)
  Mengembalikan self || other elemen self || other dari bijaksana.

  Pernyataan

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

• ElementsLogicalor (_ :)
  Mengembalikan self || other Elemen self || other , menyiarkan other .

  Pernyataan

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

Tersedia di mana `scalar`:` tensorflownumeric`

• terpotong (min: Max :)
  Mengembalikan max(min(self, max), min) .

  Pernyataan

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

• terpotong (min: Max :)
  Mengembalikan max(min(self, max), min) .

  Pernyataan

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

• terpotong (min: Max :)
  Mengembalikan max(min(self, max), min) .

  Pernyataan

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

• terpotong (min: Max :)
  Mengembalikan max(min(self, max), min) .

  Pernyataan

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

Tersedia di mana `scalar`:` SignedNumeric`

• -(_ :)
  Mengembalikan negasi dari elemen tensor yang ditentukan.

  Pernyataan

  @differentiable
  public prefix static func - (rhs: Tensor) -> Tensor

Tersedia di mana `scalar`:` numeric`

• kuadrat ()
  Pernyataan

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

Tersedia di mana `scalar`:` tensorflowfloatingpoint`

• ISFINITE
  Mengembalikan tensor boolean yang menunjukkan elemen -elemen x mana yang terbatas.

  Pernyataan

  public var isFinite: Tensor<Bool> { get }

• isinfinite
  Mengembalikan tensor boolean yang menunjukkan elemen -elemen x mana yang tidak terbatas.

  Pernyataan

  public var isInfinite: Tensor<Bool> { get }

• isnan
  Mengembalikan tensor boolean yang menunjukkan unsur-unsur x mana yang bernilai nan.

  Pernyataan

  public var isNaN: Tensor<Bool> { get }

Tersedia di mana `scalar` ==` bool`

• semua()
  Mengembalikan true jika semua skalar sama dengan true . Jika tidak, mengembalikan false .

  Pernyataan

  public func all() -> Bool

• setiap()
  Mengembalikan true jika ada skalar sama dengan true . Jika tidak, mengembalikan false .

  Pernyataan

  public func any() -> Bool

• Semua (SqueezeMaxes :)
  Melakukan logis dan operasi di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• apapun (squeezingaxes :)
  Melakukan logis dan operasi di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• semua (sepanjangx :)
  Melakukan logis dan operasi di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• apa pun (sepanjangx :)
  Melakukan logis atau operasi di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

Tersedia di mana `scalar`:` numeric` & `sebanding`

• min ()
  Pernyataan

  @differentiable
  public func min() -> Tensor

• max ()
  Pernyataan

  @differentiable
  public func max() -> Tensor

• Max (Squeezingaxes :)
  Mengembalikan nilai maksimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Max (Squeezingaxes :)
  Mengembalikan nilai maksimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Max (Squeezingaxes :)
  Mengembalikan nilai maksimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• min (squeezingaxes :)
  Mengembalikan nilai minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• min (squeezingaxes :)
  Mengembalikan nilai minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• min (squeezingaxes :)
  Mengembalikan nilai minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• argmax (squeezingaxis :)
  Mengembalikan indeks nilai maksimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• argmin (squeezingaxis :)
  Mengembalikan indeks nilai minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Min (Bersama :)
  Mengembalikan minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Min (Bersama :)
  Mengembalikan minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Min (Bersama :)
  Mengembalikan minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Max (Bersama :)
  Mengembalikan minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Max (Bersama :)
  Mengembalikan minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Max (Bersama :)
  Mengembalikan minimum di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• argmax ()
  Mengembalikan indeks nilai maksimum skalar yang rata.

  Pernyataan

  public func argmax() -> Tensor<Int32>

• argmin ()
  Mengembalikan indeks nilai minimum skalar yang rata.

  Pernyataan

  public func argmin() -> Tensor<Int32>

Tersedia di mana `scalar`:` numeric`

• jumlah (squeezingaxes :)
  Mengembalikan jumlah di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• jumlah (squeezingaxes :)
  Mengembalikan jumlah di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• jumlah (squeezingaxes :)
  Mengembalikan jumlah di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• jumlah()
  Pernyataan

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

• Sum (Bersama :)
  Mengembalikan jumlah di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Sum (Bersama :)
  Mengembalikan jumlah di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Sum (Bersama :)
  Mengembalikan jumlah di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Produk (Squeezingaxes :)
  Mengembalikan produk di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Produk (Squeezingaxes :)
  Mengembalikan produk di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Produk (Squeezingaxes :)
  Mengembalikan produk di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• produk()
  Pernyataan

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

• Produk (Bersama :)
  Mengembalikan produk di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Produk (Bersama :)
  Mengembalikan produk di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Produk (Bersama :)
  Mengembalikan produk di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• berarti (squeezingaxes :)
  Mengembalikan rata -rata aritmatika di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• berarti (squeezingaxes :)
  Mengembalikan rata -rata aritmatika di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• berarti (squeezingaxes :)
  Mengembalikan rata -rata aritmatika di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank...rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• berarti()
  Pernyataan

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

• Berarti (Bersama :)
  Mengembalikan rata -rata aritmatika di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Berarti (Bersama :)
  Mengembalikan rata -rata aritmatika di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Berarti (Bersama :)
  Mengembalikan rata -rata aritmatika di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Varians (Squeezingaxes :)
  Mengembalikan varians di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan. Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Varians (Squeezingaxes :)
  Mengembalikan varians di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan. Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Varians (Squeezingaxes :)
  Mengembalikan varians di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1. tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• perbedaan()
  Pernyataan

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

• Varians (Bersama :)
  Mengembalikan varians di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1. tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Varians (Bersama :)
  Mengembalikan varians di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1. tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Varians (Bersama :)
  Mengembalikan varians di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1. tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• Cumulativeum (Bersama: Eksklusif: terbalik :)
  Mengembalikan jumlah kumulatif tensor ini di sepanjang sumbu yang ditentukan. Secara default, fungsi ini melakukan jumlah kumulatif inklusif yang berarti bahwa elemen pertama dari input identik dengan elemen pertama dari output:

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

  Dengan menetapkan argumen exclusive ke true , jumlah kumulatif eksklusif dilakukan sebagai gantinya:

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

  Dengan menetapkan argumen reverse ke true , jumlah kumulatif dilakukan dalam arah yang berlawanan:

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

  Ini lebih efisien daripada secara terpisah membalikkan tensor yang dihasilkan.

  Prasyarat

  axis harus berada di rentang -rank..<rank .

  Pernyataan

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

  Parameter

  axis	Sumbu di mana untuk melakukan operasi jumlah kumulatif.
  exclusive	Menunjukkan apakah akan melakukan jumlah kumulatif eksklusif.
  reverse	Menunjukkan apakah akan melakukan jumlah kumulatif dalam urutan terbalik.

  Nilai Pengembalian

  Hasil operasi jumlah kumulatif.

• Cumulativeum (Bersama: Eksklusif: terbalik :)
  Mengembalikan jumlah kumulatif tensor ini di sepanjang sumbu yang ditentukan. Secara default, fungsi ini melakukan jumlah kumulatif inklusif yang berarti bahwa elemen pertama dari input identik dengan elemen pertama dari output:

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

  Dengan menetapkan argumen exclusive ke true , jumlah kumulatif eksklusif dilakukan sebagai gantinya:

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

  Dengan menetapkan argumen reverse ke true , jumlah kumulatif dilakukan dalam arah yang berlawanan:

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

  Ini lebih efisien daripada secara terpisah membalikkan tensor yang dihasilkan.

  Prasyarat

  axis.rank harus 0 .

  Prasyarat

  axis harus berada di rentang -rank..<rank .

  Pernyataan

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

  Parameter

  axis	Sumbu di mana untuk melakukan operasi jumlah kumulatif.
  exclusive	Menunjukkan apakah akan melakukan jumlah kumulatif eksklusif.
  reverse	Menunjukkan apakah akan melakukan jumlah kumulatif dalam urutan terbalik.

  Nilai Pengembalian

  Hasil operasi jumlah kumulatif.

• CumulativeProduct (Bersama: Eksklusif: Reverse :)
  Mengembalikan produk kumulatif tensor ini di sepanjang sumbu yang ditentukan. Secara default, fungsi ini melakukan produk kumulatif inklusif yang berarti bahwa elemen pertama dari input identik dengan elemen pertama dari output:

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

  Dengan mengatur argumen exclusive ke true , produk kumulatif eksklusif dilakukan sebagai gantinya:

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

  Dengan menetapkan argumen reverse ke true , produk kumulatif dilakukan dalam arah yang berlawanan:

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

  Ini lebih efisien daripada secara terpisah membalikkan tensor yang dihasilkan.

  Prasyarat

  axis harus berada di rentang -rank..<rank .

  Pernyataan

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

  Parameter

  axis	Sumbu di mana untuk melakukan operasi produk kumulatif.
  exclusive	Menunjukkan apakah akan melakukan produk kumulatif eksklusif.
  reverse	Menunjukkan apakah akan melakukan produk kumulatif dalam urutan terbalik.

  Nilai Pengembalian

  Hasil dari operasi produk kumulatif.

• CumulativeProduct (Bersama: Eksklusif: Reverse :)
  Mengembalikan produk kumulatif tensor ini di sepanjang sumbu yang ditentukan. Secara default, fungsi ini melakukan produk kumulatif inklusif yang berarti bahwa elemen pertama dari input identik dengan elemen pertama dari output:

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

  Dengan mengatur argumen exclusive ke true , produk kumulatif eksklusif dilakukan sebagai gantinya:

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

  Dengan menetapkan argumen reverse ke true , produk kumulatif dilakukan dalam arah yang berlawanan:

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

  Ini lebih efisien daripada secara terpisah membalikkan tensor yang dihasilkan.

  Prasyarat

  axis harus memiliki peringkat 0 .

  Prasyarat

  axis harus berada di rentang -rank..<rank .

  Pernyataan

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

  Parameter

  axis	Sumbu di mana untuk melakukan operasi produk kumulatif.
  exclusive	Menunjukkan apakah akan melakukan produk kumulatif eksklusif.
  reverse	Menunjukkan apakah akan melakukan produk kumulatif dalam urutan terbalik.

  Nilai Pengembalian

  Hasil dari operasi produk kumulatif.

Tersedia di mana `scalar`:` tensorflowfloatingpoint`

• StandardDeviation (SqueezeMaxes :)
  Mengembalikan standar deviasi elemen di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 . Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• StandardDeviation (SqueezeMaxes :)
  Mengembalikan standar deviasi elemen di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 . Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• StandardDeviation (SqueezeMaxes :)
  Mengembalikan standar deviasi elemen di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 . Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• StandardDeviation ()
  Mengembalikan standar deviasi semua elemen dalam tensor ini. Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

• StandardDeviation (Bersama :)
  Mengembalikan standar deviasi elemen di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 . Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• StandardDeviation (Bersama :)
  Mengembalikan standar deviasi elemen di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 . Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• StandardDeviation (Bersama :)
  Mengembalikan standar deviasi elemen di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 . Tidak menerapkan koreksi Bessel.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• LOGSUMEXP (SqueezeMaxes :)
  Mengembalikan log(exp(self).sum(squeezingAxes: axes)) . Dimensi yang dikurangi dihilangkan.

  Fungsi ini lebih stabil secara numerik daripada log(exp(self).sum(squeezingAxes: axes)) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• LOGSUMEXP (SqueezeMaxes :)
  Mengembalikan log(exp(self).sum(squeezingAxes: axes)) . Dimensi yang dikurangi dihilangkan.

  Fungsi ini lebih stabil secara numerik daripada log(exp(self).sum(squeezingAxes: axes)) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• LOGSUMEXP (SqueezeMaxes :)
  Mengembalikan log(exp(self).sum(squeezingAxes: axes)) . Dimensi yang dikurangi dihilangkan.

  Fungsi ini lebih stabil secara numerik daripada log(exp(self).sum(squeezingAxes: axes)) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• LogsumExp ()
  Mengembalikan log(exp(self).sum()) . Hasilnya adalah skalar.

  Fungsi ini lebih stabil secara numerik daripada komputasi log(exp(self).sum()) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Pernyataan

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

• LogsumExp (Bersama :)
  Mengembalikan log(exp(self).sum(alongAxes: axes)) . Dimensi yang dikurangi dipertahankan dengan nilai 1 .

  Fungsi ini lebih stabil secara numerik daripada log(exp(self).sum(alongAxes: axes)) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• LogsumExp (Bersama :)
  Mengembalikan log(exp(self).sum(alongAxes: axes)) . Dimensi yang dikurangi dipertahankan dengan nilai 1 .

  Fungsi ini lebih stabil secara numerik daripada log(exp(self).sum(alongAxes: axes)) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• LogsumExp (Bersama :)
  Mengembalikan log(exp(self).sum(alongAxes: axes)) . Dimensi yang dikurangi dipertahankan dengan nilai 1 .

  Fungsi ini lebih stabil secara numerik daripada log(exp(self).sum(alongAxes: axes)) secara langsung. Ini menghindari luapan yang disebabkan oleh menghitung exp dari input besar dan underflow yang disebabkan oleh menghitung log input kecil.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• momen (squeezingaks :)
  Mengembalikan rata -rata dan varian tensor ini di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  axes harus memiliki peringkat 1 .

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• momen (squeezingaks :)
  Mengembalikan rata -rata dan varian tensor ini di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

  @differentiable(wrt: self)
  public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

  Parameter

  axes	Dimensi untuk mengurangi.

• momen (squeezingaks :)
  Mengembalikan rata -rata dan varian tensor ini di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dihilangkan.

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

  @differentiable(wrt: self)
  public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

  Parameter

  axes	Dimensi untuk mengurangi.

• momen ()
  Mengembalikan rata -rata dan varian dari elemen tensor ini.

  Pernyataan

  @differentiable(wrt: self)
  public func moments() -> Moments<Scalar>

• momen (sepanjangx :)
  Mengembalikan rata -rata dan varian tensor ini di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 .

  Prasyarat

  axes harus memiliki peringkat 1 .

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

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

  Parameter

  axes	Dimensi untuk mengurangi.

• momen (sepanjangx :)
  Mengembalikan rata -rata dan varian tensor ini di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 .

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

  @differentiable(wrt: self)
  public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

  Parameter

  axes	Dimensi untuk mengurangi.

• momen (sepanjangx :)
  Mengembalikan rata -rata dan varian tensor ini di sepanjang sumbu yang ditentukan. Dimensi yang dikurangi dipertahankan dengan nilai 1 .

  Prasyarat

  Setiap nilai dalam axes harus dalam kisaran -rank..<rank .

  Pernyataan

  @differentiable(wrt: self)
  public func moments(alongAxes axes: Int...) -> Moments<Scalar>

  Parameter

  axes	Dimensi untuk mengurangi.

Tersedia di mana `scalar`:` numeric`

• • (_: _ :)
  Melakukan multiplikasi matriks antara dua tensor dan menghasilkan hasilnya.

  Pernyataan

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

Tersedia di mana `scalar`:` tensorflowfloatingpoint`

• vjpinitdeviceandfrecision like (_: deviceandfrecision :)
  Pernyataan

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

• Batchnormalized (Bersama: Offset: Skala: Epsilon :)
  Mengembalikan tensor yang dihitung dari normalisasi batch input di sepanjang sumbu yang ditentukan.

  Secara khusus, pengembalian (self - mu) / (var + epsilon) * gamma + beta di mana mu dan var masing -masing adalah rata -rata dan varian self sepanjang axis .

  Pernyataan

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

  Parameter

  axis	Dimensi batch.
  offset	Offset, juga dikenal sebagai beta.
  scale	Skala, juga dikenal sebagai gamma.
  epsilon	Nilai kecil ditambahkan ke denominator untuk stabilitas numerik.

• menggabungkan(_:_:)
  Menggabungkan dua tensor di sepanjang sumbu terakhir.

  Pernyataan

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

• jumlah(_:_:)
  Menambahkan dua nilai dan menghasilkan jumlahnya.

  Pernyataan

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

• rata-rata(_:_:)
  Rata -rata dua nilai.

  Pernyataan

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

• berkembang biak(_:_:)
  Mengalikan dua nilai.

  Pernyataan

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

• tumpukan(_:_:)
  Tumpuk dua nilai.

  Pernyataan

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

• init (bentuk :)
  Pernyataan

  @derivative
  init(shape: scalars)

Tersedia di mana `scalar`:` diseimbangkan`

• ==(_:_:)
  Pernyataan

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

• ! = (_: _ :)
  Pernyataan

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

Tersedia di mana `scalar`:` codable`

• Encode (untuk :)
  Pernyataan

  public func encode(to encoder: Encoder) throws

• init (dari :)
  Pernyataan

  public init(from decoder: Decoder) throws

Tersedia di mana `scalar`:` numeric`

• nol
  Tensor nol skalar.

• nol
  Pernyataan

  public static var zero: Tensor { get }

• +(_: _ :)
  Menambahkan dua tensor dan menghasilkan jumlahnya.

  Catatan

  + mendukung penyiaran.

  Pernyataan

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

• -(_: _ :)
  Kurangi satu tensor dari yang lain dan menghasilkan perbedaan mereka.

  Catatan

  - Mendukung siaran.

  Pernyataan

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

• satu
  Tensor skalar satu.

  Pernyataan

  public static var one: Tensor { get }

• kebalikan
  Mengembalikan timbal balik dari unsur-bijak dari self .

  Pernyataan

  public var reciprocal: Tensor { get }

• .*(_: _ :)
  Mengalikan dua elemen tensor dan menghasilkan produk mereka.

  Catatan

  .* Mendukung siaran.

  Pernyataan

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

Tersedia di mana `scalar`:` tensorflowfloatingpoint`

• Garis SinggungVektor
  Pernyataan

  public typealias TangentVector = Tensor

• zeroTangentVectorInitializer
  Pernyataan

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

• membubuhi keterangan(_:)
  Menambahkan anotasi.

  Catatan: Hanya X10 yang didukung. Untuk backend lainnya, self yang dimakhikan dikembalikan.

  Pernyataan

  @differentiable(wrt: self)
  public func annotate(_ annotation: String) -> Tensor<Scalar>

  Parameter

  annotation

  Anotasi yang akan ditambahkan.

  Nilai Pengembalian

  Tensor beranotasi.

• vjpannotate (_ :)
  Pernyataan

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