אזהרה: פרויקט זה הוצא משימוש. Swift for TensorFlow היה ניסוי בפלטפורמת הדור הבא ללמידת מכונה, המשלבת את המחקר העדכני ביותר על פני למידת מכונה, מהדרים, תכנות שניתן להבדיל, עיצוב מערכות ומעבר לכך. זה הועבר לארכיון בפברואר 2021.

דף זה תורגם על ידי Cloud Translation API.

DifferentiableView

@frozen
public struct DifferentiableView

extension Array.DifferentiableView: Differentiable
where Element: Differentiable

extension Array.DifferentiableView: EuclideanDifferentiable
where Element: EuclideanDifferentiable

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

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

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

התצוגה של מערך כסעפת המוצר הניתנת להבדלה של Element מוכפלת עם עצמו פעמים count .

זמין כאשר 'אלמנט': 'ניתן להבדיל'

בסיס
המערך הנצפה.
הַצהָרָה
public var base: [Element] { get set }
init(_:)
יוצר תצוגה ניתנת להבדלה של המערך הנתון.
הַצהָרָה
public init(_ base: [Element])
init(_:)
הַצהָרָה
@derivative init(_: <<error type>>)

TangentVector

הַצהָרָה

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

התקדם:)

הַצהָרָה

public mutating mutating func move(along direction: TangentVector)

zeroTangentVectorInitializer
סגירה שמייצרת TangentVector של אפסים עם count זהה self .
הַצהָרָה
public var zeroTangentVectorInitializer: () -> TangentVector { get }

זמין כאשר 'אלמנט': 'EuclideanDifferentiable'

differentiableVectorView

הַצהָרָה

public var differentiableVectorView: Array.DifferentiableView.TangentVector { get }

זמין כאשר 'Element': 'Differentiable' & 'Equatable'

==(_:_:)

הַצהָרָה

public static func == (
  lhs: Array.DifferentiableView,
  rhs: Array.DifferentiableView
) -> Bool

זמין כאשר 'אלמנט': 'ניתן להבדיל'

init(arrayLiteral:)

הַצהָרָה

public init(arrayLiteral elements: Element...)

תיאור
הַצהָרָה
public var description: String { get }

זמין כאשר 'אלמנט': 'AdditiveArithmetic' ו'Differentiable'

אֶפֶס

הַצהָרָה

public static var zero: Array.DifferentiableView { get }

+(_:_:)

הַצהָרָה

public static func + (
  lhs: Array.DifferentiableView,
  rhs: Array.DifferentiableView
) -> Array.DifferentiableView

-(_:_:)

הַצהָרָה

public static func - (
  lhs: Array.DifferentiableView,
  rhs: Array.DifferentiableView
) -> Array.DifferentiableView

מנוי (_:)

הַצהָרָה

public subscript(index: Int) -> Element { get }

זמין כאשר 'אלמנט': 'ניתן להבדיל'

AllKeyPaths

הַצהָרָה

public typealias AllKeyPaths = [PartialKeyPath<Array.DifferentiableView>]

allKeyPaths

הַצהָרָה

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

זמין כאשר 'Element': 'Differentiable' & 'ElementaryFunctions'

sqrt(_:)
השורש הריבועי של x .
עבור טיפוסים אמיתיים, אם x הוא שלילי התוצאה היא .nan . עבור טיפוסים מורכבים יש חתך ענף על הציר האמיתי השלילי.
הַצהָרָה
public static func sqrt(_ x: `Self`) -> Array<Element>.DifferentiableView
חַסַת עָלִים(_:)
הקוסינוס של x , מתפרש כזווית ברדיאנים.
הַצהָרָה
public static func cos(_ x: `Self`) -> Array<Element>.DifferentiableView
חטא(_:)
הסינוס של x , מתפרש כזווית ברדיאנים.
הַצהָרָה
public static func sin(_ x: `Self`) -> Array<Element>.DifferentiableView
לְהִשְׁתַזֵף(_:)
הטנגנס של x , מתפרש כזווית ברדיאנים.
הַצהָרָה
public static func tan(_ x: `Self`) -> Array<Element>.DifferentiableView

acos(_:)

הקוסינוס ההפוך של x ברדיאנים.

הַצהָרָה

public static func acos(_ x: `Self`) -> Array<Element>.DifferentiableView

asin(_:)

הסינוס ההפוך של x ברדיאנים.

הַצהָרָה

public static func asin(_ x: `Self`) -> Array<Element>.DifferentiableView

שיזוף(_:)

הטנגנס ההפוך של x ברדיאנים.

הַצהָרָה

public static func atan(_ x: `Self`) -> Array<Element>.DifferentiableView

cosh(_:)

הקוסינוס ההיפרבולי של x .

הַצהָרָה

public static func cosh(_ x: `Self`) -> Array<Element>.DifferentiableView

sinh(_:)

הסינוס ההיפרבולי של x .

הַצהָרָה

public static func sinh(_ x: `Self`) -> Array<Element>.DifferentiableView

טן(_:)

הטנגנס ההיפרבולי של x .

הַצהָרָה

public static func tanh(_ x: `Self`) -> Array<Element>.DifferentiableView

acosh(_:)

הקוסינוס ההיפרבולי ההפוך של x .

הַצהָרָה

public static func acosh(_ x: `Self`) -> Array<Element>.DifferentiableView

asinh(_:)

הסינוס ההיפרבולי ההפוך של x .

הַצהָרָה

public static func asinh(_ x: `Self`) -> Array<Element>.DifferentiableView

atanh(_:)

הטנגנס ההיפרבולי ההפוך של x .

הַצהָרָה

public static func atanh(_ x: `Self`) -> Array<Element>.DifferentiableView

exp(_:)
הפונקציה המעריכית שהוחלה על x , או e**x .
הַצהָרָה
public static func exp(_ x: `Self`) -> Array<Element>.DifferentiableView

exp2(_:)

שניים מועלים לעוצמה x .

הַצהָרָה

public static func exp2(_ x: `Self`) -> Array<Element>.DifferentiableView

exp10(_:)

עשר מורם לעוצמה x .

הַצהָרָה

public static func exp10(_ x: `Self`) -> Array<Element>.DifferentiableView

expm1(_:)
exp(x) - 1 מוערך כדי לשמור על דיוק קרוב לאפס.
הַצהָרָה
public static func expm1(_ x: `Self`) -> Array<Element>.DifferentiableView

עֵץ(_:)

הלוגריתם הטבעי של x .

הַצהָרָה

public static func log(_ x: `Self`) -> Array<Element>.DifferentiableView

log2(_:)

הלוגריתם בסיס שניים של x .

הַצהָרָה

public static func log2(_ x: `Self`) -> Array<Element>.DifferentiableView

log10(_:)

הלוגריתם של בסיס עשר של x .

הַצהָרָה

public static func log10(_ x: `Self`) -> Array<Element>.DifferentiableView

log1p(_:)
log(1 + x) מוערך כדי לשמור על דיוק קרוב לאפס.
הַצהָרָה
public static func log1p(_ x: `Self`) -> Array<Element>.DifferentiableView
פאו(_:_:)
exp(y log(x)) מחושב ללא אובדן דיוק ביניים.
עבור טיפוסים אמיתיים, אם x הוא שלילי התוצאה היא NaN, גם אם y יש ערך אינטגרלי. עבור טיפוסים מורכבים, יש חתך ענף על הציר האמיתי השלילי.
הַצהָרָה
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>.DifferentiableView

פאו(_:_:)

x מוגדל בחזקת n .

המכפלה של n עותקים של x .

הַצהָרָה

public static func pow(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView

שורש(_:_:)
השורש ה- n של x .
עבור טיפוסים אמיתיים, אם x הוא שלילי ו- n זוגי, התוצאה היא NaN. עבור טיפוסים מורכבים, יש ענף חתוך לאורך הציר האמיתי השלילי.
הַצהָרָה
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView

זמין כאשר 'אלמנט': 'ניתן להבדיל'

אֵלֵמֶנט

הַצהָרָה

public typealias Element = Array<Element>.Element

אינדקס

הַצהָרָה

public typealias Index = Array<Element>.Index

מדדים

הַצהָרָה

public typealias Indices = Array<Element>.Indices

רצף משנה

הַצהָרָה

public typealias SubSequence = Array<Element>.SubSequence

מנוי (_:)

הַצהָרָה

public subscript(position: Array<Element>.Index) -> Element { get set }

startIndex
הַצהָרָה
public var startIndex: Index { get }
EndIndex
הַצהָרָה
public var endIndex: Index { get }
init()
הַצהָרָה
public init()

זמין כאשר 'Element': 'Differentiable' & 'VectorProtocol'

VectorSpaceScalar

הַצהָרָה

public typealias VectorSpaceScalar = Element.VectorSpaceScalar

מוֹסִיף(_:)

הַצהָרָה

public func adding(_ x: Element.VectorSpaceScalar) -> Array<Element>.DifferentiableView

לְהוֹסִיף(_:)

הַצהָרָה

public mutating mutating func add(_ x: Element.VectorSpaceScalar)

מְחַסֵר(_:)

הַצהָרָה

public func subtracting(_ x: Element.VectorSpaceScalar) -> Array<Element>.DifferentiableView

להחסיר(_:)

הַצהָרָה

public mutating mutating func subtract(_ x: Element.VectorSpaceScalar)

קנה מידה (לפי:)

הַצהָרָה

public func scaled(by scale: Element.VectorSpaceScalar) -> Array<Element>.DifferentiableView

קנה מידה (לפי:)

הַצהָרָה

public mutating mutating func scale(by scale: Element.VectorSpaceScalar)

זמין כאשר `Element`: `Differentiable` & `PointwiseMultiplitive`

אחד
הַצהָרָה
public static var one: `Self` { get }
הֲדָדִי
הַצהָרָה
public var reciprocal: `Self` { get }

.*(_:_:)

הַצהָרָה

public static func .* (lhs: `Self`, rhs: `Self`) -> Array<Element>.DifferentiableView

.*=(_:_:)

הַצהָרָה

public static func .*= (lhs: inout `Self`, rhs: `Self`)