flux tenseur :: portion

Sommaire

Typedefs

LoaderSource en utilisant
Source < std::unique_ptr< Loader >>
StoragePathSourceAdapter en utilisant
SourceAdapter < StoragePath, std::unique_ptr< Loader >>

Les fonctions

DEFINE_CLASS_REGISTRY (StoragePathSourceAdapterRegistry, StoragePathSourceAdapter )
operator!= (const Loader::Metadata & a, const Loader::Metadata & b)
bool
operator!= (const ServableStateSnapshot< T > & a, const ServableStateSnapshot< T > & b)
bool
operator!= (const ServableHandle < T > & l, const ServableHandle < U > & r)
constexpr bool
operator!= (const ServableStateMonitor::ServableStateAndTime & a, const ServableStateMonitor::ServableStateAndTime & b)
bool
operator<< (std::ostream & os, LoaderHarness::State state)
std::ostream &
operator<< (std::ostream & os, const ServableStateMonitor::ServableStateAndTime & state_and_time)
std::ostream &
operator== (const AspiredVersionPolicy::ServableAction & lhs, const AspiredVersionPolicy::ServableAction & rhs)
bool
operator== (const Loader::Metadata & a, const Loader::Metadata & b)
bool
operator== (const ServableStateSnapshot< T > & a, const ServableStateSnapshot< T > & b)
bool
operator== (const ServableHandle < T > & l, const ServableHandle < U > & r)
constexpr bool
operator== (const ServableStateMonitor::ServableStateAndTime & a, const ServableStateMonitor::ServableStateAndTime & b)
bool

Des classes

tensorflow :: servant :: AspiredVersionPolicy

Une interface pour la stratégie à appliquer pour la transition des versions utilisables dans un flux utilisable.

tensorflow :: servant :: AspiredVersionsManager

Un gestionnaire qui implémente l'API Target< Loader > qui utilise des rappels de versions aspirées pour dicter les versions utilisables à charger.

tensorflow :: servant :: AspiredVersionsManagerBuilder

Construit un AspiredVersionsManager avec des options et des sources qui lui sont connectées.

tensorflow :: servant :: BasicManager

Aide à gérer le cycle de vie des servables, y compris leur chargement, leur service et leur déchargement.

tensorflow :: service :: CachingManager

Un gestionnaire qui gère et charge les servables à la demande.

tensorflow :: servant :: ClassifierInterface

Interface agnostique de type modèle pour effectuer la classification.

tensorflow :: servant :: ErrorInjectingSourceAdapter
tensorflow :: servant :: FileSystemStoragePathSource

Une source de chemin de stockage qui aspire des versions pour un ensemble donné de servables.

tensorflow :: service :: chargeur

Une abstraction standardisée pour un objet qui gère le cycle de vie d'un servable, y compris son chargement et son déchargement.

tensorflow :: servant :: LoaderHarness

LoaderHarness est un widget que le Manager utilise pour s'accrocher et parler à un Loader tant qu'il le possède.

tensorflow :: service :: gestionnaire

Le gestionnaire est responsable du chargement, du déchargement, de la recherche et de la gestion de la durée de vie de tous les objets utilisables via leurs chargeurs.

tensorflow :: servant :: PathPrefixLoaderFactory

Une LoaderFactory simple qui recherche un servable sur un chemin formé en concaténant un préfixe de chemin fixe avec le nom du servable.

tensorflow :: servant :: RegressorInterface

Interface indépendante du modèle pour effectuer la régression.

tensorflow :: servant :: ResourceUnsafeLoader

Un Loader qui est inconscient des ressources.

tensorflow :: servant :: SavedModelBundleFactory

Une fabrique qui crée des SavedModelBundles à partir des chemins d'exportation SavedModel ou SessionBundle.

tensorflow :: service :: ServableHandle

Un pointeur intelligent vers l'objet servable sous-jacent T récupéré à partir du Loader .

tensorflow :: servant :: ServableStateMonitor

Un utilitaire qui écoute un EventBus<ServableState> et garde une trace de l'état de chaque servable mentionné sur le bus.

tensorflow :: servant :: ServerCore

ServerCore contient des méthodes d'état et d'assistance permettant la construction de ModelServers prenant en charge plusieurs interfaces.

tensorflow :: service :: ServingSession

Une session qui bloque les méthodes de changement d'état telles que Close(), tout en autorisant Run() pour un accès en lecture seule (non appliqué).

tensorflow :: service :: ServingSessionWrapper

Une ServingSession qui encapsule une session donnée et bloque tous les appels autres que Run().

tensorflow :: servant :: SharedPtrHandle

Une implémentation de UntypedServableHandle utilisant shared_ptr pour effectuer le comptage de références sur le Loader qui possède le Servable.

tensorflow :: servant :: Source

Une abstraction pour un module qui source les servables à charger, ou, plus précisément, gère les données qui peuvent être utilisées pour charger ces servables.

tensorflow :: servant :: SourceAdapter

Une abstraction pour un module qui reçoit des rappels de version aspirée avec des données de type InputType et les convertit en appels avec des données de type OutputType.

tensorflow :: servant :: UnarySourceAdapter
tensorflow :: servant :: UntypedServableHandle

Descripteur non modélisé d'un servable, utilisé en interne dans le gestionnaire pour récupérer un objet servable dont le type a été effacé à partir du Loader .

Structures

tensorflow :: servant :: AspiredServableStateSnapshot

Un instantané de l'état et des aspirations d'un servable.

tensorflow :: servant :: ServableRequest

Une requête pour un objet servable chargé spécifique.

tensorflow :: servant :: ServableStateSnapshot

Espaces de noms

tensorflow :: servant :: interne
tensorflow :: servant :: test_util

Typedefs

LoaderSource

Source< std::unique_ptr< Loader >> LoaderSource

StoragePathSourceAdapter StoragePathSourceAdapter

SourceAdapter< StoragePath, std::unique_ptr< Loader >> StoragePathSourceAdapter

Les fonctions

DEFINE_CLASS_REGISTRY

 DEFINE_CLASS_REGISTRY(
  StoragePathSourceAdapterRegistry,
  StoragePathSourceAdapter
)

opérateur !=

bool operator!=(
  const Loader::Metadata & a,
  const Loader::Metadata & b
)

opérateur !=

bool operator!=(
  const ServableStateSnapshot< T > & a,
  const ServableStateSnapshot< T > & b
)

opérateur !=

constexpr bool operator!=(
  const ServableHandle< T > & l,
  const ServableHandle< U > & r
)

opérateur !=

bool operator!=(
  const ServableStateMonitor::ServableStateAndTime & a,
  const ServableStateMonitor::ServableStateAndTime & b
)

opérateur

std::ostream & operator<<(
  std::ostream & os,
  LoaderHarness::State state
)

opérateur

std::ostream & operator<<(
  std::ostream & os,
  const ServableStateMonitor::ServableStateAndTime & state_and_time
)

opérateur==

bool operator==(
  const AspiredVersionPolicy::ServableAction & lhs,
  const AspiredVersionPolicy::ServableAction & rhs
)

opérateur==

bool operator==(
  const Loader::Metadata & a,
  const Loader::Metadata & b
)

opérateur==

bool operator==(
  const ServableStateSnapshot< T > & a,
  const ServableStateSnapshot< T > & b
)

opérateur==

constexpr bool operator==(
  const ServableHandle< T > & l,
  const ServableHandle< U > & r
)

opérateur==

bool operator==(
  const ServableStateMonitor::ServableStateAndTime & a,
  const ServableStateMonitor::ServableStateAndTime & b
)