Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

tensorflow :: servindo :: ServableStateMonitor

#include <servable_state_monitor.h>

Um utilitário que escuta um EventBus <ServableState> e controla o estado de cada serviço mencionado no barramento.

Resumo

O caso de uso pretendido é para rastrear os estados de servables em um Gerente .

Oferece uma interface para consultar os estados de serviço. Pode ser útil como base para painéis, bem como para testar um gerente.

IMPORTANTE: É necessário criar este monitor antes de arranjar para eventos a serem publicados no ônibus evento, por exemplo, dando o ônibus evento para um gerente .

Construtores e Destruidores

ServableStateMonitor (EventBus< ServableState > *bus, const Options & options)
~ServableStateMonitor ()

Tipos públicos

BoundedLog usando
std::deque< ServableStateAndTime >
NotifyFn usando
std::function< void(const ServableState &)>
ServableMap usando
std::map< ServableName, VersionMap >
ServableName usando
string
ServableSet usando
std::set< ServableName >
ServableStateNotifierFn usando
std::function< void(bool reached_goal_state, const std::map< ServableId, ServableState::ManagerState > &states_reached)>
Notifica quando todos os servables atingem o 'goal_state'.
Version usando
int64
VersionMap usando
std::map< Version, ServableStateAndTime, std::greater< Version >>

Funções públicas

ForgetUnloadedServableStates ()
void
Remove todas as versões de serviço do ServableMap cujos estados fizeram a transição para kEnd.
GetAllServableStates ()
ServableMap
Retorna os estados atuais de todas as versões rastreadas de todos os servables.
GetAvailableServableStates ()
ServableSet
GetBoundedLog ()
BoundedLog
Retorna o log limitado atual de eventos de estado de serviço tratados.
GetLiveServableStates ()
ServableMap
Retorna os estados atuais de todas as versões de todos os servables que não fizeram a transição para o estado ServableState :: ManagerState :: kEnd.
GetState (const ServableId & servable_id)
optional< ServableState >
Retorna o estado atual de um serviço ou nullopt se esse serviço não está sendo rastreado.
GetStateAndTime (const ServableId & servable_id)
optional< ServableStateAndTime >
Retorna o estado e a hora atuais de um serviço ou nullopt se esse serviço não está sendo rastreado.
GetVersionStates (const string & servable_name)
VersionMap
Retorna os estados atuais de todas as versões rastreadas do serviço fornecido, se houver.
Notify (const NotifyFn & notify_fn)
void
NotifyWhenServablesReachState (const std::vector< ServableRequest > & servables, ServableState::ManagerState goal_state, const ServableStateNotifierFn & notifier_fn)
void
WaitUntilServablesReachState (const std::vector< ServableRequest > & servables, ServableState::ManagerState goal_state, std::map< ServableId, ServableState::ManagerState > *states_reached) TF_MUST_USE_RESULT
bool
Semelhante a NotifyWhenServablesReachState (...), mas em vez de notificar, esperamos até que 'goal_state' ou kEnd seja alcançado.

Structs

tensorflow :: servindo :: ServableStateMonitor :: Opções
tensorflow :: servindo :: ServableStateMonitor :: ServableStateAndTime

Tipos públicos

BoundedLog

std::deque< ServableStateAndTime > BoundedLog

NotifyFn

std::function< void(const ServableState &)> NotifyFn

ServableMap

std::map< ServableName, VersionMap > ServableMap

ServableName

string ServableName

ServableSet

std::set< ServableName > ServableSet

ServableStateNotifierFn

std::function< void(bool reached_goal_state, const std::map< ServableId, ServableState::ManagerState > &states_reached)> ServableStateNotifierFn

Notifica quando todos os servables atingem o 'goal_state'.

Os serviços podem ser especificados de duas maneiras:

  1. Como versões específicas de um nome de fluxo de serviço. Neste caso, verificamos se a versão específica atingiu o 'goal_state' ou o kEnd.
  2. Como versões mais recentes, neste caso, qualquer versão para um nome de fluxo de serviço será comparada com 'goal_state' ou kEnd.

Chamamos 'notifier_fn' quando ambas as condições são verdadeiras -

  1. Todas as solicitações de serviço específicas alcançaram 'goal_state' ou kEnd.
  2. Todas as solicitações de serviço mais recentes alcançaram 'goal_state' ou kEnd. O 'notifier_fn' será chamado apenas uma vez, e não repetidamente.

O argumento 'reach_goal_state' é definido como verdadeiro se todos os servables específicos alcançaram 'goal_state'. Portanto, os chamadores devem verificar se 'reach_goal_state' é verdadeiro no 'notifier_fn'.

O argumento 'states_reached' é preenchido com o id do servable e o estado que atingiu. O estado seria 'goal_state' se 'reach_goal_state' fosse verdadeiro, caso contrário, conterá um ou mais servables no estado kEnd. Para as solicitações de serviço mais recentes, o id de serviço será o id do serviço no fluxo que atingiu o estado.

Versão

int64 Version

VersionMap

std::map< Version, ServableStateAndTime, std::greater< Version >> VersionMap

Funções públicas

ForgetUnloadedServableStates

void ForgetUnloadedServableStates()

Remove todas as versões de serviço do ServableMap cujos estados fizeram a transição para kEnd.

GetAllServableStates

ServableMap GetAllServableStates()

Retorna os estados atuais de todas as versões rastreadas de todos os servables.

GetAvailableServableStates

ServableSet GetAvailableServableStates()

GetBoundedLog

BoundedLog GetBoundedLog()

Retorna o log limitado atual de eventos de estado de serviço tratados.

GetLiveServableStates

ServableMap GetLiveServableStates()

Retorna os estados atuais de todas as versões de todos os servables que não fizeram a transição para o estado ServableState :: ManagerState :: kEnd.

GetState

optional< ServableState > GetState(
  const ServableId & servable_id
)

Retorna o estado atual de um serviço ou nullopt se esse serviço não está sendo rastreado.

GetStateAndTime

optional< ServableStateAndTime > GetStateAndTime(
  const ServableId & servable_id
)

Retorna o estado e a hora atuais de um serviço ou nullopt se esse serviço não está sendo rastreado.

GetVersionStates

VersionMap GetVersionStates(
  const string & servable_name
)

Retorna os estados atuais de todas as versões rastreadas do serviço fornecido, se houver.

Notificar

void Notify(
  const NotifyFn & notify_fn
)

NotifyWhenServablesReachState

void NotifyWhenServablesReachState(
  const std::vector< ServableRequest > & servables,
  ServableState::ManagerState goal_state,
  const ServableStateNotifierFn & notifier_fn
)

ServableStateMonitor

 ServableStateMonitor(
  EventBus< ServableState > *bus,
  const Options & options
)

WaitUntilServablesReachState

bool WaitUntilServablesReachState(
  const std::vector< ServableRequest > & servables,
  ServableState::ManagerState goal_state,
  std::map< ServableId, ServableState::ManagerState > *states_reached
) TF_MUST_USE_RESULT

Semelhante a NotifyWhenServablesReachState (...), mas em vez de notificar, esperamos até que 'goal_state' ou kEnd seja alcançado.

Para entender o valor de retorno e o parâmetro de retorno 'states_reached', leia a documentação em NotifyWhenServablesReachState (...).

~ ServableStateMonitor

virtual  ~ServableStateMonitor()