TFSlim models (Guild AI)
Project description
gpkg.slim.models
################
*TFSlim models (Guild AI)*
Models
######
images
======
*Generic images dataset*
Operations
^^^^^^^^^^
prepare

*Prepare images for training*
Flags
`````
**images**
*Directory containing images to prepare (required)*
**randomseed**
*Seed used for train/validation split (randomly generated)*
**valsplit**
*Percentage of images reserved for validation (30)*
inception
=========
*TFSlim Inception v1 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionresnetv2
===================
*TFSlim Inception ResNet v2 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionv2
============
*TFSlim Inception v2 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionv3
============
*TFSlim Inception v3 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionv4
============
*TFSlim Inception v4 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
mobilenet
=========
*TFSlim Mobilenet v1 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
mobilenetv21.4
================
*TFSlim Mobilenet v2 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
nasnetlarge
============
*TFSlim NASNet large classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
nasnetmobile
=============
*TFSlim NASNet mobile classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
pnasnetlarge
=============
*TFSlim PNASNet classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
pnasnetmobile
==============
*TFSlim PNASNet mobile classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnet101
==========
*TFSlim ResNet v1 101 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnet152
==========
*TFSlim ResNet v1 152 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnet50
=========
*TFSlim ResNet v1 50 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnetv2101
=============
*TFSlim ResNet v2 101 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnetv2152
=============
*TFSlim ResNet v2 152 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnetv250
============
*TFSlim ResNet v2 50 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
vgg16
======
*TFSlim VGG 16 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
vgg19
======
*TFSlim VGG 19 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
################
*TFSlim models (Guild AI)*
Models
######
images
======
*Generic images dataset*
Operations
^^^^^^^^^^
prepare

*Prepare images for training*
Flags
`````
**images**
*Directory containing images to prepare (required)*
**randomseed**
*Seed used for train/validation split (randomly generated)*
**valsplit**
*Percentage of images reserved for validation (30)*
inception
=========
*TFSlim Inception v1 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionresnetv2
===================
*TFSlim Inception ResNet v2 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionv2
============
*TFSlim Inception v2 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionv3
============
*TFSlim Inception v3 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
inceptionv4
============
*TFSlim Inception v4 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
mobilenet
=========
*TFSlim Mobilenet v1 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
mobilenetv21.4
================
*TFSlim Mobilenet v2 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
nasnetlarge
============
*TFSlim NASNet large classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
nasnetmobile
=============
*TFSlim NASNet mobile classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
pnasnetlarge
=============
*TFSlim PNASNet classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
pnasnetmobile
==============
*TFSlim PNASNet mobile classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnet101
==========
*TFSlim ResNet v1 101 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnet152
==========
*TFSlim ResNet v1 152 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnet50
=========
*TFSlim ResNet v1 50 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnetv2101
=============
*TFSlim ResNet v2 101 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnetv2152
=============
*TFSlim ResNet v2 152 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
resnetv250
============
*TFSlim ResNet v2 50 layer classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
vgg16
======
*TFSlim VGG 16 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
vgg19
======
*TFSlim VGG 19 classifier*
Operations
^^^^^^^^^^
evaluate

*Evaluate a trained model*
Flags
`````
**batchsize**
*Number of examples in each evaluated batch (100)*
**evalbatches**
*Number of batches to evaluate (all available)*
**step**
*Checkpoint step to evaluate (latest checkpoint)*
exportandfreeze

*Export an inference graph with checkpoint weights*
Flags
`````
**step**
*Checkpoint step to use for the frozen graph (latest checkpoint)*
finetune

*Finetune a trained model*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.0001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
label

*Classify an image using a trained model*
Flags
`````
**image**
*Path to image to classify (required)*
tflite

*Generate a TFLite file from a frozen graph*
Flags
`````
**outputformat**
*TF Lite output format (tflite)
Choices:
tflite
graphviz_dot
*
**quantized**
*Whether or not output arrays are quantized (no)
Choices:
yes
no
*
**quantizedinputs**
*Whether or not input arrays are quantized (no)
Choices:
yes
no
*
train

*Train model from scratch*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
transferlearn

*Train model using transfer learning*
Flags
`````
**autoscale**
*Adjust applicable flags for multiGPU systems (yes)
Set to 'no' to disable any flag value adjustments.
When this value is 'yes' (the default) the following flags are adjusted on
multiGPU systems:
 clones
 learningrate
`clones` is set to the number of available GPUs.
`learningrate` is adjusted by multiplying its specified value by the
number of GPUs.
Flags are not adjusted on single GPU or CPU only systems.
*
**batchsize**
*Number of examples in each training batch (32)*
**clones**
*Number of model clones (calculated)
This value is automatically set to the number of available GPUs if `auto
scale` is 'yes'.
When `autoscale` is 'no' this value can be increased from 1 to train the
model in parallel on multiple GPUs.
*
**learningrate**
*Initial learning rate (0.001)*
**learningratedecayepochs**
*Number of epochs after which learning rate decays (2.0)*
**learningratedecayfactor**
*Learning rate decay factor (0.94)*
**learningratedecaytype**
*Method used to decay the learning rate (exponential)
Choices:
exponential
fixed
polynomial
*
**learningrateend**
*Minimal learning rate used by polynomial learning rate decay (0.0001)*
**logsaveseconds**
*Frequency of log summary saves in seconds (60)*
**logsteps**
*Frequency of summary logs in steps (100)*
**modelsaveseconds**
*Frequency of model saves (checkpoints) in seconds (600)*
**optimizer**
*Optimizer used to train (rmsprop)
Choices:
adadelta
adagrad
adam
ftrl
momentum
rmsprop
sgd
*
**preprocessing**
*Preprocessing to use (default for model)*
**preprocessors**
*Number of preprocessing threads (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize the
preprocessor thread count for the system.
*
**readers**
*Number of parallel data readers (calculated)
This value is automatically set to logical CPU count / 2 if `autoscale`
is 'yes'.
When `autoscale` is 'no' this value can be set to optimize data reader
performance for the system.
*
**trainsteps**
*Number of steps to train (train indefinitely)*
**weightdecay**
*Decay on the model weights (4e05)*
Project details
Release history Release notifications  RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Filename, size  File type  Python version  Upload date  Hashes 

Filename, size gpkg.slim.models0.5.1py2.py3noneany.whl (7.6 kB)  File type Wheel  Python version py2.py3  Upload date  Hashes View 
Close
Hashes for gpkg.slim.models0.5.1py2.py3noneany.whl
Algorithm  Hash digest  

SHA256  63c29c501fa0f6220175599a79df3bd06ff21bc27aba6c096cac49459afc6b3e 

MD5  0480cf258d67c3ab3cc38e53a6bcb16b 

BLAKE2256  6e17917a705fd314d6ab01c23ae4d3204ecb41583a72866f641073490a37eb68 