تمت ترجمة هذه الصفحة بواسطة Cloud Translation API‏.

موت

@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
إعادة تشكيل (toShape :)
إعادة التشكيل إلى 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
البعد الذي يمكن جمعه. تلتف القيم السلبية حولها.
قيمة الإرجاع
الموتر المتجمع.

BatchGathering (في المؤشرات: على طول المحور: BatchDimensionCount:)

تُرجع شرائح هذا الموتر عند 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)) .

بث (toShape :)

تصريح

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

شريحة (lowerBounds: UpperBounds :)
يستخرج شريحة من الموتر المحدد بالحدود الدنيا والعليا لكل بعد.
تصريح
@differentiable(wrt: self) public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor
حدود
lowerBounds
الحدود الدنيا في كل بعد.
upperBounds
الحدود العليا في كل بعد.

شريحة (lowerBounds: الأحجام :)

تصريح

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

شريحة (lowerBounds: الأحجام :)

تصريح

@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
isReducedPrecision
يُرجع صحيحًا إذا كانت دقة النوع العددي الفعلي منخفضة.
حاليًا، تتضمن الأنواع العددية الفيزيائية منخفضة الدقة BFloat16 فقط.
تصريح
public var isReducedPrecision: Bool { get }
الحرف الأول(_:deviceAndPrecisionLike :)
ترقية عددي إلى موتر بنفس الجهاز والدقة مثل الموتر المحدد.
تصريح
@differentiable public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
إلى الدقة المنخفضة
إرجاع نسخة من self المحولة إلى النوع العددي الفعلي BFloat16 .
تصريح
public var toReducedPrecision: `Self` { get }
toFullPrecision
إرجاع نسخة من self المحولة إلى النوع Scalar الفيزيائي.
تصريح
public var toFullPrecision: `Self` { get }
رتبة
عدد أبعاد Tensor .
تصريح
public var rank: Int { get }
شكل
شكل Tensor .
تصريح
public var shape: TensorShape { get }
scalarCount
عدد الكميات الموجودة في Tensor .
scalarCount
تصريح
public var scalarCount: Int { get }
rankTensor
رتبة الموتر، ممثلة بـ Tensor<Int32> .
تصريح
public var rankTensor: Tensor<Int32> { get }
ShapeTensor
أبعاد الموتر ممثلة بـ Tensor<Int32> .
تصريح
public var shapeTensor: Tensor<Int32> { get }
scalarCountTensor
عدد الكميات القياسية في الموتر، ممثلة في Tensor<Int32> .
تصريح
public var scalarCountTensor: Tensor<Int32> { get }
isScalar
يُرجع 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
المحتويات العددية للموتر.
الحرف الأول (الشكل: المقاييس: toReducedPrecision: directlyOn :)
ينشئ موترًا بالشكل المحدد والكميات القياسية المتجاورة بترتيب الصف الرئيسي.
شرط مسبق
يجب أن يكون حاصل ضرب أبعاد الشكل مساويًا لعدد الكميات القياسية.
الحرف الأول (الشكل: العددية: على :)
ينشئ موترًا بالشكل المحدد والكميات القياسية المتجاورة بترتيب الصف الرئيسي.
شرط مسبق
يجب أن يكون حاصل ضرب أبعاد الشكل مساويًا لعدد الكميات القياسية.
تصريح
public init<C: Collection>( shape: TensorShape, scalars: C, on device: Device = .default ) where C.Element == Scalar
حدود
shape
شكل الموتر.
scalars
المحتويات العددية للموتر.
ArrayLiteralElement
نوع عناصر المصفوفة الحرفية.
تصريح
public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
الحرف الأول (صفيف:)
ينشئ موترًا تمت تهيئته بالعناصر المحددة.
تصريح
public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
وصف
تمثيل نصي للموتر.
ملحوظة
استخدم fullDescription للحصول على وصف غير مطبوع بشكل جيد يُظهر جميع الكميات.
تصريح
public var description: String { get }

الوصف (عرض الخط: edgeElementCount: تلخيص :)

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

تصريح

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

حدود

`lineWidth`	الحد الأقصى لعرض الخط للطباعة. يستخدم لتحديد عدد الكميات المطلوب طباعتها لكل سطر.
`edgeElementCount`	الحد الأقصى لعدد العناصر المراد طباعتها قبل وبعد التلخيص عبر علامات الحذف ( `...` ).
`summarizing`	إذا كان صحيحًا، قم بتلخيص الوصف إذا تجاوز عدد العناصر مرتين `edgeElementCount` .

وصف كامل
تمثيل نصي كامل وغير مطبوع بشكل جميل للموتر، يُظهر جميع الكميات.
تصريح
public var fullDescription: String { get }
irText

playstationDescription

تصريح

public var playgroundDescription: Any { get }

customMirror
تصريح
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)

الحرف الأول (_xla :)
تصريح
init(_xla: XLATensor)

الحرف الأول (_xlaHandle :)

تصريح

init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

xlaHandle

تصريح

var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

xlaTensor
تصريح
var xlaTensor: XLATensor { get }

متاح حيث `العددية`: `الرقمية`

غير مذيعة (toShape :)

تصريح

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

العناصرAlmostEqual(_:التسامح:)
تُرجع موترًا من القيم المنطقية يشير إلى ما إذا كانت عناصر self متساوية تقريبًا مع العناصر other .
شرط مسبق
self other يجب أن يكونا على نفس الشكل.
تصريح
public func elementsAlmostEqual( _ other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Tensor<Bool>

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

isAlmostEqual(إلى:التسامح :)
يُرجع 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`

الحرف الأول (تكرار :)
تصريح
@derivative init(repeating: shape)

متاح حيث `العددية`: `الرقمية`

الحرف الأول (_ :)
قم بإجراء تحويل من نوع العنصر من موتر Bool .
تصريح
public init(_ other: Tensor<Bool>)

الحرف الأول (_ :)

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

تصريح

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

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

الحرف الأول (_ :)
تصريح
@derivative init(_: <<error type>>)
الحرف الأول (التراص :)
تصريح
@derivative init(stacking: alongAxis)
الحرف الأول (متسلسل :)
تصريح
@derivative init(concatenating: alongAxis)

متاح حيث `العددية`: `الرقمية`

الحرف الأول (الأصفار: على :)
ينشئ موترًا مع ضبط جميع الكميات على الصفر.
تصريح
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` إيجابية.

الحرف الأول (oneHotAtIndices: العمق: onValue: offValue: المحور :)

ينشئ موترًا ساخنًا واحدًا عند مؤشرات معينة. تأخذ المواقع الممثلة 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`

الحرف الأول (linearSpaceFrom:to:count:on :)

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

تصريح

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`

الحرف الأول (randomUniform:lowerBound:upperBound:seed:on :)
ينشئ موترًا بالشكل المحدد، ويأخذ عينات عشوائية من القيم العددية من توزيع موحد بين 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`

الحرف الأول (randomUniform:lowerBound:upperBound:seed:on :)
ينشئ موترًا بالشكل المحدد، ويأخذ عينات عشوائية من القيم العددية من توزيع موحد بين 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
قيمة البذور.
الحرف الأول (عشوائي TruncatedNormal: يعني: الانحراف المعياري: البذور: على :)
ينشئ موترًا بالشكل المحدد، ويأخذ عينات عشوائية من القيم العددية من توزيع عادي مبتور.
تصريح
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`

الحرف الأول (randomCategorialLogits:sampleCount:seed :)

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

تصريح

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`

الحرف الأول (glorotUniform:seed:on :)
إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة موحدة لـ 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
قيمة البذور.
الحرف الأول (glorotNormal:seed:on :)
إنشاء موتر بالشكل المحدد عن طريق إجراء التهيئة العادية لـ 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
قيمة البذور.
الحرف الأول (heUniform:seed:on :)
إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة موحدة لـ 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
قيمة البذور.
الحرف الأول (heNormal:seed:on :)
إنشاء موتر بالشكل المحدد عن طريق إجراء التهيئة العادية لـ He (Kaiming).
يقوم بسحب عينات عشوائية من التوزيع الطبيعي المقطوع المتمركز حول 0 مع الانحراف المعياري sqrt(2 / fanIn)) الناتج عن مولد الأرقام العشوائية الافتراضي، حيث يمثل fanIn عدد ميزات الإدخال مضروبة في حجم حقل الاستلام.
المرجع: "التعمق في المقومات: تجاوز الأداء على المستوى البشري في تصنيف ImageNet"
تصريح
public init( heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
حدود
shape
أبعاد الموتر.
seed
قيمة البذور.
الحرف الأول (leCunUniform:seed:on :)
إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة موحدة لـ LeCun.
يقوم بسحب عينات عشوائية من توزيع موحد بين -limit و limit الناتج عن مولد الأرقام العشوائية الافتراضي، حيث limit هو sqrt(3 / fanIn) و fanIn يمثل عدد ميزات الإدخال مضروبة في حجم حقل الاستلام.
المرجع: "دعامة خلفية فعالة"
تصريح
public init( leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
حدود
shape
أبعاد الموتر.
seed
قيمة البذور.
الحرف الأول (leCunNormal:seed:on :)
إنشاء موتر بالشكل المحدد عن طريق إجراء تهيئة 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(المصفوفات الكاملة :)

يُرجع تحليل 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 .

svd (حساب الأشعة فوق البنفسجية: المصفوفات الكاملة :)

تُرجع تحليل القيمة المفردة 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>

إكسب2(_:)

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

تصريح

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

إكسب10(_:)

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

تصريح

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

إكسبم1(_:)
exp(x) - 1 تم تقييمها للحفاظ على الدقة بالقرب من الصفر.
تصريح
@differentiable public static func expm1(_ x: `Self`) -> Tensor<Scalar>

سجل(_:)

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

تصريح

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

السجل2(_:)

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

تصريح

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

سجل10(_:)

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

تصريح

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

سجل 1p (_ :)
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>

VectorSpaceScalar

تصريح

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`

ElementslogicalNot ()
عودة !self الحكيم.
تصريح
public func elementsLogicalNot() -> Tensor
Elementslogicaland (_ :)
إرجاع self && other .
ملحوظة
&& يدعم البث.
تصريح
public func elementsLogicalAnd(_ other: Tensor) -> Tensor
Elementslogicaland (_ :)
إرجاع self && other من العناصر ، وبث other .
تصريح
public func elementsLogicalAnd(_ other: Scalar) -> Tensor
Elementslogicalor (_ :)
إرجاع self || other عنصر self || other .
تصريح
public func elementsLogicalOr(_ other: Tensor) -> Tensor
Elementslogicalor (_ :)
إرجاع self || other عنصر self || other من الحكم ، بث other .
تصريح
public func elementsLogicalOr(_ other: Scalar) -> Tensor

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

قصاصة (دقيقة: ماكس :)

يعود max(min(self, max), min) .

تصريح

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

قصاصة (دقيقة: ماكس :)

يعود max(min(self, max), min) .

تصريح

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

قصاصة (دقيقة: ماكس :)

يعود max(min(self, max), min) .

تصريح

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

قصاصة (دقيقة: ماكس :)

يعود max(min(self, max), min) .

تصريح

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

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

-(_ :)

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

تصريح

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

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

مربعة ()

تصريح

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

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

isfinite
إرجاع موتر منطقي يشير إلى عناصر x محدودة.
تصريح
public var isFinite: Tensor<Bool> { get }
Isinfinite
إرجاع موتر منطقي يشير إلى عناصر 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
الكل (squeezingaxes :)
ينفذ عملية منطقية وعملية على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
public func all(squeezingAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.
أي (squeezingaxes :)
ينفذ عملية منطقية وعملية على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في 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

ماكس (squeezingaxes :)
إرجاع الحد الأقصى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
ماكس (squeezingaxes :)
إرجاع الحد الأقصى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func max(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
ماكس (squeezingaxes :)
إرجاع الحد الأقصى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func max(squeezingAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.
min (squeezingaxes :)
إرجاع الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
min (squeezingaxes :)
إرجاع الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func min(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
min (squeezingaxes :)
إرجاع الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func min(squeezingAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.
Argmax (squeezingaxis :)
إرجاع مؤشرات القيم القصوى على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>
حدود
axes
الأبعاد لتقليل.
Argmin (squeezingaxis :)
إرجاع مؤشرات الحد الأدنى للقيم على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في 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
الأبعاد لتقليل.
Argmax ()
إرجاع فهرس الحد الأقصى لقيمة العدادات المسطحة.
تصريح
public func argmax() -> Tensor<Int32>
Argmin ()
إرجاع فهرس الحد الأدنى لقيمة العدادات المسطحة.
تصريح
public func argmin() -> Tensor<Int32>

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

SUM (squeezingaxes :)
إرجاع المبلغ على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
SUM (squeezingaxes :)
إرجاع المبلغ على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func sum(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
SUM (squeezingaxes :)
إرجاع المبلغ على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func sum(squeezingAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.

مجموع()

تصريح

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

SUM (على adaxes :)
إرجاع المبلغ على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func sum(alongAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
SUM (على adaxes :)
إرجاع المبلغ على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func sum(alongAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
SUM (على adaxes :)
إرجاع المبلغ على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func sum(alongAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.
المنتج (squeezingaxes :)
إرجاع المنتج على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
المنتج (squeezingaxes :)
إرجاع المنتج على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func product(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
المنتج (squeezingaxes :)
إرجاع المنتج على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في 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
الأبعاد لتقليل.
يعني (squeezingaxes :)
إرجاع متوسط الحساب على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
يعني (squeezingaxes :)
إرجاع متوسط الحساب على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank...rank .
تصريح
@differentiable(wrt: self) public func mean(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
يعني (squeezingaxes :)
إرجاع متوسط الحساب على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في 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
الأبعاد لتقليل.
التباين (squeezingaxes :)
إرجاع التباين على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة. لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
التباين (squeezingaxes :)
إرجاع التباين على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة. لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func variance(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
التباين (squeezingaxes :)
إرجاع التباين على طول المحاور المحددة. يتم الاحتفاظ بالأبعاد المخفضة بالقيمة 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
الأبعاد لتقليل.

Cumulatistsum (على طول الأضلاع: حصري: عكس :)

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

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`	يشير إلى ما إذا كان سيتم تنفيذ المبلغ التراكمي بالترتيب العكسي.

قيمة الإرجاع

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

Cumulatistsum (على طول الأضلاع: حصري: عكس :)

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"

standardDeviation (squeezingaxes :)
إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
standardDeviation (squeezingaxes :)
إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
standardDeviation (squeezingaxes :)
إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.
StandardDeviation ()
إرجاع الانحراف المعياري لجميع العناصر في هذا الموتر. لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation() -> Tensor
standardDeviation (على adaxes :)
إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor
حدود
axes
الأبعاد لتقليل.
standardDeviation (على adaxes :)
إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: [Int]) -> Tensor
حدود
axes
الأبعاد لتقليل.
standardDeviation (على adaxes :)
إرجاع الانحراف المعياري للعناصر على طول المحاور المحددة. يتم الاحتفاظ الأبعاد المخفضة مع القيمة 1 . لا ينطبق تصحيح بيسيل.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Int...) -> Tensor
حدود
axes
الأبعاد لتقليل.
logsumexp (squeezingaxes :)
إرجاع 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
الأبعاد لتقليل.
logsumexp (squeezingaxes :)
إرجاع 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
الأبعاد لتقليل.
logsumexp (squeezingaxes :)
إرجاع 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
الأبعاد لتقليل.
logsumexp ()
إرجاع log(exp(self).sum()) . والنتيجة هي العددية.
هذه الوظيفة أكثر استقرارًا عدديًا من log(exp(self).sum()) مباشرة. إنه يتجنب الفائض الناتج عن حساب exp من المدخلات الكبيرة والمتدهورات السفلية الناتجة عن حساب log المدخلات الصغيرة.
تصريح
@differentiable(wrt: self) public func logSumExp() -> Tensor
logsumexp (على طول adaixes :)
إرجاع 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
الأبعاد لتقليل.
logsumexp (على طول adaixes :)
إرجاع 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
الأبعاد لتقليل.
logsumexp (على طول adaixes :)
إرجاع 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
الأبعاد لتقليل.
لحظات (squeezingaxes :)
إرجاع متوسط وتباين هذا الموتر على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن يكون axes المرتبة 1 .
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>
حدود
axes
الأبعاد لتقليل.
لحظات (squeezingaxes :)
إرجاع متوسط وتباين هذا الموتر على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في axes في النطاق -rank..<rank .
تصريح
@differentiable(wrt: self) public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>
حدود
axes
الأبعاد لتقليل.
لحظات (squeezingaxes :)
إرجاع متوسط وتباين هذا الموتر على طول المحاور المحددة. تتم إزالة الأبعاد المخفضة.
شرط مسبق
يجب أن تكون كل قيمة في 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"

VJpinitDeviceAndPrecision (_: DeviceAndPrecisionly :)

تصريح

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

batchnormalized (على طول الأضلاع: الإزاحة: المقياس: إبسيلون :)

إرجاع موتر محسوب من الدفعة الطبيعية للمدخل على طول المحور المحدد.

على وجه التحديد ، الإرجاع (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

init (الشكل :)
تصريح
@derivative init(shape: scalars)

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

== (_: _ :)

تصريح

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

! = (_: _ :)

تصريح

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

متاح حيث "العددية": "قابلة للترميز"

تشفير (إلى :)

تصريح

public func encode(to encoder: Encoder) throws

init (من :)

تصريح

public init(from decoder: Decoder) throws

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

صفر
العدد الصفر الموتر.
صفر
تصريح
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"

TangentVector
تصريح
public typealias TangentVector = Tensor

this.zeroTangentVectorInitializer

تصريح

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

علق(_:)
يضيف شرحًا.
ملاحظة: يتم دعم X10 فقط. بالنسبة للخلفية الأخرى ، يتم إرجاع self المعتمدة.
تصريح
@differentiable(wrt: self) public func annotate(_ annotation: String) -> Tensor<Scalar>
حدود
annotation
التعليق التوضيحي ليضاف.
قيمة الإرجاع
الموتر المشروح.

vjpannotate (_ :)

تصريح

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

`count`	عدد الانقسامات المراد إنشاؤها.
`axis`	البعد الذي سيتم من خلاله تقسيم هذا الموتر. تلتف القيم السلبية حولها.

`sizes`	موتر 1-D يحتوي على حجم كل انقسام.
`axis`	البعد الذي يتم من خلاله تقسيم هذا الموتر. تلتف القيم السلبية حولها.

`indices`	يحتوي على المؤشرات التي يمكن التجمع فيها.
`axis`	البعد الذي يمكن جمعه. تلتف القيم السلبية حولها.

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

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

`shape`	أبعاد الموتر.
`repeatedValue`	القيمة العددية للتكرار.

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

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

`shape`	شكل الموتر.
`scalars`	المحتويات العددية للموتر.

`shape`	أبعاد الموتر.
`lowerBound`	الحد الأدنى للتوزيع.
`upperBound`	الحد الأعلى للتوزيع.
`seed`	قيمة البذور.

`shape`	أبعاد الموتر.
`mean`	متوسط التوزيع.
`standardDeviation`	الانحراف المعياري للتوزيع.
`seed`	قيمة البذور.