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

tensorflow :: servindo :: BasicManager

Esta é uma classe abstrata.

#include <basic_manager.h>

Ajuda a gerenciar o ciclo de vida de serviços, incluindo carregamento, serviço e descarga.

Resumo

O gerenciador aceita serviços na forma de carregadores.

Começamos a gerenciar um servable por meio de um dos métodos ManageServable *. Depois disso, você pode carregar o servable chamando LoadServable () . O carregamento também tornará o servidor disponível para veiculação. Depois de decidir descarregá-lo, você pode chamar UnloadServable () nele, o que o tornará indisponível para servir e, em seguida, descarregar o servable.

Os serviços são retidos até que StopManagingServable () seja chamado. Isso permite que um gerente de nível superior com mais informações decida quando é seguro esquecer um serviço.

BasicManager rastreia os recursos (por exemplo, RAM) usados ​​pelos servables carregados e só permite o carregamento de novos servables que cabem no pool de recursos geral.

BasicManager pode ser configurado para usar um pool de threads para carregar e descarregar. Isso faz com que os métodos LoadServable () e UnloadServable () agendem o carregamento / descarregamento em vez de executá-los de forma síncrona. Se houver mais cargas / descargas pendentes do que encadeamentos no pool de encadeamentos, eles serão processados ​​na ordem FIFO.

Na presença de carregadores que superestimam as necessidades de recursos de seus servables e / ou apenas vinculam os recursos de seus servables a instâncias de dispositivo, a simultaneidade de carga / descarga pode ser reduzida abaixo do tamanho do pool de threads. Isso ocorre porque podemos ter que esperar o carregamento / descarregamento de um servable terminar para definir a disponibilidade de recursos para carregar outro servable.

REQUER:

  1. Ordem das chamadas de método - ManageServable () (e variantes) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
  2. Não agende carregamentos e descarregamentos simultâneos do mesmo serviço.
  3. Não chame load ou unload várias vezes no mesmo serviço.

Esta classe é segura para thread.

Exemplo de uso:

const ServableId id = {kServableName, 0};
std::unique_ptr<Loader> loader = ...;
...
BasicManager manager;
TF_CHECK_OK(manager.ManageServable(
  CreateServableData(id, std::move(loader))));
TF_CHECK_OK(manager.LoadServable(id));

...
TF_CHECK_OK(manager.GetServableHandle(
    ServableRequest::Latest(kServableName), &handle));
...

TF_CHECK_OK(manager.UnloadServable(id));
TF_CHECK_OK(manager.StopManagingServable(id));  

Herança

Herda de: tensorflow :: serving :: Manager

Construtores e Destruidores

~BasicManager ()
Se configurado para usar um pool de threads de carregamento / descarregamento, espera até que todas as cargas e descargas programadas tenham terminado e, em seguida, destrói o conjunto de threads.

Tipos públicos

DoneCallback usando
std::function< void(const Status &status)>
Retorno de chamada chamado no final de {Load, Unload} Servable ().
PreLoadHook usando
std::function< void(const ServableId &)>

Aulas de amigos

test_util::BasicManagerTestAccess
friend class

Funções estáticas públicas

Create ( Options options, std::unique_ptr< BasicManager > *manager)
Status

Funções públicas

CancelLoadServableRetry (const ServableId & id)
void
Cancela a nova tentativa de carregamento de serviço durante LoadServable () .
GetAdditionalServableState (const ServableId & id)
T *
GetAvailableUntypedServableHandles () const override
virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > >
GetManagedServableNames () const
std::vector< string >
GetManagedServableStateSnapshot (const ServableId & id)
optional< ServableStateSnapshot< T > >
GetManagedServableStateSnapshots (const string & servable_name) const
std::vector< ServableStateSnapshot< T > >
GetUntypedServableHandle (const ServableRequest & request, std::unique_ptr< UntypedServableHandle > *untyped_handle) override
virtual Status
ListAvailableServableIds () const override
virtual std::vector< ServableId >
Obtém uma lista de todos os IDs de serviço disponíveis, ou seja,
LoadServable (const ServableId & id, DoneCallback done_callback)
void
Carrega o servable com este id e atualiza o mapa de veiculação também.
ManageServable (ServableData< std::unique_ptr< Loader >> servable)
Status
Começa a gerenciar o servable.
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state)
Status
Semelhante ao método acima, mas os chamadores, geralmente outros gerenciadores construídos sobre este, podem associar um estado adicional ao servable.
StopManagingServable (const ServableId & id)
Status
Diz ao gerente para parar de gerenciar este serviço.
UnloadServable (const ServableId & id, DoneCallback done_callback)
void
Descarrega o servable com este id e atualiza o mapa de veiculação também.

Structs

tensorflow :: serving :: BasicManager :: Options

Opções de configuração e objetos conectáveis ​​que serão usados ​​pelo BasicManager .

Tipos públicos

DoneCallback

std::function< void(const Status &status)> DoneCallback

Retorno de chamada chamado no final de {Load, Unload} Servable ().

Passamos o status da operação para o callback.

PreLoadHook

std::function< void(const ServableId &)> PreLoadHook

Aulas de amigos

test_util :: BasicManagerTestAccess

friend class test_util::BasicManagerTestAccess

Funções estáticas públicas

Crio

Status Create(
  Options options,
  std::unique_ptr< BasicManager > *manager
)

Funções públicas

CancelLoadServableRetry

void CancelLoadServableRetry(
  const ServableId & id
)

Cancela a nova tentativa de carregamento de serviço durante LoadServable () .

Não faz nada se o serviço não for gerenciado.

Se as novas tentativas forem canceladas, o servable entra em um estado dependente do último Load () chamado nele. Se o último Load () foi bem-sucedido, ele estará no estado kReady, senão em kError.

GetAdditionalServableState

T * GetAdditionalServableState(
  const ServableId & id
)

REQUER: Este gerenciador já deveria estar gerenciando este servable, caso contrário, retornaremos nullptr.

Detalhes
Devoluções
o estado adicional para o serviço. Retorna nullptr se não houver configuração de estado adicional ou se houver uma incompatibilidade de tipo entre o que foi configurado e o que está sendo solicitado.

GetAvailableUntypedServableHandles

virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > > GetAvailableUntypedServableHandles() const override

GetManagedServableNames

std::vector< string > GetManagedServableNames() const 

Detalhes
Devoluções
os nomes de todos os servables gerenciados por este gerenciador. Os nomes estarão livres de duplicatas e não estarão em uma ordem específica.

GetManagedServableStateSnapshot

optional< ServableStateSnapshot< T > > GetManagedServableStateSnapshot(
  const ServableId & id
)

REQUER: Este gerenciador já deveria estar gerenciando este servable, caso contrário, retornaremos nullopt.

Detalhes
Devoluções
o instantâneo do estado de um determinado servable-id gerenciado por este gerenciador, se disponível.

GetManagedServableStateSnapshots

std::vector< ServableStateSnapshot< T > > GetManagedServableStateSnapshots(
  const string & servable_name
) const 

T é o tipo de estado adicional, se houver.

Detalhes
Devoluções
os instantâneos de estado de todos os servables de um determinado fluxo, gerenciados por este gerenciador.

GetUntypedServableHandle

virtual Status GetUntypedServableHandle(
  const ServableRequest & request,
  std::unique_ptr< UntypedServableHandle > *untyped_handle
) override

ListAvailableServableIds

virtual std::vector< ServableId > ListAvailableServableIds() const override

Obtém uma lista de todos os IDs de serviço disponíveis, ou seja,

cada um deles pode ser recuperado usando GetServableHandle.

LoadServable

void LoadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Carrega o servable com este id e atualiza o mapa de veiculação também.

Chama done_callback com ok iff o servable foi carregado com sucesso, caso contrário, retorna um status de erro.

Se estiver usando um pool de encadeamentos, este método faz a transição do arnês de serviço para o estado kLoading, agenda a carga e retorna, caso contrário, conclui a carga antes de retornar.

REQUER: Este gerenciador já deveria estar gerenciando este servable, para que ele seja carregado, senão chamaremos done_callback com um status de erro. Não chame isso várias vezes no mesmo serviço. Apenas um deles terá êxito e o restante falhará com um status de erro.

ManageServable

Status ManageServable(
  ServableData< std::unique_ptr< Loader >> servable
)

Começa a gerenciar o servable.

Retorna um erro se for fornecido um servable que já está sendo gerenciado.

Se o serviço estiver em um estado de erro, esse método não retornará um erro. Em vez disso, o gerenciador aceita o serviço, coloca-o no estado kError (com uma notificação enviada ao barramento de eventos) e, em seguida, para imediatamente de gerenciá-lo. Esse comportamento facilita o tratamento uniforme de erros que ocorrem nas fontes (por exemplo, caminho de arquivo inválido para dados de serviço) e aqueles que ocorrem no gerenciador (por exemplo, recursos insuficientes para carregar o serviço).

ManageServableWithAdditionalState

Status ManageServableWithAdditionalState(
  ServableData< std::unique_ptr< Loader >> servable,
  std::unique_ptr< T > additional_state
)

Semelhante ao método acima, mas os chamadores, geralmente outros gerenciadores construídos sobre este, podem associar um estado adicional ao servable.

O estado adicional pode ser ACL ou metadados vitalícios para esse serviço. A propriedade do estado é transferida para esta classe.

StopManagingServable

Status StopManagingServable(
  const ServableId & id
)

Diz ao gerente para parar de gerenciar este serviço.

Requer que o serviço esteja sendo gerenciado e que seu estado seja {kNew, kError, kDisabled}.

UnloadServable

void UnloadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Descarrega o servable com este id e atualiza o mapa de veiculação também.

Chama done_callback com ok iff o servable foi descarregado com sucesso, caso contrário, retorna um status de erro.

Se estiver usando um pool de encadeamentos, este método faz a transição do chicote de serviço para o estado kQuiescing, agenda o descarregamento e retorna, caso contrário, ele conclui o descarregamento antes de retornar.

REQUER: Este gerenciador deve ter carregado e disponibilizado este serviço, para que seja descarregado, senão chama done_callback com um status de erro. Não chame isso várias vezes no mesmo serviço. Apenas um deles terá êxito e o restante falhará com um status de erro.

~ BasicManager

 ~BasicManager() override

Se configurado para usar um pool de threads de carregamento / descarregamento, espera até que todas as cargas e descargas programadas tenham terminado e, em seguida, destrói o conjunto de threads.