स्विफ्ट फॉर टेन्सरफ्लो पायथन इंटरऑपरेबिलिटी का समर्थन करता है।
आप स्विफ्ट से पायथन मॉड्यूल आयात कर सकते हैं, पायथन फ़ंक्शंस को कॉल कर सकते हैं और स्विफ्ट और पायथन के बीच मान परिवर्तित कर सकते हैं।
import PythonKit
print(Python.version)
3.6.9 (default, Oct 8 2020, 12:12:24) [GCC 8.4.0]
पायथन संस्करण सेट करना
डिफ़ॉल्ट रूप से, जब आप import Python
, तो स्विफ्ट इंस्टॉल किए गए पायथन के नवीनतम संस्करण के लिए सिस्टम लाइब्रेरी पथ खोजता है। एक विशिष्ट पायथन इंस्टॉलेशन का उपयोग करने के लिए, PYTHON_LIBRARY
पर्यावरण चर को इंस्टॉलेशन द्वारा प्रदान की गई libpython
साझा लाइब्रेरी पर सेट करें। उदाहरण के लिए:
export PYTHON_LIBRARY="~/anaconda3/lib/libpython3.7m.so"
सटीक फ़ाइल नाम पायथन परिवेश और प्लेटफ़ॉर्म पर भिन्न होगा।
वैकल्पिक रूप से, आप PYTHON_VERSION
पर्यावरण चर सेट कर सकते हैं, जो स्विफ्ट को मिलान वाले पायथन संस्करण के लिए सिस्टम लाइब्रेरी पथ खोजने का निर्देश देता है। ध्यान दें कि PYTHON_LIBRARY
PYTHON_VERSION
से अधिक प्राथमिकता दी जाती है।
कोड में, आप PythonLibrary.useVersion
फ़ंक्शन को भी कॉल कर सकते हैं, जो PYTHON_VERSION
सेट करने के बराबर है।
// PythonLibrary.useVersion(2)
// PythonLibrary.useVersion(3, 7)
ध्यान दें: आपको किसी भी पायथन कोड को कॉल करने से पहले, import Python
ठीक बाद PythonLibrary.useVersion
चलाना चाहिए। इसका उपयोग पायथन संस्करणों को गतिशील रूप से स्विच करने के लिए नहीं किया जा सकता है।
पायथन लाइब्रेरी लोडिंग के लिए डिबग आउटपुट देखने के लिए PYTHON_LOADER_LOGGING=1
सेट करें।
मूल बातें
स्विफ्ट में, PythonObject
Python से एक ऑब्जेक्ट का प्रतिनिधित्व करता है। सभी Python API PythonObject
इंस्टेंसेस का उपयोग करते हैं और उन्हें लौटाते हैं।
स्विफ्ट में मूल प्रकार (जैसे संख्याएँ और सरणियाँ) PythonObject
में परिवर्तनीय हैं। कुछ मामलों में ( PythonConvertible
तर्क लेने वाले शाब्दिक और कार्यों के लिए), रूपांतरण अंतर्निहित रूप से होता है। स्विफ्ट मान को PythonObject
पर स्पष्ट रूप से डालने के लिए, PythonObject
इनिशियलाइज़र का उपयोग करें।
PythonObject
संख्यात्मक संचालन, अनुक्रमण और पुनरावृत्ति सहित कई मानक संचालन को परिभाषित करता है।
// Convert standard Swift types to Python.
let pythonInt: PythonObject = 1
let pythonFloat: PythonObject = 3.0
let pythonString: PythonObject = "Hello Python!"
let pythonRange: PythonObject = PythonObject(5..<10)
let pythonArray: PythonObject = [1, 2, 3, 4]
let pythonDict: PythonObject = ["foo": [0], "bar": [1, 2, 3]]
// Perform standard operations on Python objects.
print(pythonInt + pythonFloat)
print(pythonString[0..<6])
print(pythonRange)
print(pythonArray[2])
print(pythonDict["bar"])
4.0 Hello slice(5, 10, None) 3 [1, 2, 3]
// Convert Python objects back to Swift.
let int = Int(pythonInt)!
let float = Float(pythonFloat)!
let string = String(pythonString)!
let range = Range<Int>(pythonRange)!
let array: [Int] = Array(pythonArray)!
let dict: [String: [Int]] = Dictionary(pythonDict)!
// Perform standard operations.
// Outputs are the same as Python!
print(Float(int) + float)
print(string.prefix(6))
print(range)
print(array[2])
print(dict["bar"]!)
4.0 Hello 5..<10 3 [1, 2, 3]
PythonObject
कई मानक स्विफ्ट प्रोटोकॉल के अनुरूपता को परिभाषित करता है:
-
Equatable
-
Comparable
-
Hashable
-
SignedNumeric
-
Strideable
-
MutableCollection
- सभी
ExpressibleBy_Literal
प्रोटोकॉल
ध्यान दें कि ये अनुरूपताएं प्रकार-सुरक्षित नहीं हैं: यदि आप असंगत PythonObject
उदाहरण से प्रोटोकॉल कार्यक्षमता का उपयोग करने का प्रयास करते हैं तो क्रैश हो जाएगा।
let one: PythonObject = 1
print(one == one)
print(one < one)
print(one + one)
let array: PythonObject = [1, 2, 3]
for (i, x) in array.enumerated() {
print(i, x)
}
True False 2 0 1 1 2 2 3
टुपल्स को पायथन से स्विफ्ट में बदलने के लिए, आपको सांख्यिकीय रूप से टुपल की क्षमता पता होनी चाहिए।
निम्नलिखित इंस्टेंस विधियों में से किसी एक को कॉल करें:
-
PythonObject.tuple2
-
PythonObject.tuple3
-
PythonObject.tuple4
let pythonTuple = Python.tuple([1, 2, 3])
print(pythonTuple, Python.len(pythonTuple))
// Convert to Swift.
let tuple = pythonTuple.tuple3
print(tuple)
(1, 2, 3) 3 (1, 2, 3)
पायथन बिल्डिंस
वैश्विक Python
इंटरफ़ेस के माध्यम से पायथन बिल्टिन तक पहुंचें।
// `Python.builtins` is a dictionary of all Python builtins.
_ = Python.builtins
// Try some Python builtins.
print(Python.type(1))
print(Python.len([1, 2, 3]))
print(Python.sum([1, 2, 3]))
<class 'int'> 3 6
पायथन मॉड्यूल आयात करना
Python मॉड्यूल आयात करने के लिए Python.import
उपयोग करें। यह Python
में import
कीवर्ड की तरह काम करता है।
let np = Python.import("numpy")
print(np)
let zeros = np.ones([2, 3])
print(zeros)
<module 'numpy' from '/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/numpy/__init__.py'> [[1. 1. 1.] [1. 1. 1.]]
सुरक्षित आयात करने के लिए थ्रोइंग फ़ंक्शन Python.attemptImport
का उपयोग करें।
let maybeModule = try? Python.attemptImport("nonexistent_module")
print(maybeModule)
nil
numpy.ndarray
के साथ रूपांतरण
निम्नलिखित स्विफ्ट प्रकारों को numpy.ndarray
में परिवर्तित किया जा सकता है:
-
Array<Element>
-
ShapedArray<Scalar>
-
Tensor<Scalar>
रूपांतरण तभी सफल होता है जब numpy.ndarray
का dtype
Element
या Scalar
जेनेरिक पैरामीटर प्रकार के साथ संगत है।
Array
के लिए, numpy
से रूपांतरण तभी सफल होता है जब numpy.ndarray
1-D हो।
import TensorFlow
let numpyArray = np.ones([4], dtype: np.float32)
print("Swift type:", type(of: numpyArray))
print("Python type:", Python.type(numpyArray))
print(numpyArray.shape)
Swift type: PythonObject Python type: <class 'numpy.ndarray'> (4,)
// Examples of converting `numpy.ndarray` to Swift types.
let array: [Float] = Array(numpy: numpyArray)!
let shapedArray = ShapedArray<Float>(numpy: numpyArray)!
let tensor = Tensor<Float>(numpy: numpyArray)!
// Examples of converting Swift types to `numpy.ndarray`.
print(array.makeNumpyArray())
print(shapedArray.makeNumpyArray())
print(tensor.makeNumpyArray())
// Examples with different dtypes.
let doubleArray: [Double] = Array(numpy: np.ones([3], dtype: np.float))!
let intTensor = Tensor<Int32>(numpy: np.ones([2, 3], dtype: np.int32))!
[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]
छवियाँ प्रदर्शित करना
आप पायथन नोटबुक की तरह, matplotlib
उपयोग करके छवियों को इन-लाइन प्रदर्शित कर सकते हैं।
// This cell is here to display plots inside a Jupyter Notebook.
// Do not copy it into another environment.
%include "EnableIPythonDisplay.swift"
print(IPythonDisplay.shell.enable_matplotlib("inline"))
('inline', 'module://ipykernel.pylab.backend_inline')
let np = Python.import("numpy")
let plt = Python.import("matplotlib.pyplot")
let time = np.arange(0, 10, 0.01)
let amplitude = np.exp(-0.1 * time)
let position = amplitude * np.sin(3 * time)
plt.figure(figsize: [15, 10])
plt.plot(time, position)
plt.plot(time, amplitude)
plt.plot(time, -amplitude)
plt.xlabel("Time (s)")
plt.ylabel("Position (m)")
plt.title("Oscillations")
plt.show()
Use `print()` to show values.