चेतावनी: यह परियोजना बहिष्कृत है। TensorFlow के लिए स्विफ्ट मशीन लर्निंग के लिए अगली पीढ़ी के प्लेटफॉर्म में एक प्रयोग था, जिसमें मशीन लर्निंग, कंपाइलर, अलग-अलग प्रोग्रामिंग, सिस्टम डिज़ाइन और उससे आगे के नवीनतम शोध शामिल थे। इसे फरवरी 2021 में संग्रहीत किया गया था।

इस पेज का अनुवाद Cloud Translation API से किया गया है.

कैटगरी

extension Array: MutableCollectionAlgorithms

extension Array: KeyPathIterable

extension Array: Differentiable where Element: Differentiable

extension Array: EuclideanDifferentiable
where Element: EuclideanDifferentiable

extension Array : ConvertibleFromNumpyArray
where Element : NumpyScalarCompatible

extension Array where Element: Differentiable

10एन-

public extension Array where Element : NumpyScalarCompatible

extension Array: TensorArrayProtocol where Element: TensorGroup

extension Array : PythonConvertible where Element : PythonConvertible

प्लेसहोल्डर9 एल10एन-प्लेसहोल्डर10 एल10एन-प्लेसहोल्डर11 एल10एन-

extension Array: ElementaryFunctions where Element: ElementaryFunctions

extension Array : ConvertibleFromPython where Element : ConvertibleFromPython

extension Array where Element == Bool

extension Array where Element == Int64

extension Array where Element == XLATensor

extension Array where Element == UInt8

extension Array where Element: AnyTensor

extension Array where Element == PaddingConfigDimension

भिन्न-भिन्न दृश्य

Element के भिन्न-भिन्न उत्पाद के रूप में किसी सरणी का दृश्य अपने आप में count गुना बढ़ जाता है।

घोषणा

@frozen
public struct DifferentiableView

extension Array.DifferentiableView: EuclideanDifferentiable
where Element: EuclideanDifferentiable

extension Array.DifferentiableView: Differentiable
where Element: Differentiable

19 एल10

extension Array.DifferentiableView: Equatable
where Element: Differentiable & Equatable

extension Array.DifferentiableView: ExpressibleByArrayLiteral
where Element: Differentiable

extension Array.DifferentiableView: CustomStringConvertible
where Element: Differentiable

extension Array.DifferentiableView: AdditiveArithmetic
where Element: AdditiveArithmetic & Differentiable

extension Array.DifferentiableView: _KeyPathIterableBase
where Element: Differentiable

extension Array.DifferentiableView: KeyPathIterable
where Element: Differentiable

प्लेसहोल्डर26 एल10एन-प्लेसहोल्डर27 एल10एन-

extension Array.DifferentiableView: ElementaryFunctions
where Element: Differentiable & ElementaryFunctions

एल10एन-

extension Array.DifferentiableView:
  BidirectionalCollection,
  Collection,
  MutableCollection,
  RandomAccessCollection,
  RangeReplaceableCollection,
  Sequence
where Element: Differentiable

extension Array.DifferentiableView: VectorProtocol
where Element: Differentiable & VectorProtocol

extension Array.DifferentiableView: PointwiseMultiplicative
where Element: Differentiable & PointwiseMultiplicative

AllKeyPaths

घोषणा

public typealias AllKeyPaths = [PartialKeyPath<Array>]

allKeyPaths

घोषणा

public var allKeyPaths: [PartialKeyPath<Array>] { get }

उपलब्ध है जहां `तत्व`: `विभेदीकरणीय`

स्पर्शरेखावेक्टर

घोषणा

public typealias TangentVector =
  Array<Element.TangentVector>.DifferentiableView

के साथ कदम:)

घोषणा

public mutating mutating func move(along direction: TangentVector)

जीरो टैंगेंट वेक्टर इनिशियलाइज़र
एक क्लोजर जो self के समान count के साथ शून्य का TangentVector उत्पन्न करता है।
घोषणा
public var zeroTangentVectorInitializer: () -> TangentVector { get }

उपलब्ध है जहां `एलिमेंट`: `यूक्लिडियनडिफ़रेंटिएबल`

भिन्न-भिन्न वेक्टर दृश्य
घोषणा
public var differentiableVectorView: TangentVector { get }

उपलब्ध है जहां `तत्व`: `विभेदीकरणीय`

init(दोहराते हुए:)
घोषणा
@derivative init(repeating: count)

भिन्न-भिन्न मानचित्र(_:)

घोषणा

@differentiable(wrt: self)
public func differentiableMap<Result: Differentiable>(
  _ body: @differentiable (Element) -> Result
) -> [Result]

भिन्न-भिन्न कम करें(_:_:)

घोषणा

@differentiable(wrt: (self, initialResult)
public func differentiableReduce<Result: Differentiable>(
  _ initialResult: Result,
  _ nextPartialResult: @differentiable (Result, Element) -> Result
) -> Result

उपलब्ध है जहां `तत्व`: `NumpyScalarCompatible`

init(सुन्न:)
निर्दिष्ट numpy.ndarray उदाहरण के समान आकार और स्केलर के साथ एक Array बनाता है।
शर्त लगाना
numpy पायथन पैकेज स्थापित होना चाहिए।
घोषणा
public init?(numpy numpyArray: PythonObject)
पैरामीटर
numpyArray
परिवर्तित करने के लिए numpy.ndarray उदाहरण।
प्रतिलाभ की मात्रा
numpyArray को Array में बदल दिया गया। यदि numpyArray 1-D नहीं है या संगत स्केलर dtype नहीं है, तो nil लौटाता है।
makeNumpyArray()
इस Array समान स्केलर के साथ एक 1-D numpy.ndarray उदाहरण बनाता है।
शर्त लगाना
numpy पायथन पैकेज स्थापित होना चाहिए।
घोषणा
func makeNumpyArray() -> PythonObject

उपलब्ध है जहां `तत्व`: `पायथन कन्वर्टिबल`

पायथनऑब्जेक्ट
घोषणा
public var pythonObject: PythonObject { get }

उपलब्ध है जहां `तत्व`: `ConvertibleFromPython`

इस में(_:)

घोषणा

public init?(_ pythonObject: PythonObject)

उपलब्ध है जहां `एलिमेंट`: `एलिमेंटरीफंक्शन`

sqrt(_:)
x का वर्गमूल.
वास्तविक प्रकारों के लिए, यदि x ऋणात्मक है तो परिणाम .nan है। जटिल प्रकारों के लिए ऋणात्मक वास्तविक अक्ष पर एक शाखा काटी जाती है।
घोषणा
public static func sqrt(_ x: `Self`) -> Array<Element>
क्योंकि(_:)
x की कोज्या, रेडियन में एक कोण के रूप में व्याख्या की गई।
घोषणा
public static func cos(_ x: `Self`) -> Array<Element>
पाप(_:)
x की ज्या, रेडियन में एक कोण के रूप में व्याख्या की गई।
घोषणा
public static func sin(_ x: `Self`) -> Array<Element>
तन(_:)
x की स्पर्शरेखा, रेडियन में एक कोण के रूप में व्याख्या की गई।
घोषणा
public static func tan(_ x: `Self`) -> Array<Element>
एकोस(_:)
रेडियन में x का व्युत्क्रम कोज्या.
घोषणा
public static func acos(_ x: `Self`) -> Array<Element>
के रूप में(_:)
रेडियन में x की व्युत्क्रम ज्या.
घोषणा
public static func asin(_ x: `Self`) -> Array<Element>
एक भूरा(_:)
रेडियन में x का व्युत्क्रम स्पर्शरेखा।
घोषणा
public static func atan(_ x: `Self`) -> Array<Element>
कोष(_:)
x की अतिपरवलयिक कोज्या।
घोषणा
public static func cosh(_ x: `Self`) -> Array<Element>
सिंह(_:)
x की अतिशयोक्तिपूर्ण ज्या।
घोषणा
public static func sinh(_ x: `Self`) -> Array<Element>
तनह(_:)
x की अतिशयोक्तिपूर्ण स्पर्शरेखा।
घोषणा
public static func tanh(_ x: `Self`) -> Array<Element>
एकोश(_:)
x की व्युत्क्रम अतिपरवलयिक कोज्या।
घोषणा
public static func acosh(_ x: `Self`) -> Array<Element>
असिन्ह(_:)
x की व्युत्क्रम अतिपरवलयिक ज्या।
घोषणा
public static func asinh(_ x: `Self`) -> Array<Element>
अतान्ह(_:)
x का व्युत्क्रम अतिशयोक्तिपूर्ण स्पर्शरेखा।
घोषणा
public static func atanh(_ x: `Self`) -> Array<Element>
क्स्प(_:)
घातीय फ़ंक्शन x , या e**x पर लागू होता है।
घोषणा
public static func exp(_ x: `Self`) -> Array<Element>
exp2(_:)
दो को घात x तक बढ़ाया गया।
घोषणा
public static func exp2(_ x: `Self`) -> Array<Element>
exp10(_:)
दस को x घात तक बढ़ाया गया।
घोषणा
public static func exp10(_ x: `Self`) -> Array<Element>
expm1(_:)
exp(x) - 1 का मूल्यांकन किया गया ताकि सटीकता को शून्य के करीब रखा जा सके।
घोषणा
public static func expm1(_ x: `Self`) -> Array<Element>
लकड़ी का लट्ठा(_:)
x का प्राकृतिक लघुगणक।
घोषणा
public static func log(_ x: `Self`) -> Array<Element>
लॉग2(_:)
x का आधार-दो लघुगणक।
घोषणा
public static func log2(_ x: `Self`) -> Array<Element>
लॉग10(_:)
x का आधार-दस लघुगणक।
घोषणा
public static func log10(_ x: `Self`) -> Array<Element>
लॉग1पी(_:)
log(1 + x) मूल्यांकन किया गया ताकि सटीकता को शून्य के करीब रखा जा सके।
घोषणा
public static func log1p(_ x: `Self`) -> Array<Element>
पाउ(_:_:)
exp(y log(x)) की गणना मध्यवर्ती परिशुद्धता के नुकसान के बिना की गई।
वास्तविक प्रकारों के लिए, यदि x ऋणात्मक है तो परिणाम NaN है, भले ही y का एक अभिन्न मान हो। जटिल प्रकारों के लिए, नकारात्मक वास्तविक अक्ष पर एक शाखा काटी जाती है।
घोषणा
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>
पाउ(_:_:)
x n घात तक बढ़ाया गया।
x की n प्रतियों का गुणनफल।
घोषणा
public static func pow(_ x: `Self`, _ n: Int) -> Array<Element>
जड़(_:_:)
x का n वाँ मूल।
वास्तविक प्रकारों के लिए, यदि x ऋणात्मक है और n सम है, तो परिणाम NaN है। जटिल प्रकारों के लिए, नकारात्मक वास्तविक अक्ष के साथ एक शाखा काटी जाती है।
घोषणा
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>

उपलब्ध है जहां `एलिमेंट`: `टेन्सरग्रुप`

init(_owning:count:)

घोषणा

public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int)

init(_handles:)

घोषणा

public init<C: RandomAccessCollection>(
  _handles: C
) where C.Element: _AnyTensorHandle

उपलब्ध है जहां `तत्व` == `UInt8`

sha1()
टिप्पणी
SHA1 हैश केवल 20 बाइट्स लंबा है और इसलिए लौटाए गए SIMD32<UInt8> के केवल पहले 20 बाइट्स गैर-शून्य हैं।
घोषणा
func sha1() -> SIMD32<UInt8>
sha512()
घोषणा
func sha512() -> SIMD64<UInt8>

उपलब्ध है जहां `एलिमेंट` == `बूल`

मर्जिंगमास्क(साथ:)
a || b की गणना करता है a || b तत्ववार जैसे कि हम दो मुखौटे एक साथ कर रहे थे।
घोषणा
public func mergingMask(with other: [Bool]) -> [Bool]

उपलब्ध है जहां `एलिमेंट` == `Int64`

withArrayRef(_:)

घोषणा

func withArrayRef<Result>(_ body: (Int64ArrayRef) throws -> Result) rethrows -> Result

उपलब्ध है जहां `एलिमेंट` == `XLAtensor`

withArrayRef(_:)

घोषणा

func withArrayRef<Result>(_ body: (OpaqueXLATensorArrayRef) throws -> Result) rethrows -> Result

उपलब्ध है जहां `एलिमेंट`: `AnyTensor`

withArrayRef(_:)

घोषणा

func withArrayRef<T, Result>(_ body: (OpaqueXLATensorArrayRef) throws -> Result) rethrows
  -> Result
where Element == Tensor<T>

उपलब्ध है जहां `एलिमेंट` == `पैडिंगकॉन्फिगडिमेंशन`

withArrayRef(_:)

घोषणा

func withArrayRef<Result>(_ body: (inout PaddingConfig) -> Result) -> Result

कैटगरी

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

पैरामीटर

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

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा

घोषणा