पायथन इंटरऑपरेबिलिटी

TensorFlow.org पर देखें GitHub पर स्रोत देखें

स्विफ्ट फॉर टेन्सरफ्लो पायथन इंटरऑपरेबिलिटी का समर्थन करता है।

आप स्विफ्ट से पायथन मॉड्यूल आयात कर सकते हैं, पायथन फ़ंक्शंस को कॉल कर सकते हैं और स्विफ्ट और पायथन के बीच मान परिवर्तित कर सकते हैं।

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.