def test_flag_help_in_xml_enum_class(self):
class Version(enum.Enum):
STABLE = 0
EXPERIMENTAL = 1
flags.DEFINE_enum_class('cc_version', 'STABLE', Version,
'Compiler version to use.', flag_values=self.fv)
expected_output = ('<flag>\n'
' <file>tool</file>\n'
' <name>cc_version</name>\n'
' <meaning><stable|experimental>: '
'Compiler version to use.</meaning>\n'
' <default>stable</default>\n'
' <current>Version.STABLE</current>\n'
' <type>enum class</type>\n'
' <enum_value>STABLE</enum_value>\n'
' <enum_value>EXPERIMENTAL</enum_value>\n'
'</flag>\n')
self._check_flag_help_in_xml('cc_version', 'tool', expected_output)
import config
import time
import matplotlib.pyplot as plt
from dataset import build_dataset
from config import TrainMode
import pandas as pd
import cv2
from absl import app, flags, logging
from tqdm import tqdm
FLAGS = flags.FLAGS
flags.DEFINE_enum_class(
'train_mode',
default=TrainMode.ALL,
enum_class=TrainMode,
help="Select training mode, one of {'ALL', 'GAN', 'VAE'}")
# GAN functions.
seed = tf.random.normal([4, config.NZ])
generator = Generator().build()
discriminator = Discriminator().build()
inv_generator = invG().build()
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
generator_opt = tf.keras.optimizers.Adam(config.LR)
discriminator_opt = tf.keras.optimizers.Adam(config.LR)
from absl import app, flags
from enum import unique, Enum
from kazoo.client import KazooClient
from yolo3.utils import get_classes
@unique
class MODE(Enum):
STATUS = 1
CONFIG = 2
ZOOKEEPER = 3
FLAGS = flags.FLAGS
flags.DEFINE_enum_class("mode",
default=MODE.ZOOKEEPER,
enum_class=MODE,
help='exec mode')
flags.DEFINE_multi_string("addresses",
default=[
"10.12.102.32:8500", "10.12.102.33:8500",
"10.12.102.52:8500", "10.12.102.53:8500"
],
help='grpc servers address')
def get_config(*args):
return bytes('#'.join(str(arg) for arg in args), encoding="utf8")
def main(_):
if MODE.STATUS == FLAGS.mode:
import code_to_subtokenized_sentences
import tokenizer_registry
FLAGS = flags.FLAGS
flags.DEFINE_string('vocabulary_filepath', None,
'Path to the subword vocabulary.')
flags.DEFINE_string('input_filepath', None,
'Path to the Python source code file.')
flags.DEFINE_string('output_filepath', None,
'Path to the output file of subtokenized source code.')
flags.DEFINE_enum_class('tokenizer',
default=tokenizer_registry.TokenizerEnum.PYTHON,
enum_class=tokenizer_registry.TokenizerEnum,
help='The tokenizer to use.')
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
# The value of the `TokenizerEnum` is a `CuBertTokenizer` subclass.
tokenizer = FLAGS.tokenizer.value()
subword_tokenizer = text_encoder.SubwordTextEncoder(
FLAGS.vocabulary_filepath)
with open(FLAGS.input_filepath, 'r') as input_file:
code = input_file.read()
# print('#' * 80)
".tfrecord",
"Should be '.tfrecod' or '.txtpb'",
)
flags.DEFINE_string(
"vocab_file",
None,
"The vocabulary file that the BERT model was trained on.",
)
flags.DEFINE_bool(
"convert_to_examples",
True,
"If true convert interactions to examples.",
)
flags.DEFINE_enum_class(
"mode",
intermediate_pretrain_utils.Mode.ALL,
intermediate_pretrain_utils.Mode,
"Mode to run in.",
)
flags.DEFINE_integer(
"max_seq_length",
128,
"See tf_example_utils.ClassifierConversionConfig",
)
flags.DEFINE_boolean(
"use_fake_table",
False,
"Replace table with a constant.",
)
flags.DEFINE_boolean(
"add_opposite_table",
False,
"""Utilities for running beam pipelines."""
import enum
from absl import flags
from apache_beam import runners
from apache_beam.options import pipeline_options
from apache_beam.runners.direct import direct_runner
class RunnerType(enum.Enum):
DIRECT = 1
DATAFLOW = 2
flags.DEFINE_enum_class("runner_type", RunnerType.DIRECT, RunnerType,
"Runner type to use.")
# Google Cloud options.
# See https://beam.apache.org/get-started/wordcount-example/
flags.DEFINE_string("gc_project", None, "e.g. my-project-id")
# GC regions: https://cloud.google.com/compute/docs/regions-zones
flags.DEFINE_string("gc_region", None, "e.g. us-central1")
flags.DEFINE_string("gc_job_name", None, "e.g. myjob")
flags.DEFINE_string("gc_staging_location", None,
"e.g. gs://your-bucket/staging")
flags.DEFINE_string("gc_temp_location", None, "e.g. gs://your-bucket/temp")
flags.DEFINE_boolean("save_main_session", False,
"Useful when getting NameErrors from global imports.")
# Pass Tapas sources to GC.
# See https://beam.apache.org/documentation/sdks/python-pipeline-dependencies/
flags.DEFINE_list(
"extra_packages",
from typing import Sequence
from absl import app
from absl import flags
from squiggles import generate_data
_BASE_PATH = flags.DEFINE_string(
'base_path',
None,
'Output filename base (including directory path).',
required=True,
)
_SQUIGGLE_ALGORITHM = flags.DEFINE_enum_class(
'squiggle_algorithm',
generate_data.LatentSpace.UNDEFINED,
generate_data.LatentSpace,
'Which latent space to use to generate squiggles: "sine_net" or "taylor"',
)
_SAMPLES_PER_SHARD = flags.DEFINE_integer(
'samples_per_shard',
None,
'The number of squiggle examples to include in each shard.',
required=True,
)
_NUM_TRAIN_SHARDS = flags.DEFINE_integer(
'num_train_shards',
1,
'how many shards in the "train" split',
)
_NUM_TEST_SHARDS = flags.DEFINE_integer(
'num_test_shards',
tf.compat.v1.enable_eager_execution()
tf.compat.v1.enable_v2_behavior()
tf.compat.v1.enable_v2_tensorshape()
from yolo3.enums import BACKBONE, MODE, OPT
from train import train
from train_backbone import train as train_backbone
from yolo import YOLO, detect_video, detect_img, export_tflite_model, export_serving_model, calculate_map, export_tfjs_model
from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession
FLAGS = flags.FLAGS
flags.DEFINE_enum_class(
'backbone',
default=BACKBONE.MOBILENETV2,
enum_class=BACKBONE,
help=
"Select network backbone, One of {'MOBILENETV2','DARKNET53','EFFICIENTNET'}"
)
flags.DEFINE_integer('batch_size',
default=8,
lower_bound=0,
help="Train batch size")
flags.DEFINE_string('config', default=None, help="Config path")
flags.DEFINE_multi_integer('epochs',
default=[10, 10],
lower_bound=0,
help="Frozen train epochs and Full train epochs")
flags.DEFINE_string('export', default='export_model/8', help="Export path")
flags.DEFINE_string('input', default=None, help="Input data for various mode")
flags.DEFINE_multi_integer('input_size',
'Path to file defining a config dict.')
flags.DEFINE_integer(
'batch_size', default=128, help=('Batch size for training.'))
flags.DEFINE_bool('cache', default=False, help=('If True, cache the dataset.'))
flags.DEFINE_integer(
'num_epochs', default=250, help=('Number of training epochs.'))
flags.DEFINE_enum_class(
'lr_scheduler',
default=LRScheduler.COSINE,
enum_class=LRScheduler,
help=('Learning rate scheduler. Can be set to COSINE or STEP. '
'COSINE: Cosine decay, tuned to achieve target eval acc quickly. '
'STEP: Piecewise step decay, uses constant lr at every interval,'
' allowing loss to flatten out at each lr, and exponential'
' decay of lr throughout the intervals.'))
flags.DEFINE_bool(
'half_precision',
default=True,
help=('If bfloat16/float16 should be used instead of float32.'))
flags.DEFINE_integer(
'state_dict_summary_freq',
default=200,
help='Number of training steps between state dict summaries reported to '
flags.DEFINE_list('stoichiometries', [], 'List of stoichiometries to query')
flags.DEFINE_string(
'smarts', '',
'SMARTS query to retrieve molomers with matching bond topology. '
'Note that this is a single value, not a comma separated list')
flags.DEFINE_list(
'topology_query_smiles', [],
'List of smiles to query, where the valid bond lengths are '
'given by --bond_lengths_csv and --bond_lengths. '
'Will return all molecules where the given smiles is a '
'valid decsription of that geometry given the bond lengths. '
'If you are using the default bond lengths, you should just '
'use --smiles as this method is much slower.')
flags.DEFINE_float('random_fraction', 0.0,
'Randomly return this fraction of DB.')
flags.DEFINE_enum_class('output_format', OutputFormat.PBTXT, OutputFormat,
'Format for the found SMU entries')
flags.DEFINE_enum_class(
'which_topologies', smu_utils_lib.WhichTopologies.ALL,
smu_utils_lib.WhichTopologies, 'This flag has double duty. '
'For btids, smiles, and smarts queries, it specifies which topologies'
'to match. For sdf and atomic2_input output formats, it specifies which bond '
'topologies should be returned:\n '
'"all" means all topologies,\n '
'"best" means a single best topology,\n '
'"starting" means the single topology used for the calculations,\n '
'"itc" means all topologies detected with our original bond lengths,\n '
'"mlcr" means all topologies using very permissive covalent radii\n '
'(from Meng and Lewis), '
'"csd" means all topologies using bond lengths from the '
'Cambridge Structural Database')
flags.DEFINE_boolean(
from meta_dataset.data import utils
import tensorflow.compat.v1 as tf
tf.enable_eager_execution()
flags.DEFINE_multi_string('gin_config', None,
'List of paths to the config files.')
flags.DEFINE_multi_string('gin_bindings', None,
'List of Gin parameter bindings.')
flags.DEFINE_string('output_dir', '/tmp/cached_episodes/',
'Root directory for saving episodes.')
flags.DEFINE_integer('num_episodes', 600, 'Number of episodes to sample.')
flags.DEFINE_string('dataset_name', 'omniglot', 'Dataset name to create '
'episodes from.')
flags.DEFINE_enum_class('split', learning_spec.Split.TEST, learning_spec.Split,
'See learning_spec.Split for '
'allowed values.')
flags.DEFINE_boolean(
'ignore_dag_ontology', False, 'If True the dag ontology'
' for Imagenet dataset is not used.')
flags.DEFINE_boolean(
'ignore_bilevel_ontology', False, 'If True the bilevel'
' sampling for Omniglot dataset is not used.')
tf.flags.DEFINE_string(
'records_root_dir', '',
'Root directory containing a subdirectory per dataset.')
FLAGS = flags.FLAGS
def main(unused_argv):
logging.info(FLAGS.output_dir)
class Model(enum.Enum):
vae = enum.auto()
avae = enum.auto()
class EncoderArch(enum.Enum):
color_mnist_mlp_encoder = 'ColorMnistMLPEncoder'
class DecoderArch(enum.Enum):
color_mnist_mlp_decoder = 'ColorMnistMLPDecoder'
_DATASET = flags.DEFINE_enum_class('dataset',
data_iterators.Dataset.color_mnist,
data_iterators.Dataset,
'Dataset to train on')
_LATENT_DIM = flags.DEFINE_integer('latent_dim', 32,
'Number of latent dimensions.')
_TRAIN_BATCH_SIZE = flags.DEFINE_integer('train_batch_size', 64,
'Train batch size.')
_TEST_BATCH_SIZE = flags.DEFINE_integer('test_batch_size', 64,
'Testing batch size.')
_TEST_EVERY = flags.DEFINE_integer('test_every', 1000,
'Test every N iterations.')
_ITERATIONS = flags.DEFINE_integer('iterations', 102000,
'Number of training iterations.')
_OBS_VAR = flags.DEFINE_float(
'obs_var', 0.5, 'Observation variance of the data. (Default 0.5)')
_MODEL = flags.DEFINE_enum_class('model', Model.avae, Model,
flags.DEFINE_integer('malmo_base_port',
default=9001,
help='malmo base port (to prevent conflicts)')
flags.DEFINE_integer('train_seed', default=0, help='random seed for train')
flags.DEFINE_string('test_model',
default='impala',
help='which model to test (bc/impala)')
# env params:
flags.DEFINE_integer(
'max_step_mul',
default=40,
help='maximum step multiplier; > 0, 1 = no step multiplier')
flags.DEFINE_integer('pov_resolution', default=32, help='pov resolution')
flags.DEFINE_enum_class('pov_color_space',
default=ColorSpace.RGB,
enum_class=ColorSpace,
help='pov color space')
flags.DEFINE_integer('num_camera_actions',
default=3,
help='number of discrete camera actions (odd value!)')
flags.DEFINE_integer('camera_max_angle',
default=30,
help='max camera angle change in one direction')
flags.DEFINE_bool('fixed_step_mul',
default=False,
help='fixed step multiplier')
flags.DEFINE_integer('step_mul',
default=8,
help='step multiplier, if fixed_step_mul=True')
# model params:
from tensorflow_serving.apis import get_model_status_pb2, model_service_pb2_grpc, model_management_pb2
import grpc
from absl import app, flags
from enum import unique, Enum
@unique
class MODE(Enum):
STATUS = 1
CONFIG = 2
FLAGS = flags.FLAGS
flags.DEFINE_enum_class("mode",
default=MODE.STATUS,
enum_class=MODE,
help='exec mode')
flags.DEFINE_string("address",
default="10.12.102.32:8500",
help='grpc server address')
def main(_):
channel = grpc.insecure_channel(FLAGS.address)
stub = model_service_pb2_grpc.ModelServiceStub(channel)
if MODE.STATUS == FLAGS.mode:
request = get_model_status_pb2.GetModelStatusRequest()
request.model_spec.name = 'pascal'
request.model_spec.signature_name = 'serving_default'
result = stub.GetModelStatus(request)
"The number of training examples in one forward/backward pass.",
)
flags.DEFINE_float(
"base_learning_rate",
13e-4,
"The default rate at which weights are updated during training.",
)
flags.DEFINE_bool(
"add_self_attention",
True,
"Add self attention instead of Cross attention.",
)
flags.DEFINE_enum_class(
"fusion_method",
FusionMethod.CONCAT,
FusionMethod,
"Fusion method for joint representation.",
)
flags.DEFINE_bool("use_train_and_val", True,
"Use both train and val for training.")
flags.DEFINE_integer("seed", 1204, "Random seed.")
flags.DEFINE_integer("hidden_dimension", 1024, "Dimension of hidden states.")
flags.DEFINE_integer("number_of_epochs", 70, "Number of epochs for training.")
flags.DEFINE_integer("start_epoch", 0,
"Epoch at which training should start/restart.")
flags.DEFINE_integer("warmup_length", 5,
"Number of epochs for the warmup stage.")
flags.DEFINE_float("warmup_factor", 0.5,
"Factor by which learning rate is multiplied.")
from absl import flags
from injector import Binder, Module, inject, singleton
from rep0st.framework import app
from rep0st.framework.scheduler import Scheduler, SchedulerModule
from rep0st.service.feature_service import FeatureService, FeatureServiceModule
from rep0st.db.post import Type as PostType
log = logging.getLogger(__name__)
FLAGS = flags.FLAGS
flags.DEFINE_string(
'rep0st_update_features_job_schedule', '* * * * * *',
'Schedule in crontab format for running the feature update job.')
flags.DEFINE_enum_class(
'rep0st_update_features_post_type', PostType.IMAGE, PostType,
'The post type (image, video, ...) this job should index.')
class UpdateFeaturesJobModule(Module):
def configure(self, binder: Binder):
binder.install(FeatureServiceModule)
binder.install(SchedulerModule)
binder.bind(UpdateFeaturesJob)
@singleton
class UpdateFeaturesJob:
feature_service: FeatureService
@inject
flags.DEFINE_string("input_interactions_dir", None, "Directory with inputs.")
flags.DEFINE_string("input_tables_dir", None, "Directory with inputs.")
flags.DEFINE_string("output_dir", None, "Directory with outputs.")
flags.DEFINE_string("vocab_file", None,
"The vocabulary file that the BERT model was trained on.")
flags.DEFINE_integer("max_seq_length", None,
"Max length of a sequence in word pieces.")
flags.DEFINE_float("max_column_id", None, "Max column id to extract.")
flags.DEFINE_float("max_row_id", None, "Max row id to extract.")
flags.DEFINE_integer(
"cell_trim_length", -1,
"If > 0: Trim cells so that the length is <= this value.")
flags.DEFINE_boolean("use_document_title", None,
"Include document title text in the tf example.")
flags.DEFINE_enum_class("converter_impl", create_data.ConverterImplType.PYTHON,
create_data.ConverterImplType,
"Implementation to map interactions to tf examples.")
FLAGS = flags.FLAGS
def run(inputs, outputs, input_format):
beam_runner.run(
create_data.build_retrieval_pipeline(
input_files=inputs,
input_format=input_format,
output_files=outputs,
config=tf_example_utils.RetrievalConversionConfig(
vocab_file=FLAGS.vocab_file,
max_seq_length=FLAGS.max_seq_length,
max_column_id=FLAGS.max_column_id,
max_row_id=FLAGS.max_row_id,
from wikigraphs.data import tokenizers
from wikigraphs.data import wikitext
class DatasetType(enum.Enum):
text = 1
graph = 2
wikitext = 3
FLAGS = flags.FLAGS
flags.DEFINE_string(
'data_dir', '', 'Path to the directory that contains the'
' unzipped wikitext-103 data.')
flags.DEFINE_string('vocab_file_path', '', 'Path to the output vocab file.')
flags.DEFINE_enum_class('data_type', DatasetType.wikitext, DatasetType,
'One of {`wikitext`, `graph`, `text`}.')
flags.DEFINE_integer(
'threshold', 1, 'Frequency threshold for a word to be'
' included in the vocabulary.')
flags.DEFINE_string('version', 'max256',
'Which version of paired data to use.')
def get_vocab(dataset: wikitext.RawDataset) -> List[Tuple[str, int]]:
"""Build vocabulary, return (word, count) tuples sorted by count."""
vocab = collections.defaultdict(int)
for pair in dataset:
for t in pair.text.split(' '):
if t:
vocab[t] += 1
"""Scripts to convert predictions file to other formats."""
from absl import app
from absl import flags
from tapas.scripts import convert_predictions_utils
FLAGS = flags.FLAGS
flags.DEFINE_list('interaction_files', None,
'A list of files contain interactions protos.')
flags.DEFINE_list('prediction_files', None,
'A list of files that contain model prediction.')
flags.DEFINE_string('output_directory', None,
'Output directory where converted files will be stored.')
flags.DEFINE_enum_class('dataset_format', None,
convert_predictions_utils.DatasetFormat,
'Dataset format.')
def main(_):
convert_predictions_utils.convert(FLAGS.interaction_files,
FLAGS.prediction_files,
FLAGS.output_directory,
FLAGS.dataset_format)
if __name__ == '__main__':
flags.mark_flag_as_required('interaction_files')
flags.mark_flag_as_required('prediction_files')
flags.mark_flag_as_required('output_directory')
flags.mark_flag_as_required('dataset_format')
from absl import app
from absl import flags
from density_functional_approximation_dm21 import neural_numint
_OUT_DIR = flags.DEFINE_string('out_dir',
None,
'Output directory.',
required=True)
_BATCH_SIZE = flags.DEFINE_integer(
'batch_size',
1000,
'Number of grid points exported functional will process in a single call.',
lower_bound=0)
_FUNCTIONAL = flags.DEFINE_enum_class('functional',
neural_numint.Functional.DM21,
neural_numint.Functional,
'Functional to export.')
def export(
functional: neural_numint.Functional,
export_path: str,
batch_dim: int,
) -> None:
"""Export a functional and its derivatives to a single saved_model.
Args:
functional: functional to export.
export_path: path to saved the model to.
batch_dim: number of grid points to process in a single call.
"""
'Flag `step_size_transitions` needs to be divisible by'
' the `batch_size` x `unroll_length`.')
return FLAGS.step_size_transitions // (batch_size * unroll_length)
raise ValueError(
'Exactly one of the flags `batches_per_step`, '
'`step_size_unroll` and `step_size_transitions` needs to be '
'non-zero.')
flags.DEFINE_integer(
'epochs_per_step', 1, 'How many times to pass over all the'
' batches during a training step.')
# Profiling.
flags.DEFINE_enum_class(
'profile_inference_return', learner_config.InferenceReturn.END,
learner_config.InferenceReturn,
'Allows early returns in the inference function to profile performance.')
FLAGS = flags.FLAGS
def training_config_from_flags() -> learner_config.TrainingConfig:
"""Returns training config from the command line flags."""
return learner_config.TrainingConfig(
batch_mode=FLAGS.batch_mode,
batch_size=batch_size_from_flags(),
batches_per_step=batches_per_step_from_flags(),
block_inference_on_training=FLAGS.block_inference_on_training,
clip_norm=FLAGS.clip_norm,
env_batch_size=FLAGS.env_batch_size,
env_name=FLAGS.env_name,
pbtxt = 1
sdf_opt = 2
sdf_init = 3
sdf_init_opt = 4
flags.DEFINE_string(
'input_sqlite', None,
'Path of sqlite file to read. Must be on the local filesystem.')
flags.DEFINE_string(
'output_path', None,
'Path to output file to write. If not specified, will write to stdout.')
flags.DEFINE_list('btids', [], 'List of bond topology ids to query')
flags.DEFINE_list('cids', [], 'List of conformer ids to query')
flags.DEFINE_list('smiles', [], 'List of smiles to query')
flags.DEFINE_enum_class('output_format', OutputFormat.pbtxt, OutputFormat,
'Format for the found SMU entries')
FLAGS = flags.FLAGS
class PBTextOutputter:
"""Simple internal class to write entries to text protocol buffer."""
def __init__(self, output_path):
"""Creates PBTextOutputter.
Args:
output_path: file path to write to
"""
if output_path:
self.outfile = gfile.GFile(output_path, 'w')
from cola import constants
from cola import contrastive
from cola import supervised
FLAGS = flags.FLAGS
flags.DEFINE_string("tpu_address", None, "TPU Address.")
flags.DEFINE_string("experiment_id", None,
"Unique id to use for model checkpointing.")
flags.DEFINE_string("strategy", "tpu",
"TF distribute strategy either of `tpu` or `gpu`.")
flags.DEFINE_enum_class("training_mode", constants.TrainingMode.SSL,
constants.TrainingMode, "Mode of model training.")
flags.DEFINE_string("model_dir", None,
"Path to directory where to store models.")
flags.DEFINE_enum_class(
"ssl_dataset", constants.Dataset.AS, constants.Dataset,
"Name of the dataset to use for self-supervised pre-training.")
flags.DEFINE_enum_class("ds_dataset", constants.Dataset.MUSAN,
constants.Dataset,
"Name of the downstream task dataset.")
flags.DEFINE_string("ssl_checkpoint_id", None,
"Self-supervised model checkpoint id.")
flags.DEFINE_string('graph_yaxis_title', 'AverageReturn',
'Title for the y-axis or event_name is used.')
flags.DEFINE_string('event_name', 'AverageReturn', 'Name of event to track.')
flags.DEFINE_integer('end_step', None,
'If set, processing of the event log ends on this step.')
flags.DEFINE_boolean('show_graph', False, 'If true, show graph in a window.')
class GraphAggTypes(enum.Enum):
"""Enum of options to aggregate data when generating a graph."""
MEAN = 'mean'
MEDIAN = 'median'
flags.DEFINE_enum_class('graph_agg', GraphAggTypes.MEAN, GraphAggTypes,
'Method to aggregate data for the graph.')
Number = Union[int, float]
class StatsBuilder(object):
"""Builds graphs and other summary information from eventlogs."""
def __init__(self,
eventlog_dirs: List[str],
event_tag: str,
output_path: str = '.',
title: str = '',
xaxis_title: str = 'steps',
yaxis_title: Optional[str] = None,
graph_agg: GraphAggTypes = GraphAggTypes.MEAN,
output_prefix: str = 'results',
'The number of concurrent threads for throughput tests.')
flags.DEFINE_boolean(
'ch_network_throughput_time', False,
'throughput metrics will be average request times (ms) '
'instead of rate (Mb/s).')
flags.DEFINE_integer('ch_network_throughput_samples', 5,
'The number of test samples for throughput tests.')
flags.DEFINE_boolean(
'ch_network_throughput_slowest_thread', False, 'If set, '
'throughput metrics will be based on the speed of the '
'slowest thread instead of average speed X number of '
'threads.')
flags.DEFINE_integer(
'ch_network_tcp_samples', 10, 'The number of test samples '
'for TCP tests (rtt, ssl or ttfb).')
flags.DEFINE_enum_class('ch_ssl_encryption_type', TlsEncryptionType.ECC,
TlsEncryptionType, 'Encryption type to use for SSL.')
CLIENT_ZONE = flags.DEFINE_string(
'ch_client_zone', None,
'zone to launch the network or storage test client in. ')
ENDPOINT_ZONE = flags.DEFINE_string(
'ch_endpoint_zone', None,
'zone to launch the network server or storage test bucket in. ')
FLAGS = flags.FLAGS
HTTP_DIR = '/var/www/html/web-probe'
OUTPUT = 'network.csv'
TRUE = 'True'
FALSE = 'False'
def CheckPrerequisites(_):
from supcon import enums
from supcon import hparams
FLAGS = flags.FLAGS
# Train and eval batch sizes. For TPU execution, these are the total batch sizes
# for all TPUs together, not the smaller per-TPU ones.
flags.DEFINE_integer('batch_size', 2048, 'Train batch size')
flags.DEFINE_integer('eval_batch_size', 128, 'The batch size to use for eval.')
# Architecture
flags.DEFINE_float('resnet_width', 1., 'Width of the resnet to be'
'used in the model')
flags.DEFINE_enum_class(
'resnet_architecture', enums.EncoderArchitecture.RESNET_V1,
enums.EncoderArchitecture, 'Name of the resnet'
' architecture to be used in the model.')
flags.DEFINE_integer('resnet_depth', 50, 'Depth of the Resnet model')
flags.DEFINE_bool(
'zero_initialize_classifier', False,
'Whether or not to initialize parameters in the classification head '
'to 0. Otherwise uses glorot uniform.')
flags.DEFINE_bool('use_projection_batch_norm', False,
'Whether to use batch norm in the projection head.')
flags.DEFINE_bool(
'use_projection_batch_norm_beta', True,
'Whether projection head batch norm layers should have a beta (bias) '
'parameter.')
flags.DEFINE_bool(
'normalize_embedding', True,
'If the outputs of the encoder should be normalized before being input to '
from typing import Any, List
import enum
from absl import flags
from injector import Binder, Injector, Module
FLAGS = flags.FLAGS
class Environment(enum.Enum):
DEVELOPMENT = 'DEVELOPMENT'
PRODUCTION = 'PRODUCTION'
flags.DEFINE_enum_class('environment', Environment.PRODUCTION, Environment,
'Environment this application is running in.')
class EnvironmentModule(Module):
def configure(self, binder: Binder) -> None:
binder.bind(Environment, to=FLAGS.environment)
def get_bindings(injector: Injector) -> List[Any]:
if not injector:
return []
return list(injector.binder._bindings.keys()) + get_bindings(
injector.parent)
