موتر

@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

مجموعة متعددة الأبعاد من العناصر التي تمثل تعميمًا للمتجهات والمصفوفات لأبعاد أعلى محتملة.

تصف المعلمة العامة Scalar نوع الكميات الموجودة في الموتر (مثل Int32 و Float وما إلى ذلك).

  • TensorHandle الأساسي.

    ملحوظة

    handle عام للسماح بالعمليات التي يحددها المستخدم، ولكن لا ينبغي استخدامه عادةً.

    تصريح

    public let handle: TensorHandle<Scalar>

  • تصريح

    public init(handle: TensorHandle<Scalar>)

  • يقوم بتفكيك البعد المحدد لموتر الرتبة R إلى موترات الرتبة المتعددة (R-1) . يفك موترات N من هذا الموتر عن طريق تقطيعه على طول axis ، حيث يتم استنتاج N من شكل هذا الموتر. على سبيل المثال، بالنظر إلى موتر بالشكل [A, B, C, D] :

    • إذا كان axis == 0 ، فإن الموتر i -th في المصفوفة التي تم إرجاعها هو الشريحة self[i, :, :, :] وسيكون لكل موتر في تلك المصفوفة شكل [B, C, D] . (لاحظ أن البعد الذي تم تفكيكه قد اختفى، على عكس Tensor.split(numSplits:alongAxis) أو Tensor.split(sizes:alongAxis) ).
    • إذا كان axis == 1 ، فإن الموتر i -th في المصفوفة التي تم إرجاعها هو value[:, i, :, :] وسيكون لكل موتر في تلك المصفوفة شكل [A, C, D] .
    • إلخ.

    هذا هو عكس Tensor.init(stacking:alongAxis:) .

    شرط مسبق

    يجب أن يكون axis في النطاق [-rank, rank) ، حيث rank هي رتبة الموترات المتوفرة.

    تصريح

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

    حدود

    axis

    البعد الذي يمكن فكه. تلتف القيم السلبية حولها.

    قيمة الإرجاع

    صفيف يحتوي على الموترات غير المكدسة.

  • يقسم الموتر إلى موترات متعددة. يتم تقسيم الموتر على طول axis البعد إلى count من الموترات الأصغر. يتطلب هذا أن count بتقسيم shape[axis] بالتساوي.

    على سبيل المثال:

    // 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors along dimension 1:
let parts = value.split(count: 3, alongAxis: 1)
parts[0] // has shape [5, 10]
parts[1] // has shape [5, 10]
parts[2] // has shape [5, 10]

    شرط مسبق

    يجب أن يقسم count حجم axis البعد بالتساوي.

    شرط مسبق

    يجب أن يكون axis في النطاق [-rank, rank) ، حيث rank هي رتبة الموترات المتوفرة.

    تصريح

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

    حدود

    count

    عدد الانقسامات المراد إنشاؤها.

    axis

    البعد الذي سيتم من خلاله تقسيم هذا الموتر. تلتف القيم السلبية حولها.

    قيمة الإرجاع

    مصفوفة تحتوي على جزء الموترات.

  • يقسم الموتر إلى موترات متعددة. يتم تقسيم الموتر إلى قطع sizes.shape[0] . شكل القطعة i له نفس شكل هذا الموتر باستثناء axis البعد حيث الحجم هو sizes[i] .

    على سبيل المثال:

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

    شرط مسبق

    يجب أن تصل القيم الموجودة في sizes إلى حجم axis البعد.

    شرط مسبق

    يجب أن يكون axis في النطاق [-rank, rank) ، حيث rank هي رتبة الموترات المتوفرة.

    تصريح

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

    حدود

    sizes

    موتر 1-D يحتوي على حجم كل انقسام.

    axis

    البعد الذي يتم من خلاله تقسيم هذا الموتر. تلتف القيم السلبية حولها.

    قيمة الإرجاع

    مصفوفة تحتوي على أجزاء الموترات.

  • تصريح

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

  • إرجاع موتر مبلط، تم إنشاؤه عن طريق تبليط هذا الموتر.

    يقوم هذا المنشئ بإنشاء موتر جديد عن طريق تكرار هذا الموتر multiples مرات. يحتوي البعد i للموتر الذي تم إنشاؤه على عناصر self.shape[i] * multiples[i] ، ويتم تكرار قيم هذا الموتر مرات multiples[i] على طول البعد i . على سبيل المثال، يؤدي تقسيم [abcd] بواسطة [2] إلى إنتاج [abcdabcd] .

    شرط مسبق

    يجب أن تكون rank المتوقعة للمضاعفات 1 .

    شرط مسبق

    يجب أن يكون شكل multiples [tensor.rank] .

    شرط مسبق

    يجب أن تكون جميع الكميات العددية في multiples غير سالبة.

    تصريح

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

  • إرجاع موتر مبلط، تم إنشاؤه عن طريق تبليط هذا الموتر.

    يقوم هذا المنشئ بإنشاء موتر جديد عن طريق تكرار هذا الموتر multiples مرات. يحتوي البعد i للموتر الذي تم إنشاؤه على عناصر self.shape[i] * multiples[i] ، ويتم تكرار قيم هذا الموتر مرات multiples[i] على طول البعد i . على سبيل المثال، يؤدي تقسيم [abcd] بواسطة [2] إلى إنتاج [abcdabcd] .

    شرط مسبق

    يجب أن تكون rank المتوقعة للمضاعفات 1 .

    شرط مسبق

    يجب أن يكون شكل multiples [tensor.rank] .

    تصريح

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

  • إعادة التشكيل إلى شكل Tensor المحدد.

    شرط مسبق

    عدد الكميات يتطابق مع الشكل الجديد.

    تصريح

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

  • إعادة التشكيل إلى الشكل المحدد.

    شرط مسبق

    عدد الكميات يتطابق مع الشكل الجديد.

    تصريح

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

  • إعادة التشكيل إلى Tensor المحدد الذي يمثل الشكل.

    شرط مسبق

    عدد الكميات يتطابق مع الشكل الجديد.

    تصريح

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

  • قم بإرجاع نسخة من الموتر المنهار إلى Tensor أحادي الأبعاد، بترتيب الصف الرئيسي.

    تصريح

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

  • تُرجع Tensor موسع الشكل، مع إدراج البعد 1 في مؤشرات الشكل المحددة.

    تصريح

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

  • تُرجع Tensor موسع الشكل، مع إدراج البعد 1 في مؤشرات الشكل المحددة.

    تصريح

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

  • تُرجع Tensor مرفوع الرتبة ببُعد رئيسي قدره 1.

    تصريح

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

  • إزالة الأبعاد المحددة للحجم 1 من شكل الموتر. إذا لم يتم تحديد أي أبعاد، فستتم إزالة جميع أبعاد الحجم 1.

    تصريح

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

  • إزالة الأبعاد المحددة للحجم 1 من شكل الموتر. إذا لم يتم تحديد أي أبعاد، فستتم إزالة جميع أبعاد الحجم 1.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بالترتيب المحدد.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بالترتيب المحدد.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بالترتيب المحدد.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بالترتيب المحدد.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بالترتيب المحدد.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بالترتيب المحدد.

    تصريح

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

  • تُرجع موترًا منقولًا، مع تبديل الأبعاد بترتيب عكسي.

    تصريح

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

  • إرجاع موتر بأبعاد محددة معكوسة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes ضمن النطاق -rank..<rank .

    شرط مسبق

    ويجب ألا يكون هناك ازدواجية في axes .

    تصريح

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

  • إرجاع موتر بأبعاد محددة معكوسة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes ضمن النطاق -rank..<rank .

    شرط مسبق

    ويجب ألا يكون هناك ازدواجية في axes .

    تصريح

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

  • إرجاع موتر بأبعاد محددة معكوسة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes ضمن النطاق -rank..<rank .

    شرط مسبق

    ويجب ألا يكون هناك ازدواجية في axes .

    تصريح

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

  • إرجاع موتر متسلسل على طول المحور المحدد.

    شرط مسبق

    يجب أن يكون للموترات نفس الأبعاد، باستثناء المحور المحدد.

    شرط مسبق

    يجب أن يكون المحور في النطاق -rank..<rank .

    تصريح

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

  • مشغل سلسلة.

    ملحوظة

    ++ هو عامل تشغيل مخصص غير موجود في Swift، ولكنه موجود في Haskell/Scala. إضافتها ليست تغييرًا طفيفًا في اللغة وقد تكون مثيرة للجدل. ستتم مناقشة وجود/تسمية ++ خلال مرحلة تصميم واجهة برمجة التطبيقات اللاحقة.

    تصريح

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

  • تُرجع موترًا عن طريق جمع شرائح المدخلات في indices على طول بُعد axis

    بالنسبة indices 0-D (العددية):

    result[p_0,          ..., p_{axis-1},
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices,
     p_{axis + 1}, ..., p_{N-1}]

    بالنسبة indices 1-D (المتجهة):

    result[p_0,          ..., p_{axis-1},
       i,
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices[i],
     p_{axis + 1}, ..., p_{N-1}]

    في الحالة العامة، ينتج موتر ناتج حيث:

    result[p_0,             ..., p_{axis-1},
       i_{batch\_dims}, ..., i_{M-1},
       p_{axis + 1},    ..., p_{N-1}] =
self[p_0,             ..., p_{axis-1},
     indices[i_0,     ..., i_{M-1}],
     p_{axis + 1},    ..., p_{N-1}]

    حيث N = self.rank و M = indices.rank .

    شكل الموتر الناتج هو: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

    ملحوظة

    على وحدة المعالجة المركزية، إذا تم العثور على فهرس خارج النطاق، فسيتم ظهور خطأ. في وحدة معالجة الرسومات، إذا تم العثور على فهرس خارج النطاق، فسيتم تخزين 0 في قيم الإخراج المقابلة.

    شرط مسبق

    يجب أن يكون axis في النطاق [-rank, rank) .

    تصريح

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

    حدود

    indices

    يحتوي على المؤشرات التي يمكن التجمع فيها.

    axis

    البعد الذي يمكن جمعه. تلتف القيم السلبية حولها.

    قيمة الإرجاع

    الموتر المتجمع.

  • تُرجع شرائح هذا الموتر عند indices بطول axis ، مع تجاهل أبعاد batchDimensionCount الأولى التي تتوافق مع أبعاد الدفعة. يتم تنفيذ التجميع على طول البعد الأول غير الدُفعي.

    يؤدي وظيفة مماثلة gathering ، باستثناء أن شكل الموتر الناتج أصبح الآن shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

    شرط مسبق

    يجب أن يكون axis في النطاق -rank..<rank ، بينما يكون أيضًا أكبر من أو يساوي batchDimensionCount .

    شرط مسبق

    يجب أن يكون batchDimensionCount أقل من indices.rank .

    تصريح

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

    حدود

    indices

    يحتوي على مؤشرات لجمع.

    axis

    البعد الذي يمكن جمعه. تلتف القيم السلبية حولها.

    batchDimensionCount

    عدد أبعاد الدُفعة البادئة المطلوب تجاهلها.

    قيمة الإرجاع

    الموتر المتجمع.

  • يُرجع موترًا عن طريق جمع القيم بعد تطبيق القناع المنطقي المقدم على الإدخال.

    على سبيل المثال:

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

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

    بشكل عام، 0 < mask.rank = K <= tensor.rank ، ويجب أن يتطابق شكل mask مع أبعاد K الأولى لشكل tensor . لدينا بعد ذلك: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] حيث [i1, ..., iK] هو الإدخال true i mask (ترتيب الصف الرئيسي).

    يمكن استخدام axis مع mask للإشارة إلى المحور الذي سيتم القناع منه. في هذه الحالة، يجب أن يتطابق axis + mask.rank <= tensor.rank وشكل mask مع dimensions of the المحور 's shape must match the first + Mask.rank لشكل الموتر.

    شرط مسبق

    لا يمكن أن يكون mask عددًا: mask.rank != 0 .

    تصريح

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

    حدود

    mask

    موتر منطقي KD، حيث K <= self.rank .

    axis

    موتر عدد صحيح 0-D يمثل المحور في self المراد القناع منه، حيث K + axis <= self.rank .

    قيمة الإرجاع

    (self.rank - K + 1) موتر ذو أبعاد يتم ملؤه بإدخالات في هذا الموتر المطابق للقيم true في mask .

  • تُرجع مواقع القيم غير الصفرية/الحقيقية في هذا الموتر.

    يتم إرجاع الإحداثيات في موتر ثنائي الأبعاد حيث يمثل البعد الأول (الصفوف) عدد العناصر غير الصفرية، والبعد الثاني (الأعمدة) يمثل إحداثيات العناصر غير الصفرية. ضع في اعتبارك أن شكل موتر الخرج يمكن أن يختلف اعتمادًا على عدد القيم الحقيقية الموجودة في هذا الموتر. يتم إخراج المؤشرات بترتيب الصف الرئيسي.

    على سبيل المثال:

    // 'input' is [[true, false], [true, false]]
// 'input' has 2 true values and so the output has 2 rows.
// 'input' has rank of 2, and so the second dimension of the output has size 2.
input.nonZeroIndices() // is [[0, 0], [1, 0]]

// 'input' is [[[ true, false], [ true, false]],
//             [[false,  true], [false,  true]],
//             [[false, false], [false,  true]]]
// 'input' has 5 true values and so the output has 5 rows.
// 'input' has rank 3, and so the second dimension of the output has size 3.
input.nonZeroIndices() // is [[0, 0, 0],
                       //     [0, 1, 0],
                       //     [1, 0, 1],
                       //     [1, 1, 1],
                       //     [2, 1, 1]]

    تصريح

    public func nonZeroIndices() -> Tensor<Int64>

    قيمة الإرجاع

    موتر ذو شكل (num_true, rank(condition)) .

  • تصريح

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

  • تصريح

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

  • البث إلى نفس الشكل مثل Tensor المحدد.

    شرط مسبق

    يجب أن يكون الشكل المحدد متوافقًا مع البث.

    تصريح

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

  • تصريح

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

  • يستخرج شريحة من الموتر المحدد بالحدود الدنيا والعليا لكل بعد.

    تصريح

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

    حدود

    lowerBounds

    الحدود الدنيا في كل بعد.

    upperBounds

    الحدود العليا في كل بعد.

  • تصريح

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

  • تصريح

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

  • تصريح

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

  • يتأكد من أن كل عنصر من axes يشير إلى محور self ، ويوقف البرنامج بتشخيص خلاف ذلك.

    تصريح

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

  • يتأكد من أن كل عنصر من axes يشير إلى محور self ، ويوقف البرنامج بتشخيص خلاف ذلك.

    تصريح

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

  • يتحقق من أن k تشير إلى محور self ، ويوقف البرنامج بتشخيص خلاف ذلك.

    تصريح

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

  • تصريح

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

  • يقوم بإنشاء نسخة other على Device المحدد.

    تصريح

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

  • ينشئ موترًا بالشكل المحدد وقيمة عددية واحدة متكررة.

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    repeatedValue

    القيمة العددية للتكرار.

  • ينشئ موترًا بالشكل المحدد وقيمة عددية واحدة متكررة.

    تصريح

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

    حدود

    repeatedValue

    القيمة العددية للتكرار.

    shape

    أبعاد الموتر.

  • إنشاء موتر عن طريق بث العدد المحدد إلى رتبة معينة مع كون جميع الأبعاد 1.

    تصريح

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

  • ينشئ موترًا من مجموعة من الموترات (والتي قد تكون في حد ذاتها عددًا قياسيًا).

    تصريح

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

  • يكدس tensors ، على طول axis ، في موتر جديد ذو رتبة واحدة أعلى من الموتر الحالي وكل موتر في tensors .

    بالنظر إلى أن جميع tensors لها شكل [A, B, C] و tensors.count = N ، إذن:

    • إذا كان axis == 0 فإن الموتر الناتج سيكون له الشكل [N, A, B, C] .
    • إذا كان axis == 1 فإن الموتر الناتج سيكون له الشكل [A, N, B, C] .
    • إلخ.

    على سبيل المثال:

    // 'x' is [1, 4]
// 'y' is [2, 5]
// 'z' is [3, 6]
Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]

    هذا هو عكس Tensor.unstacked(alongAxis:) .

    شرط مسبق

    يجب أن يكون لجميع الموترات نفس الشكل.

    شرط مسبق

    يجب أن يكون axis في النطاق [-rank, rank) ، حيث rank هي رتبة الموترات المتوفرة.

    تصريح

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

    حدود

    tensors

    الموترات للتكديس.

    axis

    البعد الذي يمكن تكديسه. تلتف القيم السلبية حولها.

    قيمة الإرجاع

    الموتر المكدس.

  • يسلسل tensors على طول البعد axis .

    بالنظر إلى أن tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] ، فإن النتيجة المتسلسلة لها شكل [D0, D1, ... Raxis, ...Dn] ، حيث Raxis = sum(Daxis(i)) . وهذا يعني أن البيانات الواردة من موترات الإدخال يتم ربطها على طول بُعد axis .

    على سبيل المثال:

    // t1 is [[1, 2, 3], [4, 5, 6]]
// t2 is [[7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

// t3 has shape [2, 3]
// t4 has shape [2, 3]
Tensor(concatenating: [t3, t4]) // has shape [4, 3]
Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]

    ملحوظة

    إذا كنت تقوم بالتسلسل على طول محور جديد، ففكر في استخدام Tensor.init(stacking:alongAxis:) .

    شرط مسبق

    يجب أن يكون لجميع الموترات نفس الرتبة وأن تكون جميع الأبعاد باستثناء axis متساوية.

    شرط مسبق

    يجب أن يكون axis في النطاق [-rank, rank) ، حيث rank هي رتبة الموترات المتوفرة.

    تصريح

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

    حدود

    tensors

    التوترات لتسلسل.

    axis

    البعد الذي يمكن من خلاله التسلسل. تلتف القيم السلبية حولها.

    قيمة الإرجاع

    الموتر المتسلسل.

  • يستبدل عناصر هذا الموتر بعناصر other في الممرات التي يكون فيها mask true .

    شرط مسبق

    يجب أن يكون self other نفس الشكل. إذا كانت self other عددية، فيجب أن يكون mask أيضًا عدديًا. إذا كانت رتبة self other أكبر من أو تساوي 1 ، فيجب أن يكون mask نفس شكل self أو أن يكون Tensor أحادي الأبعاد بحيث يكون mask.scalarCount == self.shape[0] .

    تصريح

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

  • يُرجع صحيحًا إذا كانت دقة النوع العددي الفعلي منخفضة.

    حاليًا، تتضمن الأنواع العددية الفيزيائية منخفضة الدقة BFloat16 فقط.

    تصريح

    public var isReducedPrecision: Bool { get }

  • ترقية عددي إلى موتر بنفس الجهاز والدقة مثل الموتر المحدد.

    تصريح

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

  • إرجاع نسخة من self المحولة إلى النوع العددي الفعلي BFloat16 .

    تصريح

    public var toReducedPrecision: `Self` { get }

  • إرجاع نسخة من self المحولة إلى النوع العددي Scalar .

    تصريح

    public var toFullPrecision: `Self` { get }

  • عدد أبعاد Tensor .

    تصريح

    public var rank: Int { get }

  • شكل Tensor .

    تصريح

    public var shape: TensorShape { get }

  • عدد الكميات الموجودة في Tensor .

  • تصريح

    public var scalarCount: Int { get }

  • رتبة الموتر، ممثلة بـ Tensor<Int32> .

    تصريح

    public var rankTensor: Tensor<Int32> { get }

  • أبعاد الموتر ممثلة بـ Tensor<Int32> .

    تصريح

    public var shapeTensor: Tensor<Int32> { get }

  • عدد الكميات القياسية في الموتر، ممثلة في Tensor<Int32> .

    تصريح

    public var scalarCountTensor: Tensor<Int32> { get }

  • يُرجع true إذا كانت rank تساوي 0 false إذا كانت غير ذلك.

    تصريح

    public var isScalar: Bool { get }

  • تُرجع العنصر العددي المفرد إذا كانت rank تساوي 0 ولا nil بخلاف ذلك.

    تصريح

    public var scalar: Scalar? { get }

  • إعادة تشكيل إلى العددية.

    شرط مسبق

    يحتوي الموتر على عدد قياسي واحد بالضبط.

    تصريح

    @differentiable
public func scalarized() -> Scalar

  • تصريح

    public var array: ShapedArray<Scalar> { get }

  • تصريح

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

  • ينشئ موتر 0-D من قيمة عددية.

    تصريح

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

  • إنشاء موتر 1D من الكميات القياسية.

    تصريح

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

  • إنشاء موتر 1D من الكميات القياسية.

    تصريح

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

  • ينشئ موترًا بالشكل المحدد والكميات القياسية المتجاورة بترتيب الصف الرئيسي.

    شرط مسبق

    يجب أن يكون حاصل ضرب أبعاد الشكل مساويًا لعدد الكميات القياسية.

    تصريح

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

    حدود

    shape

    شكل الموتر.

    scalars

    المحتويات العددية للموتر.

  • ينشئ موترًا بالشكل المحدد والكميات القياسية المتجاورة بترتيب الصف الرئيسي.

    شرط مسبق

    يجب أن يكون حاصل ضرب أبعاد الشكل مساويًا لعدد الكميات القياسية.

    تصريح

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

    حدود

    shape

    شكل الموتر.

    scalars

    المحتويات العددية للموتر.

  • ينشئ موترًا بالشكل المحدد والكميات القياسية المتجاورة بترتيب الصف الرئيسي.

    شرط مسبق

    يجب أن يكون حاصل ضرب أبعاد الشكل مساويًا لعدد الكميات القياسية.

  • ينشئ موترًا بالشكل المحدد والكميات القياسية المتجاورة بترتيب الصف الرئيسي.

    شرط مسبق

    يجب أن يكون حاصل ضرب أبعاد الشكل مساويًا لعدد الكميات القياسية.

    تصريح

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

    حدود

    shape

    شكل الموتر.

    scalars

    المحتويات العددية للموتر.

  • نوع عناصر المصفوفة الحرفية.

    تصريح

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • ينشئ موترًا تمت تهيئته بالعناصر المحددة.

    تصريح

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

  • تمثيل نصي للموتر.

    ملحوظة

    استخدم fullDescription للحصول على وصف غير مطبوع بشكل جيد يُظهر جميع الكميات.

    تصريح

    public var description: String { get }

  • تمثيل نصي للموتر. تُرجع وصفًا ملخصًا إذا كان summarize صحيحًا وكان عدد العناصر يتجاوز ضعف edgeElementCount .

    تصريح

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

    حدود

    lineWidth

    الحد الأقصى لعرض الخط للطباعة. يستخدم لتحديد عدد الكميات المطلوب طباعتها لكل سطر.

    edgeElementCount

    الحد الأقصى لعدد العناصر المراد طباعتها قبل وبعد التلخيص عبر علامات الحذف ( ... ).

    summarizing

    إذا كان صحيحًا، قم بتلخيص الوصف إذا تجاوز عدد العناصر مرتين edgeElementCount .

  • تمثيل نصي كامل وغير مطبوع بشكل جميل للموتر، يُظهر جميع الكميات.

    تصريح

    public var fullDescription: String { get }

  • تصريح

    public var playgroundDescription: Any { get }

  • تصريح

    public var customMirror: Mirror { get }

  • الشروح التي تصف هذا الموتر.

    تصريح

    public var annotations: String { get }

  • اسم مستعار للتعليقات التوضيحية.

    تصريح

    public var summary: String { get }

  • تصريح

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

  • تصريح

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

  • تصريح

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

  • تصريح

    init(_xla: XLATensor)

  • تصريح

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • تصريح

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • تصريح

    var xlaTensor: XLATensor { get }
متاح حيث `العددية`: `الرقمية`

  • تصريح

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

  • تصريح

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

  • تصريح

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

  • الوضع الذي يملي كيفية تعبئة الموتر.

    تصريح

    public enum PaddingMode

  • يُرجع موترًا مبطنًا بثابت وفقًا لأحجام الحشو المحددة.

    تصريح

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

  • يُرجع موترًا مبطنًا وفقًا لأحجام ووضع الحشو المحدد.

    تصريح

    @differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
متاح حيث `العددية`: `الرقمية` و`القابلة للمقارنة`

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs < rhs .

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs <= rhs .

    تصريح

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

  • إرجاع موتر من الكميات المنطقية عن طريق حساب عنصر lhs > rhs .

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs >= rhs .

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs < rhs .

    ملحوظة

    .< يدعم البث .

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs <= rhs .

    ملحوظة

    .<= يدعم البث.

    تصريح

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

  • إرجاع موتر من الكميات المنطقية عن طريق حساب عنصر lhs > rhs .

    ملحوظة

    .> يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs >= rhs .

    ملحوظة

    .>= يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs < rhs .

    ملحوظة

    .< يدعم البث .

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs <= rhs .

    ملحوظة

    .<= يدعم البث.

    تصريح

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

  • إرجاع موتر من الكميات المنطقية عن طريق حساب عنصر lhs > rhs .

    ملحوظة

    .> يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs >= rhs .

    ملحوظة

    .>= يدعم البث.

    تصريح

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
متاح حيث `Scalar`: `Equatable`

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs == rhs .

    ملحوظة

    .== يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs != rhs .

    ملحوظة

    .!= يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs == rhs .

    ملحوظة

    .== يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs != rhs .

    ملحوظة

    .!= يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs == rhs .

    ملحوظة

    .== يدعم البث.

    تصريح

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

  • تُرجع موترًا من الكميات المنطقية عن طريق حساب عنصر lhs != rhs .

    ملحوظة

    .!= يدعم البث.

    تصريح

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
متاح حيث `Scalar`: `TensorFlowFloatingPoint` و`Equatable`

  • تُرجع موترًا من القيم المنطقية يشير إلى ما إذا كانت عناصر self متساوية تقريبًا مع العناصر other .

    شرط مسبق

    self other يجب أن يكونا على نفس الشكل.

    تصريح

    public func elementsAlmostEqual(
  _ other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
متاح حيث `Scalar`: `TensorFlowFloatingPoint`

  • يُرجع true إذا كانت جميع عناصر self متساوية تقريبًا مع العناصر other .

    شرط مسبق

    self other يجب أن يكونا على نفس الشكل.

    تصريح

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
متاح حيث `Scalar`: `TensorFlowNumeric`

  • يتم تشغيل مجموع النسخ المتماثلة لهذا الموتر. يجب أن يحدث نفس مجموع النسخ المتماثلة على كل جهاز من الأجهزة الأخرى المشاركة في المجموع.

    تصريح

    public mutating mutating func crossReplicaSum(_ scale: Double)
متاح حيث `Scalar`: `TensorFlowFloatingPoint`
متاح حيث `العددية`: `الرقمية`

  • قم بإجراء تحويل من نوع العنصر من موتر Bool .

    تصريح

    public init(_ other: Tensor<Bool>)

  • إجراء تحويل عنصري من Tensor آخر.

    تصريح

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
متاح حيث `Scalar`: `TensorFlowFloatingPoint`
متاح حيث `العددية`: `الرقمية`

  • ينشئ موترًا مع ضبط جميع الكميات على الصفر.

    تصريح

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

    حدود

    shape

    شكل الموتر.

  • ينشئ موترًا مع ضبط جميع الكميات على واحد.

    تصريح

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

    حدود

    shape

    شكل الموتر.

  • ينشئ موترًا مع ضبط جميع الكميات القياسية على الصفر وله نفس الشكل والنوع مثل الموتر المقدم.

    تصريح

    public init(zerosLike other: Tensor)

    حدود

    other

    Tensor الذي سيتم استخدام شكله ونوع بياناته.

  • ينشئ موترًا مع تعيين جميع الكميات القياسية على موتر له نفس الشكل والنوع مثل الموتر المقدم.

    تصريح

    public init(onesLike other: Tensor)

    حدود

    other

    Tensor الذي سيتم استخدام شكله ونوع بياناته.

  • ينشئ موترًا أحادي الأبعاد يمثل تسلسلًا من قيمة البداية إلى القيمة النهائية، ولكن لا يتضمنها، مع التدرج بالمبلغ المحدد.

    تصريح

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

    حدود

    start

    قيمة البداية المطلوب استخدامها للتسلسل. إذا كان التسلسل يحتوي على أي قيم، فالقيمة الأولى هي start .

    end

    قيمة نهاية للحد من التسلسل. end ليست أبدًا عنصرًا في التسلسل الناتج.

    stride

    مقدار الخطوة مع كل تكرار. يجب أن تكون stride إيجابية.

  • ينشئ موترًا أحادي الأبعاد يمثل تسلسلًا من قيمة البداية إلى القيمة النهائية، ولكن لا يتضمنها، مع التدرج بالمبلغ المحدد.

    تصريح

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

    حدود

    start

    قيمة البداية المطلوب استخدامها للتسلسل. إذا كان التسلسل يحتوي على أي قيم، فالقيمة الأولى هي start .

    end

    قيمة نهاية للحد من التسلسل. end ليست أبدًا عنصرًا في التسلسل الناتج.

    stride

    مقدار الخطوة مع كل تكرار. يجب أن تكون stride إيجابية.

  • ينشئ موترًا ساخنًا واحدًا عند مؤشرات معينة. تأخذ المواقع الممثلة indices قيمة onValue ( 1 افتراضيًا)، بينما تأخذ جميع المواقع الأخرى قيمة offValue ( 0 افتراضيًا). إذا كانت indices الإدخال هي الرتبة n ، فإن الموتر الجديد سيكون له الرتبة n+1 . يتم إنشاء المحور الجديد عند axis البعد (افتراضيًا، يتم إلحاق المحور الجديد في النهاية).

    إذا كانت indices عددية، فإن شكل الموتر الجديد سيكون متجهًا depth الطول.

    إذا كانت indices متجهًا features الطول، فسيكون شكل الإخراج: الميزات × العمق، إذا كان المحور == -1 العمق × الميزات، إذا كان المحور == 0

    إذا كانت indices عبارة عن مصفوفة (دفعة) ذات شكل [batch, features] ، فسيكون شكل الإخراج: دفعة × ميزات × عمق، إذا كان المحور == -1 دفعة × عمق × ميزات، إذا كان المحور == 1 عمق × دفعة × ميزات إذا كان المحور == 0

    تصريح

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

    حدود

    indices

    Tensor المؤشرات.

    depth

    عددي يحدد عمق البعد الساخن الواحد.

    onValue

    عددي يحدد القيمة في الموقع المشار إليه بواسطة بعض الفهارس في indices .

    offValue

    عددي يحدد القيمة في موقع لا يشير إليه أي فهرس في indices .

    axis

    المحور المراد ملؤه. الافتراضي هو -1 ، وهو محور داخلي جديد.

متاح حيث `Scalar`: `TensorFlowFloatingPoint`

  • ينشئ موترًا أحادي الأبعاد يمثل تسلسلًا من قيمة البداية، حتى القيمة النهائية ويتضمنها، متباعدًا بالتساوي لإنشاء عدد القيم المحددة.

    تصريح

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

    حدود

    start

    قيمة البداية المطلوب استخدامها للتسلسل. إذا كان التسلسل يحتوي على أي قيم، فالقيمة الأولى هي start .

    end

    قيمة نهاية للحد من التسلسل. end هي العنصر الأخير في التسلسل الناتج.

    count

    عدد القيم في التسلسل الناتج. يجب أن يكون count إيجابيا.

  • ينشئ موترًا أحادي الأبعاد يمثل تسلسلًا من قيمة البداية، حتى القيمة النهائية ويتضمنها، متباعدًا بالتساوي لإنشاء عدد القيم المحددة.

    شرط مسبق

    يجب أن تكون start ، to ، count عن Tensors تحتوي على قيمة عددية واحدة.

    تصريح

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

    حدود

    start

    قيمة البداية المطلوب استخدامها للتسلسل. إذا كان التسلسل يحتوي على أي قيم، فالقيمة الأولى هي start .

    end

    قيمة نهاية للحد من التسلسل. end هي العنصر الأخير في التسلسل الناتج.

    count

    عدد القيم في التسلسل الناتج. يجب أن يكون count إيجابيا.

متاح حيث `Scalar`: `TensorFlowIndex`

  • ينشئ موترًا بالشكل المحدد، ويأخذ عينات عشوائية من القيم العددية من توزيع موحد بين lowerBound و upperBound .

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    lowerBound

    الحد الأدنى للتوزيع.

    upperBound

    الحد الأعلى للتوزيع.

    seed

    قيمة البذور.

متاح حيث `Scalar`: `TensorFlowFloatingPoint`

  • ينشئ موترًا بالشكل المحدد، ويأخذ عينات عشوائية من القيم العددية من توزيع موحد بين lowerBound و upperBound .

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    lowerBound

    الحد الأدنى للتوزيع.

    upperBound

    الحد الأعلى للتوزيع.

    seed

    قيمة البذور.

  • إنشاء موتر بالشكل المحدد، وأخذ عينات عشوائية من القيم العددية من التوزيع الطبيعي.

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    mean

    متوسط ​​التوزيع.

    standardDeviation

    الانحراف المعياري للتوزيع.

    seed

    قيمة البذور.

  • ينشئ موترًا بالشكل المحدد، ويأخذ عينات عشوائية من القيم العددية من توزيع عادي مبتور.

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    mean

    متوسط ​​التوزيع.

    standardDeviation

    الانحراف المعياري للتوزيع.

    seed

    قيمة البذور.

متاح حيث `Scalar`: `TensorFlowIndex`

  • إنشاء موتر عن طريق رسم عينات من التوزيع الفئوي.

    تصريح

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

    حدود

    randomCategorialLogits

    موتر ثنائي الأبعاد بالشكل [batchSize, classCount] . تمثل كل شريحة [i, :] احتمالات السجل غير الطبيعية لجميع الفئات.

    sampleCount

    0-د. عدد العينات المستقلة المراد رسمها لكل شريحة صفية.

    seed

    قيمة البذور.

    قيمة الإرجاع

    موتر ثنائي الأبعاد بالشكل [batchSize, sampleCount] . تحتوي كل شريحة [i, :] على تسميات الفصل المرسومة ذات النطاق [0, classCount) .

متاح حيث `Scalar`: `TensorFlowFloatingPoint`

  • إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة موحدة لـ Glorot (Xavier).

    يقوم بسحب عينات عشوائية من توزيع موحد بين -limit و limit المتولدة بواسطة مولد الأرقام العشوائية الافتراضي، حيث limit هو sqrt(6 / (fanIn + fanOut)) ويمثل fanIn / fanOut عدد ميزات الإدخال والإخراج مضروبة في المستقبل حجم الحقل.

    المرجع: "فهم صعوبة تدريب الشبكات العصبية العميقة المغذية"

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    seed

    قيمة البذور.

  • إنشاء موتر بالشكل المحدد عن طريق إجراء التهيئة العادية لـ Glorot (Xavier).

    يقوم بسحب عينات عشوائية من التوزيع الطبيعي المقطوع المتمركز حول 0 مع الانحراف المعياري sqrt(2 / (fanIn + fanOut)) الذي تم إنشاؤه بواسطة مولد الأرقام العشوائية الافتراضية، حيث يمثل fanIn / fanOut عدد ميزات الإدخال والإخراج مضروبة في حقل الاستلام مقاس.

    المرجع: "فهم صعوبة تدريب الشبكات العصبية العميقة المغذية"

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    seed

    قيمة البذور.

  • إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة موحدة لـ He (Kaiming).

    يقوم بسحب عينات عشوائية من توزيع موحد بين -limit و limit الناتج عن مولد الأرقام العشوائية الافتراضي، حيث limit هو sqrt(6 / fanIn) و fanIn يمثل عدد ميزات الإدخال مضروبة في حجم حقل الاستلام.

    المرجع: "التعمق في المقومات: تجاوز الأداء على المستوى البشري في تصنيف ImageNet"

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    seed

    قيمة البذور.

  • إنشاء موتر بالشكل المحدد عن طريق إجراء التهيئة العادية لـ He (Kaiming).

    يقوم بسحب عينات عشوائية من التوزيع الطبيعي المقطوع المتمركز حول 0 مع الانحراف المعياري sqrt(2 / fanIn)) الناتج عن مولد الأرقام العشوائية الافتراضي، حيث يمثل fanIn عدد ميزات الإدخال مضروبة في حجم حقل الاستلام.

    المرجع: "التعمق في المقومات: تجاوز الأداء على المستوى البشري في تصنيف ImageNet"

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    seed

    قيمة البذور.

  • إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة موحدة لـ LeCun.

    يقوم بسحب عينات عشوائية من توزيع موحد بين -limit و limit الناتج عن مولد الأرقام العشوائية الافتراضي، حيث limit هو sqrt(3 / fanIn) و fanIn يمثل عدد ميزات الإدخال مضروبة في حجم حقل الاستلام.

    المرجع: "دعامة خلفية فعالة"

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    seed

    قيمة البذور.

  • إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة LeCun العادية.

    يقوم بسحب عينات عشوائية من التوزيع الطبيعي المقطوع المتمركز حول 0 مع الانحراف المعياري sqrt(1 / fanIn) الناتج عن مولد الأرقام العشوائية الافتراضية، حيث يمثل fanIn عدد ميزات الإدخال مضروبة في حجم حقل الاستلام.

    المرجع: "دعامة خلفية فعالة"

    تصريح

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

    حدود

    shape

    أبعاد الموتر.

    seed

    قيمة البذور.

  • إنشاء مصفوفة متعامدة أو موتر.

    إذا كان شكل الموتر المراد تهيئته ثنائي الأبعاد، تتم تهيئته بمصفوفة متعامدة تم الحصول عليها من تحليل QR لمصفوفة أرقام عشوائية مأخوذة من التوزيع الطبيعي. إذا كانت المصفوفة تحتوي على صفوف أقل من الأعمدة فإن الناتج سيكون له صفوف متعامدة. وبخلاف ذلك، سيكون للإخراج أعمدة متعامدة.

    إذا كان شكل الموتر المراد تهيئته أكثر من ثنائي الأبعاد، فستتم تهيئة مصفوفة الشكل [shape[0] * ... * shape[rank - 2], shape[rank - 1]] . يتم بعد ذلك إعادة تشكيل المصفوفة لإعطاء موتر الشكل المطلوب.

    تصريح

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

    حدود

    shape

    شكل الموتر.

    gain

    عامل مضاعف لتطبيقه على الموتر المتعامد.

    seed

    مجموعة من عددين صحيحين لتكوين مولد الأرقام العشوائية.

متاح حيث `Scalar`: `TensorFlowNumeric`

  • إرجاع الجزء القطري [المُجمَّع] من الموتر [المُجمَّع]. بالنسبة لمثيل الموتر للشكل [..., M, N] ، يكون الإخراج موترًا للشكل [..., K] ، حيث K يساوي min(N, M) .

    على سبيل المثال:

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

    تصريح

    @differentiable
public func diagonalPart() -> Tensor

  • يبني مصفوفة قطرية [مجمعة]. بالنسبة لمثيل الموتر للشكل [..., M] ، فإن الإخراج هو موتر للشكل [..., M, M] .

    على سبيل المثال:

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

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

    تصريح

    @differentiable
public func diagonal() -> Tensor

  • تُرجع self بقيم قطرية جديدة، نظرًا لأن self عبارة عن مصفوفة مجمعة بشكل اختياري.

    الموتر الذي تم إرجاعه له نفس الشكل والقيم مثل self ، باستثناء الأقطار المحددة للمصفوفات الأعمق التي يتم استبدالها بالقيم في diagonal .

    المعلمة القطرية: موتر ذو rank - 1 يمثل القيم القطرية الجديدة.

    تصريح

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

  • تصريح

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

  • إرجاع نسخة من الموتر الأعمق المحدد بحدود النطاق المركزي. الناتج هو موتر بنفس شكل المثال [..., :, :] .

    على سبيل المثال:

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

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

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

    تصريح

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

    حدود

    subdiagonalCount

    عدد الأقطار الفرعية التي يجب الاحتفاظ بها. إذا كانت سلبية، احتفظ بالمثلث السفلي بأكمله.

    superdiagonalCount

    عدد الأقطار الفائقة التي يجب الاحتفاظ بها. إذا كانت سلبية، احتفظ بالمثلث العلوي بأكمله.

متاح حيث `Scalar`: `TensorFlowFloatingPoint`

  • يُرجع تحليل QR لكل مصفوفة داخلية في الموتر، وموتر بمصفوفات متعامدة داخلية q وموتر بمصفوفات مثلثية علوية داخلية r ، بحيث يكون الموتر مساويًا لـ matmul(q, r) .

    تصريح

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

    حدود

    fullMatrices

    إذا كان true ، قم بحساب الحجم الكامل q و r . بخلاف ذلك، قم بحساب الأعمدة min(shape[rank - 1], shape[rank - 2]) البادئة فقط في q .

  • تُرجع تحليل القيمة المفردة self ، نظرًا لأن self عبارة عن مصفوفة مجمعة اختياريًا.

    تحليل القيمة المفردة (SVD) self المجمعة اختياريًا هو القيم s u و v ، بحيث:

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

    must be a tensor with shape [..., M, N] . Let K = دقيقة (M، N)`.

    شرط مسبق

    يجب أن تكون self موترًا بالشكل [..., M, N] .

    تصريح

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

    حدود

    computeUV

    إذا كان true ، فسيتم حساب المتجهين المفردين الأيسر والأيمن وإرجاعهما كـ u و v على التوالي. إذا كانت القيمة false ، فسيتم إرجاع القيم nil بالشكل u و v .

    fullMatrices

    إذا true ، فإن u و v لهما أشكال [..., M, M] و [..., N, N] على التوالي. إذا كانت false ، فإن u و v لهما أشكال [..., M, K] و [..., K, N] على التوالي. يتم تجاهله عندما يكون computeUV خطأ.

    قيمة الإرجاع

    • s: القيم المفردة بالشكل [..., K] . داخل كل متجه، يتم فرز القيم المفردة بترتيب تنازلي.
    • u: المتجهات المفردة اليسرى.
    • v: المتجهات المفردة الصحيحة.

  • الجذر التربيعي ل x .

    بالنسبة للأنواع الحقيقية، إذا كانت x سالبة فإن النتيجة هي .nan . بالنسبة للأنواع المعقدة، يوجد قطع فرعي على المحور الحقيقي السلبي.

    تصريح

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

  • جيب تمام x ، يتم تفسيره على أنه زاوية بالراديان.

    تصريح

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

  • جيب x ، يتم تفسيره على أنه زاوية بالراديان.

    تصريح

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

  • ظل x ، يتم تفسيره على أنه زاوية بالراديان.

    تصريح

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

  • جيب التمام العكسي لـ x بالراديان.

    تصريح

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

  • جيب الجيب العكسي لـ x بالراديان.

    تصريح

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

  • المماس العكسي لـ x بالراديان.

    تصريح

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

  • جيب التمام الزائدي لـ x .

    تصريح

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

  • الجيب الزائدي لـ x .

    تصريح

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

  • المماس الزائدي لـ x .

    تصريح

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

  • جيب التمام الزائد العكسي لـ x

    تصريح

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

  • الجيب الزائد العكسي من x .

    تصريح

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

  • الظل الزائد العكسي من x .

    تصريح

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

  • الوظيفة الأسية المطبقة على x ، أو e**x .

    تصريح

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

  • اثنان رفعت إلى السلطة x .

    تصريح

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

  • عشرة رفعت إلى السلطة x .

    تصريح

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

  • exp(x) - 1 تم تقييمها للحفاظ على الدقة بالقرب من الصفر.

    تصريح

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

  • اللوغاريتم الطبيعي من x .

    تصريح

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

  • لوغاريتم القاعدة اثنين من x .

    تصريح

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

  • لوغاريتم القاعدة من x

    تصريح

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

  • log(1 + x) تم تقييمه من أجل الحفاظ على الدقة بالقرب من الصفر.

    تصريح

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

  • exp(y log(x)) محسوبة دون فقدان الدقة الوسيطة.

    بالنسبة للأنواع الحقيقية ، إذا كانت x سالبة ، فإن النتيجة هي NAN ، حتى لو كانت y لها قيمة متكاملة. بالنسبة للأنواع المعقدة ، يوجد فرع على المحور الحقيقي السلبي.

    تصريح

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

  • x أثيرت إلى قوة n .

    نتاج نسخ n من x .

    تصريح

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

  • جذر n من x .

    بالنسبة للأنواع الحقيقية ، إذا كانت x سلبية و n حتى ، فإن النتيجة هي NAN. بالنسبة للأنواع المعقدة ، هناك قطع فرع على طول المحور الحقيقي السلبي.

    تصريح

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

  • تصريح

    public typealias VectorSpaceScalar = Float

  • تصريح

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

  • تصريح

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

  • تصريح

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
متاح حيث "العددية": "رقمي"

  • يضيف العددية إلى كل عدادات من الموتر وتنتج المبلغ.

    تصريح

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

  • يضيف العددية إلى كل عدادات من الموتر وتنتج المبلغ.

    تصريح

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

  • يطرح العددية من كل عدادات من الموتر وتنتج الفرق.

    تصريح

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

  • يطرح العددية من كل عدادات من الموتر وينتج الفرق

    تصريح

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

  • يضيف اثنين من الموترات ويخزن النتيجة في المتغير الأيسر.

    ملحوظة

    += يدعم البث.

    تصريح

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

  • يضيف العددية إلى كل عدادات من الموتر ويخزن النتيجة في متغير الجانب الأيسر.

    تصريح

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

  • يطرح الموتر الثاني من الأول ويخزن النتيجة في متغير الجانب الأيسر.

    ملحوظة

    -= يدعم البث.

    تصريح

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

  • يطرح العددية من كل عدادات من الموتر ويخزن النتيجة في متغير الجانب الأيسر.

    تصريح

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

  • إرجاع الموتر الناتج عن مضاعفة اثنين من الموترات.

    ملحوظة

    * يدعم البث.

    تصريح

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

  • إرجاع الموتر عن طريق ضربه مع كل عدادات من الموتر.

    تصريح

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

  • يضاعف العددية مع كل عدادات من الموتر وينتج المنتج.

    تصريح

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

  • يضاعف اثنين من الموتر ويخزن النتيجة في متغير الجانب الأيسر.

    ملحوظة

    *= يدعم البث.

    تصريح

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

  • يضاعف الموتر مع العددية ، وبث العددية ، ويخزن النتيجة في متغير الجانب الأيسر.

    تصريح

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

  • إرجاع حاصل تقسيم الموتر الأول على الثانية.

    ملحوظة

    / يدعم البث.

    تصريح

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

  • إرجاع حاصل تقسيم العددية على الموتر ، وبث العددية.

    تصريح

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

  • إرجاع حاصل تقسيم الموتر على العددية ، وبث العددية.

    تصريح

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

  • يقسم أول موتر على الثانية ويخزن الحاصل في المتغير الأيسر.

    تصريح

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

  • يقسم الموتر على العددية ، وبث العددية ، ويخزن الحاصل في المتغير الأيسر.

    تصريح

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

  • إرجاع ما تبقى من تقسيم الموتر الأول على الثانية.

    ملحوظة

    % يدعم البث.

    تصريح

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

  • إرجاع ما تبقى من تقسيم الموتر على العددية ، وبث العددية.

    تصريح

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

  • إرجاع ما تبقى من تقسيم العددية على الموتر ، وبث العددية.

    تصريح

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

  • يقسم أول موتر على الثانية ويخزن الباقي في المتغير الأيسر.

    تصريح

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

  • يقسم الموتر على العددية ويخزن الباقي في المتغير الأيسر.

    تصريح

    public static func %= (lhs: inout Tensor, rhs: Scalar)
متاح حيث `القيد ==` bool`

  • عودة !self الحكيم.

    تصريح

    public func elementsLogicalNot() -> Tensor

  • إرجاع self && other .

    ملحوظة

    && يدعم البث.

    تصريح

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

  • إرجاع self && other من العناصر ، وبث other .

    تصريح

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

  • إرجاع self || other عنصر self || other .

    تصريح

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

  • إرجاع self || other عنصر self || other من الحكم ، بث other .

    تصريح

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
متاح حيث "العددية": `Tensorflownumeric` `
متاح حيث "العددية": `signednumeric`

  • إرجاع نفي العنصر الموتر المحدد.

    تصريح

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
متاح حيث "العددية": "رقمي"

  • تصريح

    @differentiable(wrt: self)
public func squared() -> Tensor
متاح حيث "العددية": "TensorFlowFloatingpoint"

  • إرجاع موتر منطقي يشير إلى عناصر x محدودة.

    تصريح

    public var isFinite: Tensor<Bool> { get }

  • إرجاع موتر منطقي يشير إلى عناصر x غير محدودة.

    تصريح

    public var isInfinite: Tensor<Bool> { get }

  • إرجاع موتر منطقي يشير إلى عناصر x ذات القيمة النانوية.

    تصريح

    public var isNaN: Tensor<Bool> { get }
متاح حيث `القيد ==` bool`

  • إرجاع true إذا كانت جميع الأرقام مساوية true . خلاف ذلك، ترجع false .

    تصريح

    public func all() -> Bool

  • إرجاع true إذا كانت أي عدد سكالي تساوي true . خلاف ذلك، ترجع false .

    تصريح

    public func any() -> Bool

  • ينفذ عملية منطقية وعملية على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • ينفذ عملية منطقية وعملية على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • ينفذ عملية منطقية وعملية على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • ينفذ عملية منطقية أو عملية على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

متاح حيث "العددية": `numeric` &` قابلة للمقارنة ``

  • تصريح

    @differentiable
public func min() -> Tensor

  • تصريح

    @differentiable
public func max() -> Tensor

  • إرجاع الحد الأقصى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأقصى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأقصى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع مؤشرات القيم القصوى على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع مؤشرات الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الحد الأدنى على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع فهرس الحد الأقصى لقيمة العدادات المسطحة.

    تصريح

    public func argmax() -> Tensor<Int32>

  • إرجاع فهرس الحد الأدنى لقيمة العدادات المسطحة.

    تصريح

    public func argmin() -> Tensor<Int32>
متاح حيث "العددية": "رقمي"

  • إرجاع المبلغ على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المبلغ على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المبلغ على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • تصريح

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

  • إرجاع المبلغ على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المبلغ على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المبلغ على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المنتج على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المنتج على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المنتج على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • تصريح

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

  • إرجاع المنتج على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المنتج على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المنتج على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​الحساب على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​الحساب على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​الحساب على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank...rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • تصريح

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

  • إرجاع متوسط ​​الحساب على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​الحساب على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​الحساب على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع التباين على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة. لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع التباين على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة. لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع التباين على طول المحاور المحددة. يتم الاحتفاظ بالأبعاد المخفضة بالقيمة 1. لا تنطبق على تصحيح Bessel.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • تصريح

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

  • إرجاع التباين على طول المحاور المحددة. يتم الاحتفاظ بالأبعاد المخفضة بالقيمة 1. لا تنطبق على تصحيح Bessel.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع التباين على طول المحاور المحددة. يتم الاحتفاظ بالأبعاد المخفضة بالقيمة 1. لا تنطبق على تصحيح Bessel.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع التباين على طول المحاور المحددة. يتم الاحتفاظ بالأبعاد المخفضة بالقيمة 1. لا تنطبق على تصحيح Bessel.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع المبلغ التراكمي لهذا الموتر على طول المحور المحدد. بشكل افتراضي ، تقوم هذه الوظيفة بمجموع تراكمي شامل مما يعني أن العنصر الأول من الإدخال مطابق للعنصر الأول من الإخراج:

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

    من خلال تعيين الوسيطة exclusive إلى true ، يتم تنفيذ مبلغ تراكمي حصري بدلاً من ذلك:

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

    من خلال تعيين الوسيطة reverse إلى true ، يتم تنفيذ المبلغ التراكمي في الاتجاه المعاكس:

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

    هذا أكثر كفاءة من عكس الموتر الناتج بشكل منفصل.

    شرط مسبق

    يجب أن يكون axis في النطاق -rank..<rank .

    تصريح

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

    حدود

    axis

    المحور الذي يؤدي على طول عملية المبلغ التراكمي.

    exclusive

    يشير إلى ما إذا كان سيتم إجراء مبلغ تراكمي حصري.

    reverse

    يشير إلى ما إذا كان سيتم تنفيذ المبلغ التراكمي بالترتيب العكسي.

    قيمة الإرجاع

    نتيجة عملية المبلغ التراكمي.

  • إرجاع المبلغ التراكمي لهذا الموتر على طول المحور المحدد. بشكل افتراضي ، تقوم هذه الوظيفة بمجموع تراكمي شامل مما يعني أن العنصر الأول من الإدخال مطابق للعنصر الأول من الإخراج:

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

    من خلال تعيين الوسيطة exclusive إلى true ، يتم تنفيذ مبلغ تراكمي حصري بدلاً من ذلك:

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

    من خلال تعيين الوسيطة reverse إلى true ، يتم تنفيذ المبلغ التراكمي في الاتجاه المعاكس:

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

    هذا أكثر كفاءة من عكس الموتر الناتج بشكل منفصل.

    شرط مسبق

    يجب أن يكون axis.rank 0 .

    شرط مسبق

    يجب أن يكون axis في النطاق -rank..<rank .

    تصريح

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

    حدود

    axis

    المحور الذي يؤدي على طول عملية المبلغ التراكمي.

    exclusive

    يشير إلى ما إذا كان سيتم إجراء مبلغ تراكمي حصري.

    reverse

    يشير إلى ما إذا كان سيتم تنفيذ المبلغ التراكمي بالترتيب العكسي.

    قيمة الإرجاع

    نتيجة عملية المبلغ التراكمي.

  • إرجاع المنتج التراكمي لهذا الموتر على طول المحور المحدد. بشكل افتراضي ، تقوم هذه الوظيفة بمنتج تراكمي شامل مما يعني أن العنصر الأول من الإدخال مطابق للعنصر الأول من الإخراج:

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

    من خلال تعيين الوسيطة exclusive إلى true ، يتم تنفيذ منتج تراكمي حصري بدلاً من ذلك:

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

    من خلال تعيين الوسيطة reverse إلى true ، يتم تنفيذ المنتج التراكمي في الاتجاه المعاكس:

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

    هذا أكثر كفاءة من عكس الموتر الناتج بشكل منفصل.

    شرط مسبق

    يجب أن يكون axis في النطاق -rank..<rank .

    تصريح

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

    حدود

    axis

    المحور الذي يؤدي على طول تشغيل المنتج التراكمي.

    exclusive

    يشير إلى ما إذا كان سيتم إجراء منتج تراكمي حصري.

    reverse

    يشير ما إذا كان سيتم تنفيذ المنتج التراكمي بترتيب عكسي.

    قيمة الإرجاع

    نتيجة عملية المنتج التراكمي.

  • إرجاع المنتج التراكمي لهذا الموتر على طول المحور المحدد. بشكل افتراضي ، تقوم هذه الوظيفة بمنتج تراكمي شامل مما يعني أن العنصر الأول من الإدخال مطابق للعنصر الأول من الإخراج:

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

    من خلال تعيين الوسيطة exclusive إلى true ، يتم تنفيذ منتج تراكمي حصري بدلاً من ذلك:

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

    من خلال تعيين الوسيطة reverse إلى true ، يتم تنفيذ المنتج التراكمي في الاتجاه المعاكس:

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

    هذا أكثر كفاءة من عكس الموتر الناتج بشكل منفصل.

    شرط مسبق

    يجب أن يكون axis المرتبة 0 .

    شرط مسبق

    يجب أن يكون axis في النطاق -rank..<rank .

    تصريح

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

    حدود

    axis

    المحور الذي يؤدي على طول تشغيل المنتج التراكمي.

    exclusive

    يشير إلى ما إذا كان سيتم إجراء منتج تراكمي حصري.

    reverse

    يشير ما إذا كان سيتم تنفيذ المنتج التراكمي بترتيب عكسي.

    قيمة الإرجاع

    نتيجة عملية المنتج التراكمي.

متاح حيث "العددية": "TensorFlowFloatingpoint"

  • إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الانحراف المعياري لجميع العناصر في هذا الموتر. لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

  • إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع log(exp(self).sum(squeezingAxes: axes)) . تتم إزالة الأبعاد المخفضة.

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum(squeezingAxes: axes)) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع log(exp(self).sum(squeezingAxes: axes)) . تتم إزالة الأبعاد المخفضة.

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum(squeezingAxes: axes)) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع log(exp(self).sum(squeezingAxes: axes)) . تتم إزالة الأبعاد المخفضة.

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum(squeezingAxes: axes)) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع log(exp(self).sum()) . والنتيجة هي العددية.

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum()) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    تصريح

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

  • إرجاع log(exp(self).sum(alongAxes: axes)) . يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 .

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum(alongAxes: axes)) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع log(exp(self).sum(alongAxes: axes)) . يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 .

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum(alongAxes: axes)) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع log(exp(self).sum(alongAxes: axes)) . يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 .

    هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum(alongAxes: axes)) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​وتباين هذا الموتر على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن يكون axes المرتبة 1 .

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​وتباين هذا الموتر على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​وتباين هذا الموتر على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​وتباين عناصر هذا الموتر.

    تصريح

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

  • إرجاع متوسط ​​وتباين هذا الموتر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 .

    شرط مسبق

    يجب أن يكون axes المرتبة 1 .

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​وتباين هذا الموتر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 .

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

  • إرجاع متوسط ​​وتباين هذا الموتر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 .

    شرط مسبق

    يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .

    تصريح

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

    حدود

    axes

    الأبعاد لتقليل.

متاح حيث "العددية": "رقمي"

  • يؤدي تكاثر المصفوفة بين اثنين من الموترات وينتج النتيجة.

    تصريح

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
متاح حيث "العددية": "TensorFlowFloatingpoint"

  • تصريح

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

  • إرجاع موتر محسوب من الدفعة الطبيعية للمدخل على طول المحور المحدد.

    على وجه التحديد ، الإرجاع (self - mu) / (var + epsilon) * gamma + beta حيث mu و var على التوالي متوسط ​​وتباين self على طول axis .

    تصريح

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

    حدود

    axis

    البعد الدُفعات.

    offset

    الإزاحة ، والمعروفة أيضا باسم بيتا.

    scale

    المقياس ، والمعروف أيضا باسم جاما.

    epsilon

    القيمة الصغيرة المضافة إلى المقام للاستقرار العددي.

  • يسلط اثنين من الموترات على طول المحور الأخير.

    تصريح

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

  • يضيف قيمتين وينتج مجموعهما.

    تصريح

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

  • متوسط ​​قيمتين.

    تصريح

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

  • يضاعف قيمتين.

    تصريح

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

  • كومة قيمتين.

    تصريح

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

  • تصريح

    @derivative
init(shape: scalars)
متاح حيث "العددية": `equatable"

  • تصريح

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

  • تصريح

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
متاح حيث "العددية": "قابلة للترميز"
متاح حيث "العددية": "رقمي"

  • العدد الصفر الموتر.

  • تصريح

    public static var zero: Tensor { get }

  • يضيف اثنين من الموترات وينتج مجموعهم.

    ملحوظة

    + يدعم البث.

    تصريح

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

  • يطرح موتر واحد من الآخر وينتج اختلافهم.

    ملحوظة

    - يدعم البث.

    تصريح

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

  • العددية موتر واحد.

    تصريح

    public static var one: Tensor { get }

  • إرجاع العنصر المتبادل من self .

    تصريح

    public var reciprocal: Tensor { get }

  • يضاعف اثنين من tensors العنصر وينتج منتجهما.

    ملحوظة

    .* يدعم البث.

    تصريح

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
متاح حيث "العددية": "TensorFlowFloatingpoint"

  • تصريح

    public typealias TangentVector = Tensor

  • تصريح

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

  • يضيف شرحًا.

    ملاحظة: يتم دعم X10 فقط. بالنسبة للخلفية الأخرى ، يتم إرجاع self المعتمدة.

    تصريح

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

    حدود

    annotation

    التعليق التوضيحي ليضاف.

    قيمة الإرجاع

    الموتر المشروح.

  • تصريح

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