Struct gcp_client::google::cloud::ml::v1::TrainingInput

pub struct TrainingInput {
    pub scale_tier: i32,
    pub master_type: String,
    pub worker_type: String,
    pub parameter_server_type: String,
    pub worker_count: i64,
    pub parameter_server_count: i64,
    pub package_uris: Vec<String>,
    pub python_module: String,
    pub args: Vec<String>,
    pub hyperparameters: Option<HyperparameterSpec>,
    pub region: String,
    pub job_dir: String,
    pub runtime_version: String,
}

Represents input parameters for a training job.

Fields

scale_tier: i32

Required. Specifies the machine types, the number of replicas for workers and parameter servers.

master_type: String

Optional. Specifies the type of virtual machine to use for your training job's master worker.

The following types are supported:

standard

A basic machine configuration suitable for training simple models with small to moderate datasets.

large_model

A machine with a lot of memory, specially suited for parameter servers when your model is large (having many hidden layers or layers with very large numbers of nodes).

complex_model_s

A machine suitable for the master and workers of the cluster when your model requires more computation than the standard machine can handle satisfactorily.

complex_model_m

A machine with roughly twice the number of cores and roughly double the memory of complex_model_s.

complex_model_l

A machine with roughly twice the number of cores and roughly double the memory of complex_model_m.

standard_gpu

A machine equivalent to standard that also includes a GPU that you can use in your trainer.

complex_model_m_gpu

A machine equivalent to coplex_model_m that also includes four GPUs.

You must set this value when scaleTier is set to CUSTOM.

worker_type: String

Optional. Specifies the type of virtual machine to use for your training job's worker nodes.

The supported values are the same as those described in the entry for masterType.

This value must be present when scaleTier is set to CUSTOM and workerCount is greater than zero.

parameter_server_type: String

Optional. Specifies the type of virtual machine to use for your training job's parameter server.

The supported values are the same as those described in the entry for master_type.

This value must be present when scaleTier is set to CUSTOM and parameter_server_count is greater than zero.

worker_count: i64

Optional. The number of worker replicas to use for the training job. Each replica in the cluster will be of the type specified in worker_type.

This value can only be used when scale_tier is set to CUSTOM. If you set this value, you must also set worker_type.

parameter_server_count: i64

Optional. The number of parameter server replicas to use for the training job. Each replica in the cluster will be of the type specified in parameter_server_type.

This value can only be used when scale_tier is set to CUSTOM.If you set this value, you must also set parameter_server_type.

package_uris: Vec<String>

Required. The Google Cloud Storage location of the packages with the training program and any additional dependencies.

python_module: String

Required. The Python module name to run after installing the packages.

args: Vec<String>

Optional. Command line arguments to pass to the program.

hyperparameters: Option<HyperparameterSpec>

Optional. The set of Hyperparameters to tune.

region: String

Required. The Google Compute Engine region to run the training job in.

job_dir: String

Optional. A Google Cloud Storage path in which to store training outputs and other data needed for training. This path is passed to your TensorFlow program as the 'job_dir' command-line argument. The benefit of specifying this field is that Cloud ML validates the path for use in training.

runtime_version: String

Optional. The Google Cloud ML runtime version to use for training. If not set, Google Cloud ML will choose the latest stable version.

Implementations

impl TrainingInput

pub fn scale_tier(&self) -> ScaleTier

Returns the enum value of scale_tier, or the default if the field is set to an invalid enum value.

pub fn set_scale_tier(&mut self, value: ScaleTier)

Sets scale_tier to the provided enum value.

Trait Implementations

impl Clone for TrainingInput

fn clone(&self) -> TrainingInput

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrainingInput

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for TrainingInput

fn default() -> TrainingInput

Returns the "default value" for a type.

impl Message for TrainingInput

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message to a buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message with a length-delimiter to a buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    B: Buf,
    Self: Default, 

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    B: Buf,
    Self: Default, 

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<TrainingInput> for TrainingInput

fn eq(&self, other: &TrainingInput) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TrainingInput) -> bool

This method tests for !=.

impl StructuralPartialEq for TrainingInput