रॉ टेन्सरफ्लो ऑपरेटर

TensorFlow पर निर्माण, TensorFlow के लिए स्विफ्ट एपीआई डिजाइन के लिए एक नया दृष्टिकोण लेता है। एपीआई को स्थापित पुस्तकालयों से सावधानीपूर्वक तैयार किया जाता है और नए भाषा मुहावरों के साथ जोड़ा जाता है। इसका मतलब यह है कि सभी TensorFlow API सीधे स्विफ्ट API के रूप में उपलब्ध नहीं होंगे, और हमारे API क्यूरेशन को विकसित करने के लिए समय और समर्पित प्रयास की आवश्यकता है। हालाँकि, यदि आपका पसंदीदा TensorFlow ऑपरेटर स्विफ्ट में उपलब्ध नहीं है, तो चिंता न करें - TensorFlow स्विफ्ट लाइब्रेरी आपको _Raw नेमस्पेस के तहत अधिकांश TensorFlow ऑपरेटरों तक पारदर्शी पहुंच प्रदान करती है।

आरंभ करने के लिए TensorFlow आयात करें।

import TensorFlow

कच्चे ऑपरेटरों को कॉल करना

कोड पूर्णता के माध्यम से _Raw नेमस्पेस के अंतर्गत आपको जिस फ़ंक्शन की आवश्यकता है उसे ढूंढें।

print(_Raw.mul(Tensor([2.0, 3.0]), Tensor([5.0, 6.0])))

[10.0, 18.0]

एक नए मल्टीप्ल ऑपरेटर को परिभाषित करना

मल्टीप्लाई पहले से ही Tensor पर ऑपरेटर * के रूप में उपलब्ध है, लेकिन आइए मान लें कि हम इसे .* के रूप में एक नए नाम के तहत उपलब्ध कराना चाहते थे। स्विफ्ट आपको extension घोषणाओं का उपयोग करके मौजूदा प्रकारों में विधियों या गणना की गई संपत्तियों को पूर्वव्यापी रूप से जोड़ने की अनुमति देता है।

अब, आइए एक एक्सटेंशन घोषित करके Tensor में .* जोड़ें और इसे तब उपलब्ध कराएं जब टेंसर का Scalar प्रकार Numeric के अनुरूप हो।

infix operator .* : MultiplicationPrecedence

extension Tensor where Scalar: Numeric {
    static func .* (_ lhs: Tensor, _ rhs: Tensor) -> Tensor {
        return _Raw.mul(lhs, rhs)
    }
}

let x: Tensor<Double> = [[1.0, 2.0], [3.0, 4.0]]
let y: Tensor<Double> = [[8.0, 7.0], [6.0, 5.0]]
print(x .* y)

[[ 8.0, 14.0],
 [18.0, 20.0]]

लपेटे गए फ़ंक्शन के व्युत्पन्न को परिभाषित करना

न केवल आप कच्चे टेन्सरफ्लो ऑपरेटर के लिए स्विफ्ट एपीआई को आसानी से परिभाषित कर सकते हैं, बल्कि आप इसे स्विफ्ट के प्रथम श्रेणी स्वचालित भेदभाव के साथ काम करने के लिए अलग-अलग भी बना सकते हैं।

.* को भिन्न बनाने के लिए, व्युत्पन्न फ़ंक्शन पर @derivative विशेषता का उपयोग करें और मूल फ़ंक्शन को of: लेबल के तहत एक विशेषता तर्क के रूप में निर्दिष्ट करें। चूंकि .* ऑपरेटर को तब परिभाषित किया जाता है जब सामान्य प्रकार Scalar Numeric के अनुरूप होता है, यह Tensor<Scalar> Differentiable प्रोटोकॉल के अनुरूप बनाने के लिए पर्याप्त नहीं है। प्रकार की सुरक्षा के साथ जन्मी, स्विफ्ट हमें Scalar TensorFlowFloatingPoint प्रोटोकॉल के अनुरूप बनाने के लिए @differentiable विशेषता पर एक सामान्य बाधा जोड़ने की याद दिलाएगी, जो Tensor<Scalar> को Differentiable के अनुरूप बनाएगी।

@differentiable(where Scalar: TensorFlowFloatingPoint)

infix operator .* : MultiplicationPrecedence

extension Tensor where Scalar: Numeric {
    @differentiable(where Scalar: TensorFlowFloatingPoint)
    static func .* (_ lhs: Tensor,  _ rhs: Tensor) -> Tensor {
        return _Raw.mul(lhs, rhs)
    }
}

extension Tensor where Scalar : TensorFlowFloatingPoint { 
    @derivative(of: .*)
    static func multiplyDerivative(
        _ lhs: Tensor, _ rhs: Tensor
    ) -> (value: Tensor, pullback: (Tensor) -> (Tensor, Tensor)) {
        return (lhs * rhs, { v in
            ((rhs * v).unbroadcasted(to: lhs.shape),
            (lhs * v).unbroadcasted(to: rhs.shape))
        })
    }
}

// Now, we can take the derivative of a function that calls `.*` that we just defined.
print(gradient(at: x, y) { x, y in
    (x .* y).sum()
})

(0.0, 0.0)

और ज्यादा उदाहरण

let matrix = Tensor<Float>([[1, 2], [3, 4]])

print(_Raw.matMul(matrix, matrix, transposeA: true, transposeB: true))
print(_Raw.matMul(matrix, matrix, transposeA: true, transposeB: false))
print(_Raw.matMul(matrix, matrix, transposeA: false, transposeB: true))
print(_Raw.matMul(matrix, matrix, transposeA: false, transposeB: false))

[[ 7.0, 15.0],
 [10.0, 22.0]]
[[10.0, 14.0],
 [14.0, 20.0]]
[[ 5.0, 11.0],
 [11.0, 25.0]]
[[ 7.0, 10.0],
 [15.0, 22.0]]