এই পৃষ্ঠাটি 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`	প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে সামঞ্জস্যপূর্ণ।

hingeLoss (পূর্বাভাস: প্রত্যাশিত :)

পূর্বাভাস এবং প্রত্যাশার মধ্যে কব্জা ক্ষতি প্রদান করে।

ঘোষণা

@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`	প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে সামঞ্জস্যপূর্ণ।

শ্রেণীবদ্ধ হিংজলস (পূর্বাভাস: প্রত্যাশিত :)

পূর্বাভাস এবং প্রত্যাশার মধ্যে শ্রেণীবদ্ধ কব্জা ক্ষতি প্রদান করে।

ঘোষণা

@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`	প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে সামঞ্জস্যপূর্ণ।

poissonLoss (পূর্বাভাস: প্রত্যাশিত :)

পূর্বাভাস এবং প্রত্যাশার মধ্যে পয়েসনের ক্ষতি ফিরিয়ে দেয়।

ঘোষণা

@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 divergence (KL divergence) প্রদান করে। প্রদত্ত দুটি ডিস্ট্রিবিউশন p এবং q , কেএল বিকিরণ নির্ণয় 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 (logits: সম্ভাব্যতা :)

লগিট এবং লেবেলের মধ্যে সফটম্যাক্স ক্রস এনট্রপি (শ্রেণীগত ক্রস এনট্রপি) প্রদান করে।

ঘোষণা

@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

withRandomSeedForTensorFlow (_: _ :)

প্রদত্ত এলোমেলো বীজ ছাড়া বর্তমান প্রেক্ষাপটের অনুরূপ সবকিছু আছে এমন একটি প্রেক্ষাপটে প্রদত্ত বন্ধকে কল করে।

ঘোষণা

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

পরামিতি

`randomSeed`	একটি এলোমেলো বীজ যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ হয়ে যাওয়ার পরে পুনরুদ্ধার করা হবে।
`body`	একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় `withRandomSeedForTensorFlow(_:_:)` ফাংশন।

ফেরত মূল্য

ফেরত মান, যদি থাকে, এর body বন্ধ।

withRandomNumberGeneratorForTensorFlow (_: _ :)

প্রদত্ত এলোমেলো নম্বর জেনারেটর ব্যতীত বর্তমান প্রেক্ষাপটের অনুরূপ সবকিছু আছে এমন একটি প্রেক্ষাপটে প্রদত্ত বন্ধকে কল করে।

ঘোষণা

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

পরামিতি

`randomNumberGenerator`	একটি এলোমেলো নম্বর জেনারেটর যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ হয়ে যাওয়ার পরে পুনরুদ্ধার করা হবে।
`body`	একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় `withRandomNumberGeneratorForTensorFlow(_:_:)` ফাংশন।

ফেরত মূল্য

ফেরত মান, যদি থাকে, এর body বন্ধ।

zip (_: _ :)

ঘোষণা

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

LazyTensorBarrier (on: devices: wait :)
LazyTensorBarrier নিশ্চিত করে যে সমস্ত লাইভ টেন্সর (যদি ডিভাইসে থাকে) নির্ধারিত এবং চলমান থাকে। যদি প্রতীক্ষাকে সত্যে সেট করা হয়, গণনা সম্পূর্ণ না হওয়া পর্যন্ত এই কলটি বন্ধ হয়ে যায়।
ঘোষণা
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 (at: _: in :)

ঘোষণা

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

valueWithGradient (এর :)

ঘোষণা

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

valueWithGradient (এর :)

ঘোষণা

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

valueWithGradient (এর :)

ঘোষণা

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

withRecomputationInPullbacks (_ :)
একটি ফাংশনকে তার পুলব্যাকের মধ্যে পুনরায় গণনা করুন, যা traditionalতিহ্যগত স্বয়ংক্রিয় ভিন্নতায় "চেকপয়েন্টিং" নামে পরিচিত।
ঘোষণা
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

differentiableFunction (থেকে :)

একটি ভেক্টর-জ্যাকোবিয়ান পণ্য ফাংশন থেকে একটি আলাদা ফাংশন তৈরি করুন।

ঘোষণা

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

differentiableFunction (থেকে :)

একটি ভেক্টর-জ্যাকোবিয়ান পণ্য ফাংশন থেকে একটি আলাদা ফাংশন তৈরি করুন।

ঘোষণা

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

withDevice (_: _: সঞ্চালন :)

একটি ক্লোসার এক্সিকিউট করে, TensorFlow অপারেশনগুলি একটি নির্দিষ্ট ধরনের ডিভাইসে চালায়।

ঘোষণা

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

পরামিতি

`kind`	TensorFlow অপারেশন চালানোর জন্য এক ধরনের ডিভাইস।
`index`	অপস চালানোর জন্য ডিভাইস।
`body`	একটি বন্ধ যার TensorFlow অপারেশন নির্দিষ্ট ধরনের ডিভাইসে চালানো হবে।

withDevice (নাম: সঞ্চালন :)

একটি নির্দিষ্ট নাম সহ একটি ডিভাইসে TensorFlow অপারেশন চালানোর জন্য একটি ক্লোজার চালায়।

ডিভাইসের নামের কিছু উদাহরণ:

"/ডিভাইস: CPU: 0": আপনার মেশিনের CPU।
"/জিপিইউ: 0": আপনার মেশিনের প্রথম জিপিইউর জন্য সংক্ষিপ্ত স্বরলিপি যা টেন্সরফ্লোতে দৃশ্যমান
"/Job: localhost/replica: 0/task: 0/device: GPU: 1": TensorFlow- এর কাছে দৃশ্যমান আপনার মেশিনের দ্বিতীয় GPU- এর সম্পূর্ণ যোগ্য নাম।

ঘোষণা

public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R

পরামিতি

`name`	ডিভাইসের নাম.
`body`	একটি বন্ধ যার TensorFlow অপারেশন নির্দিষ্ট ধরনের ডিভাইসে চালানো হবে।

withDefaultDevice (সঞ্চালন :)
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`	4-ডি `Tensor` আকৃতি `[batch, height, width, channels]` বা 3-ডি `Tensor` আকৃতি `[height, width, channels]` ।
`size`	ছবিগুলির নতুন আকার।
`method`	আকার পরিবর্তন পদ্ধতি। ডিফল্ট মান হল `.bilinear` ।
`antialias`	Iff `true` , যখন একটি চিত্র downsampling একটি অ্যান্টি-অ্যালায়েসিং ফিল্টার ব্যবহার করুন।

resizeArea (ছবি: size: alignCorners :)
এলাকা ইন্টারপোলেশন ব্যবহার করে ছবির আকার পরিবর্তন করুন।
পূর্বশর্ত
চিত্র র্যাঙ্ক থাকতে হবে 3 বা 4 ।
পূর্বশর্ত
আকার অবশ্যই ইতিবাচক হতে হবে।
ঘোষণা
public func resizeArea<Scalar: TensorFlowNumeric>( images: Tensor<Scalar>, size: (newHeight: Int, newWidth: Int), alignCorners: Bool = false ) -> Tensor<Float>
পরামিতি
images
4-ডি Tensor আকৃতি [batch, height, width, channels] বা 3-ডি Tensor আকৃতি [height, width, channels] ।
size
ছবিগুলির নতুন আকার।

dilation2D (_: filter: strides: rate: padding :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইড এবং প্যাডিং সহ একটি 2-ডি প্রসারণ প্রদান করে।

পূর্বশর্ত

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`	ইনপুট প্রতিটি মাত্রা জন্য প্রসারণ হার।

erosion2D (_: filter: strides: rate: padding :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রিডস এবং প্যাডিং সহ একটি 2-ডি ক্ষয় প্রদান করে।

পূর্বশর্ত

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>
গ্লোরোট ইউনিফর্ম (বীজ :)
রিটার্নস একটি ফাংশন উল্লিখিত আকৃতি জন্য Glorot (জেভিয়ার) করণ অভিন্ন আরম্ভের, এলোমেলোভাবে মধ্যে একটি অভিন্ন বিতরণ থেকে স্কালে মান স্যাম্পলিং দ্বারা একটি টেন্সর সৃষ্টি -limit এবং limit , ডিফল্ট র্যান্ডম সংখ্যা উত্পাদক, যেখানে সীমা দ্বারা উত্পন্ন sqrt(6 / (fanIn + fanOut)) এবং fanIn / fanOut ইনপুট সংখ্যা প্রতিনিধিত্ব এবং আউটপুট যদি বর্তমান, ধারণক্ষম ক্ষেত্র দ্বারা গুন বৈশিষ্ট্যগুলিও উপস্থিত রয়েছে।
ঘোষণা
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
গ্লোরোটনরমাল (বীজ :)
রিটার্নস একটি ফাংশন যে নির্দিষ্ট আকৃতি জন্য Glorot (জেভিয়ার) করণ স্বাভাবিক আরম্ভের, এলোমেলোভাবে একটি ছেঁটে ফেলা সাধারন বন্টনের থেকে স্কালে মান স্যাম্পলিং দ্বারা একটি টেন্সর সৃষ্টি কেন্দ্রেও 0 স্ট্যানডার্ড ডেভিয়েশন সঙ্গে sqrt(2 / (fanIn + fanOut)) , যেখানে fanIn / fanOut ইনপুট এবং আউটপুট বৈশিষ্ট্য সংখ্যা গ্রহণযোগ্য ক্ষেত্র আকার দ্বারা গুণিত, যদি উপস্থিত।
ঘোষণা
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
heUniform (বীজ :)
রিটার্নস একটি ফাংশন যে, তিনি (Kaiming) নির্দিষ্ট আকৃতি জন্য অভিন্ন আরম্ভের করণ এলোমেলোভাবে মধ্যে একটি অভিন্ন বিতরণ থেকে স্কালে মান স্যাম্পলিং দ্বারা একটি টেন্সর সৃষ্টি -limit এবং limit , ডিফল্ট র্যান্ডম সংখ্যা উত্পাদক, যেখানে সীমা দ্বারা উত্পন্ন sqrt(6 / fanIn) , এবং fanIn ধারণক্ষম ক্ষেত্র দ্বারা গুন ইনপুট বৈশিষ্ট্য নম্বর, যদি বর্তমান প্রতিনিধিত্ব করে।
ঘোষণা
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
সাধারণ (বীজ :)
রিটার্নস একটি ফাংশন যে তিনি নির্দিষ্ট আকৃতি জন্য (Kaiming) স্বাভাবিক আরম্ভের করণ এলোমেলোভাবে একটি ছেঁটে ফেলা সাধারন বন্টনের থেকে স্কালে মান স্যাম্পলিং দ্বারা একটি টেন্সর সৃষ্টি কেন্দ্রেও 0 স্ট্যানডার্ড ডেভিয়েশন সঙ্গে sqrt(2 / fanIn) , যেখানে fanIn ইনপুট বৈশিষ্ট্য সংখ্যা উপস্থাপন গ্রহণযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত, যদি উপস্থিত থাকে।
ঘোষণা
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunUniform (বীজ :)
রিটার্নস একটি ফাংশন যে নির্দিষ্ট আকৃতি জন্য LeCun অভিন্ন আরম্ভের করণ, এলোমেলোভাবে মধ্যে একটি অভিন্ন বিতরণ থেকে স্কালে মান স্যাম্পলিং দ্বারা একটি টেন্সর সৃষ্টি -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>
ছেঁটে ফেলা সাধারণ ইনিটিয়ালাইজার (মানে: স্ট্যান্ডার্ড ডিভিয়েশন: বীজ :)
একটি ফাংশন রিটার্ন করে যা একটি টেনসার তৈরি করে তার সমস্ত মানগুলিকে এলোমেলোভাবে একটি ছোট কাটা বন্টন থেকে শুরু করে। উৎপাদিত মান গড় সঙ্গে একটি স্বাভাবিক বন্টন অনুসরণ mean এবং মানক চ্যুতির standardDeviation , যে মূল্যবোধ যার মাত্রার বেশি গড় থেকে দুই স্ট্যান্ডার্ড ডেভিয়েশন বাদ পড়েছে এবং resampled হয় ব্যতীত।
ঘোষণা
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

চোখ (rowCount: columnCount: batchShape: on :)

একটি পরিচয় ম্যাট্রিক্স বা ম্যাট্রিক্সের একটি ব্যাচ প্রদান করে।

ঘোষণা

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

পরামিতি

`rowCount`	প্রতিটি ব্যাচের ম্যাট্রিক্সে সারির সংখ্যা।
`columnCount`	প্রতিটি ব্যাচের ম্যাট্রিক্সে কলামের সংখ্যা।
`batchShape`	ফিরে আসা টেন্সরের নেতৃস্থানীয় ব্যাচের মাত্রা।

ট্রেস (_ :)
Anচ্ছিকভাবে ব্যাচ করা ম্যাট্রিক্সের ট্রেস গণনা করে। ট্রেস হল প্রতিটি অভ্যন্তরীণ-সর্বাধিক ম্যাট্রিক্সের প্রধান কর্ণ বরাবর যোগফল।
ইনপুট আকৃতি সঙ্গে একটি টেন্সর হয় [..., 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] ।
cholesky (_ :)
এক বা একাধিক বর্গ ম্যাট্রিক্সের Cholesky পচন প্রদান করে।
ইনপুট আকৃতি একটি টেন্সর হয় [..., M, M] যার ভেতরের-পূর্বের 2 মাত্রা বর্গ ম্যাট্রিক্স গঠন করে।
ইনপুট প্রতিসম এবং ইতিবাচক নিশ্চিত হতে হবে। এই ক্রিয়াকলাপের জন্য শুধুমাত্র ইনপুটের নিম্ন-ত্রিভুজাকার অংশ ব্যবহার করা হবে। উপরের ত্রিভুজাকার অংশটি পড়া হবে না।
আউটপুট সমস্ত ইনপুট submatrices জন্য Cholesky decompositions ধারণকারী ইনপুট হিসাবে একই আকৃতি একটি টেন্সর হয় [..., :, :] ।
ঘোষণা
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
পরামিতি
input
আকৃতি একটি টেন্সর [..., M, M] ।

triangularSolve (ম্যাট্রিক্স: rhs: নিম্ন: adjoint :)

রিটার্নস সমাধান 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` , এর adjoint সঙ্গে সমাধান `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`	গণনা উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগ করার জন্য হ্রাস।

meanAbsoluteError (পূর্বাভাস: প্রত্যাশিত :)

লেবেল এবং পূর্বাভাসের মধ্যে পরম পার্থক্যের গড় গণনা করে। 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(_:) নেতিবাচক বাস্তব জন্য undefined করা হয়।

ঘোষণা

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

পরামিতি

`predicted`	একটি নিউরাল নেটওয়ার্ক থেকে পূর্বাভাস দেওয়া আউটপুট।
`expected`	প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে সামঞ্জস্যপূর্ণ।

meanAbsolutePercentageError (পূর্বাভাস: প্রত্যাশিত :)

গড় পরম শতাংশ ত্রুটি মধ্যে নির্ণয় করে 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`	প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে সামঞ্জস্যপূর্ণ।

hingeLoss (পূর্বাভাস: প্রত্যাশিত: হ্রাস :)

মধ্যে কবজা ক্ষতি নির্ণয় করে 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`	গণনা উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগ করার জন্য হ্রাস।

শ্রেণীবদ্ধ হিংজলস (পূর্বাভাস: প্রত্যাশিত: হ্রাস :)

মধ্যে শ্রেণীগত কবজা ক্ষতি নির্ণয় করে 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: লেবেল: হ্রাস :)

লগিট এবং লেবেলগুলির মধ্যে স্পার্স সফটম্যাক্স ক্রস এনট্রপি (স্পষ্ট ক্রস এনট্রপি) গণনা করে। দুই বা ততোধিক লেবেল ক্লাস থাকলে এই ক্রসেন্ট্রপি লস ফাংশনটি ব্যবহার করুন। আমরা আশা করি লেবেলগুলি পূর্ণসংখ্যা হিসাবে প্রদান করা হবে। থাকা উচিত # 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 (logits: সম্ভাব্যতা: হ্রাস :)

লগিট এবং লেবেলগুলির মধ্যে স্পার্স সফটম্যাক্স ক্রস এনট্রপি (স্পষ্ট ক্রস এনট্রপি) গণনা করে। দুই বা ততোধিক লেবেল ক্লাস থাকলে এই ক্রসেন্ট্রপি লস ফাংশনটি ব্যবহার করুন। আমরা আশা লেবেল একটি প্রদত্ত প্রদান করা 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: লেবেল: হ্রাস :)

লগিট এবং লেবেলের মধ্যে সিগময়েড ক্রস এনট্রপি (বাইনারি ক্রস এনট্রপি) গণনা করে। এই ক্রস-এনট্রপি ক্ষতিটি ব্যবহার করুন যখন শুধুমাত্র দুটি লেবেল ক্লাস থাকে (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| - δ) অন্যথায়।
উত্স: Wikipedia নিবন্ধটি ।

ঘোষণা

@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`	একটি ভাসমান বিন্দু স্কেলার যে বিন্দুকে প্রতিনিধিত্ব করে যেখানে হুবার লস ফাংশন চতুর্ভুজ থেকে রৈখিক পরিবর্তিত হয়।
`reduction`	গণনা উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগ করার জন্য হ্রাস।

abs (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুযায়ী পরম মান প্রদান করে।
ঘোষণা
@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
log2 (_ :)
নির্দিষ্ট টেন্সর উপাদান-ভিত্তিক বেস-দুই লগারিদম প্রদান করে।
ঘোষণা
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log10 (_ :)
নির্দিষ্ট টেন্সর উপাদান-ভিত্তিক বেস-দশ লগারিদম প্রদান করে।
ঘোষণা
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log1p (_ :)
রিটার্নস লগারিদম 1 + x উপাদান প্রজ্ঞাময়।
ঘোষণা
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log1mexp (_ :)
রিটার্নস 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
cos (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুযায়ী কোসাইন প্রদান করে।
ঘোষণা
@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
cosh (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুযায়ী হাইপারবোলিক কোসাইন প্রদান করে।
ঘোষণা
@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
acos (_ :)
নির্দিষ্ট টেন্সর উপাদান-ভিত্তিক বিপরীত কোসাইন প্রদান করে।
ঘোষণা
@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
acosh (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুসারে বিপরীত হাইপারবোলিক কোসাইন প্রদান করে।
ঘোষণা
@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
sqrt (_ :)
নির্দিষ্ট টেন্সর উপাদান-ভিত্তিক বর্গমূল প্রদান করে।
ঘোষণা
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
rsqrt (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুসারে বিপরীত বর্গমূল প্রদান করে।
ঘোষণা
@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
exp2 (_ :)
নির্দিষ্ট টেনসার উপাদান অনুযায়ী ক্ষমতায় উত্থাপিত দুটি প্রদান করে।
ঘোষণা
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
exp10 (_ :)
নির্দিষ্ট টেনসার উপাদান অনুযায়ী ক্ষমতায় উত্থাপিত দশটি প্রদান করে।
ঘোষণা
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
expm1 (_ :)
রিটার্নের সূচকীয় 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 যদি 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
logSigmoid (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুসারে লগ-সিগময়েড প্রদান করে। বিশেষ করে, log(1 / (1 + exp(-x))) সংখ্যাসূচক স্থিতিশীলতার জন্য, আমরা ব্যবহার -softplus(-x) ।
ঘোষণা
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
সফটপ্লাস (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুযায়ী সফটপ্লাস প্রদান করে। বিশেষ করে, নির্ণয় 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
সফটম্যাক্স (_ :)
শেষ অক্ষ বরাবর নির্দিষ্ট টেন্সরের সফটম্যাক্স প্রদান করে। বিশেষ করে, নির্ণয় exp(x) / exp(x).sum(alongAxes: -1) ।
ঘোষণা
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
softmax (_: alongAxis :)
নির্দিষ্ট অক্ষ বরাবর নির্দিষ্ট টেন্সরের সফটম্যাক্স প্রদান করে। বিশেষ করে, নির্ণয় exp(x) / exp(x).sum(alongAxes: axis) ।
ঘোষণা
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
logSoftmax (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুসারে লগ-সফটম্যাক্স প্রদান করে।
ঘোষণা
@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 / π) * (এক্স + + 0.044715 * x^3)])]।
দেখুন গসিয়ান ত্রুটি লিনিয়ার ইউনিট ।
ঘোষণা
@differentiable public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
relu (_ :)
নির্দিষ্ট টেন্সর উপাদান অনুসারে ReLU অ্যাক্টিভেশন ফাংশন প্রয়োগ করে একটি টেন্সর প্রদান করে। বিশেষ করে, নির্ণয় max(0, x) ।
ঘোষণা
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
relu6 (_ :)
রিটার্নস ReLU6 অ্যাক্টিভেশন ফাংশন, যথা প্রয়োগের দ্বারা একটি টেন্সর min(max(0, x), 6) ।
ঘোষণা
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
লিকি রেলু (_: আলফা :)
নির্দিষ্ট টেন্সর উপাদান অনুসারে লিকি রিলু অ্যাক্টিভেশন ফাংশন প্রয়োগ করে একটি টেন্সর প্রদান করে। বিশেষ করে, নির্ণয় 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
hardSigmoid (_ :)
রিটার্নস হার্ড সিগমা অ্যাক্টিভেশন ফাংশন, যথা প্রয়োগের দ্বারা একটি টেন্সর 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
hardSwish (_ :)
রিটার্নস, হার্ড ফিটফাট অ্যাক্টিভেশন ফাংশন প্রয়োগের যথা দ্বারা একটি টেন্সর 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
মিশ (_ :)
রিটার্নস Mish অ্যাক্টিভেশন ফাংশন, যথা প্রয়োগের দ্বারা একটি টেন্সর 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>

cosineDistance (_: _ :)
রিটার্নস মধ্যে কোসাইন দূরত্ব x এবং y । কোসাইন দূরত্ব হিসাবে সংজ্ঞায়িত করা হয় 1 - cosineSimilarity(x, y) ।
ঘোষণা
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
matmul (_: transposed: _: transposed :)
অন্য টেনসারের সাথে ম্যাট্রিক্স গুণন সম্পাদন করে এবং ফলাফল তৈরি করে।
ঘোষণা
@differentiable public func matmul<Scalar: Numeric>( _ lhs: Tensor<Scalar>, transposed transposeLhs: Bool = false, _ rhs: Tensor<Scalar>, transposed transposeRhs: Bool = false ) -> Tensor<Scalar>

conv1D (_: filter: stride: padding: dilation :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইড এবং প্যাডিং সহ 1-ডি কনভোলিউশন প্রদান করে।

পূর্বশর্ত

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 (_: filter: strides: padding: dilations :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইড এবং প্যাডিং সহ একটি 2-ডি কনভোলিউশন প্রদান করে।

পূর্বশর্ত

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`	ইনপুটের প্রতিটি মাত্রার জন্য প্রসারণ ফ্যাক্টর।

transposedConv2D (_: আকৃতি: ফিল্টার: strides: প্যাডিং: dilations :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রিডস এবং প্যাডিং সহ একটি 2-D ট্রান্সপোজড কনভোলিউশন প্রদান করে।

পূর্বশর্ত

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 (_: filter: strides: padding: dilations :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইডস, প্যাডিং এবং ডাইলেশন সহ একটি 3-ডি কনভোলিউশন প্রদান করে।

পূর্বশর্ত

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`	ইনপুটের প্রতিটি মাত্রার জন্য প্রসারণ ফ্যাক্টর।

গভীরভাবে কনভ 2 ডি (_: ফিল্টার: স্ট্রাইডস: প্যাডিং :)

নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রিডস এবং প্যাডিং সহ 2-D গভীরতার ভিত্তিতে কনভোলিউশন প্রদান করে।

পূর্বশর্ত

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: strides: padding :)

নির্দিষ্ট ফিল্টার সাইজ, স্ট্রাইডস এবং প্যাডিং সহ একটি 2-ডি ম্যাক্স পুলিং প্রদান করে।

ঘোষণা

@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: strides: padding :)

নির্দিষ্ট ফিল্টারের মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 3-D সর্বোচ্চ পুলিং প্রদান করে।

ঘোষণা

@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: strides: padding :)

নির্দিষ্ট ফিল্টারের মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 2-ডি গড় পুলিং প্রদান করে।

ঘোষণা

@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: strides: padding :)

নির্দিষ্ট ফিল্টারের মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 3-ডি গড় পুলিং প্রদান করে।

ঘোষণা

@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: নির্ধারণকারী: বীজ: seed2 :)

নির্দিষ্ট পুলিং অনুপাত সহ একটি 2-ডি ভগ্নাংশীয় সর্বোচ্চ পুলিং প্রদান করে।

নোট: 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-ডি `[batch, height, width, channels]` ।
`poolingRatio`	একটি তালিকা `Doubles` । এর প্রতিটি আয়তনের জন্য অনুপাত পুলিং `input` , বর্তমানে কেবল সারি এবং কর্নেল মাত্রা সমর্থন করে এবং> = 1.0 হতে হবে।
`pseudoRandom`	একটি ঐচ্ছিক `Bool` । ডিফল্ট `false` । সেট থাকে `true` , পুলিং ক্রম একটি সিউডোরান্ডম ফ্যাশন, একটি র্যান্ডম ফ্যাশন উত্পন্ন অন্যথায়।
`overlapping`	একটি ঐচ্ছিক `Bool` । ডিফল্ট `false` । যখন সেট `true` , এটা মানে যখন পুলিং, সন্নিহিত পুলিং কোষের সীমানা এ মান উভয় কোষ দ্বারা ব্যবহৃত হয়।
`deterministic`	একটি ঐচ্ছিক `Bool` । সেট যখন `true` , একটি নির্দিষ্ট পুলিং অঞ্চল গণনার গ্রাফ একটি fractionalMaxPool2D নোড উপর ব্যবহার করা হবে যখন iterating।
`seed`	একটি ঐচ্ছিক `Int64` । ডিফল্ট `0` । যদি শূন্য-এ সেট করা হয়, তাহলে এলোমেলো সংখ্যা জেনারেটর প্রদত্ত বীজ দ্বারা বীজযুক্ত হয়।
`seed2`	একটি ঐচ্ছিক `Int64` । ডিফল্ট `0` । বীজের সংঘর্ষ এড়াতে দ্বিতীয় বীজ।

depthToSpace (_: 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 * block_size * block_size)। আউটপুট উপাদান আকৃতি হয় [1, 1, 4] ।
বৃহত্তর গভীরতা আকৃতি এখানে একটি ইনপুট টেন্সর জন্য [1, 2, 2, 3] , যেমন
```
x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
```
এই অপারেশন, 2 এর block_size জন্য, আকৃতি নিম্নলিখিত টেন্সর ফিরে আসবে [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
spaceToDepth (_: 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 * block_size * block_size)। আউটপুট উপাদান আকৃতি হয় [1, 1, 4] ।
বৃহত্তর গভীরতা আকৃতি এখানে একটি ইনপুট টেন্সর জন্য [1, 2, 2, 3] , যেমন
```
x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
```
This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]
```
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
```
Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:
```
x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]
```
the operator will return the following tensor of shape [1 2 2 4] :
```
x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
```
Precondition
input.rank == 4 && b >= 2 .
Precondition
The height of the input must be divisible by b .
Precondition
The width of the input must be divisible by b .
ঘোষণা
@differentiable(wrt: input) public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

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

Builds a per-weight optimizer for 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(learningRate:momentum:weightDecay:nesterov:)

Builds a SGD based per-weight optimizer.

ঘোষণা

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

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

Builds a per-weight optimizer for Adam with weight decay.

Reference: “Adam - A Method for Stochastic Optimization”

ঘোষণা

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(using:)

Generates a new random seed for TensorFlow.

ঘোষণা

public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

concatenate(_:_:)

Concatenates two values.

ঘোষণা

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

sum(_:_:)

Adds two values and produces their sum.

ঘোষণা

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

average(_:_:)

Averages two values.

ঘোষণা

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

multiply(_:_:)

Multiplies two values.

ঘোষণা

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

stack(_:_:)

Stack two values.

ঘোষণা

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

PrintX10Metrics()
ঘোষণা
public func PrintX10Metrics()

formatStatistics(_:)

Creates a string summary of a list of training and testing stats.

ঘোষণা

public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

formatStatistics(train:test:)

ঘোষণা

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

runOnNThreads(_:_:)

Maps a function over n threads.

ঘোষণা

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

`context`	একটি প্রেক্ষাপট যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ হয়ে যাওয়ার পরে পুনরুদ্ধার করা হবে।
`body`	একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় `withContext(_:_:)` ফাংশন।

`learningPhase`	একটি শেখার পর্ব যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ হয়ে যাওয়ার পরে পুনরুদ্ধার করা হবে।
`body`	একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় `withLearningPhase(_:_:)` ফাংশন।

`mean`	স্বাভাবিক বন্টনের গড়।
`standardDeviation`	সাধারণ বিতরণের মান বিচ্যুতি।