फैलाव2डी

@frozen
public struct Dilation2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

एक 2-डी रूपात्मक फैलाव परत

यह परत दिए गए फ़िल्टर के साथ इनपुट टेंसर के रूपात्मक फैलाव को लौटाती है

• फ़िल्टर
  4-डी फैलाव फिल्टर।

  घोषणा

  public var filter: Tensor<Scalar>

• प्रगति
  स्थानिक आयामों के लिए स्लाइडिंग विंडो के चरण।

  घोषणा

  @noDerivative
  public let strides: (Int, Int)

• गद्दी
  फैलाव के लिए पैडिंग एल्गोरिदम.

  घोषणा

  @noDerivative
  public let padding: Padding

• दरें
  स्थानिक आयामों के लिए फैलाव कारक.

  घोषणा

  @noDerivative
  public let rates: (Int, Int)

• init(फ़िल्टर: स्ट्राइड्स: दरें: पैडिंग:)
  निर्दिष्ट फ़िल्टर, स्ट्राइड्स, फैलाव और पैडिंग के साथ एक Dilation2D परत बनाता है।

  घोषणा

  public init(
    filter: Tensor<Scalar>,
    strides: (Int, Int) = (1, 1),
    rates: (Int, Int) = (1, 1),
    padding: Padding = .valid
  )

  पैरामीटर

  filter	आकार का 4-डी फैलाव फ़िल्टर [फ़िल्टर ऊंचाई, फ़िल्टर चौड़ाई, इनपुट चैनल गिनती, आउटपुट चैनल गिनती]।
  strides	स्थानिक आयामों के लिए स्लाइडिंग विंडो के स्ट्राइड्स, यानी (स्ट्राइड ऊंचाई, स्ट्राइड चौड़ाई)।
  rates	स्थानिक आयामों के लिए फैलाव दर, यानी (फैलाव ऊंचाई, फैलाव चौड़ाई)।
  padding	फैलाव के लिए पैडिंग एल्गोरिदम.

• आगे(_:)
  दिए गए इनपुट पर परत लगाने से प्राप्त आउटपुट लौटाता है।

  आउटपुट स्थानिक आयामों की गणना इस प्रकार की जाती है:

  आउटपुट ऊंचाई = (इनपुट ऊंचाई + 2 * पैडिंग ऊंचाई - (फैलाव ऊंचाई * (फ़िल्टर ऊंचाई - 1) + 1)) / स्ट्राइड ऊंचाई + 1

  आउटपुट चौड़ाई = (इनपुट चौड़ाई + 2 * पैडिंग चौड़ाई - (फैलाव चौड़ाई * (फ़िल्टर चौड़ाई - 1) + 1)) / स्ट्राइड चौड़ाई + 1

  और पैडिंग आकार पैडिंग योजना द्वारा निर्धारित किए जाते हैं।

  टिप्पणी

  .valid उपयोग करते समय पैडिंग का आकार शून्य के बराबर होता है।

  घोषणा

  @differentiable
  public func forward(_ input: Tensor<Scalar>) -> Tensor<Scalar>

  पैरामीटर

  input

  आकार की परत में इनपुट [बैच आकार, इनपुट ऊंचाई, इनपुट चौड़ाई, इनपुट चैनल गिनती]।

  प्रतिलाभ की मात्रा

  आकार का आउटपुट [बैच गिनती, आउटपुट ऊंचाई, आउटपुट चौड़ाई, आउटपुट चैनल गिनती]।