ফাংশন

নিম্নলিখিত ফাংশন বিশ্বব্যাপী উপলব্ধ.

  • ভবিষ্যদ্বাণী এবং প্রত্যাশার মধ্যে L1 ক্ষতি ফেরত দেয়।

    ঘোষণা

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

    পরামিতি

    predicted

    একটি নিউরাল নেটওয়ার্ক থেকে পূর্বাভাসিত আউটপুট।

    expected

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

  • ভবিষ্যদ্বাণী এবং প্রত্যাশার মধ্যে 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

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

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

    ঘোষণা

    @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

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

  • ভবিষ্যদ্বাণী এবং প্রত্যাশার মধ্যে ত্রুটির হাইপারবোলিক কোসাইনের লগারিদম প্রদান করে।

    ঘোষণা

    @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

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

  • প্রত্যাশা এবং ভবিষ্যদ্বাণীগুলির মধ্যে 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

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

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

    ঘোষণা

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

    পরামিতি

    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

    একটি nullary বন্ধ. যদি বন্ধের একটি রিটার্ন মান থাকে, তাহলে সেই মানটি withContext(_:_:) ফাংশনের রিটার্ন মান হিসাবেও ব্যবহৃত হয়।

    ফেরত মূল্য

    body ক্লোজারের রিটার্ন মান, যদি থাকে।

  • প্রদত্ত ক্লোজারকে এমন একটি প্রেক্ষাপটের মধ্যে কল করে যেখানে প্রদত্ত শেখার পর্যায় ব্যতীত বর্তমান প্রেক্ষাপটের সাথে মিল রয়েছে।

    ঘোষণা

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

    পরামিতি

    learningPhase

    একটি শেখার পর্যায় যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ ফিরে আসার পরে পুনরুদ্ধার করা হবে।

    body

    একটি nullary বন্ধ. যদি বন্ধের একটি রিটার্ন মান থাকে, তাহলে সেই মানটিকে withLearningPhase(_:_:) ফাংশনের রিটার্ন মান হিসাবেও ব্যবহার করা হয়।

    ফেরত মূল্য

    body ক্লোজারের রিটার্ন মান, যদি থাকে।

  • প্রদত্ত ক্লোজারটিকে এমন একটি প্রেক্ষাপটের মধ্যে কল করে যেখানে প্রদত্ত এলোমেলো বীজ ব্যতীত বর্তমান প্রেক্ষাপটের সাথে মিল রয়েছে।

    ঘোষণা

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

    পরামিতি

    randomSeed

    একটি এলোমেলো বীজ যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ ফিরে আসার পরে পুনরুদ্ধার করা হবে।

    body

    একটি nullary বন্ধ. যদি বন্ধের একটি রিটার্ন মান থাকে, তাহলে সেই মানটি withRandomSeedForTensorFlow(_:_:) ফাংশনের রিটার্ন মান হিসাবেও ব্যবহৃত হয়।

    ফেরত মূল্য

    body ক্লোজারের রিটার্ন মান, যদি থাকে।

  • প্রদত্ত ক্লোজারকে এমন একটি প্রেক্ষাপটের মধ্যে কল করে যেখানে প্রদত্ত র্যান্ডম নম্বর জেনারেটর ব্যতীত বর্তমান প্রেক্ষাপটের সাথে মিল রয়েছে।

    ঘোষণা

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

    পরামিতি

    randomNumberGenerator

    একটি র্যান্ডম নম্বর জেনারেটর যা বন্ধ হওয়ার আগে সেট করা হবে এবং বন্ধ হওয়ার পরে পুনরুদ্ধার করা হবে।

    body

    একটি nullary বন্ধ. যদি বন্ধের একটি রিটার্ন মান থাকে, তাহলে সেই মানটি withRandomNumberGeneratorForTensorFlow(_:_:) ফাংশনের রিটার্ন মান হিসাবেও ব্যবহৃত হয়।

    ফেরত মূল্য

    body ক্লোজারের রিটার্ন মান, যদি থাকে।

  • ঘোষণা

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

  • LazyTensorBarrier নিশ্চিত করে যে সমস্ত লাইভ টেনসর (যদি সরবরাহ করা হয় ডিভাইসে) নির্ধারিত এবং চলমান। অপেক্ষা সত্যে সেট করা থাকলে, গণনা সম্পূর্ণ না হওয়া পর্যন্ত এই কলটি ব্লক করে।

    ঘোষণা

    public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

  • ঘোষণা

    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

  • ঘোষণা

    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

  • ঘোষণা

    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

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

    ঘোষণা

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

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

    ঘোষণা

    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

  • x এ প্রদত্ত ক্লোজার body প্রয়োগ করে। যখন একটি প্রেক্ষাপটে ব্যবহার করা হয় যেখানে 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": আপনার মেশিনের CPU।
    • “/GPU:0”: আপনার মেশিনের প্রথম GPU-এর শর্ট-হ্যান্ড নোটেশন যা TensorFlow-এ দৃশ্যমান
    • “/job:localhost/replica:0/task:0/device:GPU:1”: আপনার মেশিনের দ্বিতীয় GPU-এর সম্পূর্ণ যোগ্য নাম যা 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

    আকৃতির 4-D Tensor [batch, height, width, channels] বা 3-ডি আকৃতির 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

    আকৃতির 4-D Tensor [batch, height, width, channels] বা 3-ডি আকৃতির Tensor [height, width, channels] ।

    size

    ছবির নতুন আকার.

  • নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইডস এবং প্যাডিং সহ একটি 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

    ইনপুটের প্রতিটি মাত্রার জন্য প্রসারিত হার।

  • নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইডস এবং প্যাডিং সহ একটি 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>

  • একটি ফাংশন প্রদান করে যা নির্দিষ্ট আকৃতির জন্য গ্লোরোট (জেভিয়ার) অভিন্ন প্রারম্ভিকতা সম্পাদন করে একটি টেনসর তৈরি করে, -limit এবং limit মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলোভাবে স্কেলার মানগুলি নমুনা করে, ডিফল্ট র্যান্ডম সংখ্যা জেনারেটর দ্বারা তৈরি করা হয়, যেখানে সীমা sqrt(6 / (fanIn + fanOut)) , এবং fanIn / fanOut উপস্থিত থাকলে গ্রহণযোগ্য ক্ষেত্র দ্বারা গুণিত ইনপুট এবং আউটপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে।

    ঘোষণা

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • একটি ফাংশন প্রদান করে যা নির্দিষ্ট আকৃতির জন্য Glorot (Xavier) স্বাভাবিক সূচনা সম্পাদন করে একটি টেনসর তৈরি করে, স্ট্যান্ডার্ড ডেভিয়েশন sqrt(2 / (fanIn + fanOut)) , যেখানে fanIn / fanOut সহ 0 কে কেন্দ্র করে একটি ছেঁটে যাওয়া স্বাভাবিক বন্টন থেকে এলোমেলোভাবে স্কেলার মান নমুনা করে গ্রহনযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত ইনপুট এবং আউটপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে, যদি উপস্থিত থাকে।

    ঘোষণা

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • একটি ফাংশন প্রদান করে যা নির্দিষ্ট আকৃতির জন্য He (Kaiming) ইউনিফর্ম ইনিশিয়ালাইজেশন সম্পাদন করে একটি টেনসর তৈরি করে, -limit এবং limit মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলোভাবে স্কেলার মানগুলি নমুনা করে, ডিফল্ট র্যান্ডম সংখ্যা জেনারেটর দ্বারা উত্পন্ন হয়, যেখানে সীমা sqrt(6 / fanIn) , এবং fanIn উপস্থিত থাকলে গ্রহণযোগ্য ক্ষেত্রের দ্বারা গুণিত ইনপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে।

    ঘোষণা

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • একটি ফাংশন প্রদান করে যা নির্দিষ্ট আকৃতির জন্য He (Kaiming) স্বাভাবিক প্রারম্ভিকতা সম্পাদন করে একটি টেনসর তৈরি করে, স্ট্যান্ডার্ড ডেভিয়েশন sqrt(2 / fanIn) সহ 0 কেন্দ্রিক একটি ছেঁটে সাধারণ বিতরণ থেকে এলোমেলোভাবে স্কেলার মান নমুনা করে, যেখানে fanIn ইনপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে গ্রহনযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত, যদি উপস্থিত থাকে।

    ঘোষণা

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • একটি ফাংশন ফেরত দেয় যা নির্দিষ্ট আকৃতির জন্য LeCun ইউনিফর্ম ইনিশিয়ালাইজেশন সম্পাদন করে একটি টেনসর তৈরি করে, -limit এবং limit মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলোভাবে স্কেলার মানগুলি নমুনা করে, ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা তৈরি করা হয়, যেখানে সীমা sqrt(3 / fanIn) এবং fanIn গ্রহনযোগ্য ক্ষেত্রের দ্বারা গুণিত ইনপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে, যদি উপস্থিত থাকে।

    ঘোষণা

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • একটি ফাংশন প্রদান করে যা নির্দিষ্ট আকৃতির জন্য LeCun স্বাভাবিক প্রারম্ভিকতা সম্পাদন করে একটি টেনসর তৈরি করে, স্ট্যান্ডার্ড ডেভিয়েশন sqrt(1 / fanIn) এর সাথে 0 কেন্দ্রিক একটি ছেঁটে সাধারণ বন্টন থেকে এলোমেলোভাবে স্কেলার মান নমুনা করে, যেখানে fanIn ইনপুট বৈশিষ্ট্যের সংখ্যা দ্বারা গুণিত করে। গ্রহণযোগ্য ক্ষেত্রের আকার, যদি উপস্থিত থাকে।

    ঘোষণা

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • একটি ফাংশন ফেরত দেয় যা একটি টেনসর তৈরি করে তার সমস্ত মান এলোমেলোভাবে একটি কাটা সাধারণ বন্টন থেকে শুরু করে। উত্পন্ন মানগুলি গড় mean এবং আদর্শ বিচ্যুতি standardDeviation সহ একটি সাধারণ বন্টন অনুসরণ করে, ব্যতীত যে মানগুলি গড় থেকে দুটি আদর্শ বিচ্যুতির বেশি সেগুলি বাদ দেওয়া হয় এবং পুনরায় নমুনা করা হয়।

    ঘোষণা

    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] যার অভ্যন্তরীণ-সবচেয়ে বেশি 2 মাত্রা বর্গাকার ম্যাট্রিক্স গঠন করে।

    ইনপুট হতে হবে প্রতিসম এবং ইতিবাচক সুনির্দিষ্ট। এই অপারেশনের জন্য ইনপুটের শুধুমাত্র নিম্ন-ত্রিভুজাকার অংশ ব্যবহার করা হবে। উপরের-ত্রিভুজাকার অংশ পড়া হবে না।

    আউটপুট সমস্ত ইনপুট সাবমেট্রিসের জন্য চোলেস্কি পচন ধারণকারী ইনপুটের মতো একই আকারের একটি টেনসর [..., :, :] ।

    ঘোষণা

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

    পরামিতি

    input

    আকৃতির একটি টেনসর [..., M, M] ।

  • Ax = b দ্বারা উপস্থাপিত রৈখিক সমীকরণের সিস্টেমে সমাধান x ফিরিয়ে দেয়।

    পূর্বশর্ত

    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

    ডানদিকের মানগুলি, Ax = b তে b প্রতিনিধিত্ব করে।

    lower

    matrix নিম্ন ত্রিভুজাকার ( true ) বা উপরের ত্রিভুজাকার ( false ) কিনা। প্রচলিত মূল্য true .

    adjoint

    true হলে, matrix পরিবর্তে matrix সন্নিবেশ দিয়ে সমাধান করুন। ডিফল্ট মান false .

    ফেরত মূল্য

    Ax = b দ্বারা উপস্থাপিত রৈখিক সমীকরণের সিস্টেমের সমাধান x । x আকৃতি b এর মতই আছে।

  • expected এবং predicted মধ্যে L1 ক্ষতি গণনা করে। 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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

  • expected এবং predicted মধ্যে L2 ক্ষতি গণনা করে। 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

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

  • লেবেল এবং ভবিষ্যদ্বাণীগুলির মধ্যে ত্রুটির বর্গক্ষেত্রের গড় গণনা করে৷ 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

    প্রত্যাশিত মান, অর্থাৎ লক্ষ্য, যা সঠিক আউটপুটের সাথে মিলে যায়।

  • 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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

  • 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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

  • ভবিষ্যদ্বাণী ত্রুটির হাইপারবোলিক কোসাইনের লগারিদম গণনা করে। 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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

  • পূর্বাভাসিত এবং প্রত্যাশিত মধ্যে Poisson ক্ষতি গণনা করে Poisson ক্ষতি হল 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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

  • expected এবং predicted মধ্যে Kullback-Leibler ডাইভারজেন্স ক্ষতি গণনা করে। 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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

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

    কম্পিউটেড উপাদান-ভিত্তিক ক্ষতির মানগুলিতে প্রয়োগের জন্য হ্রাস।

  • predicted এবং expected মধ্যে Huber ক্ষতি গণনা.

    প্রতিটি মানের জন্য x error = expected - predicted :

    ঘোষণা

    @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

  • নির্দিষ্ট টেনসর উপাদান-ভিত্তিক বেস-টু লগারিদম প্রদান করে।

    ঘোষণা

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

  • নির্দিষ্ট টেনসর উপাদান-ভিত্তিক বেস-টেন লগারিদম প্রদান করে।

    ঘোষণা

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

  • 1 + x উপাদান-ভিত্তিক লগারিদম প্রদান করে।

    ঘোষণা

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

  • একটি সংখ্যাগতভাবে স্থিতিশীল পদ্ধতি ব্যবহার করে 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

  • নির্দিষ্ট টেনসর এলিমেন্টের পাওয়ারে উত্থাপিত দুটি ফেরত দেয়।

    ঘোষণা

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

  • উল্লিখিত টেনসর উপাদানের শক্তিতে দশটি উত্থাপিত করে।

    ঘোষণা

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

  • 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

  • নির্দিষ্ট টেনসর উপাদান-ভিত্তিক লগ-সিগময়েড প্রদান করে। বিশেষ করে, 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

  • নির্দিষ্ট অক্ষ বরাবর নির্দিষ্ট টেনসরের সফটম্যাক্স প্রদান করে। বিশেষ করে, exp(x) / exp(x).sum(alongAxes: axis) গণনা করে।

    ঘোষণা

    @differentiable
public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

  • নির্দিষ্ট টেনসর উপাদান-ভিত্তিক লগ-সফটম্যাক্স প্রদান করে।

    ঘোষণা

    @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 * x^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

  • 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 ।

    সূত্র: “Searching for MobileNetV3” (Howard et al. 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 ।

    সূত্র: “Searching for MobileNetV3” (Howard et al. 2019) https://arxiv.org/abs/1905.02244

    ঘোষণা

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

  • মিশ অ্যাক্টিভেশন ফাংশন প্রয়োগ করে একটি টেনসর প্রদান করে, যথা x * tanh(softplus(x)) ।

    উত্স: "মিশ: একটি স্ব-নিয়ন্ত্রিত নন-মোনোটোনিক নিউরাল অ্যাক্টিভেশন ফাংশন" 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>

  • নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইড এবং প্যাডিং সহ একটি 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

    প্রসারণ ফ্যাক্টর।

  • নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইড এবং প্যাডিং সহ একটি 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

    ইনপুটের প্রতিটি মাত্রার জন্য প্রসারিত ফ্যাক্টর।

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

    পূর্বশর্ত

    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

    ইনপুটের প্রতিটি মাত্রার জন্য প্রসারিত ফ্যাক্টর।

  • নির্দিষ্ট ইনপুট, ফিল্টার, স্ট্রাইডস, প্যাডিং এবং ডাইলেশন সহ একটি 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-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

    অপারেশন জন্য প্যাডিং.

  • নির্দিষ্ট ফিল্টার মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 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

    অপারেশন জন্য প্যাডিং.

  • নির্দিষ্ট ফিল্টার মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 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

    অপারেশন জন্য প্যাডিং.

  • নির্দিষ্ট ফিল্টার মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 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

    অপারেশন জন্য প্যাডিং.

  • নির্দিষ্ট ফিল্টার মাপ, স্ট্রাইড এবং প্যাডিং সহ একটি 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

    অপারেশন জন্য প্যাডিং.

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

    দ্রষ্টব্য: 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 সেট করা হলে, গণনা গ্রাফে একটি ভগ্নাংশ ম্যাক্সপুল2ডি নোডের উপর পুনরাবৃত্তি করার সময় একটি নির্দিষ্ট পুলিং অঞ্চল ব্যবহার করা হবে।

    seed

    একটি ঐচ্ছিক Int64 । ডিফল্ট 0 . অ-শূন্য হিসাবে সেট করা হলে, প্রদত্ত বীজ দ্বারা এলোমেলো সংখ্যা জেনারেটর বীজ হয়।

    seed2

    একটি ঐচ্ছিক Int64 । ডিফল্ট 0 . একটি দ্বিতীয় বীজ বীজ সংঘর্ষ এড়াতে.

  • 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

  • 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

  • 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

  • একটি SGD ভিত্তিক প্রতি-ওজন অপ্টিমাইজার তৈরি করে।

    ঘোষণা

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

  • ওজন ক্ষয় সহ অ্যাডামের জন্য প্রতি-ওজন অপ্টিমাইজার তৈরি করে।

    রেফারেন্স: "আডাম - স্টোকাস্টিক অপ্টিমাইজেশানের জন্য একটি পদ্ধতি"

    ঘোষণা

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

  • 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

  • ঘোষণা

    public func PrintX10Metrics()

  • প্রশিক্ষণ এবং পরীক্ষার পরিসংখ্যানের একটি তালিকার একটি স্ট্রিং সারাংশ তৈরি করে।

    ঘোষণা

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

  • ঘোষণা

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

  • n থ্রেডের উপরে একটি ফাংশন ম্যাপ করে।

    ঘোষণা

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