تحذير: هذا المشروع مهمل. كانت Swift for TensorFlow تجربة في منصة الجيل التالي للتعلم الآلي ، حيث تضمنت أحدث الأبحاث عبر التعلم الآلي والمترجمات والبرمجة القابلة للتفاضل وتصميم الأنظمة وما بعده. تمت أرشفته في فبراير 2021.

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

الدوال

الوظائف التالية متاحة عالميًا.

l1الخسارة(المتوقعة:المتوقعة :)
إرجاع خسارة L1 بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l1Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
l2الخسارة(المتوقعة:المتوقعة :)
إرجاع خسارة L2 بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l2Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
المفصلي (المتوقع: المتوقع :)
إرجاع خسارة المفصلة بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func hingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
SquaredHingeLoss(متوقع:متوقع :)
إرجاع خسارة المفصلة التربيعية بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
categoricalHingeLoss(متوقع:متوقع :)
إرجاع خسارة المفصلة الفئوية بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
logCoshLoss(المتوقع:المتوقع :)
إرجاع لوغاريتم جيب التمام الزائدي للخطأ بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func logCoshLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
بويسون لوس (المتوقع: المتوقع :)
إرجاع خسارة بواسون بين التنبؤات والتوقعات.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func poissonLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
kullbackLeiblerDivergence(متوقع:متوقع :)
إرجاع تباعد Kullback-Leibler (تباعد KL) بين التوقعات والتنبؤات. بالنظر إلى التوزيعين p و q ، يحسب تباعد KL p * log(p / q) .
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
softmaxCrossEntropy (سجلات: الاحتمالات :)
تُرجع إنتروبيا softmax المتقاطعة (إنتروبيا متقاطعة فئوية) بين اللوجيستات والتسميات.
تصريح
@differentiable(wrt: logits) public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, probabilities: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
logits
مخرجات مشفرة واحدة ساخنة من شبكة عصبية.
labels
مؤشرات (مفهرسة صفر) للمخرجات الصحيحة.
sigmoidCrossEntropy(logits:labels :)
إرجاع الإنتروبيا السيني المتقاطع (الإنتروبيا المتقاطعة الثنائية) بين اللوجيستات والتسميات.
تصريح
@differentiable(wrt: logits) @differentiable(wrt: (logits, labels) public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, labels: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
logits
الناتج غير المقيس للشبكة العصبية.
labels
القيم الصحيحة التي تتوافق مع الإخراج الصحيح.

هوية(_:)

إرجاع موتر بنفس الشكل والكميات مثل الموتر المحدد.

تصريح

@differentiable
public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

مع السياق(_:_:)

يستدعي الإغلاق المعطى ضمن سياق يحتوي على كل شيء مطابق للسياق الحالي باستثناء مرحلة التعلم المحددة.

تصريح

public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R

حدود

`context`	السياق الذي سيتم تعيينه قبل استدعاء الإغلاق واستعادته بعد عودة الإغلاق.
`body`	إغلاق فارغ. إذا كان للإغلاق قيمة إرجاع، فسيتم استخدام هذه القيمة أيضًا كقيمة إرجاع للدالة `withContext(_:_:)` .

قيمة الإرجاع

قيمة الإرجاع، إن وجدت، لإغلاق body .

معمرحلة التعلم(_:_:)

يستدعي الإغلاق المعطى ضمن سياق يحتوي على كل شيء مطابق للسياق الحالي باستثناء مرحلة التعلم المحددة.

تصريح

public func withLearningPhase<R>(
  _ learningPhase: LearningPhase,
  _ body: () throws -> R
) rethrows -> R

حدود

`learningPhase`	مرحلة التعلم التي سيتم تعيينها قبل استدعاء الإغلاق واستعادته بعد عودة الإغلاق.
`body`	إغلاق فارغ. إذا كان للإغلاق قيمة إرجاع، فسيتم استخدام هذه القيمة أيضًا كقيمة إرجاع للدالة `withLearningPhase(_:_:)` .

قيمة الإرجاع

قيمة الإرجاع، إن وجدت، لإغلاق body .

مع RandomSeedForTensorFlow(_:_:)

يستدعي الإغلاق المحدد ضمن سياق يحتوي على كل شيء مطابق للسياق الحالي باستثناء البذرة العشوائية المحددة.

تصريح

public func withRandomSeedForTensorFlow<R>(
  _ randomSeed: TensorFlowSeed,
  _ body: () throws -> R
) rethrows -> R

حدود

`randomSeed`	بذرة عشوائية سيتم تعيينها قبل استدعاء الإغلاق واستعادتها بعد عودة الإغلاق.
`body`	إغلاق فارغ. إذا كان للإغلاق قيمة إرجاع، فسيتم استخدام هذه القيمة أيضًا كقيمة إرجاع للدالة `withRandomSeedForTensorFlow(_:_:)` .

قيمة الإرجاع

قيمة الإرجاع، إن وجدت، لإغلاق body .

مع RandomNumberGeneratorForTensorFlow(_:_:)

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

تصريح

public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
  _ randomNumberGenerator: inout G,
  _ body: () throws -> R
) rethrows -> R

حدود

`randomNumberGenerator`	مولد أرقام عشوائي سيتم تعيينه قبل استدعاء الإغلاق واستعادته بعد عودة الإغلاق.
`body`	إغلاق فارغ. إذا كان للإغلاق قيمة إرجاع، فسيتم استخدام هذه القيمة أيضًا كقيمة إرجاع للدالة `withRandomNumberGeneratorForTensorFlow(_:_:)` .

قيمة الإرجاع

قيمة الإرجاع، إن وجدت، لإغلاق body .

أَزِيز(_:_:)

تصريح

public func zip<T: TensorGroup, U: TensorGroup>(
  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
) -> Dataset<Zip2TensorGroup<T, U>>

LazyTensorBarrier(على:الأجهزة:انتظر :)
يضمن LazyTensorBarrier جدولة وتشغيل جميع الموترات الحية (الموجودة على الجهاز إذا كانت متوفرة). إذا تم ضبط الانتظار على true، فسيتم حظر هذا الاستدعاء حتى اكتمال الحساب.
تصريح
public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

valueWithGradient(في:في :)

تصريح

public func valueWithGradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient(في:_:في :)

تصريح

public func valueWithGradient<T, U, R>(
  at x: T,
  _ y: U,
  in f: @differentiable (T, U) -> Tensor<R>
) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient(في:_:_:في :)

تصريح

public func valueWithGradient<T, U, V, R>(
  at x: T,
  _ y: U,
  _ z: V,
  in f: @differentiable (T, U, V) -> Tensor<R>
) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

القيمة مع التدرج (من :)

تصريح

public func valueWithGradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

القيمة مع التدرج (من :)

تصريح

public func valueWithGradient<T, U, R>(
  of f: @escaping @differentiable (T, U) -> Tensor<R>
) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

القيمة مع التدرج (من :)

تصريح

public func valueWithGradient<T, U, V, R>(
  of f: @escaping @differentiable (T, U, V) -> Tensor<R>
) -> (T, U, V) -> (
  value: Tensor<R>,
  gradient: (T.TangentVector, U.TangentVector, V.TangentVector)
)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

التدرج (في: في :)

تصريح

public func gradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

التدرج (في:_:في :)

تصريح

public func gradient<T, U, R>(
  at x: T,
  _ y: U,
  in f: @differentiable (T, U) -> Tensor<R>
) -> (T.TangentVector, U.TangentVector)
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

التدرج(في:_:_:في :)

تصريح

public func gradient<T, U, V, R>(
  at x: T,
  _ y: U,
  _ z: V,
  in f: @differentiable (T, U, V) -> Tensor<R>
) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

التدرج (من :)

تصريح

public func gradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

التدرج (من :)

تصريح

public func gradient<T, U, R>(
  of f: @escaping @differentiable (T, U) -> Tensor<R>
) -> (T, U) -> (T.TangentVector, U.TangentVector)
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

التدرج (من :)

تصريح

public func gradient<T, U, V, R>(
  of f: @escaping @differentiable (T, U, V) -> Tensor<R>
) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

مع ريكومبوتاتيونينبولباكس (_ :)
جعل وظيفة يتم إعادة حسابها في سحبها، المعروف باسم "نقطة التفتيش" في التمايز التلقائي التقليدي.
تصريح
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

دالة قابلة للتمييز (من :)

قم بإنشاء دالة قابلة للتمييز من دالة منتجات Vector-Jacobian.

تصريح

public func differentiableFunction<T : Differentiable, R : Differentiable>(
  from vjp: @escaping (T)
           -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
) -> @differentiable (T) -> R

دالة قابلة للتمييز (من :)

قم بإنشاء دالة قابلة للتمييز من دالة منتجات Vector-Jacobian.

تصريح

public func differentiableFunction<T, U, R>(
  from vjp: @escaping (T, U)
           -> (value: R, pullback: (R.TangentVector)
             -> (T.TangentVector, U.TangentVector))
) -> @differentiable (T, U) -> R

بدون مشتق (في :)
تُرجع x مثل دالة الهوية. عند استخدامها في سياق يتم فيه تمييز x بالنسبة إلى، فإن هذه الدالة لن تنتج أي مشتق عند x .
تصريح
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
بدون مشتق (في: في :)
يطبق body الإغلاق المحدد على x . عند استخدامها في سياق يتم فيه تمييز x بالنسبة إلى، فإن هذه الدالة لن تنتج أي مشتق عند x .
تصريح
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R

مع الجهاز(_:_:أداء :)

ينفذ عملية الإغلاق، مما يجعل عمليات TensorFlow تعمل على نوع معين من الأجهزة.

تصريح

public func withDevice<R>(
  _ kind: DeviceKind,
  _ index: UInt = 0,
  perform body: () throws -> R
) rethrows -> R

حدود

`kind`	نوع من الأجهزة لتشغيل عمليات TensorFlow عليه.
`index`	الجهاز الذي سيتم تشغيل العمليات عليه.
`body`	إغلاق سيتم تنفيذ عمليات TensorFlow الخاصة به على نوع الجهاز المحدد.

مع الجهاز (المسمى: أداء :)
ينفذ عملية الإغلاق، مما يجعل عمليات TensorFlow تعمل على جهاز باسم محدد.
بعض الأمثلة على أسماء الأجهزة:
- "/device:CPU:0": وحدة المعالجة المركزية لجهازك.
- "/GPU:0": تدوين مختصر لوحدة معالجة الرسومات الأولى بجهازك والتي تكون مرئية لـ TensorFlow
- "/job:localhost/replica:0/task:0/device:GPU:1": اسم مؤهل بالكامل لوحدة معالجة الرسومات الثانية لجهازك والتي تكون مرئية لـ TensorFlow.
تصريح
public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R
حدود
name
اسم الجهاز.
body
إغلاق سيتم تنفيذ عمليات TensorFlow الخاصة به على نوع الجهاز المحدد.
مع الجهاز الافتراضي (تنفيذ :)
ينفذ عملية إغلاق، مما يسمح لـ TensorFlow بوضع عمليات TensorFlow على أي جهاز. يجب أن يؤدي هذا إلى استعادة سلوك الموضع الافتراضي.
تصريح
public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R
حدود
body
إغلاق سيتم تنفيذ عمليات TensorFlow الخاصة به على نوع الجهاز المحدد.

تغيير الحجم (الصور: الحجم: الطريقة: الحواف :)

قم بتغيير حجم الصور إلى حجمها باستخدام الطريقة المحددة.

شرط مسبق

يجب أن تحتوي الصور على المرتبة 3 أو 4 .

شرط مسبق

يجب أن يكون الحجم إيجابيا.

تصريح

@differentiable(wrt: images)
public func resize(
  images: Tensor<Float>,
  size: (newHeight: Int, newWidth: Int),
  method: ResizeMethod = .bilinear,
  antialias: Bool = false
) -> Tensor<Float>

حدود

`images`	`Tensor` رباعي الأبعاد للشكل `[batch, height, width, channels]` أو `Tensor` ثلاثي الأبعاد للشكل `[height, width, channels]` .
`size`	الحجم الجديد للصور.
`method`	طريقة تغيير الحجم. القيمة الافتراضية هي `.bilinear` .
`antialias`	إذا كان `true` ، فاستخدم مرشح منع التعرج عند تصغير حجم الصورة.

تغيير الحجم (الصور: الحجم: محاذاة الزوايا :)

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

شرط مسبق

يجب أن تحتوي الصور على المرتبة 3 أو 4 .

شرط مسبق

يجب أن يكون الحجم إيجابيا.

تصريح

public func resizeArea<Scalar: TensorFlowNumeric>(
  images: Tensor<Scalar>,
  size: (newHeight: Int, newWidth: Int),
  alignCorners: Bool = false
) -> Tensor<Float>

حدود

`images`	`Tensor` رباعي الأبعاد للشكل `[batch, height, width, channels]` أو `Tensor` ثلاثي الأبعاد للشكل `[height, width, channels]` .
`size`	الحجم الجديد للصور.

dilation2D(_:تصفية:خطوات:معدلات:حشوة :)

يُرجع تمددًا ثنائي الأبعاد باستخدام المدخلات والمرشح والخطوات والحشوة المحددة.

شرط مسبق

يجب أن يكون input في المرتبة 4 .

شرط مسبق

يجب أن يكون filter المرتبة 3 .

تصريح

@differentiable(wrt: (input, filter)
public func dilation2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid
) -> Tensor<Scalar>

حدود

`input`	المدخل.
`filter`	مرشح التمدد.
`strides`	خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
`padding`	الحشوة للعملية
`rates`	معدلات التمدد لكل بعد من المدخلات.

تآكل2D(_:مرشح:خطوات:معدلات:حشوة :)

إرجاع تآكل ثنائي الأبعاد مع المدخلات والمرشح والخطوات والحشوة المحددة.

شرط مسبق

يجب أن يكون input في المرتبة 4 .

شرط مسبق

يجب أن يكون filter في المرتبة 3.

تصريح

@differentiable(wrt: (input, filter)
public func erosion2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid
) -> Tensor<Scalar>

حدود

`input`	المدخل.
`filter`	مرشح التآكل.
`strides`	خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
`padding`	الحشوة للعملية
`rates`	معدلات التمدد لكل بعد من المدخلات.

الأصفار ()
تُرجع دالة تُنشئ موترًا عن طريق تهيئة جميع قيمه إلى أصفار.
تصريح
public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
التهيئة الثابتة (القيمة :)
تُرجع دالة تُنشئ موترًا عن طريق تهيئة جميع قيمه إلى القيمة المقدمة.
تصريح
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
التهيئة الثابتة (القيمة :)
تُرجع دالة تُنشئ موترًا عن طريق تهيئته للقيمة المقدمة. لاحظ أن بث القيمة المقدمة غير مدعوم.
تصريح
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
glorotUniform (البذور :)
تُرجع دالة تُنشئ موترًا عن طريق إجراء تهيئة موحدة لـ Glorot (Xavier) للشكل المحدد، وأخذ عينات عشوائية من القيم العددية من توزيع منتظم بين -limit و limit ، والتي يتم إنشاؤها بواسطة مولد الأرقام العشوائية الافتراضي، حيث يكون Limit هو sqrt(6 / (fanIn + fanOut)) و fanIn / fanOut يمثلان عدد ميزات الإدخال والإخراج مضروبة في حقل الاستقبال، إذا كان موجودًا.
تصريح
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
جلورو نورمال (البذور :)
تُرجع دالة تنشئ موترًا عن طريق إجراء التهيئة العادية Glorot (Xavier) للشكل المحدد، وأخذ عينات عشوائية من القيم العددية من توزيع عادي مبتور يتمركز على 0 مع الانحراف المعياري sqrt(2 / (fanIn + fanOut)) ، حيث fanIn / fanOut يمثل عدد ميزات الإدخال والإخراج مضروبًا في حجم حقل الاستقبال، إن وجد.
تصريح
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
heUnform (البذور :)
تُرجع دالة تُنشئ موترًا عن طريق إجراء تهيئة موحدة لـ He (Kaiming) للشكل المحدد، وأخذ عينات عشوائية من القيم العددية من توزيع منتظم بين -limit و limit ، التي تم إنشاؤها بواسطة مولد الأرقام العشوائية الافتراضي، حيث يكون Limit هو sqrt(6 / fanIn) ، ويمثل fanIn عدد ميزات الإدخال مضروبًا في حقل الاستلام، إذا كان موجودًا.
تصريح
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
عادي (البذور :)
تُرجع دالة تنشئ موترًا عن طريق إجراء التهيئة العادية لـ He (Kaiming) للشكل المحدد، وأخذ عينات عشوائية من القيم العددية من توزيع عادي مبتور يتمركز على 0 مع الانحراف المعياري sqrt(2 / fanIn) ، حيث يمثل fanIn عدد ميزات الإدخال مضروبًا في حجم الحقل الاستقبالي، إن وجد.
تصريح
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunUniform (البذور :)
إرجاع دالة تنشئ موترًا عن طريق إجراء تهيئة موحدة لـ LeCun للشكل المحدد، وأخذ عينات عشوائية من القيم العددية من توزيع موحد بين -limit و limit ، التي تم إنشاؤها بواسطة مولد الأرقام العشوائية الافتراضي، حيث يكون Limit هو sqrt(3 / fanIn) و يمثل fanIn عدد ميزات الإدخال مضروبًا في حقل الاستقبال، إذا كان موجودًا.
تصريح
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunNormal (البذور :)
تُرجع دالة تنشئ موترًا عن طريق إجراء تهيئة LeCun العادية للشكل المحدد، وأخذ عينات عشوائية من القيم العددية من توزيع عادي مبتور يتمركز على 0 مع الانحراف المعياري sqrt(1 / fanIn) ، حيث يمثل fanIn عدد ميزات الإدخال مضروبًا في حجم الحقل الاستقبالي، إذا كان موجودا.
تصريح
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
truncatedNormalInitializer(mean:standardDeviation:seed :)
تُرجع دالة تُنشئ موترًا عن طريق تهيئة جميع قيمه بشكل عشوائي من توزيع عادي مبتور. تتبع القيم التي تم إنشاؤها توزيعًا عاديًا بمتوسط وانحراف معياري standardDeviation mean ، فيما عدا تلك القيم التي يزيد حجمها عن انحرافين معياريين عن المتوسط، يتم إسقاطها وإعادة تشكيلها.
تصريح
public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>( mean: Tensor<Scalar> = Tensor<Scalar>(0), standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1), seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
حدود
mean
متوسط التوزيع الطبيعي.
standardDeviation
الانحراف المعياري للتوزيع الطبيعي.
قيمة الإرجاع
دالة تهيئة معلمة عادية مبتورة.

==(_:_:)

تصريح

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

العين (عدد الصفوف: عدد الأعمدة: شكل الدفعة: على :)

إرجاع مصفوفة هوية أو مجموعة من المصفوفات.

تصريح

public func eye<Scalar: Numeric>(
  rowCount: Int,
  columnCount: Int? = nil,
  batchShape: [Int] = [],
  on device: Device = .default
) -> Tensor<Scalar>

حدود

`rowCount`	عدد الصفوف في كل مصفوفة دفعة.
`columnCount`	عدد الأعمدة في كل مصفوفة دفعية.
`batchShape`	أبعاد الدفعة الرائدة للموتر المرتجع.

يتعقب(_:)
يحسب أثر مصفوفة مجمعة اختياريا. التتبع هو المجموع على طول القطر الرئيسي لكل مصفوفة داخلية.
الإدخال عبارة عن موتر ذو شكل [..., M, N] . الناتج هو موتر ذو شكل [...] .
شرط مسبق
يجب أن تكون matrix موترًا بالشكل [..., M, N] .
تصريح
@differentiable(wrt: matrix) public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
حدود
matrix
موتر الشكل [..., M, N] .
تشوليسكي(_:)
إرجاع تحليل تشوليسكي لمصفوفة مربعة واحدة أو أكثر.
الإدخال عبارة عن موتر للشكل [..., M, M] والذي يشكل بعداه الداخليان مصفوفات مربعة.
يجب أن تكون المدخلات متماثلة وإيجابية محددة. سيتم استخدام الجزء المثلث السفلي فقط من الإدخال لهذه العملية. لن تتم قراءة الجزء العلوي الثلاثي.
الإخراج عبارة عن موتر بنفس شكل الإدخال الذي يحتوي على تحليلات Cholesky لجميع مصفوفات الإدخال الفرعية [..., :, :] .
تصريح
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
حدود
input
موتر الشكل [..., M, M] .

حل مثلثي (مصفوفة: rhs: أقل: مجاور :)

إرجاع الحل x إلى نظام المعادلات الخطية الذي يمثله Ax = b .

شرط مسبق

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

شرط مسبق

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

تصريح

@differentiable
public func triangularSolve<T: TensorFlowFloatingPoint>(
  matrix: Tensor<T>,
  rhs: Tensor<T>,
  lower: Bool = true,
  adjoint: Bool = false
) -> Tensor<T>

حدود

`matrix`	مصفوفة المعاملات المثلثية المدخلة، التي تمثل `A` في `Ax = b` .
`rhs`	قيم الجانب الأيمن، تمثل `b` في `Ax = b` .
`lower`	ما إذا كانت `matrix` مثلثية سفلية ( `true` ) أو مثلثية عليا ( `false` ). القيمة الافتراضية هي `true` .
`adjoint`	إذا كان `true` ، حل مع `matrix` المجاورة بدلا من `matrix` . القيمة الافتراضية هي `false` .

قيمة الإرجاع

الحل x لنظام المعادلات الخطية المتمثل في Ax = b . x له نفس شكل b .

l1الخسارة(المتوقعة:المتوقعة:التخفيض :)

يحسب خسارة L1 بين expected predicted . loss = reduction(abs(expected - predicted))

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

l2الخسارة(المتوقعة:المتوقعة:التخفيض :)

يحسب خسارة L2 بين expected predicted . loss = reduction(square(expected - predicted))

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعناصر.

خطأ مطلق (متوقع:متوقع :)
يحسب متوسط الفرق المطلق بين التسميات والتنبؤات. loss = mean(abs(expected - predicted))
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
meanSquaredError(متوقع:متوقع :)
يحسب متوسط مربعات الأخطاء بين التسميات والتنبؤات. loss = mean(square(expected - predicted))
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
meanSquaredLogarithmicError(متوقع:متوقع :)
يحسب الخطأ اللوغاريتمي التربيعي بين الخسارة predicted expected loss = square(log(expected) - log(predicted))
ملحوظة
سيتم تثبيت إدخالات الموتر السالبة عند 0 لتجنب السلوك اللوغاريتمي غير المحدد، حيث أن log(_:) غير محدد للحقيقيات السالبة.
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
يعنينسبة مئوية مطلقة (متوقع:متوقع :)
يحسب متوسط النسبة المئوية للخطأ المطلق بين predicted expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))
تصريح
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
حدود
predicted
المخرجات المتوقعة من الشبكة العصبية.
expected
القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.

المفصلي (المتوقع:المتوقع:التخفيض :)

يحسب خسارة المفصلة بين predicted expected . loss = reduction(max(0, 1 - predicted * expected)) من المتوقع أن تكون القيم expected -1 أو 1.

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعناصر.

SquaredHingeLoss(متوقع:متوقع:تخفيض :)

يحسب الخسارة المفصلية التربيعية بين predicted expected . loss = reduction(square(max(0, 1 - predicted * expected))) من المتوقع أن تكون القيم expected -1 أو 1.

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعناصر.

categoricalHingeLoss(متوقع:متوقع:تخفيض :)

يحسب خسارة المفصلة الفئوية بين predicted expected . loss = maximum(negative - positive + 1, 0) حيث negative = max((1 - expected) * predicted) positive = sum(predicted * expected)

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعناصر.

logCoshLoss(متوقع:متوقع:تخفيض :)

يحسب لوغاريتم جيب التمام الزائدي لخطأ التنبؤ. logcosh = log((exp(x) + exp(-x))/2) ، حيث x هو الخطأ predicted - expected

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

poissonLoss (متوقع:متوقع:تخفيض :)

يحسب خسارة بواسون بين المتوقعة والمتوقعة خسارة بواسون هي متوسط عناصر Tensor predicted - expected * log(predicted) .

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

kullbackLeiblerDivergence(متوقع:متوقع:تخفيض :)

يحسب خسارة التباعد Kullback-Leibler بين expected predicted . loss = reduction(expected * log(expected / predicted))

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

softmaxCrossEntropy(logits:labels:reduction :)

يحسب الإنتروبيا المتقاطعة softmax المتناثرة (الإنتروبيا المتقاطعة الفئوية) بين اللوجيستات والتسميات. استخدم وظيفة فقدان الانتروبيا هذه عندما يكون هناك فئتان أو أكثر من فئات التصنيف. نتوقع أن يتم توفير التسميات كأعداد صحيحة. يجب أن يكون هناك # classes من قيم الفاصلة العائمة لكل ميزة logits وقيمة نقطة عائمة واحدة لكل ميزة expected .

تصريح

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Int32>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`logits`	مخرجات مشفرة واحدة ساخنة من شبكة عصبية.
`labels`	مؤشرات (مفهرسة صفر) للمخرجات الصحيحة.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

softmaxCrossEntropy(سجلات:الاحتمالات:التخفيض :)

يحسب الإنتروبيا المتقاطعة softmax المتناثرة (الإنتروبيا المتقاطعة الفئوية) بين اللوجيستات والتسميات. استخدم وظيفة فقدان الانتروبيا هذه عندما يكون هناك فئتان أو أكثر من فئات التصنيف. نتوقع توفير التصنيفات في تمثيل one_hot . يجب أن يكون هناك # classes من قيم الفاصلة العائمة لكل ميزة.

تصريح

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`logits`	احتمالات السجل غير المقاسة من الشبكة العصبية.
`probabilities`	قيم الاحتمالية التي تتوافق مع الإخراج الصحيح. يجب أن يكون كل صف توزيعًا احتماليًا صالحًا.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

sigmoidCrossEntropy(logits:labels:reduction :)

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

تصريح

@differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

حدود

`logits`	الناتج غير المقيس للشبكة العصبية.
`labels`	القيم الصحيحة التي تتوافق مع الإخراج الصحيح.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

huberLoss(متوقع:متوقع:دلتا:تخفيض :)

يحسب خسارة هوبر بين predicted expected .

لكل قيمة x في error = expected - predicted :

0.5 * x^2 إذا |x| <= δ .
0.5 * δ^2 + δ * (|x| - δ) بخلاف ذلك.
المصدر: مقالة ويكيبيديا .

تصريح

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func huberLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  delta: Scalar,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

حدود

`predicted`	المخرجات المتوقعة من الشبكة العصبية.
`expected`	القيم المتوقعة، أي الأهداف، التي تتوافق مع المخرجات الصحيحة.
`delta`	مقياس النقطة العائمة الذي يمثل النقطة التي تتغير فيها دالة خسارة Huber من الدرجة الثانية إلى الخطية.
`reduction`	يتم تطبيق التخفيض على قيم الخسارة المحسوبة للعنصر.

عضلات المعدة(_:)

تُرجع القيمة المطلقة لعنصر الموتر المحدد.

تصريح

@differentiable
public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar

سجل(_:)

تُرجع اللوغاريتم الطبيعي لعنصر الموتر المحدد.

تصريح

@differentiable
public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

السجل2(_:)
تُرجع لوغاريتم الأساس الثاني لعنصر الموتر المحدد.
تصريح
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
سجل10(_:)
تُرجع اللوغاريتم ذي القاعدة العشرة لعنصر الموتر المحدد.
تصريح
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

سجل 1p (_ :)

إرجاع لوغاريتم 1 + x من حيث العناصر.

تصريح

@differentiable
public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

سجل1mexp(_:)
تُرجع log(1 - exp(x)) باستخدام نهج مستقر عدديًا.
ملحوظة
يظهر النهج في المعادلة 7 من: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .
تصريح
@differentiable public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

الخطيئة(_:)

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

تصريح

@differentiable
public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

كوس (_ :)

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

تصريح

@differentiable
public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

تان (_ :)

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

تصريح

@differentiable
public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

سينه(_:)

تُرجع جيب الجيب الزائدي لعنصر الموتر المحدد.

تصريح

@differentiable
public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

ضرب بالعصا(_:)
تُرجع جيب التمام الزائدي لعنصر الموتر المحدد.
تصريح
@differentiable public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

تانه(_:)

تُرجع الظل الزائدي لعنصر الموتر المحدد.

تصريح

@differentiable
public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

أكوس(_:)

يُرجع جيب التمام العكسي لعنصر الموتر المحدد.

تصريح

@differentiable
public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

آسين(_:)

يُرجع الجيب العكسي لعنصر الموتر المحدد.

تصريح

@differentiable
public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

عطان(_:)

إرجاع الظل العكسي لعنصر الموتر المحدد.

تصريح

@differentiable
public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

اكوش(_:)
تُرجع جيب التمام الزائدي العكسي لعنصر الموتر المحدد.
تصريح
@differentiable public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
أسينه(_:)
تُرجع جيب القطع الزائد العكسي لعنصر الموتر المحدد.
تصريح
@differentiable public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
أتناه(_:)
تُرجع المماس الزائدي العكسي لعنصر الموتر المحدد.
تصريح
@differentiable public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
الجذر التربيعي (_ :)
يُرجع الجذر التربيعي لعنصر الموتر المحدد.
تصريح
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
رسكرت (_ :)
تُرجع الجذر التربيعي العكسي لعنصر الموتر المحدد.
تصريح
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

إكسب(_:)

تُرجع الأس لعنصر الموتر المحدد.

تصريح

@differentiable
public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

إكسب2(_:)

إرجاع اثنين مرفوعًا إلى قوة عنصر الموتر المحدد.

تصريح

@differentiable
public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

إكسب10(_:)

إرجاع عشرة مرفوعة إلى قوة عنصر الموتر المحدد.

تصريح

@differentiable
public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

إكسبم1(_:)

تُرجع الأسي للعنصر x - 1 .

تصريح

@differentiable
public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

دائري(_:)
تُرجع قيم الموتر المحدد مُقربًا إلى أقرب عدد صحيح، من حيث العنصر.
تصريح
@differentiable public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

سقف(_:)

يُرجع سقف عنصر الموتر المحدد.

تصريح

@differentiable
public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

أرضية(_:)

يُرجع أرضية عنصر الموتر المحدد.

تصريح

@differentiable
public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

لافتة(_:)
يُرجع إشارة إلى علامة عنصر الموتر المحدد. على وجه التحديد، يحسب y = sign(x) = -1 if x < 0 ; 0 إذا x == 0 ; 1 إذا x > 0 .
تصريح
@differentiable public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
السيني (_ :)
إرجاع السيني لعنصر الموتر المحدد. على وجه التحديد، يحسب 1 / (1 + exp(-x)) .
تصريح
@differentiable public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
السجل السيني (_ :)
تُرجع السجل السيني لعنصر الموتر المحدد. على وجه التحديد، log(1 / (1 + exp(-x))) . لتحقيق الاستقرار العددي، نستخدم -softplus(-x) .
تصريح
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
سوفت بلس(_:)
تُرجع softplus لعنصر الموتر المحدد. على وجه التحديد، يحسب log(exp(features) + 1) .
تصريح
@differentiable public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
سوفت ساين(_:)
تُرجع العلامة الناعمة لعنصر الموتر المحدد. على وجه التحديد، يحسب features/ (abs(features) + 1) .
تصريح
@differentiable public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
سوفت ماكس(_:)
تُرجع softmax للموتر المحدد على طول المحور الأخير. على وجه التحديد، يحسب exp(x) / exp(x).sum(alongAxes: -1) .
تصريح
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
سوفت ماكس (_: على طول المحور :)
تُرجع softmax للموتر المحدد على طول المحور المحدد. على وجه التحديد، يحسب exp(x) / exp(x).sum(alongAxes: axis) .
تصريح
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

لوغ سوفت ماكس(_:)

تُرجع log-softmax لعنصر الموتر المحدد.

تصريح

@differentiable
public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

إيلو(_:)
إرجاع موتر من خلال تطبيق وحدة خطية أسية. على وجه التحديد، يحسب exp(x) - 1 إذا كان <0، و x بخلاف ذلك. شاهد تعلمًا سريعًا ودقيقًا للشبكة العميقة من خلال الوحدات الخطية الأسية (ELUs)
تصريح
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
جيلو(_:)
تُرجع تنشيطات وحدة الخطأ الخطي الغوسي (GELU) لعنصر الموتر المحدد.
على وجه التحديد، تقريب gelu xP(X <= x) ، حيث P(X <= x) هو التوزيع التراكمي القياسي الغوسي، عن طريق الحساب: x * [0.5 * (1 + tanh[√(2/π) * (x + 0.044715 * س ^ 3)])].
انظر الوحدات الخطية للخطأ الغوسي .
تصريح
@differentiable public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
ريلو(_:)
يُرجع موترًا عن طريق تطبيق وظيفة تنشيط ReLU على عنصر الموتر المحدد. على وجه التحديد، يحسب max(0, x) .
تصريح
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
ريلو6(_:)
إرجاع موتر من خلال تطبيق وظيفة التنشيط ReLU6، وهي min(max(0, x), 6) .
تصريح
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
المتسرب ريلو(_:ألفا :)
إرجاع موتر عن طريق تطبيق وظيفة تنشيط ReLU المتسربة على عنصر الموتر المحدد. على وجه التحديد، يحسب max(x, x * alpha) .
تصريح
@differentiable(wrt: x) public func leakyRelu<T: TensorFlowFloatingPoint>( _ x: Tensor<T>, alpha: Double = 0.2 ) -> Tensor<T>
سيلو(_:)
يُرجع موترًا عن طريق تطبيق وظيفة تنشيط SeLU، أي scale * alpha * (exp(x) - 1) إذا x < 0 ، scale * x بخلاف ذلك.
ملحوظة
تم تصميم هذا ليتم استخدامه مع مُهيئات طبقة قياس التباين. يرجى الرجوع إلى الشبكات العصبية ذاتية التطبيع لمزيد من المعلومات.
تصريح
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
حفيف(_:)
إرجاع موتر من خلال تطبيق وظيفة التنشيط، وهي x * sigmoid(x) .
المصدر: "البحث عن وظائف التنشيط" (راماشاندران وآخرون 2017) https://arxiv.org/abs/1710.05941
تصريح
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
السيني الثابت(_:)
إرجاع موتر من خلال تطبيق وظيفة التنشيط السيني الصلبة، وهي Relu6(x+3)/6 .
المصدر: "البحث عن MobileNetV3" (هوارد وآخرون 2019) https://arxiv.org/abs/1905.02244
تصريح
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
هاردسويش(_:)
إرجاع موتر عن طريق تطبيق وظيفة التنشيط القوية، وهي x * Relu6(x+3)/6 .
المصدر: "البحث عن MobileNetV3" (هوارد وآخرون 2019) https://arxiv.org/abs/1905.02244
تصريح
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
مش(_:)
إرجاع موتر من خلال تطبيق وظيفة التنشيط، وهي x * tanh(softplus(x)) .
المصدر: "Mish: وظيفة تنشيط عصبية ذاتية غير رتيبة" https://arxiv.org/abs/1908.08681
تصريح
@differentiable public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

الأسرى(_:_:)

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

تصريح

@differentiable
public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

الأسرى(_:_:)

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

تصريح

@differentiable(wrt: rhs)
public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

الأسرى(_:_:)

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

تصريح

@differentiable(wrt: lhs)
public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint

الأسرى(_:_:)

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

تصريح

@differentiable
public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

جذر(_:_:)

تُرجع العنصر الجذر n للموتر.

تصريح

@differentiable
public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

تربيع الفرق(_:_:)

إرجاع الفرق التربيعي بين x و y .

تصريح

@differentiable
public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

قيمة الإرجاع

(x - y) ^ 2 .

الأعلى(_:_:)

يُرجع الحد الأقصى من حيث العناصر وهو موترين.

ملحوظة

max يدعم البث.

تصريح

@differentiable
public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

الأعلى(_:_:)

تُرجع الحد الأقصى من حيث العنصر للعددية والموترة، وبث العددية.

تصريح

@differentiable(wrt: rhs)
public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

الأعلى(_:_:)

تُرجع الحد الأقصى من حيث العنصر للعددية والموترة، وبث العددية.

تصريح

@differentiable(wrt: lhs)
public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

دقيقة (_:_ :)

يُرجع الحد الأدنى من العناصر لموترين.

ملحوظة

min تدعم البث.

تصريح

@differentiable
public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

دقيقة (_:_ :)

إرجاع الحد الأدنى من العناصر للعددية والموترة، وبث العددية.

تصريح

@differentiable(wrt: rhs)
public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

دقيقة (_:_ :)

إرجاع الحد الأدنى من العناصر للعددية والموترة، وبث العددية.

تصريح

@differentiable(wrt: lhs)
public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

تشابه جيب التمام (_:_ :)

إرجاع تشابه جيب التمام بين x و y .

تصريح

@differentiable
public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

مسافة جيب التمام (_:_ :)
إرجاع مسافة جيب التمام بين x و y . يتم تعريف مسافة جيب التمام على أنها 1 - cosineSimilarity(x, y) .
تصريح
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>

ماتمول(_:منقول:_:منقول :)

ينفذ ضرب المصفوفة مع موتر آخر وينتج النتيجة.

تصريح

@differentiable
public func matmul<Scalar: Numeric>(
  _ lhs: Tensor<Scalar>,
  transposed transposeLhs: Bool = false,
  _ rhs: Tensor<Scalar>,
  transposed transposeRhs: Bool = false
) -> Tensor<Scalar>

conv1D(_:مرشح:خطوة:حشوة:تمدد :)
تُرجع التفافًا أحادي الأبعاد مع المدخلات والمرشح والخطوة والحشوة المحددة.
شرط مسبق
يجب أن يكون input في المرتبة 3 .
شرط مسبق
يجب أن يكون filter في المرتبة 3.
تصريح
@differentiable(wrt: (input, filter) public func conv1D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, stride: Int = 1, padding: Padding = .valid, dilation: Int = 1 ) -> Tensor<Scalar>
حدود
input
المدخل.
filter
مرشح الالتفاف.
stride
خطوة المرشح المنزلق.
padding
الحشوة للعملية.
dilation
عامل التمدد.

conv2D(_:تصفية:خطوات:حشوة:توسعات :)

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

شرط مسبق

يجب أن يكون input في المرتبة 4 .

شرط مسبق

يجب أن يكون filter في المرتبة 4.

تصريح

@differentiable(wrt: (input, filter)
public func conv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

حدود

`input`	المدخل.
`filter`	مرشح الالتفاف.
`strides`	خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
`padding`	الحشوة للعملية
`dilations`	عامل التمدد لكل بعد من المدخلات.

transposeConv2D(_:الشكل:مرشح:خطوات:حشو:توسعات :)

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

شرط مسبق

يجب أن يكون input في المرتبة 4 .

شرط مسبق

يجب أن يكون filter في المرتبة 4.

تصريح

@differentiable(wrt: (input, filter)
public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  shape: [Int64],
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

حدود

`input`	المدخل.
`shape`	شكل الإخراج لعملية التفكيك.
`filter`	مرشح الالتفاف.
`strides`	خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
`padding`	الحشوة للعملية
`dilations`	عامل التمدد لكل بعد من المدخلات.

conv3D(_:تصفية:خطوات:حشوة:توسعات :)

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

شرط مسبق

يجب أن يكون input في المرتبة 5 .

شرط مسبق

يجب أن يكون filter في المرتبة 5.

تصريح

@differentiable(wrt: (input, filter)
public func conv3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
) -> Tensor<Scalar>

حدود

`input`	المدخل.
`filter`	مرشح الالتفاف.
`strides`	خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
`padding`	الحشوة للعملية.
`dilations`	عامل التمدد لكل بعد من المدخلات.

DeepwiseConv2D(_:مرشح:خطوات:حشوة :)
يُرجع التفافًا عميقًا ثنائي الأبعاد مع المدخلات والمرشح والخطوات والحشوة المحددة.
شرط مسبق
يجب أن يكون input في المرتبة 4.
شرط مسبق
يجب أن يكون filter في المرتبة 4.
تصريح
@differentiable(wrt: (input, filter) public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
حدود
input
المدخل.
filter
مرشح الالتواء العميق.
strides
خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
padding
الحشوة للعملية.
maxPool2D(_:filterSize:خطوات:حشوة :)
يُرجع الحد الأقصى للتجميع ثنائي الأبعاد، مع أحجام المرشحات والخطوات والحشوة المحددة.
تصريح
@differentiable(wrt: input) public func maxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
حدود
input
المدخل.
filterSize
أبعاد نواة التجميع.
strides
خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
padding
الحشوة للعملية.
maxPool3D(_:filterSize:خطوات:حشوة :)
يُرجع الحد الأقصى للتجميع ثلاثي الأبعاد، مع أحجام المرشحات والخطوات والحشوة المحددة.
تصريح
@differentiable(wrt: input) public func maxPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
حدود
input
المدخل.
filterSize
أبعاد نواة التجميع.
strides
خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
padding
الحشوة للعملية.
avgPool2D(_:filterSize:خطوات:حشوة :)
إرجاع تجميع متوسط ثنائي الأبعاد، مع أحجام المرشحات والخطوات والحشوة المحددة.
تصريح
@differentiable(wrt: input) public func avgPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
حدود
input
المدخل.
filterSize
أبعاد نواة التجميع.
strides
خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
padding
الحشوة للعملية.
avgPool3D(_:filterSize:خطوات:حشوة :)
يُرجع تجميعًا متوسطًا ثلاثي الأبعاد، بأحجام المرشحات والخطوات والحشوة المحددة.
تصريح
@differentiable(wrt: input) public func avgPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
حدود
input
المدخل.
filterSize
أبعاد نواة التجميع.
strides
خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
padding
الحشوة للعملية.

FractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2 :)

إرجاع تجميع أقصى كسري ثنائي الأبعاد، بنسب التجميع المحددة.

ملاحظة: لا يحتوي fractionalMaxPool على تطبيق XLA، وبالتالي قد يكون له آثار على الأداء.

تصريح

@differentiable(wrt: input)
public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  poolingRatio: (Double, Double, Double, Double),
  pseudoRandom: Bool = false,
  overlapping: Bool = false,
  deterministic: Bool = false,
  seed: Int64 = 0,
  seed2: Int64 = 0
) -> Tensor<Scalar>

حدود

`input`	موتر. 4-D بالشكل `[batch, height, width, channels]` .
`poolingRatio`	قائمة `Doubles` . نسبة التجميع لكل بُعد من أبعاد `input` ، تدعم حاليًا بُعد الصف والعمود فقط ويجب أن تكون >= 1.0.
`pseudoRandom`	`Bool` اختياري. الافتراضيات `false` . عند التعيين على `true` ، يتم إنشاء تسلسل التجميع بطريقة عشوائية زائفة، وإلا بطريقة عشوائية.
`overlapping`	`Bool` اختياري. الافتراضيات `false` . عند التعيين على `true` ، فهذا يعني أنه عند التجميع، يتم استخدام القيم الموجودة على حدود خلايا التجميع المجاورة بواسطة كلا الخليتين.
`deterministic`	`Bool` اختياري . عند التعيين على `true` ، سيتم استخدام منطقة تجميع ثابتة عند التكرار عبر عقدة FractionalMaxPool2D في الرسم البياني الحسابي.
`seed`	اختياري `Int64` . الإعدادات الافتراضية إلى `0` . إذا تم ضبطه على قيمة غير صفرية، فسيتم تصنيف مولد الأرقام العشوائية بواسطة البذرة المحددة.
`seed2`	اختياري `Int64` . الإعدادات الافتراضية إلى `0` . بذرة ثانية لتجنب اصطدام البذور.

العمق إلى الفضاء (_:blockSize :)
تقوم بإرجاع نسخة من input حيث يتم نقل القيم من بُعد العمق في كتل مكانية إلى أبعاد الارتفاع والعرض.
على سبيل المثال، في حالة إدخال الشكل [1, 2, 2, 1] ، data_format = "NHWC" وblock_size = 2:
```
x = [[[[1], [2]],
      [[3], [4]]]]
```
ستنتج هذه العملية موترًا بالشكل [1, 1, 1, 4] :
```
[[[[1, 2, 3, 4]]]]
```
هنا، يحتوي الإدخال على دفعة مكونة من 1 ولكل عنصر دفعة شكل [2, 2, 1] ، وسيكون للمخرج المقابل عنصر واحد (أي العرض والارتفاع كلاهما 1) وسيكون له عمق 4 قنوات (1) * حجم الكتلة * حجم الكتلة). شكل عنصر الإخراج هو [1, 1, 4] .
بالنسبة لموتر الإدخال بعمق أكبر، هنا بالشكل [1, 2, 2, 3] ، على سبيل المثال
```
x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
```
هذه العملية، بالنسبة لحجم الكتلة 2، ستعيد موتر الشكل التالي [1, 1, 1, 12]
```
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
```
وبالمثل، بالنسبة لإدخال الشكل التالي [1 4 4 1] وحجم الكتلة 2:
```
x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]
```
سيعيد المشغل موتر الشكل التالي [1 2 2 4] :
```
x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
```
شرط مسبق
input.rank == 4 && b >= 2 .
شرط مسبق
يجب أن يكون عدد المعالم قابلاً للقسمة على مربع b .
تصريح
@differentiable(wrt: input) public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
مسافة إلى العمق (_:blockSize :)
تقوم بإرجاع نسخة من input حيث يتم نقل القيم من أبعاد الارتفاع والعرض إلى بُعد العمق.
على سبيل المثال، في حالة إدخال الشكل [1, 2, 2, 1] ، data_format = "NHWC" وblock_size = 2:
```
x = [[[[1], [2]],
      [[3], [4]]]]
```
ستنتج هذه العملية موترًا بالشكل [1, 1, 1, 4] :
```
[[[[1, 2, 3, 4]]]]
```
هنا، يحتوي الإدخال على دفعة مكونة من 1 ولكل عنصر دفعة شكل [2, 2, 1] ، وسيكون للمخرج المقابل عنصر واحد (أي العرض والارتفاع كلاهما 1) وسيكون له عمق 4 قنوات (1) * حجم الكتلة * حجم الكتلة). شكل عنصر الإخراج هو [1, 1, 4] .
بالنسبة لموتر الإدخال بعمق أكبر، هنا بالشكل [1, 2, 2, 3] ، على سبيل المثال
```
x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
```
هذه العملية، بالنسبة لحجم الكتلة 2، ستعيد موتر الشكل التالي [1, 1, 1, 12]
```
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
```
وبالمثل، بالنسبة لإدخال الشكل التالي [1 4 4 1] وحجم الكتلة 2:
```
x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]
```
سيعيد المشغل موتر الشكل التالي [1 2 2 4] :
```
x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
```
شرط مسبق
input.rank == 4 && b >= 2 .
شرط مسبق
يجب أن يكون ارتفاع الإدخال قابلاً للقسمة على b .
شرط مسبق
يجب أن يكون عرض الإدخال قابلاً للقسمة على b .
تصريح
@differentiable(wrt: input) public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

makeLARS(learningRate:momentum:trustCoefficiency:nesterov:epsilon:weightDecay :)

ينشئ مُحسِّنًا لكل وزن لـ LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

تصريح

public func makeLARS(
  learningRate: Float = 0.01,
  momentum: Float = 0.9,
  trustCoefficient: Float = 0.001,
  nesterov: Bool = false,
  epsilon: Float = 0.0,
  weightDecay: Float = 0.0
) -> ParameterGroupOptimizer

makeSGD (معدل التعلم: الزخم: الوزن: نيستيروف :)

يبني محسنًا لكل وزن يعتمد على SGD.

تصريح

public func makeSGD(
  learningRate: Float = 0.01,
  momentum: Float = 0,
  weightDecay: Float = 0,
  nesterov: Bool = false
) -> ParameterGroupOptimizer

makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon :)

يبني محسن لكل وزن لآدم مع تسوس الوزن.

المرجع: "آدم - طريقة للتحسين العشوائي"

تصريح

public func makeAdam(
  learningRate: Float = 0.01,
  beta1: Float = 0.9,
  beta2: Float = 0.999,
  weightDecayRate: Float = 0.01,
  epsilon: Float = 1e-6
) -> ParameterGroupOptimizer

RandomSeedForTensorFlow (باستخدام :)
يُنشئ بذرة عشوائية جديدة لـ TensorFlow.
تصريح
public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

سلسل(_:_:)

يسلسل قيمتين.

تصريح

@differentiable
public func concatenate<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

مجموع(_:_:)

جمع قيمتين وينتج مجموعهما.

تصريح

@differentiable
public func sum<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

متوسط(_:_:)

متوسط قيمتين.

تصريح

@differentiable
public func average<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

تتضاعف(_:_:)

ضرب قيمتين.

تصريح

@differentiable
public func multiply<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

كومة(_:_:)

كومة قيمتين.

تصريح

@differentiable
public func stack<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

برينتكس10ميتريكس ()
تصريح
public func PrintX10Metrics()
إحصائيات التنسيق(_:)
ينشئ ملخصًا لسلسلة من قائمة إحصائيات التدريب والاختبار.
تصريح
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

FormatStatistics (Train: Test :)

تصريح

public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
  -> String

RunonnThreads (_: _ :)

خرائط وظيفة على المواضيع n.

تصريح

public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]

`name`	اسم الجهاز.
`body`	إغلاق سيتم تنفيذ عمليات TensorFlow الخاصة به على نوع الجهاز المحدد.

`mean`	متوسط التوزيع الطبيعي.
`standardDeviation`	الانحراف المعياري للتوزيع الطبيعي.

`input`	المدخل.
`filterSize`	أبعاد نواة التجميع.
`strides`	خطوات المرشح المنزلق لكل بُعد من أبعاد الإدخال.
`padding`	الحشوة للعملية.