Tensör

@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

Vektörlerin ve matrislerin potansiyel olarak daha yüksek boyutlara genelleştirilmesi olan çok boyutlu bir öğe dizisi.

Genel parametre Scalar tensördeki skalerlerin türünü açıklar ( Int32 , Float vb. gibi).

• halletmek
  Temel TensorHandle .

  Not

  handle kullanıcı tanımlı işlemlere izin vermek için herkese açıktır, ancak normalde kullanılmamalıdır.

  beyan

  public let handle: TensorHandle<Scalar>

• başlangıç(tanımlayıcı :)
  beyan

  public init(handle: TensorHandle<Scalar>)

• istiflenmemiş (Eksen boyunca :)
  R dereceli bir tensörün belirli boyutunu birden fazla sıralı (R-1) tensöre açar. N bu tensörün şeklinden çıkarıldığı axis boyutu boyunca parçalayarak bu tensörden N tensörü paketinden çıkarır. Örneğin, [A, B, C, D] şeklinde bir tensör verildiğinde:

  • Eğer axis == 0 ise, döndürülen dizideki i tensör self[i, :, :, :] dilimidir ve bu dizideki her tensör [B, C, D] şekline sahip olacaktır. ( Tensor.split(numSplits:alongAxis) veya Tensor.split(sizes:alongAxis) den farklı olarak paketten çıkarılan boyutun kaybolduğunu unutmayın).
  • Eğer axis == 1 ise, o zaman döndürülen dizideki i tensör dilim value[:, i, :, :] ve bu dizideki her tensör [A, C, D] şekline sahip olacaktır.
  • Vesaire.

  Bu Tensor.init(stacking:alongAxis:) işlevinin tam tersidir.

  Önkoşul

  axis [-rank, rank) aralığında olmalıdır; burada rank , sağlanan tensörlerin sırasıdır.

  beyan

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

  Parametreler

  axis	Yığından ayrılacak boyut. Negatif değerler etrafı sarar.

  Dönüş Değeri

  Yığınlanmamış tensörleri içeren dizi.

• split(sayım:eksen boyunca :)
  Bir tensörü birden çok tensöre böler. Tensör, boyut axis boyunca count küçük tensörlere bölünür. Bu, count shape[axis] eşit şekilde bölmesini gerektirir.

  Örneğin:

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

  Önkoşul

  count boyut axis boyutunu eşit olarak bölmelidir.

  Önkoşul

  axis [-rank, rank) aralığında olmalıdır; burada rank , sağlanan tensörlerin sırasıdır.

  beyan

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

  Parametreler

  count	Oluşturulacak bölünme sayısı.
  axis	Bu tensörün bölüneceği boyut. Negatif değerler etrafı sarar.

  Dönüş Değeri

  Tensör kısmını içeren bir dizi.

• split(boyutlar:eksen boyunca :)
  Bir tensörü birden çok tensöre böler. Tensör, sizes.shape[0] parçalarına bölünür. i parçanın şekli, boyutun sizes[i] olduğu boyut axis dışında bu tensörle aynı şekle sahiptir.

  Örneğin:

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

  Önkoşul

  sizes değerlerin toplamı, boyut axis boyutuna eşit olmalıdır.

  Önkoşul

  axis [-rank, rank) aralığında olmalıdır; burada rank , sağlanan tensörlerin sırasıdır.

  beyan

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

  Parametreler

  sizes	Her bölünmenin boyutunu içeren 1 boyutlu tensör.
  axis	Bu tensörün bölüneceği boyut. Negatif değerler etrafı sarar.

  Dönüş Değeri

  Tensör parçalarını içeren dizi.

• split(boyutlar:eksen boyunca :)
  beyan

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

• kiremitli(katlar :)
  Bu tensörün döşenmesiyle oluşturulan döşenmiş bir tensörü döndürür.

  Bu yapıcı, bu tensörü multiples kez çoğaltarak yeni bir tensör oluşturur. Oluşturulan tensörün i boyutu self.shape[i] * multiples[i] elemanlarına sahiptir ve bu tensörün değerleri i boyut boyunca multiples[i] kez kopyalanır. Örneğin, [abcd] öğesinin [2] ile döşenmesi [abcdabcd] sonucunu verir.

  Önkoşul

  Katların beklenen rank 1 olmalıdır.

  Önkoşul

  multiples şekli [tensor.rank] olmalıdır.

  Önkoşul

  multiples tüm skalerler negatif olmamalıdır.

  beyan

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

• kiremitli(katlar :)
  Bu tensörün döşenmesiyle oluşturulan döşenmiş bir tensörü döndürür.

  Bu yapıcı, bu tensörü multiples kez çoğaltarak yeni bir tensör oluşturur. Oluşturulan tensörün i boyutu self.shape[i] * multiples[i] elemanlarına sahiptir ve bu tensörün değerleri i boyut boyunca multiples[i] kez kopyalanır. Örneğin, [abcd] öğesinin [2] ile döşenmesi [abcdabcd] sonucunu verir.

  Önkoşul

  Katların beklenen rank 1 olmalıdır.

  Önkoşul

  multiples şekli [tensor.rank] olmalıdır.

  beyan

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

• yeniden şekillendirildi (gibi :)
  Belirtilen Tensor şekline göre yeniden şekillendirin.

  Önkoşul

  Skaler sayısı yeni şekille eşleşiyor.

  beyan

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

• yeniden şekillendirildi(:)
  Belirtilen şekle yeniden şekillendirin.

  Önkoşul

  Skaler sayısı yeni şekille eşleşiyor.

  beyan

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

• yeniden şekillendirildi(şekillendirildi:)
  Bir şekli temsil eden belirtilen Tensor göre yeniden şekillendirin.

  Önkoşul

  Skaler sayısı yeni şekille eşleşiyor.

  beyan

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

• düzleştirilmiş()
  Tensörün bir kopyasını 1-D Tensor daraltılmış olarak ana satır sırasına göre döndürün.

  beyan

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

• genişleyenŞekil(en:)
  Belirtilen şekil indekslerine 1 boyutu eklenmiş, şekil genişletilmiş bir Tensor döndürür.

  beyan

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

• genişleyenŞekil(en:)
  Belirtilen şekil indekslerine 1 boyutu eklenmiş, şekil genişletilmiş bir Tensor döndürür.

  beyan

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

• rütbe Yükseltildi()
  Ön boyutu 1 olan, sıralaması yükseltilmiş bir Tensor döndürür.

  beyan

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

• sıkmaŞekli(at:)
  Boyut 1'in belirtilen boyutlarını tensörün şeklinden kaldırır. Hiçbir boyut belirtilmezse, boyut 1'in tüm boyutları kaldırılacaktır.

  beyan

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

• sıkmaŞekli(at:)
  Boyut 1'in belirtilen boyutlarını tensörün şeklinden kaldırır. Hiçbir boyut belirtilmezse, boyut 1'in tüm boyutları kaldırılacaktır.

  beyan

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

• aktarılmış (permütasyon :)
  Boyutların belirtilen sıraya göre değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• aktarılmış (Permütasyonlarla :)
  Boyutların belirtilen sıraya göre değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• aktarılmış (permütasyon :)
  Boyutların belirtilen sıraya göre değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• aktarılmış (Permütasyonlarla :)
  Boyutların belirtilen sıraya göre değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• aktarılmış (permütasyon :)
  Boyutların belirtilen sıraya göre değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• aktarılmış (Permütasyonlarla :)
  Boyutların belirtilen sıraya göre değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• aktarılmış()
  Boyutların ters sırada değiştirildiği, aktarılmış bir tensör döndürür.

  beyan

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

• ters(inAxes :)
  Belirtilen boyutların tersine çevrildiği bir tensör döndürür.

  Önkoşul

  axes her değer -rank..<rank aralığında olmalıdır.

  Önkoşul

  axes çoğaltma olmamalıdır.

  beyan

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

• ters(inAxes :)
  Belirtilen boyutların tersine çevrildiği bir tensör döndürür.

  Önkoşul

  axes her değer -rank..<rank aralığında olmalıdır.

  Önkoşul

  axes çoğaltma olmamalıdır.

  beyan

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

• ters(inAxes :)
  Belirtilen boyutların tersine çevrildiği bir tensör döndürür.

  Önkoşul

  axes her değer -rank..<rank aralığında olmalıdır.

  Önkoşul

  axes çoğaltma olmamalıdır.

  beyan

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

• birleştirilmiş(ile:alongAxis :)
  Belirtilen eksen boyunca birleştirilmiş bir tensör döndürür.

  Önkoşul

  Tensörlerin belirtilen eksen dışında aynı boyutlara sahip olması gerekir.

  Önkoşul

  Eksen -rank..<rank aralığında olmalıdır.

  beyan

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

• ++(_:_ :)
  Birleştirme operatörü.

  Not

  ++ Swift'de bulunmayan ancak Haskell/Scala'da bulunan özel bir operatördür. Eklenmesi önemsiz bir dil değişikliği değildir ve tartışmalı olabilir. ++ ın varlığı/adlandırılması daha sonraki bir API tasarım aşamasında tartışılacaktır.

  beyan

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

• toplama(atIndices:alongAxis :)
  Girişin dilimlerini axis boyutu boyunca indices toplayarak bir tensör döndürür

  0-D (skaler) indices için:

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

  1-D (vektör) indices için:

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

  Genel durumda, sonuç olarak aşağıdaki tensörü üretir:

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

  burada N = self.rank ve M = indices.rank .

  Ortaya çıkan tensörün şekli şöyledir: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

  Not

  CPU'da aralık dışı bir dizin bulunursa bir hata atılır. GPU'da aralık dışı bir dizin bulunursa karşılık gelen çıkış değerlerinde 0 saklanır.

  Önkoşul

  axis [-rank, rank) aralığında olmalıdır.

  beyan

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

  Parametreler

  indices	Toplanacak endeksleri içerir.
  axis	Toplanacak boyut. Negatif değerler etrafı sarar.

  Dönüş Değeri

  Toplanan tensör.

• BatchGathering(atIndices:alongAxis:batchDimensionCount :)
  Toplu iş boyutlarına karşılık gelen ilk batchDimensionCount boyutlarını yok sayarak, axis boyutu boyunca indices bu tensörün dilimlerini döndürür. Toplama, toplu olmayan ilk boyut boyunca gerçekleştirilir.

  Ortaya çıkan tensör şeklinin artık shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] olması dışında, gathering işlemine benzer işlevsellik gerçekleştirir.

  Önkoşul

  axis -rank..<rank aralığında olmalı ve aynı zamanda batchDimensionCount değerinden büyük veya ona eşit olmalıdır.

  Önkoşul

  batchDimensionCount indices.rank değerinden küçük olmalıdır.

  beyan

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

  Parametreler

  indices	Toplanacak endeksleri içerir.
  axis	Toplanacak boyut. Negatif değerler etrafı sarar.
  batchDimensionCount	Yoksayılacak önde gelen parti boyutlarının sayısı.

  Dönüş Değeri

  Toplanan tensör.

• toplama(burada:AlongAxis :)
  Sağlanan boole maskesini girişe uyguladıktan sonra değerleri toplayarak bir tensör döndürür.

  Örneğin:

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

  Genel olarak, 0 < mask.rank = K <= tensor.rank ve mask şekli, tensor şeklinin ilk K boyutlarıyla eşleşmelidir. O zaman elimizde: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , burada [i1, ..., iK] mask i true girişidir (satır-ana sıralama).

  axis maskelenecek ekseni belirtmek için mask birlikte kullanılabilir. Bu durumda axis + mask.rank <= tensor.rank ve mask şekli, tensörün şeklinin birinci axis + mask.rank dimensions of the 's shape must match the first .

  Önkoşul

  mask skaler olamaz: mask.rank != 0 .

  beyan

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

  Parametreler

  mask	KD boole tensörü, burada K <= self.rank .
  axis	self maskelenecek ekseni temsil eden 0-D tamsayı tensörü; burada K + axis <= self.rank .

  Dönüş Değeri

  (self.rank - K + 1) mask içindeki true değerlere karşılık gelen bu tensördeki girişlerle doldurulmuş boyutlu tensör.

• Sıfır Olmayan Endeksler()
  Bu tensördeki sıfır olmayan/doğru değerlerin konumlarını döndürür.

  Koordinatlar, ilk boyutun (satırlar) sıfır olmayan öğelerin sayısını temsil ettiği ve ikinci boyutun (sütunlar) sıfır olmayan öğelerin koordinatlarını temsil ettiği 2 boyutlu bir tensörde döndürülür. Çıkış tensörünün şeklinin, bu tensörde kaç tane gerçek değer bulunduğuna bağlı olarak değişebileceğini unutmayın. Endeksler satır ana sırasına göre çıkarılır.

  Örneğin:

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

  beyan

  public func nonZeroIndices() -> Tensor<Int64>

  Dönüş Değeri

  (num_true, rank(condition)) şekline sahip bir tensör.

• yayınlandı(toShape :)
  beyan

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

• yayınlandı(:)
  beyan

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

• yayınlandı (beğendim :)
  Belirtilen Tensor ile aynı şekle yayınlayın.

  Önkoşul

  Belirtilen şeklin yayına uygun olması gerekir.

  beyan

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

• .=(_:_ :)
  beyan

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

• dilim(altSınır:üstSınır:)
  Her boyut için alt ve üst sınırlar tarafından tanımlanan tensörden bir dilim çıkarır.

  beyan

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

  Parametreler

  lowerBounds	Her boyuttaki alt sınırlar.
  upperBounds	Her boyuttaki üst sınırlar.

• dilim(alt Sınırlar:boyutlar :)
  beyan

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

• dilim(alt Sınırlar:boyutlar :)
  beyan

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

• alt simge(_:)
  beyan

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

• sureValid(eksenler:işlev:dosya:satır :)
  axes her bir öğesinin self eksenini ifade edip etmediğini kontrol eder ve aksi takdirde bir tanılamayla programı durdurur.

  beyan

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

• sureValid(eksenler:işlev:dosya:satır :)
  axes her bir öğesinin self eksenini ifade edip etmediğini kontrol eder ve aksi takdirde bir tanılamayla programı durdurur.

  beyan

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

• sureValid(eksen:işlev:dosya:satır :)
  k self eksenini ifade edip etmediğini kontrol eder ve aksi halde bir tanılamayla programı durdurur.

  beyan

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

• init(harmanlama :)
  beyan

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

• init(kopyalanıyor:to:)
  Verilen Device üzerinde other öğesinin bir kopyasını oluşturur.

  beyan

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

• init(şekil:yinelenen :)
  Belirtilen şekle ve tekrarlanan tek bir skaler değere sahip bir tensör oluşturur.

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  repeatedValue	Tekrarlanacak skaler değer.

• init(yinelenen:şekil:açık :)
  Belirtilen şekle ve tekrarlanan tek bir skaler değere sahip bir tensör oluşturur.

  beyan

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

  Parametreler

  repeatedValue	Tekrarlanacak skaler değer.
  shape	Tensörün boyutları.

• init(yayın:sıralama:açık :)
  Verilen skaleri, tüm boyutların 1 olduğu belirli bir dereceye yayınlayarak bir tensör oluşturur.

  beyan

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

• başlangıç(_:)
  Bir tensör dizisinden (bunların kendileri de skaler olabilir) bir tensör oluşturur.

  beyan

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

• init(yığınlama:AlongAxis :)
  tensors axis boyutu boyunca, geçerli tensörden bir üst seviyeye ve tensors her tensöre sahip yeni bir tensöre yığınlar.

  tensors tamamının [A, B, C] şekline sahip olduğu ve tensors.count = N göz önüne alındığında, o zaman:

  • axis == 0 ise ortaya çıkan tensör [N, A, B, C] şekline sahip olacaktır.
  • axis == 1 ise ortaya çıkan tensör [A, N, B, C] şekline sahip olacaktır.
  • vesaire.

  Örneğin:

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

  Bu Tensor.unstacked(alongAxis:) öğesinin tam tersidir.

  Önkoşul

  Tüm tensörler aynı şekle sahip olmalıdır.

  Önkoşul

  axis [-rank, rank) aralığında olmalıdır; burada rank , sağlanan tensörlerin sırasıdır.

  beyan

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

  Parametreler

  tensors	Yığılacak tensörler.
  axis	Yığınlanacak boyut. Negatif değerler etrafı sarar.

  Dönüş Değeri

  Yığılmış tensör.

• init(birleştiriyor:alongAxis :)
  tensors axis boyutu boyunca birleştirir.

  tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] olduğu göz önüne alındığında, birleştirilmiş sonuç [D0, D1, ... Raxis, ...Dn] şekline sahiptir, burada Raxis = sum(Daxis(i)) . Yani giriş tensörlerinden gelen veriler axis boyutu boyunca birleştirilir.

  Örneğin:

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

  Not

  Yeni bir eksen boyunca birleştirme yapıyorsanız Tensor.init(stacking:alongAxis:) kullanmayı düşünün.

  Önkoşul

  Tüm tensörler aynı rütbeye sahip olmalı ve axis dışındaki tüm boyutlar eşit olmalıdır.

  Önkoşul

  axis [-rank, rank) aralığında olmalıdır; burada rank , sağlanan tensörlerin sırasıdır.

  beyan

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

  Parametreler

  tensors	Birleştirilecek tensörler.
  axis	Birleştirilecek boyut. Negatif değerler etrafı sarar.

  Dönüş Değeri

  Birleştirilmiş tensör.

• (ile:nerede :)
  mask true olduğu şeritlerde bu tensörün öğelerini other değiştirir.

  Önkoşul

  self ve other aynı şekle sahip olmalıdır. Eğer self ve other skaler ise mask de skaler olmalıdır. self ve other sıralaması 1 büyük veya ona eşitse, mask ya self ile aynı şekle sahip olmalı ya da mask.scalarCount == self.shape[0] olacak şekilde 1-B Tensor olmalıdır.

  beyan

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

• Azaltılmış Hassasiyet
  Fiziksel skaler türün duyarlılığı azaltılırsa true değerini döndürür.

  Şu anda azaltılmış hassasiyetli fiziksel skaler türler yalnızca BFloat16 içermektedir.

  beyan

  public var isReducedPrecision: Bool { get }

• init(_:deviceAndPrecisionLike :)
  Verilen tensörle aynı cihaz ve hassasiyetle bir tensöre skaleri yükseltir.

  beyan

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

• Azaltılmış Hassasiyet
  self BFloat16 fiziksel skaler türüne dönüştürülmüş bir kopyasını döndürür.

  beyan

  public var toReducedPrecision: `Self` { get }

• Tam Hassasiyete
  self Scalar fiziksel skaler türüne dönüştürülmüş bir kopyasını döndürür.

  beyan

  public var toFullPrecision: `Self` { get }

• rütbe
  Tensor boyut sayısı.

  beyan

  public var rank: Int { get }

• şekil
  Tensor şekli.

  beyan

  public var shape: TensorShape { get }

• skalerSayı
  Tensor skaler sayısı.

• skalerSayı
  beyan

  public var scalarCount: Int { get }

• rütbeTensor
  Tensor<Int32> olarak temsil edilen tensörün sırası.

  beyan

  public var rankTensor: Tensor<Int32> { get }

• şekil Tensörü
  Tensor<Int32> olarak temsil edilen tensörün boyutları.

  beyan

  public var shapeTensor: Tensor<Int32> { get }

• skalerSayıTensör
  Tensor<Int32> olarak temsil edilen tensördeki skaler sayısı.

  beyan

  public var scalarCountTensor: Tensor<Int32> { get }

• isScalar
  rank 0'a eşitse true , değilse false döndürür.

  beyan

  public var isScalar: Bool { get }

• skaler
  rank 0'a eşitse, aksi halde nil tek skaler öğeyi döndürür.

  beyan

  public var scalar: Scalar? { get }

• skalerleştirilmiş()
  Skaler olarak yeniden şekillendirin.

  Önkoşul

  Tensörün tam olarak bir skaleri vardır.

  beyan

  @differentiable
  public func scalarized() -> Scalar

• sıralamak
  beyan

  public var array: ShapedArray<Scalar> { get }

• skalerler
  beyan

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

• başlatma(_:açık :)
  Skaler bir değerden 0-D tensör oluşturur.

  beyan

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

• başlatma(_:açık :)
  Skalerlerden 1 boyutlu bir tensör oluşturur.

  beyan

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

• başlatma(_:açık :)
  Skalerlerden 1 boyutlu bir tensör oluşturur.

  beyan

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

• init(şekil:skalerler:açık :)
  Belirtilen şekle ve bitişik skalerlere sahip, ana satır sırasına göre bir tensör oluşturur.

  Önkoşul

  Şeklin boyutlarının çarpımı skaler sayısına eşit olmalıdır.

  beyan

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

  Parametreler

  shape	Tensörün şekli.
  scalars	Tensörün skaler içeriği.

• init(şekil:skalerler:açık :)
  Belirtilen şekle ve bitişik skalerlere sahip, ana satır sırasına göre bir tensör oluşturur.

  Önkoşul

  Şeklin boyutlarının çarpımı skaler sayısına eşit olmalıdır.

  beyan

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

  Parametreler

  shape	Tensörün şekli.
  scalars	Tensörün skaler içeriği.

• init(shape:skalerler:toReducedPrecision:directlyOn :)
  Belirtilen şekle ve bitişik skalerlere sahip, ana satır sırasına göre bir tensör oluşturur.

  Önkoşul

  Şeklin boyutlarının çarpımı skaler sayısına eşit olmalıdır.
• init(şekil:skalerler:açık :)
  Belirtilen şekle ve bitişik skalerlere sahip, ana satır sırasına göre bir tensör oluşturur.

  Önkoşul

  Şeklin boyutlarının çarpımı skaler sayısına eşit olmalıdır.

  beyan

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

  Parametreler

  shape	Tensörün şekli.
  scalars	Tensörün skaler içeriği.

• ArrayLiteralElement
  Bir dizi değişmezinin öğelerinin türü.

  beyan

  public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

• init(arrayLiteral :)
  Verilen öğelerle başlatılan bir tensör oluşturur.

  beyan

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

• Tanım
  Tensörün metinsel temsili.

  Not

  tüm skalerleri gösteren, hoş olmayan bir şekilde basılmış bir açıklama için fullDescription kullanın.

  beyan

  public var description: String { get }

• açıklama(lineWidth:edgeElementCount:özetleme :)
  Tensörün metinsel temsili. summarize doğruysa ve öğe sayısı edgeElementCount iki katını aşarsa özetlenmiş bir açıklama döndürür.

  beyan

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

  Parametreler

  lineWidth	Yazdırma için maksimum çizgi genişliği. Satır başına yazdırılacak skaler sayısını belirlemek için kullanılır.
  edgeElementCount	Üç nokta ( ... ) aracılığıyla özetlemeden önce ve sonra yazdırılacak maksimum öğe sayısı.
  summarizing	Doğruysa, öğe sayısı edgeElementCount iki katını aşarsa açıklamayı özetleyin.

• tam Açıklama
  Tensörün tüm skalerleri gösteren tam, güzel basılmamış metinsel temsili.

  beyan

  public var fullDescription: String { get }

• irText
• oyun alanıAçıklama
  beyan

  public var playgroundDescription: Any { get }

• özelAyna
  beyan

  public var customMirror: Mirror { get }

• ek açıklamalar
  Bu tensörü açıklayan açıklamalar.

  beyan

  public var annotations: String { get }

• özet
  Ek açıklamalar için bir takma ad.

  beyan

  public var summary: String { get }

• init(_owning :)
  beyan

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

• başlangıç(_handles :)
  beyan

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

• başlatma(_:açık :)
  beyan

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

• başlangıç(_xla :)
  beyan

  init(_xla: XLATensor)

• init(_xlaHandle :)
  beyan

  init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

• xlaHandle
  beyan

  var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

• xlaTensör
  beyan

  var xlaTensor: XLATensor { get }

'Skaler': 'Sayısal' olduğu yerlerde kullanılabilir

• yayınlanmadı(toShape:)
  beyan

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

• yayınlanmamış (gibi :)
  beyan

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

• yayınlanmadı(:)
  beyan

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

• Dolgu Modu
  Bir tensörün nasıl doldurulacağını belirleyen bir mod.

  beyan

  public enum PaddingMode

• dolgulu(forSizes:ile :)
  Belirtilen doldurma boyutlarına göre sabitle doldurulmuş bir tensör döndürür.

  beyan

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

• dolgulu(forSizes:mode :)
  Belirtilen dolgu boyutlarına ve moduna göre yastıklı bir tensör döndürür.

  beyan

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

'Skaler': 'Sayısal' ve 'Karşılaştırılabilir' olduğu yerlerde kullanılabilir

• .<(_:_ :)
  lhs < rhs öğesini öğe bazında hesaplayarak Boole skalerlerinin tensörünü döndürür.

  beyan

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

• .<=(_:_ :)
  lhs <= rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  beyan

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

• .>(_:_ :)
  lhs > rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  beyan

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

• .>=(_:_ :)
  Öğe bazında lhs >= rhs değerini hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  beyan

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

• .<(_:_ :)
  lhs < rhs öğesini öğe bazında hesaplayarak Boole skalerlerinin tensörünü döndürür.

  Not

  .< yayını destekler.

  beyan

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

• .<=(_:_ :)
  lhs <= rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .<= yayını destekler.

  beyan

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

• .>(_:_ :)
  lhs > rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .> yayını destekler.

  beyan

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

• .>=(_:_ :)
  Öğe bazında lhs >= rhs değerini hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .>= yayını destekler.

  beyan

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

• .<(_:_ :)
  lhs < rhs öğesini öğe bazında hesaplayarak Boole skalerlerinin tensörünü döndürür.

  Not

  .< yayını destekler.

  beyan

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

• .<=(_:_ :)
  lhs <= rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .<= yayını destekler.

  beyan

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

• .>(_:_ :)
  lhs > rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .> yayını destekler.

  beyan

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

• .>=(_:_ :)
  Öğe bazında lhs >= rhs değerini hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .>= yayını destekler.

  beyan

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

'Skaler': 'Eşitlenebilir' olduğunda kullanılabilir

• .==(_:_ :)
  lhs == rhs öğesini öğe bazında hesaplayarak Boole skalerlerinin tensörünü döndürür.

  Not

  .== yayını destekler.

  beyan

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

• .!=(_:_ :)
  lhs != rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .!= yayını destekler.

  beyan

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

• .==(_:_ :)
  lhs == rhs öğesini öğe bazında hesaplayarak Boole skalerlerinin tensörünü döndürür.

  Not

  .== yayını destekler.

  beyan

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

• .!=(_:_ :)
  lhs != rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .!= yayını destekler.

  beyan

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

• .==(_:_ :)
  lhs == rhs öğesini öğe bazında hesaplayarak Boole skalerlerinin tensörünü döndürür.

  Not

  .== yayını destekler.

  beyan

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

• .!=(_:_ :)
  lhs != rhs öğesini öğe bazında hesaplayarak Boolean skalerlerinin tensörünü döndürür.

  Not

  .!= yayını destekler.

  beyan

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

'Skaler': 'TensorFlowFloatingPoint' ve 'Eşitlenebilir' olduğu yerlerde kullanılabilir

• elementsAlmostEqual(_:tolerans:)
  self öğelerinin other öğelerinin öğelerine yaklaşık olarak eşit olup olmadığını gösteren Boole değerlerinin tensörünü döndürür.

  Önkoşul

  self ve other aynı biçimde olmalıdır.

  beyan

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

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• isAlmostEqual(to:tolerans :)
  self tüm öğeleri, other öğelerinin öğelerine yaklaşık olarak eşitse true döndürür.

  Önkoşul

  self ve other aynı biçimde olmalıdır.

  beyan

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

'Skaler': 'TensorFlowNumeric' olduğu yerde kullanılabilir

• crossReplicaSum(_:)
  Bu tensör için çapraz çoğaltma toplamı çalıştırır. Toplama katılan diğer cihazların her birinde aynı çapraz kopya toplamının gerçekleşmesi gerekir.

  beyan

  public mutating mutating func crossReplicaSum(_ scale: Double)

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• init(yinelenen :)
  beyan

  @derivative
  init(repeating: shape)

'Skaler': 'Sayısal' olduğu yerlerde kullanılabilir

• başlangıç(_:)
  Bir Bool tensöründen eleman bazında türde dönüşüm gerçekleştirin.

  beyan

  public init(_ other: Tensor<Bool>)

• başlangıç(_:)
  Başka bir Tensor öğe bazında dönüşüm gerçekleştirin.

  beyan

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

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• başlangıç(_:)
  beyan

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

• başlatma (yığınlama :)
  beyan

  @derivative
  init(stacking: alongAxis)

• init(birleştirme :)
  beyan

  @derivative
  init(concatenating: alongAxis)

'Skaler': 'Sayısal' olduğu yerlerde kullanılabilir

• başlangıç(sıfır:açık :)
  Tüm skalerlerin sıfıra ayarlandığı bir tensör oluşturur.

  beyan

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

  Parametreler

  shape

  Tensörün şekli.

• init(birler:açık :)
  Tüm skalerlerin bire ayarlandığı bir tensör oluşturur.

  beyan

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

  Parametreler

  shape

  Tensörün şekli.

• init(sıfırlarBeğen :)
  Sağlanan tensörle aynı şekle ve türe sahip, tüm skalerlerin sıfıra ayarlandığı bir tensör oluşturur.

  beyan

  public init(zerosLike other: Tensor)

  Parametreler

  other

  Şekli ve veri türü kullanılacak tensör.

• init(onesLike :)
  Tüm skalerlerin, sağlanan tensörle aynı şekle ve türe sahip bir tensöre ayarlandığı bir tensör oluşturur.

  beyan

  public init(onesLike other: Tensor)

  Parametreler

  other

  Şekli ve veri türü kullanılacak tensör.

• init(aralık Başlangıç: bitiş: adım: açık :)
  Belirtilen miktara göre adım adım ilerleyerek, başlangıç ​​değerinden bitiş değerine kadar olan ancak bu değeri içermeyen bir diziyi temsil eden 1 boyutlu bir tensör oluşturur.

  beyan

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

  Parametreler

  start	Sıra için kullanılacak başlangıç ​​değeri. Dizi herhangi bir değer içeriyorsa ilki start .
  end	Sırayı sınırlamak için bir bitiş değeri. end hiçbir zaman ortaya çıkan dizinin bir öğesi değildir.
  stride	Her yinelemede adım adım atılacak miktar. stride olumlu olmalıdır.

• init(aralıkFrom:to:stride :)
  Belirtilen miktara göre adım adım ilerleyerek, başlangıç ​​değerinden bitiş değerine kadar olan ancak bu değeri içermeyen bir diziyi temsil eden 1 boyutlu bir tensör oluşturur.

  beyan

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

  Parametreler

  start	Sıra için kullanılacak başlangıç ​​değeri. Dizi herhangi bir değer içeriyorsa ilki start .
  end	Sırayı sınırlamak için bir bitiş değeri. end hiçbir zaman ortaya çıkan dizinin bir öğesi değildir.
  stride	Her yinelemede adım adım atılacak miktar. stride olumlu olmalıdır.

• init(oneHotAtIndices:derinlik:onValue:offValue:axis :)
  Verilen endekslerde bir sıcak tensör oluşturur. indices temsil edilen konumlar onValue değer alır (varsayılan olarak 1 ), diğer tüm konumlar offValue değer alır (varsayılan olarak 0 ). Giriş indices n dereceli ise, yeni tensör n+1 sırasına sahip olacaktır. Yeni eksen, boyut axis oluşturulur (varsayılan olarak yeni eksen sona eklenir).

  indices bir skaler ise, yeni tensörün şekli uzunluk depth bir vektörü olacaktır.

  indices uzunluk features bir vektörüyse, çıktı şekli şu şekilde olacaktır: özellikler x derinlik, eğer eksen == -1 ise derinlik x özellikler, eğer eksen == 0 ise

  indices [batch, features] şeklinde bir matris (toplu) ise, çıktı şekli şu şekilde olacaktır: toplu iş x özellikler x derinlik, if eksen == -1 toplu iş x derinlik x özellikler, if eksen == 1 derinlik x toplu x özellikler , eğer eksen == 0 ise

  beyan

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

  Parametreler

  indices	İndekslerin Tensor .
  depth	Bir sıcak boyutun derinliğini tanımlayan bir skaler.
  onValue	indices bazı indekslerin atıfta bulunduğu konumdaki değeri tanımlayan bir skaler.
  offValue	indices herhangi bir indeks tarafından başvurulmayan bir konumdaki değeri tanımlayan bir skaler.
  axis	Doldurulacak eksen. Varsayılan, yeni bir en iç eksen olan -1 .

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• init(linearSpaceFrom:to:count:on :)
  Belirtilen sayıda değer oluşturmak için eşit aralıklarla yerleştirilmiş, başlangıç ​​değerinden bitiş değerine kadar ve bu değer dahil olmak üzere bir diziyi temsil eden 1 boyutlu bir tensör oluşturur.

  beyan

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

  Parametreler

  start	Sıra için kullanılacak başlangıç ​​değeri. Dizi herhangi bir değer içeriyorsa ilki start .
  end	Sırayı sınırlamak için bir bitiş değeri. end , ortaya çıkan dizinin son öğesidir.
  count	Ortaya çıkan dizideki değerlerin sayısı. count pozitif olması gerekir.

• init(linearSpaceFrom:to:count :)
  Belirtilen sayıda değer oluşturmak için eşit aralıklarla yerleştirilmiş, başlangıç ​​değerinden bitiş değerine kadar ve bu değer dahil olmak üzere bir diziyi temsil eden 1 boyutlu bir tensör oluşturur.

  Önkoşul

  start , to ve count tek bir Skaler değer içeren Tensörler olmalıdır.

  beyan

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

  Parametreler

  start	Sıra için kullanılacak başlangıç ​​değeri. Dizi herhangi bir değer içeriyorsa ilki start .
  end	Sırayı sınırlamak için bir bitiş değeri. end , ortaya çıkan dizinin son öğesidir.
  count	Ortaya çıkan dizideki değerlerin sayısı. count pozitif olması gerekir.

'Skaler': 'TensorFlowIndex' olduğu yerde kullanılabilir

• init(randomUniform:lowerBound:upperBound:seed:on :)
  lowerBound ve upperBound arasındaki tekdüze bir dağılımdan skaler değerleri rastgele örnekleyerek, belirtilen şekle sahip bir tensör oluşturur.

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  lowerBound	Dağılımın alt sınırı.
  upperBound	Dağılımın üst sınırı.
  seed	Tohum değeri.

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• init(randomUniform:lowerBound:upperBound:seed:on :)
  lowerBound ve upperBound arasındaki tekdüze bir dağılımdan skaler değerleri rastgele örnekleyerek, belirtilen şekle sahip bir tensör oluşturur.

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  lowerBound	Dağılımın alt sınırı.
  upperBound	Dağılımın üst sınırı.
  seed	Tohum değeri.

• init(randomNormal:mean:standardDeviation:seed:on :)
  Normal dağılımdan skaler değerleri rastgele örnekleyerek belirtilen şekle sahip bir tensör oluşturur.

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  mean	Dağıtımın ortalaması.
  standardDeviation	Dağılımın standart sapması.
  seed	Tohum değeri.

• init(randomTruncatedNormal:mean:standardDeviation:seed:on :)
  Kesilmiş bir Normal dağılımdan skaler değerleri rastgele örnekleyerek, belirtilen şekle sahip bir tensör oluşturur.

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  mean	Dağıtımın ortalaması.
  standardDeviation	Dağılımın standart sapması.
  seed	Tohum değeri.

'Skaler': 'TensorFlowIndex' olduğu yerde kullanılabilir

• init(randomCategorialLogits:sampleCount:seed :)
  Kategorik bir dağılımdan örnekler çizerek bir tensör oluşturur.

  beyan

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

  Parametreler

  randomCategorialLogits	[batchSize, classCount] şeklinde 2 boyutlu Tensör. Her dilim [i, :] tüm sınıflar için normalleştirilmemiş log olasılıklarını temsil eder.
  sampleCount	0-D. Her satır dilimi için çizilecek bağımsız örneklerin sayısı.
  seed	Tohum değeri.

  Dönüş Değeri

  [batchSize, sampleCount] şeklinde 2 boyutlu Tensör. Her dilim [i, :] [0, classCount) aralığına sahip çizilmiş sınıf etiketlerini içerir.

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• init(glorotUniform:tohum:açık :)
  Glorot (Xavier) tek tip başlatma gerçekleştirerek belirtilen şekle sahip bir tensör oluşturur.

  Varsayılan rastgele sayı üreteci tarafından oluşturulan -limit ve limit arasındaki tekdüze bir dağılımdan rastgele örnekler çeker; burada limit sqrt(6 / (fanIn + fanOut)) 'tır ve fanIn / fanOut giriş ve çıkış özelliklerinin sayısını alıcı değerle çarparak temsil eder. alan boyutu.

  Referans: "Derin ileri beslemeli sinir ağlarını eğitmenin zorluğunu anlama"

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  seed	Tohum değeri.

• init(glorotNormal:seed:on :)
  Glorot (Xavier) normal başlatma işlemini gerçekleştirerek belirtilen şekle sahip bir tensör oluşturur.

  Varsayılan rastgele sayı üreteci tarafından oluşturulan standart sapma sqrt(2 / (fanIn + fanOut)) ile 0 merkezli kesik normal dağılımdan rastgele örnekler çeker; burada fanIn / fanOut giriş ve çıkış özelliklerinin sayısının alıcı alanla çarpımını temsil eder. boyut.

  Referans: "Derin ileri beslemeli sinir ağlarını eğitmenin zorluğunu anlama"

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  seed	Tohum değeri.

• init(heÜniforma:tohum:açık :)
  He (Kaiming) düzgün başlatma işlemini gerçekleştirerek belirtilen şekle sahip bir tensör oluşturur.

  Varsayılan rastgele sayı üreteci tarafından oluşturulan -limit ve limit arasındaki tekdüze bir dağılımdan rastgele örnekler çeker; burada limit sqrt(6 / fanIn) 'dir ve fanIn giriş özelliklerinin sayısının alıcı alan boyutuyla çarpımını temsil eder.

  Referans: "Doğrultucuları Derinlemesine İncelemek: ImageNet Sınıflandırmasında İnsan Seviyesindeki Performansı Aşmak"

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  seed	Tohum değeri.

• init(heNormal:seed:on :)
  He (Kaiming) normal başlatmasını gerçekleştirerek belirtilen şekle sahip bir tensör oluşturur.

  Varsayılan rastgele sayı üreteci tarafından oluşturulan standart sapma sqrt(2 / fanIn)) ile 0 merkezli kesik normal dağılımdan rastgele örnekler çeker; burada fanIn giriş özelliklerinin sayısının alıcı alan boyutuyla çarpımını temsil eder.

  Referans: "Doğrultucuları Derinlemesine İncelemek: ImageNet Sınıflandırmasında İnsan Seviyesindeki Performansı Aşmak"

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  seed	Tohum değeri.

• init(leCunUniform:tohum:açık :)
  LeCun tek tip başlatma işlemini gerçekleştirerek belirtilen şekle sahip bir tensör oluşturur.

  Varsayılan rastgele sayı üreteci tarafından oluşturulan -limit ve limit arasındaki tekdüze bir dağılımdan rastgele örnekler çeker; burada limit sqrt(3 / fanIn) 'dir ve fanIn giriş özelliklerinin sayısının alıcı alan boyutuyla çarpımını temsil eder.

  Referans: “Verimli BackProp”

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  seed	Tohum değeri.

• init(leCunNormal:seed:on :)
  LeCun normal başlatma işlemini gerçekleştirerek belirtilen şekle sahip bir tensör oluşturur.

  Varsayılan rastgele sayı üreteci tarafından oluşturulan standart sapma sqrt(1 / fanIn) ile 0 merkezli kesik normal dağılımdan rastgele örnekler çeker; burada fanIn giriş özelliklerinin sayısının alıcı alan boyutuyla çarpımını temsil eder.

  Referans: “Verimli BackProp”

  beyan

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

  Parametreler

  shape	Tensörün boyutları.
  seed	Tohum değeri.

• init(ortogonal:kazanç:tohum :)
  Dik bir matris veya tensör oluşturur.

  Başlatılacak tensörün şekli iki boyutlu ise, normal dağılımdan çizilen rastgele sayılar matrisinin QR ayrışımından elde edilen dik bir matris ile başlatılır. Matrisin sütunlardan daha az satırı varsa çıktıda dik satırlar olur. Aksi takdirde çıktıda dik sütunlar bulunur.

  Başlatılacak tensörün şekli iki boyutludan fazlaysa, şekil [shape[0] * ... * shape[rank - 2], shape[rank - 1]] matrisi başlatılır. Matris daha sonra istenen şekle sahip bir tensör verecek şekilde yeniden şekillendirilir.

  beyan

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

  Parametreler

  shape	Tensörün şekli.
  gain	Ortogonal tensöre uygulanacak çarpımsal bir faktör.
  seed	Rastgele sayı üretecini oluşturmak için iki tamsayıdan oluşan bir grup.

'Skaler': 'TensorFlowNumeric' olduğu yerde kullanılabilir

• diyagonalPart()
  [Toplu] tensörün [toplu] köşegen kısmını döndürür. [..., M, N] şeklinin tensör örneği için çıktı, [..., K] şeklinde bir tensördür; burada K eşittir min(N, M) .

  Örneğin:

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

  beyan

  @differentiable
  public func diagonalPart() -> Tensor

• diyagonal()
  [Toplu] bir diyagonal dizi oluşturur. [..., M] şeklinin tensör örneği için çıktı, [..., M, M] şeklinin bir tensörüdür.

  Örneğin:

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

  beyan

  @differentiable
  public func diagonal() -> Tensor

• Diagonal(_:) ile
  self isteğe bağlı olarak toplu bir matris olduğu göz önüne alındığında, self yeni çapraz değerlerle döndürür.

  Döndürülen tensör, diagonal değerlerin üzerine yazılan en içteki matrislerin belirtilen köşegenleri dışında self ile aynı şekil ve değerlere sahiptir.

  Parametre diyagonal: Yeni diyagonal değerleri temsil eden rütbe rank - 1 olan bir tensör.

  beyan

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

• bantParçası(_:_:)
  beyan

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

• bandPart(subdiagonalCount:superdiagonalCount :)
  Merkezi bant sınırlarıyla tanımlanan en içteki tensörün bir kopyasını döndürür. Çıktı [..., :, :] örneğiyle aynı şekle sahip bir tensördür.

  Örneğin:

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

  beyan

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

  Parametreler

  subdiagonalCount	Tutulacak alt köşegenlerin sayısı. Negatifse alt üçgenin tamamını koruyun.
  superdiagonalCount	Tutulacak süper köşegenlerin sayısı. Negatifse üst üçgenin tamamını koruyun.

'Skaler': 'TensorFlowFloatingPoint' olduğu yerde kullanılabilir

• qrDecomposition(fulMatrices:)
  Tensör matmul(q, r) ye eşit olacak şekilde, iç ortogonal matrisleri q olan bir tensör ve iç üst üçgen matrisleri r olan bir tensör olan tensördeki her bir iç matrisin QR ayrıştırmasını döndürür.

  beyan

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

  Parametreler

  fullMatrices

  true ise tam boyutlu q ve r hesaplayın. Aksi takdirde, q yalnızca baştaki min(shape[rank - 1], shape[rank - 2]) sütunlarını hesaplayın.

• svd(computeUV:fullMatrices :)
  self isteğe bağlı olarak toplu işlenen bir matris olduğu göz önüne alındığında, self tekil değer ayrışmasını döndürür.

  İsteğe bağlı olarak toplu hale getirilen self matrisinin tekil değer ayrışımı (SVD), s , u ve v değerleridir, öyle ki:

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

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

  Önkoşul

  self [..., M, N] şeklinde bir tensör olmalıdır.

  beyan

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

  Parametreler

  computeUV	true ise, sol ve sağ tekil vektörler hesaplanır ve sırasıyla u ve v olarak döndürülür. false ise u ve v olarak nil değerleri döndürülür.
  fullMatrices	true ise, u ve v sırasıyla [..., M, M] ve [..., N, N] şekillerine sahiptir. false ise, u ve v sırasıyla [..., M, K] ve [..., K, N] şekillerine sahiptir. computeUV false olduğunda göz ardı edilir.

  Dönüş Değeri

  • s: [..., K] şeklinde tekil değerler. Her vektör içinde tekil değerler azalan düzende sıralanır.
  • u: Sol tekil vektörler.
  • v: Sağ tekil vektörler.
• sqrt(_ :)
  x karekökü.

  Gerçek türler için x negatifse sonuç .nan olur. Karmaşık türler için negatif gerçek eksende bir dal kesimi vardır.

  beyan

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

• çünkü(_:)
  x kosinüsü, radyan cinsinden bir açı olarak yorumlanır.

  beyan

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

• günah(_:)
  x sinüsü, radyan cinsinden bir açı olarak yorumlanır.

  beyan

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

• ten rengi(_:)
  x tanjantı, radyan cinsinden bir açı olarak yorumlanır.

  beyan

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

• acos(_ :)
  Radyan cinsinden x ters kosinüsü.

  beyan

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

• asin(_:)
  Radyan cinsinden x ters sinüsü.

  beyan

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

• atan(_:)
  Radyan cinsinden x ters tanjantı.

  beyan

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

• cosh(_:)
  x hiperbolik kosinüsü.

  beyan

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

• sinh(_:)
  x hiperbolik sinüsü.

  beyan

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

• tan(_:)
  x hiperbolik tanjantı.

  beyan

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

• acosh(_:)
  x ters hiperbolik kosinüsü.

  beyan

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

• asinh (_ :)
  x ters hiperbolik sinüs.

  beyan

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

• Atanh (_ :)
  x ters hiperbolik teğet.

  beyan

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

• exp (_ :)
  x veya e**x uygulanan üstel fonksiyon.

  beyan

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

• exp2 (_ :)
  İkisi x

  beyan

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

• exp10 (_ :)
  On iktidar için yükseldi x .

  beyan

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

• Expm1 (_ :)
  exp(x) - 1 sıfıra yakın doğruluğu korumak için değerlendirildi.

  beyan

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

• kayıt(_:)
  x doğal logaritması.

  beyan

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

• log2 (_ :)
  x temel iki logaritması.

  beyan

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

• log10 (_ :)
  x temel logaritması.

  beyan

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

• log1p (_ :)
  log(1 + x) sıfıra yakın doğruluğu korumak için değerlendirildi.

  beyan

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

• POW (_: _ :)
  exp(y log(x)) ara hassasiyet kaybı olmadan hesaplanır.

  Gerçek türler için, x negatifse, y integral bir değeri olsa bile, sonuç NAN'dır. Karmaşık tipler için, negatif gerçek eksende bir dal kesimi vardır.

  beyan

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

• POW (_: _ :)
  x n yükseldi.

  n kopyalarının ürünü x

  beyan

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

• kök(_:_:)
  x n .

  Gerçek türler için, x negatif ve n eşitse, sonuç NAN'dır. Karmaşık tipler için, negatif gerçek eksen boyunca kesilmiş bir dal vardır.

  beyan

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

• VectorsSpacesalar
  beyan

  public typealias VectorSpaceScalar = Float

• ölçekli (tarafından :)
  beyan

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

• Ekleme (_ :)
  beyan

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

• Çıkarma (_ :)
  beyan

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

Nerede `skaler ':` sayısal'

• +(_: _ :)
  Skaleri tensörün her skalerine ekler ve toplamı üretir.

  beyan

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

• +(_: _ :)
  Skaleri tensörün her skalerine ekler ve toplamı üretir.

  beyan

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

• -(_: _ :)
  Skaleri tensörün her skalerinden çıkarır ve farkı üretir.

  beyan

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

• -(_: _ :)
  Skaleri tensörün her skalerinden çıkarır ve farkı üretir

  beyan

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

• += (_: _ :)
  İki tensör ekler ve sonucu sol taraf değişkeninde saklar.

  Not

  += yayın yapmayı destekler.

  beyan

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

• += (_: _ :)
  Skaleri tensörün her skalerine ekler ve sonucu sol taraf değişkeninde saklar.

  beyan

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

• -= (_: _ :)
  İkinci tensörü birincisinden çıkarır ve sonucu sol taraf değişkeninde saklar.

  Not

  -= yayın yapmayı destekler.

  beyan

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

• -= (_: _ :)
  Skaleri tensörün her skalerinden çıkarır ve sonucu sol taraf değişkeninde saklar.

  beyan

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

• *(_: _ :)
  İki tensörün çarpılarak üretilen tensörü döndürür.

  Not

  * Yayın yapmayı destekler.

  beyan

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

• *(_: _ :)
  Tensörü tensörün her skaleriyle çarparak döndürür.

  beyan

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

• *(_: _ :)
  Skaleri tensörün her skaleriyle çoğaltır ve ürünü üretir.

  beyan

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

• *= (_: _ :)
  İki tensörü çoğaltır ve sonucu sol taraf değişkeninde saklar.

  Not

  *= yayın yapmayı destekler.

  beyan

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

• *= (_: _ :)
  Tensörü skalerle çarpar, skaleri yayınlar ve sonucu sol taraf değişkeninde saklar.

  beyan

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

• /(_: _ :)
  Birinci tensörü ikinciye bölme bölümünü döndürür.

  Not

  / yayın yapmayı destekler.

  beyan

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

• /(_: _ :)
  Skalayı tensöre bölme ve skaleri yayınlama bölümünü döndürür.

  beyan

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

• /(_: _ :)
  Skaler yayınlayarak tensörü skalerden bölme bölümünü döndürür.

  beyan

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

• /= (_: _ :)
  Birinci tensörü ikinciye böler ve bölümü sol taraf değişkeninde saklar.

  beyan

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

• /= (_: _ :)
  Tensörü skalerle bölerek skaleri yayınlar ve bölümü sol taraf değişkeninde saklar.

  beyan

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

• %(_: _ :)
  İlk tensörü ikinciye bölme geri kalanını döndürür.

  Not

  % yayın yapmayı destekler.

  beyan

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

• %(_: _ :)
  Geri kalanını tensörü skalerden bölme, skaleri yayınlar.

  beyan

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

• %(_: _ :)
  Skalayı tensöre bölme, skaleri yayınlamanın geri kalanını döndürür.

  beyan

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

• %= (_: _ :)
  Birinci tensörü ikinciye böler ve geri kalanını sol taraf değişkeninde saklar.

  beyan

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

• %= (_: _ :)
  Tensörü skaler tarafından böler ve geri kalanını sol taraf değişkeninde saklar.

  beyan

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

`Skaler '==` bool'

• ElementsLogicalNot ()
  Geri döner !self

  beyan

  public func elementsLogicalNot() -> Tensor

• ElementsLogicaland (_ :)
  self && other unsurları döndürür.

  Not

  && yayın yapmayı destekler.

  beyan

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

• ElementsLogicaland (_ :)
  self && other öğe açısından, other yayınlar.

  beyan

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

• ElementsLogicalor (_ :)
  self || other unsurlar.

  beyan

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

• ElementsLogicalor (_ :)
  self || other öğe açısından, other yayın.

  beyan

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

`Skaler 'nerede mevcuttur:` tensorflownumerik'

• kırpılmış (min: maks :)
  max(min(self, max), min) döndürür.

  beyan

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

• kırpılmış (min: maks :)
  max(min(self, max), min) döndürür.

  beyan

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

• kırpılmış (min: maks :)
  max(min(self, max), min) döndürür.

  beyan

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

• kırpılmış (min: maks :)
  max(min(self, max), min) döndürür.

  beyan

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

`Skaler ':` synednumeric'

• -(_ :)
  Belirtilen tensör elemanının olumsuzluğunu döndürür.

  beyan

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

Nerede `skaler ':` sayısal'

• kare ()
  beyan

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

Nerede `skaler ':` tensorflowfloatingpoint'

• Isfinite
  x hangi elemanlarının sonlu olduğunu gösteren bir boole tensörü döndürür.

  beyan

  public var isFinite: Tensor<Bool> { get }

• Isinfinite
  Hangi x elemanlarının sonsuz olduğunu gösteren bir boole tensörü döndürür.

  beyan

  public var isInfinite: Tensor<Bool> { get }

• NaN
  Hangi x elemanlarının nan değerli olduğunu gösteren bir boolean tensörü döndürür.

  beyan

  public var isNaN: Tensor<Bool> { get }

`Skaler '==` bool'

• Tümü()
  Tüm skalerler true ise true döndürür. Aksi takdirde, false döndürür.

  beyan

  public func all() -> Bool

• herhangi()
  Herhangi bir skaler true ise true döndürür. Aksi takdirde, false döndürür.

  beyan

  public func any() -> Bool

• Hepsi (Sıkmaxes :)
  Belirtilen eksenler boyunca mantıklı ve işlem gerçekleştirir. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• herhangi bir (fışkırtma :)
  Belirtilen eksenler boyunca mantıklı ve işlem gerçekleştirir. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• hepsi (boyunca
  Belirtilen eksenler boyunca mantıklı ve işlem gerçekleştirir. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• herhangi bir (boyunca :)
  Belirtilen eksenler boyunca mantıklı veya işlem gerçekleştirir. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

`Skaler ':` sayısal' & 'Karşılaştırılabilir'

• min ()
  beyan

  @differentiable
  public func min() -> Tensor

• maks ()
  beyan

  @differentiable
  public func max() -> Tensor

• max (fışkırma .)
  Belirtilen eksenler boyunca maksimum değerleri döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• max (fışkırma .)
  Belirtilen eksenler boyunca maksimum değerleri döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• max (fışkırma .)
  Belirtilen eksenler boyunca maksimum değerleri döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Min (Sıkmaxes :)
  Belirtilen eksenler boyunca minimum değerleri döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Min (Sıkmaxes :)
  Belirtilen eksenler boyunca minimum değerleri döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Min (Sıkmaxes :)
  Belirtilen eksenler boyunca minimum değerleri döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Argmax (Sıkmaxis :)
  Belirtilen eksenler boyunca maksimum değerlerin endekslerini döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Argmin (Sıkmaxis :)
  Minimum değerlerin endekslerini belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• min (boyunca
  Minimumu belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• min (boyunca
  Minimumu belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• min (boyunca
  Minimumu belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• max (boyunca
  Minimumu belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• max (boyunca
  Minimumu belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• max (boyunca
  Minimumu belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• argmax ()
  Düzleştirilmiş skalerlerin maksimum değerinin dizinini döndürür.

  beyan

  public func argmax() -> Tensor<Int32>

• argmin ()
  Düzleştirilmiş skalerlerin minimum değerinin dizinini döndürür.

  beyan

  public func argmin() -> Tensor<Int32>

Nerede `skaler ':` sayısal'

• SUM (Squeezingaxes :)
  Toplamı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• SUM (Squeezingaxes :)
  Toplamı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• SUM (Squeezingaxes :)
  Toplamı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• SUM ()
  beyan

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

• toplam (boyunca
  Toplamı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• toplam (boyunca
  Toplamı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• toplam (boyunca
  Toplamı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Ürün (Sıkma .)
  Ürünü belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Ürün (Sıkma .)
  Ürünü belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Ürün (Sıkma .)
  Ürünü belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ürün()
  beyan

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

• ürün (boyunca
  Ürünü belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ürün (boyunca
  Ürünü belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ürün (boyunca
  Ürünü belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ortalama (sıkma .)
  Belirtilen eksenler boyunca aritmetik ortalamayı döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ortalama (sıkma .)
  Belirtilen eksenler boyunca aritmetik ortalamayı döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ortalama (sıkma .)
  Belirtilen eksenler boyunca aritmetik ortalamayı döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank...rank olmalıdır.

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Anlam()
  beyan

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

• ortalama (boyunca
  Belirtilen eksenler boyunca aritmetik ortalamayı döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ortalama (boyunca
  Belirtilen eksenler boyunca aritmetik ortalamayı döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• ortalama (boyunca
  Belirtilen eksenler boyunca aritmetik ortalamayı döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Varyans (Sıkma. :)
  Varyansı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Varyans (Sıkma. :)
  Varyansı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Varyans (Sıkma. :)
  Varyansı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değerle tutulur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• varyans()
  beyan

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

• varyans (boyunca
  Varyansı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değerle tutulur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• varyans (boyunca
  Varyansı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değerle tutulur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• varyans (boyunca
  Varyansı belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değerle tutulur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Kümülatifler (Bulsamik: Özel: Ters :)
  Bu tensörün kümülatif toplamını belirtilen eksen boyunca döndürür. Varsayılan olarak, bu işlev kapsayıcı bir kümülatif toplam gerçekleştirir, bu da girişin ilk öğesinin çıktının ilk öğesiyle aynı olduğu anlamına gelir:

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

  exclusive argümanı true olarak ayarlayarak, bunun yerine özel bir kümülatif toplam gerçekleştirilir:

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

  reverse argümanı true olarak ayarlayarak, kümülatif toplam ters yönde gerçekleştirilir:

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

  Bu, ortaya çıkan tensörü ayrı ayrı tersine çevirmekten daha verimlidir.

  Önkoşul

  axis -rank..<rank .

  beyan

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

  Parametreler

  axis	Kümülatif toplam işlemi gerçekleştirmek için eksen.
  exclusive	Özel bir kümülatif toplamın yapılıp yapılmayacağını gösterir.
  reverse	Kümülatif toplamı tersine çevrilmiş sırayla gerçekleştirip gerçekleştirmeyeceğini gösterir.

  Dönüş Değeri

  Kümülatif toplam işleminin sonucu.

• Kümülatifler (Bulsamik: Özel: Ters :)
  Bu tensörün kümülatif toplamını belirtilen eksen boyunca döndürür. Varsayılan olarak, bu işlev kapsayıcı bir kümülatif toplam gerçekleştirir, bu da girişin ilk öğesinin çıktının ilk öğesiyle aynı olduğu anlamına gelir:

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

  exclusive argümanı true olarak ayarlayarak, bunun yerine özel bir kümülatif toplam gerçekleştirilir:

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

  reverse argümanı true olarak ayarlayarak, kümülatif toplam ters yönde gerçekleştirilir:

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

  Bu, ortaya çıkan tensörü ayrı ayrı tersine çevirmekten daha verimlidir.

  Önkoşul

  axis.rank 0 olmalıdır.

  Önkoşul

  axis -rank..<rank .

  beyan

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

  Parametreler

  axis	Kümülatif toplam işlemi gerçekleştirmek için eksen.
  exclusive	Özel bir kümülatif toplamın yapılıp yapılmayacağını gösterir.
  reverse	Kümülatif toplamı tersine çevrilmiş sırayla gerçekleştirip gerçekleştirmeyeceğini gösterir.

  Dönüş Değeri

  Kümülatif toplam işleminin sonucu.

• Kümülatif Product (Bonsuk: Özel: Ters :)
  Bu tensörün kümülatif ürününü belirtilen eksen boyunca döndürür. Varsayılan olarak, bu işlev kapsayıcı bir kümülatif ürün gerçekleştirir, bu da girişin ilk öğesinin çıktının ilk öğesiyle aynı olduğu anlamına gelir:

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

  exclusive argümanı true olarak ayarlayarak, bunun yerine özel bir kümülatif ürün gerçekleştirilir:

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

  reverse argümanı true olarak ayarlayarak, kümülatif ürün ters yönde gerçekleştirilir:

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

  Bu, ortaya çıkan tensörü ayrı ayrı tersine çevirmekten daha verimlidir.

  Önkoşul

  axis -rank..<rank .

  beyan

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

  Parametreler

  axis	Kümülatif ürün operasyonunu gerçekleştirmek için eksen.
  exclusive	Özel bir kümülatif ürünün gerçekleştirilip gerçekleştirilmeyeceğini gösterir.
  reverse	Kümülatif ürünü ters sırada gerçekleştirip gerçekleştirmeyeceğini gösterir.

  Dönüş Değeri

  Kümülatif ürün operasyonunun sonucu.

• Kümülatif Product (Bonsuk: Özel: Ters :)
  Bu tensörün kümülatif ürününü belirtilen eksen boyunca döndürür. Varsayılan olarak, bu işlev kapsayıcı bir kümülatif ürün gerçekleştirir, bu da girişin ilk öğesinin çıktının ilk öğesiyle aynı olduğu anlamına gelir:

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

  exclusive argümanı true olarak ayarlayarak, bunun yerine özel bir kümülatif ürün gerçekleştirilir:

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

  reverse argümanı true olarak ayarlayarak, kümülatif ürün ters yönde gerçekleştirilir:

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

  Bu, ortaya çıkan tensörü ayrı ayrı tersine çevirmekten daha verimlidir.

  Önkoşul

  axis 0 Sıra olmalıdır.

  Önkoşul

  axis -rank..<rank .

  beyan

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

  Parametreler

  axis	Kümülatif ürün operasyonunu gerçekleştirmek için eksen.
  exclusive	Özel bir kümülatif ürünün gerçekleştirilip gerçekleştirilmeyeceğini gösterir.
  reverse	Kümülatif ürünü ters sırada gerçekleştirip gerçekleştirmeyeceğini gösterir.

  Dönüş Değeri

  Kümülatif ürün operasyonunun sonucu.

Nerede `skaler ':` tensorflowfloatingpoint'

• StandardDeviation (Squeezingaxes :)
  Belirtilen eksenler boyunca elemanların standart sapmasını döndürür. Azaltılmış boyutlar 1 değeri ile korunur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• StandardDeviation (Squeezingaxes :)
  Belirtilen eksenler boyunca elemanların standart sapmasını döndürür. Azaltılmış boyutlar 1 değeri ile korunur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• StandardDeviation (Squeezingaxes :)
  Belirtilen eksenler boyunca elemanların standart sapmasını döndürür. Azaltılmış boyutlar 1 değeri ile korunur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• StandardDeviation ()
  Bu tensördeki tüm öğelerin standart sapmasını döndürür. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

• StandardDeviation (boyunca :)
  Belirtilen eksenler boyunca elemanların standart sapmasını döndürür. Azaltılmış boyutlar 1 değeri ile korunur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• StandardDeviation (boyunca :)
  Belirtilen eksenler boyunca elemanların standart sapmasını döndürür. Azaltılmış boyutlar 1 değeri ile korunur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• StandardDeviation (boyunca :)
  Belirtilen eksenler boyunca elemanların standart sapmasını döndürür. Azaltılmış boyutlar 1 değeri ile korunur. Bessel'in düzeltmesini uygulamaz.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• logsumexp (fışkırma .)
  log(exp(self).sum(squeezingAxes: axes)) Azaltılmış boyutlar kaldırılır.

  Bu işlev, bilgisayar log(exp(self).sum(squeezingAxes: axes)) Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• logsumexp (fışkırma .)
  log(exp(self).sum(squeezingAxes: axes)) Azaltılmış boyutlar kaldırılır.

  Bu işlev, bilgisayar log(exp(self).sum(squeezingAxes: axes)) Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• logsumexp (fışkırma .)
  log(exp(self).sum(squeezingAxes: axes)) Azaltılmış boyutlar kaldırılır.

  Bu işlev, bilgisayar log(exp(self).sum(squeezingAxes: axes)) Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• logsumexp ()
  log(exp(self).sum()) döndürür. Sonuç bir skaler.

  Bu işlev, doğrudan bilgi işlem log(exp(self).sum()) daha sayısal olarak kararlıdır. Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  beyan

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

• logsumexp (boyunca :)
  log(exp(self).sum(alongAxes: axes)) Azaltılmış boyutlar 1 değeri ile korunur.

  Bu işlev, doğrudan bilgi işlem log(exp(self).sum(alongAxes: axes)) . Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• logsumexp (boyunca :)
  log(exp(self).sum(alongAxes: axes)) Azaltılmış boyutlar 1 değeri ile korunur.

  Bu işlev, doğrudan bilgi işlem log(exp(self).sum(alongAxes: axes)) . Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• logsumexp (boyunca :)
  log(exp(self).sum(alongAxes: axes)) Azaltılmış boyutlar 1 değeri ile korunur.

  Bu işlev, doğrudan bilgi işlem log(exp(self).sum(alongAxes: axes)) . Küçük girişlerin exp hesaplanmasının neden olduğu büyük girişlerin ve alt akışların log hesaplanmasının neden olduğu taşmalardan kaçınır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Anlar (Sıkma. :)
  Bu tensörün ortalamasını ve varyansını belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes 1 sıraya sahip olmalıdır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Anlar (Sıkma. :)
  Bu tensörün ortalamasını ve varyansını belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Anlar (Sıkma. :)
  Bu tensörün ortalamasını ve varyansını belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar kaldırılır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• Anlar ()
  Bu tensör elemanlarının ortalamasını ve varyansını döndürür.

  beyan

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

• anlar (boyunca :)
  Bu tensörün ortalamasını ve varyansını belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes 1 sıraya sahip olmalıdır.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• anlar (boyunca :)
  Bu tensörün ortalamasını ve varyansını belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

• anlar (boyunca :)
  Bu tensörün ortalamasını ve varyansını belirtilen eksenler boyunca döndürür. Azaltılmış boyutlar 1 değeri ile korunur.

  Önkoşul

  axes her değer -rank..<rank .

  beyan

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

  Parametreler

  axes	Azaltılacak boyutlar.

Nerede `skaler ':` sayısal'

• • (_: _ :)
  İki tensör arasında matris çarpımı gerçekleştirir ve sonucu üretir.

  beyan

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

Nerede `skaler ':` tensorflowfloatingpoint'

• VjpinitDeviceandPRECISICISEY (_: deviceandprecision gibi :)
  beyan

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

• BatchNormalize (Bulunma: Ofset: Ölçek: Epsilon :)
  Belirtilen eksen boyunca girişin normalize edilmesinden hesaplanan bir tensörü döndürür.

  Özellikle, mu ve var sırasıyla axis boyunca ortalama ve self olan (self - mu) / (var + epsilon) * gamma + beta .

  beyan

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

  Parametreler

  axis	Toplu boyut.
  offset	Ofset, beta olarak da bilinir.
  scale	Gamma olarak da bilinen ölçek.
  epsilon	Sayısal stabilite için paydaya eklenen küçük bir değer.

• Konsantre (_: _ :)
  Son eksen boyunca iki tensörü birleştirir.

  beyan

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

• toplam (_: _ :)
  İki değer ekler ve toplamlarını üretir.

  beyan

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

• ortalama(_:_:)
  Ortalama iki değer.

  beyan

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

• çarpın (_: _ :)
  İki değeri çoğaltır.

  beyan

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

• yığın(_:_:)
  İki değeri istifleyin.

  beyan

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

• init (şekil :)
  beyan

  @derivative
  init(shape: scalars)

Nerede `skaler ':' Equatable '

• == (_: _ :)
  beyan

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

• ! = (_: _ :)
  beyan

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

`Skaler ':` `kodlanabilir' '

• kodlamak (to :)
  beyan

  public func encode(to encoder: Encoder) throws

• init (from :)
  beyan

  public init(from decoder: Decoder) throws

Nerede `skaler ':` sayısal'

• sıfır
  Skaler sıfır tensör.

• sıfır
  beyan

  public static var zero: Tensor { get }

• +(_: _ :)
  İki tensör ekler ve toplamlarını üretir.

  Not

  + yayın yapmayı destekler.

  beyan

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

• -(_: _ :)
  Bir tensörü diğerinden çıkarır ve farklarını üretir.

  Not

  - Yayın yapmayı destekler.

  beyan

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

• bir
  Skaler bir tensör.

  beyan

  public static var one: Tensor { get }

• karşılıklı
  self elementine karşılıklı olarak döner.

  beyan

  public var reciprocal: Tensor { get }

• .*(_: _ :)
  İki tensörü element olarak çoğaltır ve ürünlerini üretir.

  Not

  .* Yayın yapmayı destekler.

  beyan

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

Nerede `skaler ':` tensorflowfloatingpoint'

• TeğetVektör
  beyan

  public typealias TangentVector = Tensor

• sıfırotanjentvektörü
  beyan

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

• açıklama ekle(_ :)
  Bir ek açıklama ekler.

  Not: Yalnızca X10 desteklenir. Diğer arka uçlar için, umodifiye self geri döner.

  beyan

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

  Parametreler

  annotation

  Eklenecek ek açıklama.

  Dönüş Değeri

  Açıklamalı tensör.

• vjPannotate (_ :)
  beyan

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