7 ডিসেম্বর এমএল সিম্পোজিয়ামে মহিলাদের অংশগ্রহণ করুন এখনই নিবন্ধন করুন৷

কার্যাদি

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

  • পূর্বাভাস এবং প্রত্যাশার মধ্যে 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 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

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

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

    ঘোষণা

    @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

    একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় withContext(_:_:) ফাংশন।

    ফেরত মূল্য

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

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

    ঘোষণা

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

    পরামিতি

    learningPhase

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

    body

    একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় withLearningPhase(_:_:) ফাংশন।

    ফেরত মূল্য

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

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

    ঘোষণা

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

    পরামিতি

    randomSeed

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

    body

    একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় withRandomSeedForTensorFlow(_:_:) ফাংশন।

    ফেরত মূল্য

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

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

    ঘোষণা

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

    পরামিতি

    randomNumberGenerator

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

    body

    একটি নালারী বন্ধ। অবসান একটি ফিরতি মূল্য থাকে, তাহলে যে মান এছাড়াও ফেরত মান হিসেবে ব্যবহার করা হয় withRandomNumberGeneratorForTensorFlow(_:_:) ফাংশন।

    ফেরত মূল্য

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

  • ঘোষণা

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • LazyTensorBarrier নিশ্চিত করে যে সমস্ত লাইভ টেন্সর (যদি ডিভাইসে থাকে) নির্ধারিত এবং চলমান থাকে। যদি প্রতীক্ষাকে সত্যে সেট করা হয়, গণনা সম্পূর্ণ না হওয়া পর্যন্ত এই কলটি বন্ধ হয়ে যায়।

    ঘোষণা

    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
  • একটি ফাংশনকে তার পুলব্যাকের মধ্যে পুনরায় গণনা করুন, যা traditionalতিহ্যগত স্বয়ংক্রিয় ভিন্নতায় "চেকপয়েন্টিং" নামে পরিচিত।

    ঘোষণা

    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
  • প্রদত্ত অবসান প্রয়োগ body থেকে x । যখন একটি প্রসঙ্গ যেখানে ব্যবহৃত x থেকে সম্মান সঙ্গে পৃথকীকৃত করা হচ্ছে, এই ফাংশন যে কোনো অমৌলিক উত্পাদন করা হবে না x

    ঘোষণা

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
  • একটি ক্লোসার এক্সিকিউট করে, TensorFlow অপারেশনগুলি একটি নির্দিষ্ট ধরনের ডিভাইসে চালায়।

    ঘোষণা

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

    পরামিতি

    kind

    TensorFlow অপারেশন চালানোর জন্য এক ধরনের ডিভাইস।

    index

    অপস চালানোর জন্য ডিভাইস।

    body

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

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

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

    • "/ডিভাইস: 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 অপারেশন নির্দিষ্ট ধরনের ডিভাইসে চালানো হবে।

  • 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 একটি অ্যান্টি-অ্যালায়েসিং ফিল্টার ব্যবহার করুন।

  • এলাকা ইন্টারপোলেশন ব্যবহার করে ছবির আকার পরিবর্তন করুন।

    পূর্বশর্ত

    চিত্র র্যাঙ্ক থাকতে হবে 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

    ছবিগুলির নতুন আকার।

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

    ঘোষণা

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • রিটার্নস একটি ফাংশন যে নির্দিষ্ট আকৃতি জন্য 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
  • একটি পরিচয় ম্যাট্রিক্স বা ম্যাট্রিক্সের একটি ব্যাচ প্রদান করে।

    ঘোষণা

    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 পচন প্রদান করে।

    ইনপুট আকৃতি একটি টেন্সর হয় [..., M, M] যার ভেতরের-পূর্বের 2 মাত্রা বর্গ ম্যাট্রিক্স গঠন করে।

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

    আউটপুট সমস্ত ইনপুট submatrices জন্য Cholesky decompositions ধারণকারী ইনপুট হিসাবে একই আকৃতি একটি টেন্সর হয় [..., :, :]

    ঘোষণা

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

    পরামিতি

    input

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

  • রিটার্নস সমাধান 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 = bx হিসাবে একই আকৃতি আছে b

  • এটি L1 কমে যাওয়ার মধ্যে নির্ণয় করে expected এবং predictedloss = 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 কমে যাওয়ার মধ্যে নির্ণয় করে expected এবং predictedloss = 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(_:) নেতিবাচক বাস্তব জন্য undefined করা হয়।

    ঘোষণা

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

    পরামিতি

    predicted

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

    expected

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

  • গড় পরম শতাংশ ত্রুটি মধ্যে নির্ণয় করে predicted এবং expectedloss = 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 এবং expectedloss = 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 এবং expectedloss = 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 এবং expectedloss = 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

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

  • পূর্বাভাস ও প্রত্যাশিত পইসন কমে যাওয়ার মধ্যে পইসন ক্ষতি নির্ণয় করে উপাদানের গড় 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

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

  • মধ্যে নির্ণয় Kullback-Leibler বিকিরণ ক্ষতি expected এবং predictedloss = 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

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

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

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

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

    জন্য প্রতিটি মান 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

    একটি ভাসমান বিন্দু স্কেলার যে বিন্দুকে প্রতিনিধিত্ব করে যেখানে হুবার লস ফাংশন চতুর্ভুজ থেকে রৈখিক পরিবর্তিত হয়।

    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 / π) * (এক্স + + 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
  • নির্দিষ্ট টেন্সর উপাদান অনুসারে লিকি রিলু অ্যাক্টিভেশন ফাংশন প্রয়োগ করে একটি টেন্সর প্রদান করে। বিশেষ করে, নির্ণয় max(x, x * alpha)

    ঘোষণা

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • রিটার্নস SeLU অ্যাক্টিভেশন ফাংশন প্রয়োগের দ্বারা একটি টেন্সর, যথা scale * alpha * (exp(x) - 1) যদি x < 0 , এবং scale * x অন্যথায়।

    বিঃদ্রঃ

    এটি ভেরিয়েন্স স্কেলিং লেয়ার ইনিশিয়ালাইজারের সাথে ব্যবহার করার জন্য ডিজাইন করা হয়েছে। পড়ুন দয়া করে নিজ স্বাভাবিক নিউরাল নেটওয়ার্ক আরও তথ্যের জন্য।

    ঘোষণা

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • রিটার্নস ফিটফাট অ্যাক্টিভেশন ফাংশন, যথা প্রয়োগের দ্বারা একটি টেন্সর x * sigmoid(x)

    উত্স: (। রামচন্দ্রন এট 2017) "অ্যাক্টিভেশন কার্যাবলী খুঁজছেন" https://arxiv.org/abs/1710.05941

    ঘোষণা

    @differentiable
    public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • রিটার্নস হার্ড সিগমা অ্যাক্টিভেশন ফাংশন, যথা প্রয়োগের দ্বারা একটি টেন্সর Relu6(x+3)/6

    উত্স: "MobileNetV3 খুঁজছেন।" (হাওয়ার্ড এট 2019) https://arxiv.org/abs/1905.02244

    ঘোষণা

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • রিটার্নস, হার্ড ফিটফাট অ্যাক্টিভেশন ফাংশন প্রয়োগের যথা দ্বারা একটি টেন্সর x * Relu6(x+3)/6

    উত্স: "MobileNetV3 খুঁজছেন।" (হাওয়ার্ড এট 2019) https://arxiv.org/abs/1905.02244

    ঘোষণা

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • রিটার্নস 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>
  • রিটার্নস মধ্যে কোসাইন দূরত্ব 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-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

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

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

    নোট: 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 । বীজের সংঘর্ষ এড়াতে দ্বিতীয় বীজ।

  • একটি কপি ফেরত পাঠায় 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
  • একটি কপি ফেরত পাঠায় 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
  • 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
  • Builds a SGD based per-weight optimizer.

    ঘোষণা

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • 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
  • Generates a new random seed for TensorFlow.

    ঘোষণা

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    ঘোষণা

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    ঘোষণা

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    ঘোষণা

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    ঘোষণা

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    ঘোষণা

    @differentiable
    public func stack<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • ঘোষণা

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    ঘোষণা

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
  • ঘোষণা

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    ঘোষণা

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