Nolski/tf-tfjs.md

## tf-tfjs.md

      
    Raw
  

              tf-tfjs.md
            
          
tf method
tfjs method


tf.argsort(values,axis=-1,direction='ASCENDING',stable=False,name=None)
tbd


tf.audio.decode_wav(contents,desired_channels=-1,desired_samples=-1,name=None)
tbd


tf.audio.encode_wav(audio,sample_rate,name=None)
tbd


tf.autograph.experimental.do_not_convert(func=None)
tbd


tf.autograph.set_verbosity(level,alsologtostdout=False)
tbd


tf.autograph.to_code(entity,recursive=True,experimental_optional_features=None)
tbd


tf.autograph.to_graph(entity,recursive=True,experimental_optional_features=None)
tbd


tf.autograph.trace(*args)
tbd


tf.batch_to_space(input,block_shape,crops,name=None)
tbd


tf.bitcast(input,type,name=None)
tbd


tf.bitwise.bitwise_and(x,y,name=None)
tbd


tf.bitwise.bitwise_or(x,y,name=None)
tbd


tf.bitwise.bitwise_xor(x,y,name=None)
tbd


tf.bitwise.invert(x,name=None)
tbd


tf.bitwise.left_shift(x,y,name=None)
tbd


tf.bitwise.right_shift(x,y,name=None)
tbd


tf.boolean_mask(tensor,mask,axis=None,name='boolean_mask')
tbd


tf.broadcast_dynamic_shape(shape_x,shape_y)
tbd


tf.broadcast_static_shape(shape_x,shape_y)
tbd


tf.broadcast_to(input,shape,name=None)
tbd


tf.case(pred_fn_pairs,default=None,exclusive=False,strict=False,name='case')
tbd


tf.clip_by_global_norm(t_list,clip_norm,use_norm=None,name=None)
tbd


tf.clip_by_norm(t,clip_norm,axes=None,name=None)
tbd


tf.clip_by_value(t,clip_value_min,clip_value_max,name=None)
tbd


tf.compat.as_bytes(bytes_or_text,encoding='utf-8')
tbd


tf.compat.as_str_any(value)
tbd


tf.compat.as_text(bytes_or_text,encoding='utf-8')
tbd


tf.compat.dimension_at_index(shape,index)
tbd


tf.compat.dimension_value(dimension)
tbd


tf.compat.forward_compatibility_horizon(year,month,day)
tbd


tf.compat.forward_compatible(year,month,day)
tbd


tf.compat.path_to_str(path)
tbd


tf.compat.v1.Print(input_,data,message=None,first_n=None,summarize=None,name=None)
tbd


tf.compat.v1.add_check_numerics_ops()
tbd


tf.compat.v1.add_to_collection(name,value)
tbd


tf.compat.v1.add_to_collections(names,value)
tbd


tf.compat.v1.all_variables()
tbd


tf.compat.v1.app.run(main=None,argv=None)
tbd


tf.compat.v1.arg_max(input,dimension,output_type=tf.dtypes.int64,name=None)
tbd


tf.compat.v1.arg_min(input,dimension,output_type=tf.dtypes.int64,name=None)
tbd


tf.compat.v1.argmax(input,axis=None,name=None,dimension=None,output_type=tf.dtypes.int64)
tbd


tf.compat.v1.argmin(input,axis=None,name=None,dimension=None,output_type=tf.dtypes.int64)
tbd


tf.compat.v1.assert_equal(x,y,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_greater(x,y,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_greater_equal(x,y,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_integer(x,message=None,name=None)
tbd


tf.compat.v1.assert_less(x,y,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_less_equal(x,y,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_near(x,y,rtol=None,atol=None,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_negative(x,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_non_negative(x,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_non_positive(x,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_none_equal(x,y,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_positive(x,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_rank(x,rank,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_rank_at_least(x,rank,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_rank_in(x,ranks,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.assert_scalar(tensor,name=None,message=None)
tbd


tf.compat.v1.assert_type(tensor,tf_type,message=None,name=None)
tbd


tf.compat.v1.assert_variables_initialized(var_list=None)
tbd


tf.compat.v1.assign(ref,value,validate_shape=None,use_locking=None,name=None)
assign(newValue)


tf.compat.v1.assign_add(ref,value,use_locking=None,name=None)
tbd


tf.compat.v1.assign_sub(ref,value,use_locking=None,name=None)
tbd


tf.compat.v1.autograph.to_code(entity,recursive=True,arg_values=None,arg_types=None,indentation='',experimental_optional_features=None)
tbd


tf.compat.v1.autograph.to_graph(entity,recursive=True,arg_values=None,arg_types=None,experimental_optional_features=None)
tbd


tf.compat.v1.batch_gather(params,indices,name=None)
tbd


tf.compat.v1.batch_scatter_update(ref,indices,updates,use_locking=True,name=None)
tbd


tf.compat.v1.batch_to_space(input,crops,block_size,name=None,block_shape=None)
tbd


tf.compat.v1.batch_to_space_nd(input,block_shape,crops,name=None)
tbd


tf.compat.v1.bincount(arr,weights=None,minlength=None,maxlength=None,dtype=tf.dtypes.int32)
tbd


tf.compat.v1.boolean_mask(tensor,mask,name='boolean_mask',axis=None)
tbd


tf.compat.v1.case(pred_fn_pairs,default=None,exclusive=False,strict=False,name='case')
tbd


tf.compat.v1.clip_by_average_norm(t,clip_norm,name=None)
tbd


tf.compat.v1.colocate_with(op,ignore_existing=False)
tbd


tf.compat.v1.cond(pred,true_fn=None,false_fn=None,strict=False,name=None,fn1=None,fn2=None)
tbd


tf.compat.v1.confusion_matrix(labels,predictions,num_classes=None,dtype=tf.dtypes.int32,name=None,weights=None)
tbd


tf.compat.v1.constant(value,dtype=None,shape=None,name='Const',verify_shape=False)
tf.initializers.constant(args)


tf.compat.v1.container(container_name)
tbd


tf.compat.v1.control_flow_v2_enabled()
tbd


tf.compat.v1.convert_to_tensor(value,dtype=None,name=None,preferred_dtype=None,dtype_hint=None)
tbd


tf.compat.v1.convert_to_tensor_or_indexed_slices(value,dtype=None,name=None)
tbd


tf.compat.v1.convert_to_tensor_or_sparse_tensor(value,dtype=None,name=None)
tbd


tf.compat.v1.count_nonzero(input_tensor=None,axis=None,keepdims=None,dtype=tf.dtypes.int64,name=None,reduction_indices=None,keep_dims=None,input=None)
tbd


tf.compat.v1.count_up_to(ref,limit,name=None)
tbd


tf.compat.v1.create_partitioned_variables(shape,slicing,initializer,dtype=tf.dtypes.float32,trainable=True,collections=None,name=None,reuse=None)
tbd


tf.compat.v1.data.experimental.Counter(start=0,step=1,dtype=tf.dtypes.int64)
tbd


tf.compat.v1.data.experimental.RaggedTensorStructure(dtype,shape,ragged_rank)
tbd


tf.compat.v1.data.experimental.SparseTensorStructure(dtype,shape)
tbd


tf.compat.v1.data.experimental.TensorArrayStructure(dtype,element_shape,dynamic_size,infer_shape)
tbd


tf.compat.v1.data.experimental.TensorStructure(dtype,shape)
tbd


tf.compat.v1.data.experimental.choose_from_datasets(datasets,choice_dataset)
tbd


tf.compat.v1.data.experimental.make_batched_features_dataset(file_pattern,batch_size,features,reader=tf.compat.v1.data.TFRecordDataset,label_key=None,reader_args=None,num_epochs=None,shuffle=True,shuffle_buffer_size=10000,shuffle_seed=None,prefetch_buffer_size=dataset_ops.AUTOTUNE,reader_num_threads=1,parser_num_threads=2,sloppy_ordering=False,drop_final_batch=False)
tbd


tf.compat.v1.data.experimental.make_csv_dataset(file_pattern,batch_size,column_names=None,column_defaults=None,label_name=None,select_columns=None,field_delim=',',use_quote_delim=True,na_value='',header=True,num_epochs=None,shuffle=True,shuffle_buffer_size=10000,shuffle_seed=None,prefetch_buffer_size=dataset_ops.AUTOTUNE,num_parallel_reads=1,sloppy=False,num_rows_for_inference=100,compression_type=None,ignore_errors=False)
tbd


tf.compat.v1.data.experimental.map_and_batch_with_legacy_function(map_func,batch_size,num_parallel_batches=None,drop_remainder=False,num_parallel_calls=None)
tbd


tf.compat.v1.data.experimental.sample_from_datasets(datasets,weights=None,seed=None)
tbd


tf.compat.v1.data.get_output_classes(dataset_or_iterator)
tbd


tf.compat.v1.data.get_output_shapes(dataset_or_iterator)
tbd


tf.compat.v1.data.get_output_types(dataset_or_iterator)
tbd


tf.compat.v1.data.make_initializable_iterator(dataset,shared_name=None)
tbd


tf.compat.v1.data.make_one_shot_iterator(dataset)
tbd


tf.compat.v1.debugging.assert_shapes(shapes,data=None,summarize=None,message=None,name=None)
tbd


tf.compat.v1.decode_csv(records,record_defaults,field_delim=',',use_quote_delim=True,name=None,na_value='',select_cols=None)
tbd


tf.compat.v1.decode_raw(input_bytes=None,out_type=None,little_endian=True,name=None,bytes=None)
tbd


tf.compat.v1.delete_session_tensor(handle,name=None)
tbd


tf.compat.v1.depth_to_space(input,block_size,name=None,data_format='NHWC')
tbd


tf.compat.v1.device(device_name_or_function)
tbd


tf.compat.v1.disable_control_flow_v2()
tbd


tf.compat.v1.disable_eager_execution()
tbd


tf.compat.v1.disable_resource_variables()
tbd


tf.compat.v1.disable_tensor_equality()
tbd


tf.compat.v1.disable_v2_behavior()
tbd


tf.compat.v1.disable_v2_tensorshape()
tbd


tf.compat.v1.distribute.get_loss_reduction()
tbd


tf.compat.v1.distributions.kl_divergence(distribution_a,distribution_b,allow_nan_stats=True,name=None)
tbd


tf.compat.v1.enable_control_flow_v2()
tbd


tf.compat.v1.enable_eager_execution(config=None,device_policy=None,execution_mode=None)
tbd


tf.compat.v1.enable_resource_variables()
tbd


tf.compat.v1.enable_tensor_equality()
tbd


tf.compat.v1.enable_v2_behavior()
tbd


tf.compat.v1.enable_v2_tensorshape()
tbd


tf.compat.v1.errors.error_code_from_exception_type(cls)
tbd


tf.compat.v1.errors.exception_type_from_error_code(error_code)
tbd


tf.compat.v1.estimator.classifier_parse_example_spec(feature_columns,label_key,label_dtype=tf.dtypes.int64,label_default=None,weight_column=None)
tbd


tf.compat.v1.estimator.experimental.dnn_logit_fn_builder(units,hidden_units,feature_columns,activation_fn,dropout,input_layer_partitioner,batch_norm)
tbd


tf.compat.v1.estimator.experimental.linear_logit_fn_builder(units,feature_columns,sparse_combiner='sum')
tbd


tf.compat.v1.estimator.inputs.numpy_input_fn(x,y=None,batch_size=128,num_epochs=1,shuffle=None,queue_capacity=1000,num_threads=1)
tbd


tf.compat.v1.estimator.inputs.pandas_input_fn(x,y=None,batch_size=128,num_epochs=1,shuffle=None,queue_capacity=1000,num_threads=1,target_column='target')
tbd


tf.compat.v1.estimator.regressor_parse_example_spec(feature_columns,label_key,label_dtype=tf.dtypes.float32,label_default=None,label_dimension=1,weight_column=None)
tbd


tf.compat.v1.expand_dims(input,axis=None,name=None,dim=None)
tbd


tf.compat.v1.experimental.output_all_intermediates(state)
tbd


tf.compat.v1.extract_image_patches(images,ksizes=None,strides=None,rates=None,padding=None,name=None,sizes=None)
tbd


tf.compat.v1.feature_column.categorical_column_with_vocabulary_file(key,vocabulary_file,vocabulary_size=None,num_oov_buckets=0,default_value=None,dtype=tf.dtypes.string)
tbd


tf.compat.v1.feature_column.input_layer(features,feature_columns,weight_collections=None,trainable=True,cols_to_vars=None,cols_to_output_tensors=None)
tbd


tf.compat.v1.feature_column.linear_model(features,feature_columns,units=1,sparse_combiner='sum',weight_collections=None,trainable=True,cols_to_vars=None)
tbd


tf.compat.v1.feature_column.make_parse_example_spec(feature_columns)
tbd


tf.compat.v1.feature_column.shared_embedding_columns(categorical_columns,dimension,combiner='mean',initializer=None,shared_embedding_collection_name=None,ckpt_to_load_from=None,tensor_name_in_ckpt=None,max_norm=None,trainable=True)
tbd


tf.compat.v1.fixed_size_partitioner(num_shards,axis=0)
tbd


tf.compat.v1.flags.DEFINE(parser,name,default,help,flag_values=_flagvalues.FLAGS,serializer=None,module_name=None,**args)
tbd


tf.compat.v1.flags.DEFINE_alias(name,original_name,flag_values=_flagvalues.FLAGS,module_name=None)
tbd


tf.compat.v1.flags.DEFINE_bool(name,default,help,flag_values=_flagvalues.FLAGS,module_name=None,**args)
tbd


tf.compat.v1.flags.DEFINE_enum(name,default,enum_values,help,flag_values=_flagvalues.FLAGS,module_name=None,**args)
tbd


tf.compat.v1.flags.DEFINE_enum_class(name,default,enum_class,help,flag_values=_flagvalues.FLAGS,module_name=None,**args)
tbd


tf.compat.v1.flags.DEFINE_flag(flag,flag_values=_flagvalues.FLAGS,module_name=None)
tbd


tf.compat.v1.flags.DEFINE_float(name,default,help,lower_bound=None,upper_bound=None,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_integer(name,default,help,lower_bound=None,upper_bound=None,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_list(name,default,help,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_multi(parser,serializer,name,default,help,flag_values=_flagvalues.FLAGS,module_name=None,**args)
tbd


tf.compat.v1.flags.DEFINE_multi_enum(name,default,enum_values,help,flag_values=_flagvalues.FLAGS,case_sensitive=True,**args)
tbd


tf.compat.v1.flags.DEFINE_multi_enum_class(name,default,enum_class,help,flag_values=_flagvalues.FLAGS,module_name=None,**args)
tbd


tf.compat.v1.flags.DEFINE_multi_float(name,default,help,lower_bound=None,upper_bound=None,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_multi_integer(name,default,help,lower_bound=None,upper_bound=None,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_multi_string(name,default,help,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_spaceseplist(name,default,help,comma_compat=False,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.DEFINE_string(name,default,help,flag_values=_flagvalues.FLAGS,**args)
tbd


tf.compat.v1.flags.adopt_module_key_flags(module,flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.declare_key_flag(flag_name,flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.disclaim_key_flags()
tbd


tf.compat.v1.flags.doc_to_help(doc)
tbd


tf.compat.v1.flags.flag_dict_to_args(flag_map)
tbd


tf.compat.v1.flags.get_help_width()
tbd


tf.compat.v1.flags.mark_bool_flags_as_mutual_exclusive(flag_names,required=False,flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.mark_flag_as_required(flag_name,flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.mark_flags_as_mutual_exclusive(flag_names,required=False,flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.mark_flags_as_required(flag_names,flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.multi_flags_validator(flag_names,message='Flagvalidationfailed',flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.register_multi_flags_validator(flag_names,multi_flags_checker,message='Flagsvalidationfailed',flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.register_validator(flag_name,checker,message='Flagvalidationfailed',flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.flags.text_wrap(text,length=None,indent='',firstline_indent=None)
tbd


tf.compat.v1.flags.tf_decorator.make_decorator(target,decorator_func,decorator_name=None,decorator_doc='',decorator_argspec=None)
tbd


tf.compat.v1.flags.tf_decorator.rewrap(decorator_func,previous_target,new_target)
tbd


tf.compat.v1.flags.tf_decorator.tf_stack.convert_stack(stack,include_func_start_lineno=False)
tbd


tf.compat.v1.flags.tf_decorator.tf_stack.extract_stack(limit=None)
tbd


tf.compat.v1.flags.tf_decorator.tf_stack.extract_stack_file_and_line(max_length=1000)
tbd


tf.compat.v1.flags.tf_decorator.unwrap(maybe_tf_decorator)
tbd


tf.compat.v1.flags.validator(flag_name,message='Flagvalidationfailed',flag_values=_flagvalues.FLAGS)
tbd


tf.compat.v1.floor_div(x,y,name=None)
tbd


tf.compat.v1.gather(params,indices,validate_indices=None,name=None,axis=None,batch_dims=0)
tf.gather(x,indices,axis?)


tf.compat.v1.gather_nd(params,indices,name=None,batch_dims=0)
tbd


tf.compat.v1.get_collection(key,scope=None)
tbd


tf.compat.v1.get_collection_ref(key)
tbd


tf.compat.v1.get_default_graph()
tbd


tf.compat.v1.get_default_session()
tbd


tf.compat.v1.get_local_variable(name,shape=None,dtype=None,initializer=None,regularizer=None,trainable=False,collections=None,caching_device=None,partitioner=None,validate_shape=True,use_resource=None,custom_getter=None,constraint=None,synchronization=tf.VariableSynchronization.AUTO,aggregation=tf.compat.v1.VariableAggregation.NONE)
tbd


tf.compat.v1.get_seed(op_seed)
tbd


tf.compat.v1.get_session_handle(data,name=None)
tbd


tf.compat.v1.get_session_tensor(handle,dtype,name=None)
tbd


tf.compat.v1.get_variable(name,shape=None,dtype=None,initializer=None,regularizer=None,trainable=None,collections=None,caching_device=None,partitioner=None,validate_shape=True,use_resource=None,custom_getter=None,constraint=None,synchronization=tf.VariableSynchronization.AUTO,aggregation=tf.compat.v1.VariableAggregation.NONE)
tbd


tf.compat.v1.get_variable_scope()
tbd


tf.compat.v1.gfile.Copy(oldpath,newpath,overwrite=False)
tbd


tf.compat.v1.gfile.DeleteRecursively(dirname)
tbd


tf.compat.v1.gfile.Exists(filename)
tbd


tf.compat.v1.gfile.Glob(filename)
tbd


tf.compat.v1.gfile.IsDirectory(dirname)
tbd


tf.compat.v1.gfile.ListDirectory(dirname)
tbd


tf.compat.v1.gfile.MakeDirs(dirname)
tbd


tf.compat.v1.gfile.MkDir(dirname)
tbd


tf.compat.v1.gfile.Remove(filename)
tbd


tf.compat.v1.gfile.Rename(oldname,newname,overwrite=False)
tbd


tf.compat.v1.gfile.Stat(filename)
tbd


tf.compat.v1.gfile.Walk(top,in_order=True)
tbd


tf.compat.v1.global_variables(scope=None)
tbd


tf.compat.v1.global_variables_initializer()
tbd


tf.compat.v1.gradients(ys,xs,grad_ys=None,name='gradients',colocate_gradients_with_ops=False,gate_gradients=False,aggregation_method=None,stop_gradients=None,unconnected_gradients=tf.UnconnectedGradients.NONE)
tbd


tf.compat.v1.graph_util.convert_variables_to_constants(sess,input_graph_def,output_node_names,variable_names_whitelist=None,variable_names_blacklist=None)
tbd


tf.compat.v1.graph_util.extract_sub_graph(graph_def,dest_nodes)
tbd


tf.compat.v1.graph_util.must_run_on_cpu(node,pin_variables_on_cpu=False)
tbd


tf.compat.v1.graph_util.remove_training_nodes(input_graph,protected_nodes=None)
tbd


tf.compat.v1.graph_util.tensor_shape_from_node_def_name(graph,input_name)
tbd


tf.compat.v1.hessians(ys,xs,name='hessians',colocate_gradients_with_ops=False,gate_gradients=False,aggregation_method=None)
tbd


tf.compat.v1.image.crop_and_resize(image,boxes,box_ind=None,crop_size=None,method='bilinear',extrapolation_value=0,name=None,box_indices=None)
tbd


tf.compat.v1.image.draw_bounding_boxes(images,boxes,name=None,colors=None)
tbd


tf.compat.v1.image.extract_glimpse(input,size,offsets,centered=True,normalized=True,uniform_noise=True,name=None)
tbd


tf.compat.v1.image.resize(images,size,method=ResizeMethodV1.BILINEAR,align_corners=False,preserve_aspect_ratio=False,name=None)
tbd


tf.compat.v1.image.resize_area(images,size,align_corners=False,name=None)
tbd


tf.compat.v1.image.resize_bicubic(images,size,align_corners=False,name=None,half_pixel_centers=False)
tbd


tf.compat.v1.image.resize_bilinear(images,size,align_corners=False,name=None,half_pixel_centers=False)
tbd


tf.compat.v1.image.resize_image_with_pad(image,target_height,target_width,method=ResizeMethodV1.BILINEAR,align_corners=False)
tbd


tf.compat.v1.image.resize_nearest_neighbor(images,size,align_corners=False,name=None,half_pixel_centers=False)
tbd


tf.compat.v1.image.sample_distorted_bounding_box(image_size,bounding_boxes,seed=None,seed2=None,min_object_covered=0.1,aspect_ratio_range=None,area_range=None,max_attempts=None,use_image_if_no_bounding_boxes=None,name=None)
tbd


tf.compat.v1.initialize_all_tables(name='init_all_tables')
tbd


tf.compat.v1.initialize_all_variables()
tbd


tf.compat.v1.initialize_local_variables()
tbd


tf.compat.v1.initialize_variables(var_list,name='init')
tbd


tf.compat.v1.io.tf_record_iterator(path,options=None)
tbd


tf.compat.v1.is_variable_initialized(variable)
tbd


tf.compat.v1.keras.backend.get_session(op_input_list=())
tbd


tf.compat.v1.keras.backend.set_session(session)
tbd


tf.compat.v1.keras.estimator.model_to_estimator(keras_model=None,keras_model_path=None,custom_objects=None,model_dir=None,config=None,checkpoint_format='saver')
tbd


tf.compat.v1.keras.initializers.he_normal(seed=None)
tbd


tf.compat.v1.keras.initializers.he_uniform(seed=None)
tbd


tf.compat.v1.keras.initializers.lecun_normal(seed=None)
tbd


tf.compat.v1.keras.initializers.lecun_uniform(seed=None)
tbd


tf.compat.v1.layers.average_pooling1d(inputs,pool_size,strides,padding='valid',data_format='channels_last',name=None)
tbd


tf.compat.v1.layers.average_pooling2d(inputs,pool_size,strides,padding='valid',data_format='channels_last',name=None)
tbd


tf.compat.v1.layers.average_pooling3d(inputs,pool_size,strides,padding='valid',data_format='channels_last',name=None)
tbd


tf.compat.v1.layers.batch_normalization(inputs,axis=-1,momentum=0.99,epsilon=0.001,center=True,scale=True,beta_initializer=tf.zeros_initializer(),gamma_initializer=tf.ones_initializer(),moving_mean_initializer=tf.zeros_initializer(),moving_variance_initializer=tf.ones_initializer(),beta_regularizer=None,gamma_regularizer=None,beta_constraint=None,gamma_constraint=None,training=False,trainable=True,name=None,reuse=None,renorm=False,renorm_clipping=None,renorm_momentum=0.99,fused=None,virtual_batch_size=None,adjustment=None)
tbd


tf.compat.v1.layers.conv1d(inputs,filters,kernel_size,strides=1,padding='valid',data_format='channels_last',dilation_rate=1,activation=None,use_bias=True,kernel_initializer=None,bias_initializer=tf.zeros_initializer(),kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tf.conv1d(x,filter,stride,pad,dataFormat?,dilation?,dimRoundingMode?)


tf.compat.v1.layers.conv2d(inputs,filters,kernel_size,strides=(1,1),padding='valid',data_format='channels_last',dilation_rate=(1,1),activation=None,use_bias=True,kernel_initializer=None,bias_initializer=tf.zeros_initializer(),kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tf.conv2d(x,filter,strides,pad,dataFormat?,dilations?,dimRoundingMode?)


tf.compat.v1.layers.conv2d_transpose(inputs,filters,kernel_size,strides=(1,1),padding='valid',data_format='channels_last',activation=None,use_bias=True,kernel_initializer=None,bias_initializer=tf.zeros_initializer(),kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tbd


tf.compat.v1.layers.conv3d(inputs,filters,kernel_size,strides=(1,1,1),padding='valid',data_format='channels_last',dilation_rate=(1,1,1),activation=None,use_bias=True,kernel_initializer=None,bias_initializer=tf.zeros_initializer(),kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tf.conv3d(x,filter,strides,pad,dataFormat?,dilations?)


tf.compat.v1.layers.conv3d_transpose(inputs,filters,kernel_size,strides=(1,1,1),padding='valid',data_format='channels_last',activation=None,use_bias=True,kernel_initializer=None,bias_initializer=tf.zeros_initializer(),kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tbd


tf.compat.v1.layers.dense(inputs,units,activation=None,use_bias=True,kernel_initializer=None,bias_initializer=tf.zeros_initializer(),kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tf.layers.dense(args)


tf.compat.v1.layers.dropout(inputs,rate=0.5,noise_shape=None,seed=None,training=False,name=None)
tf.dropout(x,rate,noiseShape?,seed?)


tf.compat.v1.layers.experimental.keras_style_scope()
tbd


tf.compat.v1.layers.experimental.set_keras_style()
tbd


tf.compat.v1.layers.flatten(inputs,name=None,data_format='channels_last')
tf.util.flatten(arr,result?,skipTypedArray?)


tf.compat.v1.layers.max_pooling1d(inputs,pool_size,strides,padding='valid',data_format='channels_last',name=None)
tbd


tf.compat.v1.layers.max_pooling2d(inputs,pool_size,strides,padding='valid',data_format='channels_last',name=None)
tbd


tf.compat.v1.layers.max_pooling3d(inputs,pool_size,strides,padding='valid',data_format='channels_last',name=None)
tbd


tf.compat.v1.layers.separable_conv1d(inputs,filters,kernel_size,strides=1,padding='valid',data_format='channels_last',dilation_rate=1,depth_multiplier=1,activation=None,use_bias=True,depthwise_initializer=None,pointwise_initializer=None,bias_initializer=tf.zeros_initializer(),depthwise_regularizer=None,pointwise_regularizer=None,bias_regularizer=None,activity_regularizer=None,depthwise_constraint=None,pointwise_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tbd


tf.compat.v1.layers.separable_conv2d(inputs,filters,kernel_size,strides=(1,1),padding='valid',data_format='channels_last',dilation_rate=(1,1),depth_multiplier=1,activation=None,use_bias=True,depthwise_initializer=None,pointwise_initializer=None,bias_initializer=tf.zeros_initializer(),depthwise_regularizer=None,pointwise_regularizer=None,bias_regularizer=None,activity_regularizer=None,depthwise_constraint=None,pointwise_constraint=None,bias_constraint=None,trainable=True,name=None,reuse=None)
tbd


tf.compat.v1.linalg.l2_normalize(x,axis=None,epsilon=1e-12,name=None,dim=None)
tbd


tf.compat.v1.lite.experimental.convert_op_hints_to_stubs(session=None,graph_def=None,write_callback=(lambdagraph_def,comments:None))
tbd


tf.compat.v1.lite.experimental.get_potentially_supported_ops()
tbd


tf.compat.v1.lite.experimental.nn.dynamic_rnn(cell,inputs,sequence_length=None,initial_state=None,dtype=None,parallel_iterations=None,swap_memory=False,time_major=True,scope=None)
tbd


tf.compat.v1.lite.toco_convert(input_data,input_tensors,output_tensors,*args,**kwargs)
tbd


tf.compat.v1.load_file_system_library(library_filename)
tbd


tf.compat.v1.local_variables(scope=None)
tbd


tf.compat.v1.local_variables_initializer()
tbd


tf.compat.v1.logging.TaskLevelStatusMessage(msg)
tbd


tf.compat.v1.logging.debug(msg,*args,**kwargs)
tbd


tf.compat.v1.logging.error(msg,*args,**kwargs)
tbd


tf.compat.v1.logging.fatal(msg,*args,**kwargs)
tbd


tf.compat.v1.logging.flush()
tbd


tf.compat.v1.logging.get_verbosity()
tbd


tf.compat.v1.logging.info(msg,*args,**kwargs)
tbd


tf.compat.v1.logging.log(level,msg,*args,**kwargs)
tf.log(x)


tf.compat.v1.logging.log_every_n(level,msg,n,*args)
tbd


tf.compat.v1.logging.log_first_n(level,msg,n,*args)
tbd


tf.compat.v1.logging.log_if(level,msg,condition,*args)
tbd


tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.INFO)
tbd


tf.compat.v1.logging.set_verbosity(v)
tbd


tf.compat.v1.logging.vlog(level,msg,*args,**kwargs)
tbd


tf.compat.v1.logging.warn(msg,*args,**kwargs)
tbd


tf.compat.v1.logging.warning(msg,*args,**kwargs)
tbd


tf.compat.v1.losses.absolute_difference(labels,predictions,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.add_loss(loss,loss_collection=tf.GraphKeys.LOSSES)
tbd


tf.compat.v1.losses.compute_weighted_loss(losses,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.cosine_distance(labels,predictions,axis=None,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS,dim=None)
tbd


tf.compat.v1.losses.get_losses(scope=None,loss_collection=tf.GraphKeys.LOSSES)
tbd


tf.compat.v1.losses.get_regularization_loss(scope=None,name='total_regularization_loss')
tbd


tf.compat.v1.losses.get_regularization_losses(scope=None)
tbd


tf.compat.v1.losses.get_total_loss(add_regularization_losses=True,name='total_loss',scope=None)
tbd


tf.compat.v1.losses.hinge_loss(labels,logits,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.huber_loss(labels,predictions,weights=1.0,delta=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.log_loss(labels,predictions,weights=1.0,epsilon=1e-07,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.mean_pairwise_squared_error(labels,predictions,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES)
tbd


tf.compat.v1.losses.mean_squared_error(labels,predictions,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.sigmoid_cross_entropy(multi_class_labels,logits,weights=1.0,label_smoothing=0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.softmax_cross_entropy(onehot_labels,logits,weights=1.0,label_smoothing=0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.losses.sparse_softmax_cross_entropy(labels,logits,weights=1.0,scope=None,loss_collection=tf.GraphKeys.LOSSES,reduction=Reduction.SUM_BY_NONZERO_WEIGHTS)
tbd


tf.compat.v1.make_template(name_,func_,create_scope_now_=False,unique_name_=None,custom_getter_=None,**kwargs)
tbd


tf.compat.v1.math.in_top_k(predictions,targets,k,name=None)
tbd


tf.compat.v1.math.log_softmax(logits,axis=None,name=None,dim=None)
tbd


tf.compat.v1.math.softmax(logits,axis=None,name=None,dim=None)
tf.softmax(logits,dim?)


tf.compat.v1.metrics.accuracy(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.auc(labels,predictions,weights=None,num_thresholds=200,metrics_collections=None,updates_collections=None,curve='ROC',name=None,summation_method='trapezoidal',thresholds=None)
tbd


tf.compat.v1.metrics.average_precision_at_k(labels,predictions,k,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.false_negatives(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.false_negatives_at_thresholds(labels,predictions,thresholds,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.false_positives(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.false_positives_at_thresholds(labels,predictions,thresholds,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean(values,weights=None,metrics_collections=None,updates_collections=None,name=None)
tf.mean(x,axis?,keepDims?)


tf.compat.v1.metrics.mean_absolute_error(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean_cosine_distance(labels,predictions,dim,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean_iou(labels,predictions,num_classes,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean_per_class_accuracy(labels,predictions,num_classes,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean_relative_error(labels,predictions,normalizer,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean_squared_error(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.mean_tensor(values,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.percentage_below(values,threshold,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.precision(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tf.metrics.precision(yTrue,yPred)


tf.compat.v1.metrics.precision_at_k(labels,predictions,k,class_id=None,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.precision_at_thresholds(labels,predictions,thresholds,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.precision_at_top_k(labels,predictions_idx,k=None,class_id=None,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.recall(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tf.metrics.recall(yTrue,yPred)


tf.compat.v1.metrics.recall_at_k(labels,predictions,k,class_id=None,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.recall_at_thresholds(labels,predictions,thresholds,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.recall_at_top_k(labels,predictions_idx,k=None,class_id=None,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.root_mean_squared_error(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.sensitivity_at_specificity(labels,predictions,specificity,weights=None,num_thresholds=200,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.sparse_average_precision_at_k(labels,predictions,k,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.sparse_precision_at_k(labels,predictions,k,class_id=None,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.specificity_at_sensitivity(labels,predictions,sensitivity,weights=None,num_thresholds=200,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.true_negatives(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.true_negatives_at_thresholds(labels,predictions,thresholds,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.true_positives(labels,predictions,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.metrics.true_positives_at_thresholds(labels,predictions,thresholds,weights=None,metrics_collections=None,updates_collections=None,name=None)
tbd


tf.compat.v1.min_max_variable_partitioner(max_partitions=1,axis=0,min_slice_size=(256<<10),bytes_per_string_element=16)
tbd


tf.compat.v1.model_variables(scope=None)
tbd


tf.compat.v1.moving_average_variables(scope=None)
tbd


tf.compat.v1.multinomial(logits,num_samples,seed=None,name=None,output_dtype=None)
tf.multinomial(logits,numSamples,seed?,normalized?)


tf.compat.v1.nn.avg_pool(value,ksize,strides,padding,data_format='NHWC',name=None,input=None)
tbd


tf.compat.v1.nn.batch_norm_with_global_normalization(t=None,m=None,v=None,beta=None,gamma=None,variance_epsilon=None,scale_after_normalization=None,name=None,input=None,mean=None,variance=None)
tbd


tf.compat.v1.nn.bidirectional_dynamic_rnn(cell_fw,cell_bw,inputs,sequence_length=None,initial_state_fw=None,initial_state_bw=None,dtype=None,parallel_iterations=None,swap_memory=False,time_major=False,scope=None)
tbd


tf.compat.v1.nn.conv1d(value=None,filters=None,stride=None,padding=None,use_cudnn_on_gpu=None,data_format=None,name=None,input=None,dilations=None)
tf.conv1d(x,filter,stride,pad,dataFormat?,dilation?,dimRoundingMode?)


tf.compat.v1.nn.conv2d(input,filter=None,strides=None,padding=None,use_cudnn_on_gpu=True,data_format='NHWC',dilations=[1,1,1,1],name=None,filters=None)
tf.conv2d(x,filter,strides,pad,dataFormat?,dilations?,dimRoundingMode?)


tf.compat.v1.nn.conv2d_backprop_filter(input,filter_sizes,out_backprop,strides,padding,use_cudnn_on_gpu=True,data_format='NHWC',dilations=[1,1,1,1],name=None)
tbd


tf.compat.v1.nn.conv2d_backprop_input(input_sizes,filter=None,out_backprop=None,strides=None,padding=None,use_cudnn_on_gpu=True,data_format='NHWC',dilations=[1,1,1,1],name=None,filters=None)
tbd


tf.compat.v1.nn.conv2d_transpose(value=None,filter=None,output_shape=None,strides=None,padding='SAME',data_format='NHWC',name=None,input=None,filters=None,dilations=None)
tbd


tf.compat.v1.nn.conv3d(input,filter=None,strides=None,padding=None,data_format='NDHWC',dilations=[1,1,1,1,1],name=None,filters=None)
tf.conv3d(x,filter,strides,pad,dataFormat?,dilations?)


tf.compat.v1.nn.conv3d_backprop_filter(input,filter_sizes,out_backprop,strides,padding,data_format='NDHWC',dilations=[1,1,1,1,1],name=None)
tbd


tf.compat.v1.nn.conv3d_transpose(value,filter=None,output_shape=None,strides=None,padding='SAME',data_format='NDHWC',name=None,input=None,filters=None,dilations=None)
tbd


tf.compat.v1.nn.convolution(input,filter,padding,strides=None,dilation_rate=None,name=None,data_format=None,filters=None,dilations=None)
tbd


tf.compat.v1.nn.crelu(features,name=None,axis=-1)
tbd


tf.compat.v1.nn.ctc_beam_search_decoder(inputs,sequence_length,beam_width=100,top_paths=1,merge_repeated=True)
tbd


tf.compat.v1.nn.ctc_loss(labels,inputs=None,sequence_length=None,preprocess_collapse_repeated=False,ctc_merge_repeated=True,ignore_longer_outputs_than_inputs=False,time_major=True,logits=None)
tbd


tf.compat.v1.nn.depthwise_conv2d(input,filter,strides,padding,rate=None,name=None,data_format=None,dilations=None)
tbd


tf.compat.v1.nn.depthwise_conv2d_native(input,filter,strides,padding,data_format='NHWC',dilations=[1,1,1,1],name=None)
tbd


tf.compat.v1.nn.dilation2d(input,filter=None,strides=None,rates=None,padding=None,name=None,filters=None,dilations=None)
tbd


tf.compat.v1.nn.dropout(x,keep_prob=None,noise_shape=None,seed=None,name=None,rate=None)
tf.dropout(x,rate,noiseShape?,seed?)


tf.compat.v1.nn.dynamic_rnn(cell,inputs,sequence_length=None,initial_state=None,dtype=None,parallel_iterations=None,swap_memory=False,time_major=False,scope=None)
tbd


tf.compat.v1.nn.embedding_lookup(params,ids,partition_strategy='mod',name=None,validate_indices=True,max_norm=None)
tbd


tf.compat.v1.nn.embedding_lookup_sparse(params,sp_ids,sp_weights,partition_strategy='mod',name=None,combiner=None,max_norm=None)
tbd


tf.compat.v1.nn.erosion2d(value,kernel,strides,rates,padding,name=None)
tbd


tf.compat.v1.nn.fractional_avg_pool(value,pooling_ratio,pseudo_random=False,overlapping=False,deterministic=False,seed=0,seed2=0,name=None)
tbd


tf.compat.v1.nn.fractional_max_pool(value,pooling_ratio,pseudo_random=False,overlapping=False,deterministic=False,seed=0,seed2=0,name=None)
tbd


tf.compat.v1.nn.fused_batch_norm(x,scale,offset,mean=None,variance=None,epsilon=0.001,data_format='NHWC',is_training=True,name=None)
tbd


tf.compat.v1.nn.max_pool(value,ksize,strides,padding,data_format='NHWC',name=None,input=None)
tbd


tf.compat.v1.nn.max_pool_with_argmax(input,ksize,strides,padding,data_format='NHWC',Targmax=None,name=None,output_dtype=None,include_batch_in_index=False)
tbd


tf.compat.v1.nn.moments(x,axes,shift=None,name=None,keep_dims=None,keepdims=None)
tf.moments(x,axis?,keepDims?)


tf.compat.v1.nn.nce_loss(weights,biases,labels,inputs,num_sampled,num_classes,num_true=1,sampled_values=None,remove_accidental_hits=False,partition_strategy='mod',name='nce_loss')
tbd


tf.compat.v1.nn.pool(input,window_shape,pooling_type,padding,dilation_rate=None,strides=None,name=None,data_format=None,dilations=None)
tf.pool(input,windowShape,poolingType,pad,dilations?,strides?)


tf.compat.v1.nn.quantized_avg_pool(input,min_input,max_input,ksize,strides,padding,name=None)
tbd


tf.compat.v1.nn.quantized_conv2d(input,filter,min_input,max_input,min_filter,max_filter,strides,padding,out_type=tf.dtypes.qint32,dilations=[1,1,1,1],name=None)
tbd


tf.compat.v1.nn.quantized_max_pool(input,min_input,max_input,ksize,strides,padding,name=None)
tbd


tf.compat.v1.nn.quantized_relu_x(features,max_value,min_features,max_features,out_type=tf.dtypes.quint8,name=None)
tbd


tf.compat.v1.nn.raw_rnn(cell,loop_fn,parallel_iterations=None,swap_memory=False,scope=None)
tbd


tf.compat.v1.nn.relu_layer(x,weights,biases,name=None)
tbd


tf.compat.v1.nn.safe_embedding_lookup_sparse(embedding_weights,sparse_ids,sparse_weights=None,combiner='mean',default_id=None,name=None,partition_strategy='div',max_norm=None)
tbd


tf.compat.v1.nn.sampled_softmax_loss(weights,biases,labels,inputs,num_sampled,num_classes,num_true=1,sampled_values=None,remove_accidental_hits=True,partition_strategy='mod',name='sampled_softmax_loss',seed=None)
tbd


tf.compat.v1.nn.separable_conv2d(input,depthwise_filter,pointwise_filter,strides,padding,rate=None,name=None,data_format=None,dilations=None)
tbd


tf.compat.v1.nn.sigmoid_cross_entropy_with_logits(_sentinel=None,labels=None,logits=None,name=None)
tbd


tf.compat.v1.nn.softmax_cross_entropy_with_logits(_sentinel=None,labels=None,logits=None,dim=-1,name=None,axis=None)
tbd


tf.compat.v1.nn.softmax_cross_entropy_with_logits_v2(labels,logits,axis=None,name=None,dim=None)
tbd


tf.compat.v1.nn.sparse_softmax_cross_entropy_with_logits(_sentinel=None,labels=None,logits=None,name=None)
tbd


tf.compat.v1.nn.static_bidirectional_rnn(cell_fw,cell_bw,inputs,initial_state_fw=None,initial_state_bw=None,dtype=None,sequence_length=None,scope=None)
tbd


tf.compat.v1.nn.static_rnn(cell,inputs,initial_state=None,dtype=None,sequence_length=None,scope=None)
tbd


tf.compat.v1.nn.static_state_saving_rnn(cell,inputs,state_saver,state_name,sequence_length=None,scope=None)
tbd


tf.compat.v1.nn.sufficient_statistics(x,axes,shift=None,keep_dims=None,name=None,keepdims=None)
tbd


tf.compat.v1.nn.weighted_cross_entropy_with_logits(labels=None,logits=None,pos_weight=None,name=None,targets=None)
tbd


tf.compat.v1.nn.weighted_moments(x,axes,frequency_weights,name=None,keep_dims=None,keepdims=None)
tbd


tf.compat.v1.nn.xw_plus_b(x,weights,biases,name=None)
tbd


tf.compat.v1.no_regularizer(_)
tbd


tf.compat.v1.norm(tensor,ord='euclidean',axis=None,keepdims=None,name=None,keep_dims=None)
tf.norm(x,ord?,axis?,keepDims?)


tf.compat.v1.ones_like(tensor,dtype=None,name=None,optimize=True)
tbd


tf.compat.v1.op_scope(values,name,default_name=None)
tbd


tf.compat.v1.pad(tensor,paddings,mode='CONSTANT',name=None,constant_values=0)
tf.pad(x,paddings,constantValue?)


tf.compat.v1.parse_example(serialized,features,name=None,example_names=None)
tbd


tf.compat.v1.parse_single_example(serialized,features,name=None,example_names=None)
tbd


tf.compat.v1.placeholder(dtype,shape=None,name=None)
tbd


tf.compat.v1.placeholder_with_default(input,shape,name=None)
tbd


tf.compat.v1.profiler.advise(graph=None,run_meta=None,options=_DEFAULT_ADVISE_OPTIONS)
tbd


tf.compat.v1.profiler.profile(graph=None,run_meta=None,op_log=None,cmd='scope',options=_DEFAULT_PROFILE_OPTIONS)
tf.profile(f)


tf.compat.v1.profiler.write_op_log(graph,log_dir,op_log=None,run_meta=None,add_trace=True)
tbd


tf.compat.v1.py_func(func,inp,Tout,stateful=True,name=None)
tbd


tf.compat.v1.quantize_v2(input,min_range,max_range,T,mode='MIN_COMBINED',name=None,round_mode='HALF_AWAY_FROM_ZERO')
tbd


tf.compat.v1.ragged.constant_value(pylist,dtype=None,ragged_rank=None,inner_shape=None,row_splits_dtype='int64')
tbd


tf.compat.v1.ragged.placeholder(dtype,ragged_rank,value_shape=None,name=None)
tbd


tf.compat.v1.random.stateless_multinomial(logits,num_samples,seed,output_dtype=tf.dtypes.int64,name=None)
tbd


tf.compat.v1.random_poisson(lam,shape,dtype=tf.dtypes.float32,seed=None,name=None)
tbd


tf.compat.v1.reduce_all(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_any(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_join(inputs,axis=None,keep_dims=None,separator='',name=None,reduction_indices=None,keepdims=None)
tbd


tf.compat.v1.reduce_logsumexp(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_max(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_mean(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_min(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_prod(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.reduce_sum(input_tensor,axis=None,keepdims=None,name=None,reduction_indices=None,keep_dims=None)
tbd


tf.compat.v1.report_uninitialized_variables(var_list=None,name='report_uninitialized_variables')
tbd


tf.compat.v1.reset_default_graph()
tbd


tf.compat.v1.resource_loader.get_data_files_path()
tbd


tf.compat.v1.resource_loader.get_path_to_datafile(path)
tbd


tf.compat.v1.resource_loader.get_root_dir_with_all_resources()
tbd


tf.compat.v1.resource_loader.load_resource(path)
tbd


tf.compat.v1.resource_loader.readahead_file_path(path,readahead='128M')
tbd


tf.compat.v1.resource_variables_enabled()
tbd


tf.compat.v1.reverse_sequence(input,seq_lengths,seq_axis=None,batch_axis=None,name=None,seq_dim=None,batch_dim=None)
tbd


tf.compat.v1.saved_model.build_signature_def(inputs=None,outputs=None,method_name=None)
tbd


tf.compat.v1.saved_model.build_tensor_info(tensor)
tbd


tf.compat.v1.saved_model.classification_signature_def(examples,classes,scores)
tbd


tf.compat.v1.saved_model.contains_saved_model(export_dir)
tbd


tf.compat.v1.saved_model.get_tensor_from_tensor_info(tensor_info,graph=None,import_scope=None)
tbd


tf.compat.v1.saved_model.is_valid_signature(signature_def)
tbd


tf.compat.v1.saved_model.load(sess,tags,export_dir,import_scope=None,**saver_kwargs)
tbd


tf.compat.v1.saved_model.main_op.main_op()
tbd


tf.compat.v1.saved_model.main_op_with_restore(restore_op_name)
tbd


tf.compat.v1.saved_model.predict_signature_def(inputs,outputs)
tbd


tf.compat.v1.saved_model.regression_signature_def(examples,predictions)
tbd


tf.compat.v1.saved_model.simple_save(session,export_dir,inputs,outputs,legacy_init_op=None)
tbd


tf.compat.v1.scalar_mul(scalar,x,name=None)
tbd


tf.compat.v1.scatter_add(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_div(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_max(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_min(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_mul(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_nd_add(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_nd_sub(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_nd_update(ref,indices,updates,use_locking=True,name=None)
tbd


tf.compat.v1.scatter_sub(ref,indices,updates,use_locking=False,name=None)
tbd


tf.compat.v1.scatter_update(ref,indices,updates,use_locking=True,name=None)
tbd


tf.compat.v1.serialize_many_sparse(sp_input,name=None,out_type=tf.dtypes.string)
tbd


tf.compat.v1.serialize_sparse(sp_input,name=None,out_type=tf.dtypes.string)
tbd


tf.compat.v1.set_random_seed(seed)
tbd


tf.compat.v1.setdiff1d(x,y,index_dtype=tf.dtypes.int32,name=None)
tbd


tf.compat.v1.shape(input,name=None,out_type=tf.dtypes.int32)
tbd


tf.compat.v1.size(input,name=None,out_type=tf.dtypes.int32)
tbd


tf.compat.v1.space_to_batch(input,paddings,block_size=None,name=None,block_shape=None)
tbd


tf.compat.v1.space_to_depth(input,block_size,name=None,data_format='NHWC')
tbd


tf.compat.v1.sparse_add(a,b,threshold=None,thresh=None)
tbd


tf.compat.v1.sparse_concat(axis,sp_inputs,name=None,expand_nonconcat_dim=False,concat_dim=None,expand_nonconcat_dims=None)
tbd


tf.compat.v1.sparse_matmul(a,b,transpose_a=False,transpose_b=False,a_is_sparse=False,b_is_sparse=False,name=None)
tbd


tf.compat.v1.sparse_merge(sp_ids,sp_values,vocab_size,name=None,already_sorted=False)
tbd


tf.compat.v1.sparse_placeholder(dtype,shape=None,name=None)
tbd


tf.compat.v1.sparse_reduce_max(sp_input,axis=None,keepdims=None,reduction_axes=None,keep_dims=None)
tbd


tf.compat.v1.sparse_reduce_max_sparse(sp_input,axis=None,keepdims=None,reduction_axes=None,keep_dims=None)
tbd


tf.compat.v1.sparse_reduce_sum(sp_input,axis=None,keepdims=None,reduction_axes=None,keep_dims=None)
tbd


tf.compat.v1.sparse_reduce_sum_sparse(sp_input,axis=None,keepdims=None,reduction_axes=None,keep_dims=None)
tbd


tf.compat.v1.sparse_segment_mean(data,indices,segment_ids,name=None,num_segments=None)
tbd


tf.compat.v1.sparse_segment_sqrt_n(data,indices,segment_ids,name=None,num_segments=None)
tbd


tf.compat.v1.sparse_segment_sum(data,indices,segment_ids,name=None,num_segments=None)
tbd


tf.compat.v1.sparse_split(keyword_required=KeywordRequired(),sp_input=None,num_split=None,axis=None,name=None,split_dim=None)
tbd


tf.compat.v1.sparse_to_dense(sparse_indices,output_shape,sparse_values,default_value=0,validate_indices=True,name=None)
tbd


tf.compat.v1.squeeze(input,axis=None,name=None,squeeze_dims=None)
tf.squeeze(x,axis?)


tf.compat.v1.string_split(source,sep=None,skip_empty=True,delimiter=None,result_type='SparseTensor',name=None)
tbd


tf.compat.v1.string_to_hash_bucket(string_tensor=None,num_buckets=None,name=None,input=None)
tbd


tf.compat.v1.string_to_number(string_tensor=None,out_type=tf.dtypes.float32,name=None,input=None)
tbd


tf.compat.v1.strings.length(input,name=None,unit='BYTE')
tbd


tf.compat.v1.strings.split(input=None,sep=None,maxsplit=-1,result_type='SparseTensor',source=None,name=None)
tf.split(x,numOrSizeSplits,axis?)


tf.compat.v1.strings.substr(input,pos,len,name=None,unit='BYTE')
tbd


tf.compat.v1.substr(input,pos,len,name=None,unit='BYTE')
tbd


tf.compat.v1.summary.all_v2_summary_ops()
tbd


tf.compat.v1.summary.audio(name,tensor,sample_rate,max_outputs=3,collections=None,family=None)
tbd


tf.compat.v1.summary.get_summary_description(node_def)
tbd


tf.compat.v1.summary.histogram(name,values,collections=None,family=None)
tbd


tf.compat.v1.summary.image(name,tensor,max_outputs=3,collections=None,family=None)
tbd


tf.compat.v1.summary.initialize(graph=None,session=None)
tbd


tf.compat.v1.summary.merge(inputs,collections=None,name=None)
tbd


tf.compat.v1.summary.merge_all(key=tf.GraphKeys.SUMMARIES,scope=None,name=None)
tbd


tf.compat.v1.summary.scalar(name,tensor,collections=None,family=None)
tf.scalar(value,dtype?)


tf.compat.v1.summary.tensor_summary(name,tensor,summary_description=None,collections=None,summary_metadata=None,family=None,display_name=None)
tbd


tf.compat.v1.summary.text(name,tensor,collections=None)
tbd


tf.compat.v1.tables_initializer(name='init_all_tables')
tbd


tf.compat.v1.test.assert_equal_graph_def(actual,expected,checkpoint_v2=False,hash_table_shared_name=False)
tbd


tf.compat.v1.test.compute_gradient(x,x_shape,y,y_shape,x_init_value=None,delta=0.001,init_targets=None,extra_feed_dict=None)
tbd


tf.compat.v1.test.compute_gradient_error(x,x_shape,y,y_shape,x_init_value=None,delta=0.001,init_targets=None,extra_feed_dict=None)
tbd


tf.compat.v1.test.get_temp_dir()
tbd


tf.compat.v1.test.test_src_dir_path(relative_path)
tbd


tf.compat.v1.to_bfloat16(x,name='ToBFloat16')
tbd


tf.compat.v1.to_complex128(x,name='ToComplex128')
tbd


tf.compat.v1.to_complex64(x,name='ToComplex64')
tbd


tf.compat.v1.to_double(x,name='ToDouble')
tbd


tf.compat.v1.to_float(x,name='ToFloat')
tbd


tf.compat.v1.to_int32(x,name='ToInt32')
tbd


tf.compat.v1.to_int64(x,name='ToInt64')
tbd


tf.compat.v1.tpu.batch_parallel(computation,inputs=None,num_shards=1,infeed_queue=None,device_assignment=None,name=None)
tbd


tf.compat.v1.tpu.bfloat16_scope()
tbd


tf.compat.v1.tpu.core(num)
tbd


tf.compat.v1.tpu.cross_replica_sum(x,group_assignment=None,name=None)
tbd


tf.compat.v1.tpu.experimental.embedding_column(categorical_column,dimension,combiner='mean',initializer=None,max_sequence_length=0)
tbd


tf.compat.v1.tpu.experimental.shared_embedding_columns(categorical_columns,dimension,combiner='mean',initializer=None,shared_embedding_collection_name=None,max_sequence_lengths=None)
tbd


tf.compat.v1.tpu.initialize_system(embedding_config=None,job=None)
tbd


tf.compat.v1.tpu.outside_compilation(computation,*args,**kwargs)
tbd


tf.compat.v1.tpu.replicate(computation,inputs=None,infeed_queue=None,device_assignment=None,name=None,maximum_shapes=None)
tbd


tf.compat.v1.tpu.rewrite(computation,inputs=None,infeed_queue=None,device_assignment=None,name=None)
tbd


tf.compat.v1.tpu.shard(computation,inputs=None,num_shards=1,input_shard_axes=None,outputs_from_all_shards=True,output_shard_axes=None,infeed_queue=None,device_assignment=None,name=None)
tbd


tf.compat.v1.tpu.shutdown_system(job=None)
tbd


tf.compat.v1.train.MonitoredTrainingSession(master='',is_chief=True,checkpoint_dir=None,scaffold=None,hooks=None,chief_only_hooks=None,save_checkpoint_secs=USE_DEFAULT,save_summaries_steps=USE_DEFAULT,save_summaries_secs=USE_DEFAULT,config=None,stop_grace_period_secs=120,log_step_count_steps=100,max_wait_secs=7200,save_checkpoint_steps=USE_DEFAULT,summary_dir=None)
tbd


tf.compat.v1.train.NewCheckpointReader(filepattern)
tbd


tf.compat.v1.train.add_queue_runner(qr,collection=tf.GraphKeys.QUEUE_RUNNERS)
tbd


tf.compat.v1.train.assert_global_step(global_step_tensor)
tbd


tf.compat.v1.train.basic_train_loop(supervisor,train_step_fn,args=None,kwargs=None,master='')
tbd


tf.compat.v1.train.batch(tensors,batch_size,num_threads=1,capacity=32,enqueue_many=False,shapes=None,dynamic_pad=False,allow_smaller_final_batch=False,shared_name=None,name=None)
batch(batchSize,smallLastBatch?)


tf.compat.v1.train.batch_join(tensors_list,batch_size,capacity=32,enqueue_many=False,shapes=None,dynamic_pad=False,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.checkpoint_exists(checkpoint_prefix)
tbd


tf.compat.v1.train.cosine_decay(learning_rate,global_step,decay_steps,alpha=0.0,name=None)
tbd


tf.compat.v1.train.cosine_decay_restarts(learning_rate,global_step,first_decay_steps,t_mul=2.0,m_mul=1.0,alpha=0.0,name=None)
tbd


tf.compat.v1.train.create_global_step(graph=None)
tbd


tf.compat.v1.train.do_quantize_training_on_graphdef(input_graph,num_bits)
tbd


tf.compat.v1.train.experimental.disable_mixed_precision_graph_rewrite()
tbd


tf.compat.v1.train.experimental.enable_mixed_precision_graph_rewrite(opt,loss_scale='dynamic')
tbd


tf.compat.v1.train.exponential_decay(learning_rate,global_step,decay_steps,decay_rate,staircase=False,name=None)
tbd


tf.compat.v1.train.export_meta_graph(filename=None,meta_info_def=None,graph_def=None,saver_def=None,collection_list=None,as_text=False,graph=None,export_scope=None,clear_devices=False,clear_extraneous_savers=False,strip_default_attrs=False,save_debug_info=False,**kwargs)
tbd


tf.compat.v1.train.generate_checkpoint_state_proto(save_dir,model_checkpoint_path,all_model_checkpoint_paths=None,all_model_checkpoint_timestamps=None,last_preserved_timestamp=None)
tbd


tf.compat.v1.train.get_checkpoint_mtimes(checkpoint_prefixes)
tbd


tf.compat.v1.train.get_global_step(graph=None)
tbd


tf.compat.v1.train.get_or_create_global_step(graph=None)
tbd


tf.compat.v1.train.global_step(sess,global_step_tensor)
tbd


tf.compat.v1.train.import_meta_graph(meta_graph_or_file,clear_devices=False,import_scope=None,**kwargs)
tbd


tf.compat.v1.train.init_from_checkpoint(ckpt_dir_or_file,assignment_map)
tbd


tf.compat.v1.train.input_producer(input_tensor,element_shape=None,num_epochs=None,shuffle=True,seed=None,capacity=32,shared_name=None,summary_name=None,name=None,cancel_op=None)
tbd


tf.compat.v1.train.inverse_time_decay(learning_rate,global_step,decay_steps,decay_rate,staircase=False,name=None)
tbd


tf.compat.v1.train.limit_epochs(tensor,num_epochs=None,name=None)
tbd


tf.compat.v1.train.linear_cosine_decay(learning_rate,global_step,decay_steps,num_periods=0.5,alpha=0.0,beta=0.001,name=None)
tbd


tf.compat.v1.train.maybe_batch(tensors,keep_input,batch_size,num_threads=1,capacity=32,enqueue_many=False,shapes=None,dynamic_pad=False,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.maybe_batch_join(tensors_list,keep_input,batch_size,capacity=32,enqueue_many=False,shapes=None,dynamic_pad=False,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.maybe_shuffle_batch(tensors,batch_size,capacity,min_after_dequeue,keep_input,num_threads=1,seed=None,enqueue_many=False,shapes=None,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.maybe_shuffle_batch_join(tensors_list,batch_size,capacity,min_after_dequeue,keep_input,seed=None,enqueue_many=False,shapes=None,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.natural_exp_decay(learning_rate,global_step,decay_steps,decay_rate,staircase=False,name=None)
tbd


tf.compat.v1.train.noisy_linear_cosine_decay(learning_rate,global_step,decay_steps,initial_variance=1.0,variance_decay=0.55,num_periods=0.5,alpha=0.0,beta=0.001,name=None)
tbd


tf.compat.v1.train.piecewise_constant(x,boundaries,values,name=None)
tbd


tf.compat.v1.train.polynomial_decay(learning_rate,global_step,decay_steps,end_learning_rate=0.0001,power=1.0,cycle=False,name=None)
tbd


tf.compat.v1.train.range_input_producer(limit,num_epochs=None,shuffle=True,seed=None,capacity=32,shared_name=None,name=None)
tbd


tf.compat.v1.train.remove_checkpoint(checkpoint_prefix,checkpoint_format_version=tf.train.SaverDef.V2,meta_graph_suffix='meta')
tbd


tf.compat.v1.train.replica_device_setter(ps_tasks=0,ps_device='/job:ps',worker_device='/job:worker',merge_devices=True,cluster=None,ps_ops=None,ps_strategy=None)
tbd


tf.compat.v1.train.sdca_fprint(input,name=None)
tbd


tf.compat.v1.train.sdca_optimizer(sparse_example_indices,sparse_feature_indices,sparse_feature_values,dense_features,example_weights,example_labels,sparse_indices,sparse_weights,dense_weights,example_state_data,loss_type,l1,l2,num_loss_partitions,num_inner_iterations,adaptative=True,name=None)
tbd


tf.compat.v1.train.sdca_shrink_l1(weights,l1,l2,name=None)
tbd


tf.compat.v1.train.shuffle_batch(tensors,batch_size,capacity,min_after_dequeue,num_threads=1,seed=None,enqueue_many=False,shapes=None,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.shuffle_batch_join(tensors_list,batch_size,capacity,min_after_dequeue,seed=None,enqueue_many=False,shapes=None,allow_smaller_final_batch=False,shared_name=None,name=None)
tbd


tf.compat.v1.train.slice_input_producer(tensor_list,num_epochs=None,shuffle=True,seed=None,capacity=32,shared_name=None,name=None)
tbd


tf.compat.v1.train.start_queue_runners(sess=None,coord=None,daemon=True,start=True,collection=tf.GraphKeys.QUEUE_RUNNERS)
tbd


tf.compat.v1.train.string_input_producer(string_tensor,num_epochs=None,shuffle=True,seed=None,capacity=32,shared_name=None,name=None,cancel_op=None)
tbd


tf.compat.v1.train.summary_iterator(path)
tbd


tf.compat.v1.train.update_checkpoint_state(save_dir,model_checkpoint_path,all_model_checkpoint_paths=None,latest_filename=None,all_model_checkpoint_timestamps=None,last_preserved_timestamp=None)
tbd


tf.compat.v1.train.warm_start(ckpt_to_initialize_from,vars_to_warm_start='.*',var_name_to_vocab_info=None,var_name_to_prev_var_name=None)
tbd


tf.compat.v1.trainable_variables(scope=None)
tbd


tf.compat.v1.transpose(a,perm=None,name='transpose',conjugate=False)
tf.transpose(x,perm?)


tf.compat.v1.tuple(tensors,name=None,control_inputs=None)
tbd


tf.compat.v1.user_ops.my_fact()
tbd


tf.compat.v1.variable_axis_size_partitioner(max_shard_bytes,axis=0,bytes_per_string_element=16,max_shards=None)
tbd


tf.compat.v1.variable_creator_scope(variable_creator)
tbd


tf.compat.v1.variable_op_scope(values,name_or_scope,default_name=None,initializer=None,regularizer=None,caching_device=None,partitioner=None,custom_getter=None,reuse=None,dtype=None,use_resource=None,constraint=None)
tbd


tf.compat.v1.variables_initializer(var_list,name='init')
tbd


tf.compat.v1.verify_tensor_all_finite(t=None,msg=None,name=None,x=None,message=None)
tbd


tf.compat.v1.where(condition,x=None,y=None,name=None)
tf.where(condition,a,b)


tf.compat.v1.while_loop(cond,body,loop_vars,shape_invariants=None,parallel_iterations=10,back_prop=True,swap_memory=False,name=None,maximum_iterations=None,return_same_structure=False)
tbd


tf.compat.v1.wrap_function(fn,signature,name=None)
tbd


tf.compat.v1.zeros_like(tensor,dtype=None,name=None,optimize=True)
tbd


tf.concat(values,axis,name='concat')
tf.concat(tensors,axis?)


tf.cond(pred,true_fn=None,false_fn=None,name=None)
tbd


tf.config.experimental.get_device_policy()
tbd


tf.config.experimental.get_memory_growth(device)
tbd


tf.config.experimental.get_synchronous_execution()
tbd


tf.config.experimental.get_virtual_device_configuration(device)
tbd


tf.config.experimental.get_visible_devices(device_type=None)
tbd


tf.config.experimental.list_logical_devices(device_type=None)
tbd


tf.config.experimental.list_physical_devices(device_type=None)
tbd


tf.config.experimental.set_device_policy(device_policy)
tbd


tf.config.experimental.set_memory_growth(device,enable)
tbd


tf.config.experimental.set_synchronous_execution(enable)
tbd


tf.config.experimental.set_virtual_device_configuration(device,virtual_devices)
tbd


tf.config.experimental.set_visible_devices(devices,device_type=None)
tbd


tf.config.experimental_connect_to_cluster(cluster_spec_or_resolver,job_name='localhost',task_index=0,protocol=None,make_master_device_default=True)
tbd


tf.config.experimental_connect_to_host(remote_host=None,job_name='worker')
tbd


tf.config.experimental_list_devices()
tbd


tf.config.experimental_run_functions_eagerly(run_eagerly)
tbd


tf.config.get_soft_device_placement()
tbd


tf.config.optimizer.get_experimental_options()
tbd


tf.config.optimizer.get_jit()
tbd


tf.config.optimizer.set_experimental_options(options)
tbd


tf.config.optimizer.set_jit(enabled)
tbd


tf.config.set_soft_device_placement(enabled)
tbd


tf.config.threading.get_inter_op_parallelism_threads()
tbd


tf.config.threading.get_intra_op_parallelism_threads()
tbd


tf.config.threading.set_inter_op_parallelism_threads(num_threads)
tbd


tf.config.threading.set_intra_op_parallelism_threads(num_threads)
tbd


tf.constant(value,dtype=None,shape=None,name='Const')
tf.initializers.constant(args)


tf.control_dependencies(control_inputs)
tbd


tf.convert_to_tensor(value,dtype=None,dtype_hint=None,name=None)
tbd


tf.custom_gradient(f)
tbd


tf.data.experimental.Counter(start=0,step=1,dtype=tf.dtypes.int64)
tbd


tf.data.experimental.bucket_by_sequence_length(element_length_func,bucket_boundaries,bucket_batch_sizes,padded_shapes=None,padding_values=None,pad_to_bucket_boundary=False,no_padding=False,drop_remainder=False)
tbd


tf.data.experimental.bytes_produced_stats(tag)
tbd


tf.data.experimental.cardinality(dataset)
tbd


tf.data.experimental.choose_from_datasets(datasets,choice_dataset)
tbd


tf.data.experimental.copy_to_device(target_device,source_device='/cpu:0')
tbd


tf.data.experimental.dense_to_sparse_batch(batch_size,row_shape)
tbd


tf.data.experimental.enumerate_dataset(start=0)
tbd


tf.data.experimental.from_variant(variant,structure)
tbd


tf.data.experimental.get_next_as_optional(iterator)
tbd


tf.data.experimental.get_single_element(dataset)
tbd


tf.data.experimental.get_structure(dataset_or_iterator)
tbd


tf.data.experimental.group_by_reducer(key_func,reducer)
tbd


tf.data.experimental.group_by_window(key_func,reduce_func,window_size=None,window_size_func=None)
tbd


tf.data.experimental.ignore_errors()
tbd


tf.data.experimental.latency_stats(tag)
tbd


tf.data.experimental.make_batched_features_dataset(file_pattern,batch_size,features,reader=tf.compat.v1.data.TFRecordDataset,label_key=None,reader_args=None,num_epochs=None,shuffle=True,shuffle_buffer_size=10000,shuffle_seed=None,prefetch_buffer_size=dataset_ops.AUTOTUNE,reader_num_threads=1,parser_num_threads=2,sloppy_ordering=False,drop_final_batch=False)
tbd


tf.data.experimental.make_csv_dataset(file_pattern,batch_size,column_names=None,column_defaults=None,label_name=None,select_columns=None,field_delim=',',use_quote_delim=True,na_value='',header=True,num_epochs=None,shuffle=True,shuffle_buffer_size=10000,shuffle_seed=None,prefetch_buffer_size=dataset_ops.AUTOTUNE,num_parallel_reads=1,sloppy=False,num_rows_for_inference=100,compression_type=None,ignore_errors=False)
tbd


tf.data.experimental.make_saveable_from_iterator(iterator)
tbd


tf.data.experimental.map_and_batch(map_func,batch_size,num_parallel_batches=None,drop_remainder=False,num_parallel_calls=None)
tbd


tf.data.experimental.parallel_interleave(map_func,cycle_length,block_length=1,sloppy=False,buffer_output_elements=None,prefetch_input_elements=None)
tbd


tf.data.experimental.parse_example_dataset(features,num_parallel_calls=1)
tbd


tf.data.experimental.prefetch_to_device(device,buffer_size=None)
tbd


tf.data.experimental.rejection_resample(class_func,target_dist,initial_dist=None,seed=None)
tbd


tf.data.experimental.sample_from_datasets(datasets,weights=None,seed=None)
tbd


tf.data.experimental.scan(initial_state,scan_func)
tbd


tf.data.experimental.shuffle_and_repeat(buffer_size,count=None,seed=None)
tbd


tf.data.experimental.take_while(predicate)
tbd


tf.data.experimental.to_variant(dataset)
tbd


tf.data.experimental.unbatch()
tbd


tf.data.experimental.unique()
tbd


tf.debugging.Assert(condition,data,summarize=None,name=None)
tbd


tf.debugging.assert_all_finite(x,message,name=None)
tbd


tf.debugging.assert_equal(x,y,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_greater(x,y,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_greater_equal(x,y,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_integer(x,message=None,name=None)
tbd


tf.debugging.assert_less(x,y,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_less_equal(x,y,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_near(x,y,rtol=None,atol=None,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_negative(x,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_non_negative(x,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_non_positive(x,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_none_equal(x,y,summarize=None,message=None,name=None)
tbd


tf.debugging.assert_positive(x,message=None,summarize=None,name=None)
tbd


tf.debugging.assert_proper_iterable(values)
tbd


tf.debugging.assert_rank(x,rank,message=None,name=None)
tbd


tf.debugging.assert_rank_at_least(x,rank,message=None,name=None)
tbd


tf.debugging.assert_rank_in(x,ranks,message=None,name=None)
tbd


tf.debugging.assert_same_float_dtype(tensors=None,dtype=None)
tbd


tf.debugging.assert_scalar(tensor,message=None,name=None)
tbd


tf.debugging.assert_shapes(shapes,data=None,summarize=None,message=None,name=None)
tbd


tf.debugging.assert_type(tensor,tf_type,message=None,name=None)
tbd


tf.debugging.check_numerics(tensor,message,name=None)
tbd


tf.debugging.get_log_device_placement()
tbd


tf.debugging.is_numeric_tensor(tensor)
tbd


tf.debugging.set_log_device_placement(enabled)
tbd


tf.device(device_name)
tbd


tf.distribute.experimental_set_strategy(strategy)
tbd


tf.distribute.get_replica_context()
tbd


tf.distribute.get_strategy()
tbd


tf.distribute.has_strategy()
tbd


tf.distribute.in_cross_replica_context()
tbd


tf.dtypes.as_dtype(type_value)
tbd


tf.dtypes.cast(x,dtype,name=None)
tf.cast(x,dtype)


tf.dtypes.complex(real,imag,name=None)
tf.complex(real,imag)


tf.dtypes.saturate_cast(value,dtype,name=None)
tbd


tf.dynamic_partition(data,partitions,num_partitions,name=None)
tbd


tf.dynamic_stitch(indices,data,name=None)
tbd


tf.edit_distance(hypothesis,truth,normalize=True,name='edit_distance')
tbd


tf.einsum(equation,*inputs,**kwargs)
tbd


tf.ensure_shape(x,shape,name=None)
tbd


tf.estimator.add_metrics(estimator,metric_fn)
tbd


tf.estimator.classifier_parse_example_spec(feature_columns,label_key,label_dtype=tf.dtypes.int64,label_default=None,weight_column=None)
tbd


tf.estimator.experimental.build_raw_supervised_input_receiver_fn(features,labels,default_batch_size=None)
tbd


tf.estimator.experimental.call_logit_fn(logit_fn,features,mode,params,config)
tbd


tf.estimator.experimental.make_early_stopping_hook(estimator,should_stop_fn,run_every_secs=60,run_every_steps=None)
tbd


tf.estimator.experimental.make_stop_at_checkpoint_step_hook(estimator,last_step,wait_after_file_check_secs=30)
tbd


tf.estimator.experimental.stop_if_higher_hook(estimator,metric_name,threshold,eval_dir=None,min_steps=0,run_every_secs=60,run_every_steps=None)
tbd


tf.estimator.experimental.stop_if_lower_hook(estimator,metric_name,threshold,eval_dir=None,min_steps=0,run_every_secs=60,run_every_steps=None)
tbd


tf.estimator.experimental.stop_if_no_decrease_hook(estimator,metric_name,max_steps_without_decrease,eval_dir=None,min_steps=0,run_every_secs=60,run_every_steps=None)
tbd


tf.estimator.experimental.stop_if_no_increase_hook(estimator,metric_name,max_steps_without_increase,eval_dir=None,min_steps=0,run_every_secs=60,run_every_steps=None)
tbd


tf.estimator.export.build_parsing_serving_input_receiver_fn(feature_spec,default_batch_size=None)
tbd


tf.estimator.export.build_raw_serving_input_receiver_fn(features,default_batch_size=None)
tbd


tf.estimator.regressor_parse_example_spec(feature_columns,label_key,label_dtype=tf.dtypes.float32,label_default=None,label_dimension=1,weight_column=None)
tbd


tf.estimator.train_and_evaluate(estimator,train_spec,eval_spec)
tbd


tf.executing_eagerly()
tbd


tf.expand_dims(input,axis,name=None)
tbd


tf.experimental.function_executor_type(executor_type)
tbd


tf.extract_volume_patches(input,ksizes,strides,padding,name=None)
tbd


tf.eye(num_rows,num_columns=None,batch_shape=None,dtype=tf.dtypes.float32,name=None)
tf.eye(numRows,numColumns?,batchShape?,dtype?)


tf.feature_column.bucketized_column(source_column,boundaries)
tbd


tf.feature_column.categorical_column_with_hash_bucket(key,hash_bucket_size,dtype=tf.dtypes.string)
tbd


tf.feature_column.categorical_column_with_identity(key,num_buckets,default_value=None)
tbd


tf.feature_column.categorical_column_with_vocabulary_file(key,vocabulary_file,vocabulary_size=None,dtype=tf.dtypes.string,default_value=None,num_oov_buckets=0)
tbd


tf.feature_column.categorical_column_with_vocabulary_list(key,vocabulary_list,dtype=None,default_value=-1,num_oov_buckets=0)
tbd


tf.feature_column.crossed_column(keys,hash_bucket_size,hash_key=None)
tbd


tf.feature_column.embedding_column(categorical_column,dimension,combiner='mean',initializer=None,ckpt_to_load_from=None,tensor_name_in_ckpt=None,max_norm=None,trainable=True)
tbd


tf.feature_column.indicator_column(categorical_column)
tbd


tf.feature_column.make_parse_example_spec(feature_columns)
tbd


tf.feature_column.numeric_column(key,shape=(1,),default_value=None,dtype=tf.dtypes.float32,normalizer_fn=None)
tbd


tf.feature_column.sequence_categorical_column_with_hash_bucket(key,hash_bucket_size,dtype=tf.dtypes.string)
tbd


tf.feature_column.sequence_categorical_column_with_identity(key,num_buckets,default_value=None)
tbd


tf.feature_column.sequence_categorical_column_with_vocabulary_file(key,vocabulary_file,vocabulary_size=None,num_oov_buckets=0,default_value=None,dtype=tf.dtypes.string)
tbd


tf.feature_column.sequence_categorical_column_with_vocabulary_list(key,vocabulary_list,dtype=None,default_value=-1,num_oov_buckets=0)
tbd


tf.feature_column.sequence_numeric_column(key,shape=(1,),default_value=0.0,dtype=tf.dtypes.float32,normalizer_fn=None)
tbd


tf.feature_column.shared_embeddings(categorical_columns,dimension,combiner='mean',initializer=None,shared_embedding_collection_name=None,ckpt_to_load_from=None,tensor_name_in_ckpt=None,max_norm=None,trainable=True)
tbd


tf.feature_column.weighted_categorical_column(categorical_column,weight_feature_key,dtype=tf.dtypes.float32)
tbd


tf.fill(dims,value,name=None)
tf.fill(shape,value,dtype?)


tf.fingerprint(data,method='farmhash64',name=None)
tbd


tf.foldl(fn,elems,initializer=None,parallel_iterations=10,back_prop=True,swap_memory=False,name=None)
tbd


tf.foldr(fn,elems,initializer=None,parallel_iterations=10,back_prop=True,swap_memory=False,name=None)
tbd


tf.function(func=None,input_signature=None,autograph=True,experimental_autograph_options=None,experimental_relax_shapes=False)
tbd


tf.gather(params,indices,validate_indices=None,axis=None,batch_dims=0,name=None)
tf.gather(x,indices,axis?)


tf.gather_nd(params,indices,batch_dims=0,name=None)
tbd


tf.get_logger()
tbd


tf.get_static_value(tensor,partial=False)
tbd


tf.grad_pass_through(f)
tbd


tf.gradients(ys,xs,grad_ys=None,name='gradients',gate_gradients=False,aggregation_method=None,stop_gradients=None,unconnected_gradients=tf.UnconnectedGradients.NONE)
tbd


tf.graph_util.import_graph_def(graph_def,input_map=None,return_elements=None,name=None,op_dict=None,producer_op_list=None)
tbd


tf.guarantee_const(input,name=None)
tbd


tf.hessians(ys,xs,gate_gradients=False,aggregation_method=None,name='hessians')
tbd


tf.histogram_fixed_width(values,value_range,nbins=100,dtype=tf.dtypes.int32,name=None)
tbd


tf.histogram_fixed_width_bins(values,value_range,nbins=100,dtype=tf.dtypes.int32,name=None)
tbd


tf.identity(input,name=None)
tf.initializers.identity(args)


tf.identity_n(input,name=None)
tbd


tf.image.adjust_brightness(image,delta)
tbd


tf.image.adjust_contrast(images,contrast_factor)
tbd


tf.image.adjust_gamma(image,gamma=1,gain=1)
tbd


tf.image.adjust_hue(image,delta,name=None)
tbd


tf.image.adjust_jpeg_quality(image,jpeg_quality,name=None)
tbd


tf.image.adjust_saturation(image,saturation_factor,name=None)
tbd


tf.image.central_crop(image,central_fraction)
tbd


tf.image.combined_non_max_suppression(boxes,scores,max_output_size_per_class,max_total_size,iou_threshold=0.5,score_threshold=float('-inf'),pad_per_class=False,clip_boxes=True,name=None)
tbd


tf.image.convert_image_dtype(image,dtype,saturate=False,name=None)
tbd


tf.image.crop_and_resize(image,boxes,box_indices,crop_size,method='bilinear',extrapolation_value=0,name=None)
tbd


tf.image.crop_to_bounding_box(image,offset_height,offset_width,target_height,target_width)
tbd


tf.image.draw_bounding_boxes(images,boxes,colors,name=None)
tbd


tf.image.encode_png(image,compression=-1,name=None)
tbd


tf.image.extract_patches(images,sizes,strides,rates,padding,name=None)
tbd


tf.image.flip_left_right(image)
tbd


tf.image.flip_up_down(image)
tbd


tf.image.grayscale_to_rgb(images,name=None)
tbd


tf.image.hsv_to_rgb(images,name=None)
tbd


tf.image.image_gradients(image)
tbd


tf.image.non_max_suppression(boxes,scores,max_output_size,iou_threshold=0.5,score_threshold=float('-inf'),name=None)
tbd


tf.image.non_max_suppression_overlaps(overlaps,scores,max_output_size,overlap_threshold=0.5,score_threshold=float('-inf'),name=None)
tbd


tf.image.non_max_suppression_padded(boxes,scores,max_output_size,iou_threshold=0.5,score_threshold=float('-inf'),pad_to_max_output_size=False,name=None)
tbd


tf.image.non_max_suppression_with_scores(boxes,scores,max_output_size,iou_threshold=0.5,score_threshold=float('-inf'),soft_nms_sigma=0.0,name=None)
tbd


tf.image.pad_to_bounding_box(image,offset_height,offset_width,target_height,target_width)
tbd


tf.image.per_image_standardization(image)
tbd


tf.image.psnr(a,b,max_val,name=None)
tbd


tf.image.random_brightness(image,max_delta,seed=None)
tbd


tf.image.random_contrast(image,lower,upper,seed=None)
tbd


tf.image.random_crop(value,size,seed=None,name=None)
tbd


tf.image.random_flip_left_right(image,seed=None)
tbd


tf.image.random_flip_up_down(image,seed=None)
tbd


tf.image.random_hue(image,max_delta,seed=None)
tbd


tf.image.random_jpeg_quality(image,min_jpeg_quality,max_jpeg_quality,seed=None)
tbd


tf.image.random_saturation(image,lower,upper,seed=None)
tbd


tf.image.resize(images,size,method=ResizeMethod.BILINEAR,preserve_aspect_ratio=False,antialias=False,name=None)
tbd


tf.image.resize_with_crop_or_pad(image,target_height,target_width)
tbd


tf.image.resize_with_pad(image,target_height,target_width,method=ResizeMethod.BILINEAR,antialias=False)
tbd


tf.image.rgb_to_grayscale(images,name=None)
tbd


tf.image.rgb_to_hsv(images,name=None)
tbd


tf.image.rgb_to_yiq(images)
tbd


tf.image.rgb_to_yuv(images)
tbd


tf.image.rot90(image,k=1,name=None)
tbd


tf.image.sample_distorted_bounding_box(image_size,bounding_boxes,seed=0,min_object_covered=0.1,aspect_ratio_range=None,area_range=None,max_attempts=None,use_image_if_no_bounding_boxes=None,name=None)
tbd


tf.image.sobel_edges(image)
tbd


tf.image.ssim(img1,img2,max_val,filter_size=11,filter_sigma=1.5,k1=0.01,k2=0.03)
tbd


tf.image.ssim_multiscale(img1,img2,max_val,power_factors=_MSSSIM_WEIGHTS,filter_size=11,filter_sigma=1.5,k1=0.01,k2=0.03)
tbd


tf.image.total_variation(images,name=None)
tbd


tf.image.transpose(image,name=None)
tf.transpose(x,perm?)


tf.image.yiq_to_rgb(images)
tbd


tf.image.yuv_to_rgb(images)
tbd


tf.init_scope()
tbd


tf.io.decode_and_crop_jpeg(contents,crop_window,channels=0,ratio=1,fancy_upscaling=True,try_recover_truncated=False,acceptable_fraction=1,dct_method='',name=None)
tbd


tf.io.decode_base64(input,name=None)
tbd


tf.io.decode_bmp(contents,channels=0,name=None)
tbd


tf.io.decode_compressed(bytes,compression_type='',name=None)
tbd


tf.io.decode_csv(records,record_defaults,field_delim=',',use_quote_delim=True,na_value='',select_cols=None,name=None)
tbd


tf.io.decode_gif(contents,name=None)
tbd


tf.io.decode_image(contents,channels=None,dtype=tf.dtypes.uint8,name=None,expand_animations=True)
tbd


tf.io.decode_jpeg(contents,channels=0,ratio=1,fancy_upscaling=True,try_recover_truncated=False,acceptable_fraction=1,dct_method='',name=None)
tbd


tf.io.decode_json_example(json_examples,name=None)
tbd


tf.io.decode_png(contents,channels=0,dtype=tf.dtypes.uint8,name=None)
tbd


tf.io.decode_proto(bytes,message_type,field_names,output_types,descriptor_source='local://',message_format='binary',sanitize=False,name=None)
tbd


tf.io.decode_raw(input_bytes,out_type,little_endian=True,fixed_length=None,name=None)
tbd


tf.io.deserialize_many_sparse(serialized_sparse,dtype,rank=None,name=None)
tbd


tf.io.encode_base64(input,pad=False,name=None)
tbd


tf.io.encode_jpeg(image,format='',quality=95,progressive=False,optimize_size=False,chroma_downsampling=True,density_unit='in',x_density=300,y_density=300,xmp_metadata='',name=None)
tbd


tf.io.encode_proto(sizes,values,field_names,message_type,descriptor_source='local://',name=None)
tbd


tf.io.extract_jpeg_shape(contents,output_type=tf.dtypes.int32,name=None)
tbd


tf.io.gfile.copy(src,dst,overwrite=False)
tbd


tf.io.gfile.exists(path)
tbd


tf.io.gfile.glob(pattern)
tbd


tf.io.gfile.isdir(path)
tbd


tf.io.gfile.listdir(path)
tbd


tf.io.gfile.makedirs(path)
tbd


tf.io.gfile.mkdir(path)
tbd


tf.io.gfile.remove(path)
tbd


tf.io.gfile.rename(src,dst,overwrite=False)
tbd


tf.io.gfile.rmtree(path)
tbd


tf.io.gfile.stat(path)
tbd


tf.io.gfile.walk(top,topdown=True,onerror=None)
tbd


tf.io.is_jpeg(contents,name=None)
tbd


tf.io.match_filenames_once(pattern,name=None)
tbd


tf.io.matching_files(pattern,name=None)
tbd


tf.io.parse_example(serialized,features,example_names=None,name=None)
tbd


tf.io.parse_sequence_example(serialized,context_features=None,sequence_features=None,example_names=None,name=None)
tbd


tf.io.parse_single_example(serialized,features,example_names=None,name=None)
tbd


tf.io.parse_single_sequence_example(serialized,context_features=None,sequence_features=None,example_name=None,name=None)
tbd


tf.io.parse_tensor(serialized,out_type,name=None)
tbd


tf.io.read_file(filename,name=None)
tbd


tf.io.serialize_many_sparse(sp_input,out_type=tf.dtypes.string,name=None)
tbd


tf.io.serialize_sparse(sp_input,out_type=tf.dtypes.string,name=None)
tbd


tf.io.serialize_tensor(tensor,name=None)
tbd


tf.io.write_file(filename,contents,name=None)
tbd


tf.io.write_graph(graph_or_graph_def,logdir,name,as_text=True)
tbd


tf.is_tensor(x)
tbd


tf.keras.Input(shape=None,batch_size=None,name=None,dtype=None,sparse=False,tensor=None,ragged=False,**kwargs)
tbd


tf.keras.activations.deserialize(name,custom_objects=None)
tbd


tf.keras.activations.elu(x,alpha=1.0)
tf.elu(x)


tf.keras.activations.exponential(x)
tbd


tf.keras.activations.get(identifier)
get(...locs)


tf.keras.activations.hard_sigmoid(x)
tbd


tf.keras.activations.linear(x)
tbd


tf.keras.activations.relu(x,alpha=0.0,max_value=None,threshold=0)
tf.relu(x)


tf.keras.activations.selu(x)
tf.selu(x)


tf.keras.activations.serialize(activation)
tbd


tf.keras.activations.sigmoid(x)
tf.sigmoid(x)


tf.keras.activations.softmax(x,axis=-1)
tf.softmax(logits,dim?)


tf.keras.activations.softplus(x)
tf.softplus(x)


tf.keras.activations.softsign(x)
tbd


tf.keras.activations.tanh(x)
tf.tanh(x)


tf.keras.applications.DenseNet121(*args,**kwargs)
tbd


tf.keras.applications.DenseNet169(*args,**kwargs)
tbd


tf.keras.applications.DenseNet201(*args,**kwargs)
tbd


tf.keras.applications.InceptionResNetV2(*args,**kwargs)
tbd


tf.keras.applications.InceptionV3(*args,**kwargs)
tbd


tf.keras.applications.MobileNet(*args,**kwargs)
tbd


tf.keras.applications.MobileNetV2(*args,**kwargs)
tbd


tf.keras.applications.NASNetLarge(*args,**kwargs)
tbd


tf.keras.applications.NASNetMobile(*args,**kwargs)
tbd


tf.keras.applications.ResNet101(*args,**kwargs)
tbd


tf.keras.applications.ResNet101V2(*args,**kwargs)
tbd


tf.keras.applications.ResNet152(*args,**kwargs)
tbd


tf.keras.applications.ResNet152V2(*args,**kwargs)
tbd


tf.keras.applications.ResNet50(*args,**kwargs)
tbd


tf.keras.applications.ResNet50V2(*args,**kwargs)
tbd


tf.keras.applications.VGG16(*args,**kwargs)
tbd


tf.keras.applications.VGG19(*args,**kwargs)
tbd


tf.keras.applications.Xception(*args,**kwargs)
tbd


tf.keras.applications.densenet.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.densenet.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.imagenet_utils.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.imagenet_utils.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.inception_resnet_v2.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.inception_resnet_v2.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.inception_v3.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.inception_v3.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.mobilenet.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.mobilenet.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.mobilenet_v2.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.mobilenet_v2.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.nasnet.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.nasnet.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.resnet.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.resnet.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.resnet_v2.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.resnet_v2.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.vgg16.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.vgg16.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.vgg19.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.vgg19.preprocess_input(*args,**kwargs)
tbd


tf.keras.applications.xception.decode_predictions(*args,**kwargs)
tbd


tf.keras.applications.xception.preprocess_input(*args,**kwargs)
tbd


tf.keras.backend.abs(x)
tf.abs(x)


tf.keras.backend.all(x,axis=None,keepdims=False)
tf.all(x,axis?,keepDims?)


tf.keras.backend.any(x,axis=None,keepdims=False)
tf.any(x,axis?,keepDims?)


tf.keras.backend.arange(start,stop=None,step=1,dtype='int32')
tbd


tf.keras.backend.argmax(x,axis=-1)
tbd


tf.keras.backend.argmin(x,axis=-1)
tbd


tf.keras.backend.backend()
tf.backend()


tf.keras.backend.batch_dot(x,y,axes=None)
tbd


tf.keras.backend.batch_flatten(x)
tbd


tf.keras.backend.batch_get_value(tensors)
tbd


tf.keras.backend.batch_normalization(x,mean,var,beta,gamma,axis=-1,epsilon=0.001)
tbd


tf.keras.backend.batch_set_value(tuples)
tbd


tf.keras.backend.bias_add(x,bias,data_format=None)
tbd


tf.keras.backend.binary_crossentropy(target,output,from_logits=False)
tbd


tf.keras.backend.cast(x,dtype)
tf.cast(x,dtype)


tf.keras.backend.cast_to_floatx(x)
tbd


tf.keras.backend.categorical_crossentropy(target,output,from_logits=False,axis=-1)
tbd


tf.keras.backend.clear_session()
tbd


tf.keras.backend.clip(x,min_value,max_value)
tbd


tf.keras.backend.concatenate(tensors,axis=-1)
concatenate(dataset)


tf.keras.backend.constant(value,dtype=None,shape=None,name=None)
tf.initializers.constant(args)


tf.keras.backend.conv1d(x,kernel,strides=1,padding='valid',data_format=None,dilation_rate=1)
tf.conv1d(x,filter,stride,pad,dataFormat?,dilation?,dimRoundingMode?)


tf.keras.backend.conv2d(x,kernel,strides=(1,1),padding='valid',data_format=None,dilation_rate=(1,1))
tf.conv2d(x,filter,strides,pad,dataFormat?,dilations?,dimRoundingMode?)


tf.keras.backend.conv2d_transpose(x,kernel,output_shape,strides=(1,1),padding='valid',data_format=None,dilation_rate=(1,1))
tbd


tf.keras.backend.conv3d(x,kernel,strides=(1,1,1),padding='valid',data_format=None,dilation_rate=(1,1,1))
tf.conv3d(x,filter,strides,pad,dataFormat?,dilations?)


tf.keras.backend.cos(x)
tf.cos(x)


tf.keras.backend.count_params(x)
tbd


tf.keras.backend.ctc_batch_cost(y_true,y_pred,input_length,label_length)
tbd


tf.keras.backend.ctc_decode(y_pred,input_length,greedy=True,beam_width=100,top_paths=1)
tbd


tf.keras.backend.ctc_label_dense_to_sparse(labels,label_lengths)
tbd


tf.keras.backend.cumprod(x,axis=0)
tbd


tf.keras.backend.cumsum(x,axis=0)
tf.cumsum(x,axis?,exclusive?,reverse?)


tf.keras.backend.dot(x,y)
tf.dot(t1,t2)


tf.keras.backend.dropout(x,level,noise_shape=None,seed=None)
tf.dropout(x,rate,noiseShape?,seed?)


tf.keras.backend.dtype(x)
tbd


tf.keras.backend.elu(x,alpha=1.0)
tf.elu(x)


tf.keras.backend.epsilon()
tbd


tf.keras.backend.equal(x,y)
tf.equal(a,b)


tf.keras.backend.eval(x)
tbd


tf.keras.backend.exp(x)
tf.exp(x)


tf.keras.backend.expand_dims(x,axis=-1)
tbd


tf.keras.backend.eye(size,dtype=None,name=None)
tf.eye(numRows,numColumns?,batchShape?,dtype?)


tf.keras.backend.flatten(x)
tf.util.flatten(arr,result?,skipTypedArray?)


tf.keras.backend.floatx()
tbd


tf.keras.backend.foldl(fn,elems,initializer=None,name=None)
tbd


tf.keras.backend.foldr(fn,elems,initializer=None,name=None)
tbd


tf.keras.backend.function(inputs,outputs,updates=None,name=None,**kwargs)
tbd


tf.keras.backend.gather(reference,indices)
tf.gather(x,indices,axis?)


tf.keras.backend.get_uid(prefix='')
tbd


tf.keras.backend.get_value(x)
tbd


tf.keras.backend.gradients(loss,variables)
tbd


tf.keras.backend.greater(x,y)
tf.greater(a,b)


tf.keras.backend.greater_equal(x,y)
tbd


tf.keras.backend.hard_sigmoid(x)
tbd


tf.keras.backend.image_data_format()
tbd


tf.keras.backend.in_test_phase(x,alt,training=None)
tbd


tf.keras.backend.in_top_k(predictions,targets,k)
tbd


tf.keras.backend.in_train_phase(x,alt,training=None)
tbd


tf.keras.backend.int_shape(x)
tbd


tf.keras.backend.is_keras_tensor(x)
tbd


tf.keras.backend.is_sparse(tensor)
tbd


tf.keras.backend.l2_normalize(x,axis=None)
tbd


tf.keras.backend.learning_phase()
tbd


tf.keras.backend.learning_phase_scope(value)
tbd


tf.keras.backend.less(x,y)
tf.less(a,b)


tf.keras.backend.less_equal(x,y)
tbd


tf.keras.backend.local_conv1d(inputs,kernel,kernel_size,strides,data_format=None)
tbd


tf.keras.backend.local_conv2d(inputs,kernel,kernel_size,strides,output_shape,data_format=None)
tbd


tf.keras.backend.log(x)
tf.log(x)


tf.keras.backend.manual_variable_initialization(value)
tbd


tf.keras.backend.map_fn(fn,elems,name=None,dtype=None)
tbd


tf.keras.backend.max(x,axis=None,keepdims=False)
tf.max(x,axis?,keepDims?)


tf.keras.backend.maximum(x,y)
tf.maximum(a,b)


tf.keras.backend.mean(x,axis=None,keepdims=False)
tf.mean(x,axis?,keepDims?)


tf.keras.backend.min(x,axis=None,keepdims=False)
tf.min(x,axis?,keepDims?)


tf.keras.backend.minimum(x,y)
tf.minimum(a,b)


tf.keras.backend.moving_average_update(x,value,momentum)
tbd


tf.keras.backend.name_scope(name)
tbd


tf.keras.backend.ndim(x)
tbd


tf.keras.backend.normalize_batch_in_training(x,gamma,beta,reduction_axes,epsilon=0.001)
tbd


tf.keras.backend.not_equal(x,y)
tbd


tf.keras.backend.one_hot(indices,num_classes)
tbd


tf.keras.backend.ones(shape,dtype=None,name=None)
tf.initializers.ones()


tf.keras.backend.ones_like(x,dtype=None,name=None)
tbd


tf.keras.backend.permute_dimensions(x,pattern)
tbd


tf.keras.backend.placeholder(shape=None,ndim=None,dtype=None,sparse=False,name=None,ragged=False)
tbd


tf.keras.backend.pool2d(x,pool_size,strides=(1,1),padding='valid',data_format=None,pool_mode='max')
tbd


tf.keras.backend.pool3d(x,pool_size,strides=(1,1,1),padding='valid',data_format=None,pool_mode='max')
tbd


tf.keras.backend.pow(x,a)
tf.pow(base,exp)


tf.keras.backend.print_tensor(x,message='')
tbd


tf.keras.backend.prod(x,axis=None,keepdims=False)
tf.prod(x,axis?,keepDims?)


tf.keras.backend.random_binomial(shape,p=0.0,dtype=None,seed=None)
tbd


tf.keras.backend.random_normal(shape,mean=0.0,stddev=1.0,dtype=None,seed=None)
tbd


tf.keras.backend.random_normal_variable(shape,mean,scale,dtype=None,name=None,seed=None)
tbd


tf.keras.backend.random_uniform(shape,minval=0.0,maxval=1.0,dtype=None,seed=None)
tbd


tf.keras.backend.random_uniform_variable(shape,low,high,dtype=None,name=None,seed=None)
tbd


tf.keras.backend.relu(x,alpha=0.0,max_value=None,threshold=0)
tf.relu(x)


tf.keras.backend.repeat(x,n)
repeat(count?)


tf.keras.backend.repeat_elements(x,rep,axis)
tbd


tf.keras.backend.reset_uids()
tbd


tf.keras.backend.reshape(x,shape)
tf.layers.reshape(args)


tf.keras.backend.resize_images(x,height_factor,width_factor,data_format,interpolation='nearest')
tbd


tf.keras.backend.resize_volumes(x,depth_factor,height_factor,width_factor,data_format)
tbd


tf.keras.backend.reverse(x,axes)
tf.reverse(x,axis?)


tf.keras.backend.rnn(step_function,inputs,initial_states,go_backwards=False,mask=None,constants=None,unroll=False,input_length=None,time_major=False,zero_output_for_mask=False)
tf.layers.rnn(args)


tf.keras.backend.round(x)
tf.round(x)


tf.keras.backend.separable_conv2d(x,depthwise_kernel,pointwise_kernel,strides=(1,1),padding='valid',data_format=None,dilation_rate=(1,1))
tbd


tf.keras.backend.set_epsilon(value)
tbd


tf.keras.backend.set_floatx(value)
tbd


tf.keras.backend.set_image_data_format(data_format)
tbd


tf.keras.backend.set_learning_phase(value)
tbd


tf.keras.backend.set_value(x,value)
tbd


tf.keras.backend.shape(x)
tbd


tf.keras.backend.sigmoid(x)
tf.sigmoid(x)


tf.keras.backend.sign(x)
tf.sign(x)


tf.keras.backend.sin(x)
tf.sin(x)


tf.keras.backend.softmax(x,axis=-1)
tf.softmax(logits,dim?)


tf.keras.backend.softplus(x)
tf.softplus(x)


tf.keras.backend.softsign(x)
tbd


tf.keras.backend.sparse_categorical_crossentropy(target,output,from_logits=False,axis=-1)
tbd


tf.keras.backend.spatial_2d_padding(x,padding=((1,1),(1,1)),data_format=None)
tbd


tf.keras.backend.spatial_3d_padding(x,padding=((1,1),(1,1),(1,1)),data_format=None)
tbd


tf.keras.backend.sqrt(x)
tf.sqrt(x)


tf.keras.backend.square(x)
tf.square(x)


tf.keras.backend.squeeze(x,axis)
tf.squeeze(x,axis?)


tf.keras.backend.stack(x,axis=0)
tf.stack(tensors,axis?)


tf.keras.backend.std(x,axis=None,keepdims=False)
tbd


tf.keras.backend.stop_gradient(variables)
tbd


tf.keras.backend.sum(x,axis=None,keepdims=False)
tf.sum(x,axis?,keepDims?)


tf.keras.backend.switch(condition,then_expression,else_expression)
tbd


tf.keras.backend.tanh(x)
tf.tanh(x)


tf.keras.backend.temporal_padding(x,padding=(1,1))
tbd


tf.keras.backend.tile(x,n)
tf.tile(x,reps)


tf.keras.backend.to_dense(tensor)
tbd


tf.keras.backend.transpose(x)
tf.transpose(x,perm?)


tf.keras.backend.truncated_normal(shape,mean=0.0,stddev=1.0,dtype=None,seed=None)
tbd


tf.keras.backend.update(x,new_x)
tbd


tf.keras.backend.update_add(x,increment)
tbd


tf.keras.backend.update_sub(x,decrement)
tbd


tf.keras.backend.var(x,axis=None,keepdims=False)
tbd


tf.keras.backend.variable(value,dtype=None,name=None,constraint=None)
tf.variable(initialValue,trainable?,name?,dtype?)


tf.keras.backend.zeros(shape,dtype=None,name=None)
tf.initializers.zeros()


tf.keras.backend.zeros_like(x,dtype=None,name=None)
tbd


tf.keras.constraints.deserialize(config,custom_objects=None)
tbd


tf.keras.constraints.get(identifier)
get(...locs)


tf.keras.constraints.serialize(constraint)
tbd


tf.keras.datasets.boston_housing.load_data(path='boston_housing.npz',test_split=0.2,seed=113)
tbd


tf.keras.datasets.cifar10.load_data()
tbd


tf.keras.datasets.cifar100.load_data(label_mode='fine')
tbd


tf.keras.datasets.fashion_mnist.load_data()
tbd


tf.keras.datasets.imdb.get_word_index(path='imdb_word_index.json')
tbd


tf.keras.datasets.imdb.load_data(path='imdb.npz',num_words=None,skip_top=0,maxlen=None,seed=113,start_char=1,oov_char=2,index_from=3,**kwargs)
tbd


tf.keras.datasets.mnist.load_data(path='mnist.npz')
tbd


tf.keras.datasets.reuters.get_word_index(path='reuters_word_index.json')
tbd


tf.keras.datasets.reuters.load_data(path='reuters.npz',num_words=None,skip_top=0,maxlen=None,test_split=0.2,seed=113,start_char=1,oov_char=2,index_from=3,**kwargs)
tbd


tf.keras.estimator.model_to_estimator(keras_model=None,keras_model_path=None,custom_objects=None,model_dir=None,config=None,checkpoint_format='checkpoint')
tbd


tf.keras.experimental.export_saved_model(model,saved_model_path,custom_objects=None,as_text=False,input_signature=None,serving_only=False)
tbd


tf.keras.experimental.load_from_saved_model(saved_model_path,custom_objects=None)
tbd


tf.keras.experimental.terminate_keras_multiprocessing_pools(grace_period=0.1,use_sigkill=False)
tbd


tf.keras.initializers.deserialize(config,custom_objects=None)
tbd


tf.keras.initializers.get(identifier)
get(...locs)


tf.keras.initializers.he_normal(seed=None)
tbd


tf.keras.initializers.he_uniform(seed=None)
tbd


tf.keras.initializers.lecun_normal(seed=None)
tbd


tf.keras.initializers.lecun_uniform(seed=None)
tbd


tf.keras.initializers.serialize(initializer)
tbd


tf.keras.layers.add(inputs,**kwargs)
tf.add(a,b)


tf.keras.layers.average(inputs,**kwargs)
tf.layers.average(args?)


tf.keras.layers.concatenate(inputs,axis=-1,**kwargs)
concatenate(dataset)


tf.keras.layers.deserialize(config,custom_objects=None)
tbd


tf.keras.layers.dot(inputs,axes,normalize=False,**kwargs)
tf.dot(t1,t2)


tf.keras.layers.maximum(inputs,**kwargs)
tf.maximum(a,b)


tf.keras.layers.minimum(inputs,**kwargs)
tf.minimum(a,b)


tf.keras.layers.multiply(inputs,**kwargs)
tf.layers.multiply(args?)


tf.keras.layers.serialize(layer)
tbd


tf.keras.layers.subtract(inputs,**kwargs)
tbd


tf.keras.losses.KLD(y_true,y_pred)
tbd


tf.keras.losses.MAE(y_true,y_pred)
tbd


tf.keras.losses.MAPE(y_true,y_pred)
tbd


tf.keras.losses.MSE(y_true,y_pred)
tbd


tf.keras.losses.MSLE(y_true,y_pred)
tbd


tf.keras.losses.binary_crossentropy(y_true,y_pred,from_logits=False,label_smoothing=0)
tbd


tf.keras.losses.categorical_crossentropy(y_true,y_pred,from_logits=False,label_smoothing=0)
tbd


tf.keras.losses.categorical_hinge(y_true,y_pred)
tbd


tf.keras.losses.cosine_similarity(y_true,y_pred,axis=-1)
tbd


tf.keras.losses.deserialize(name,custom_objects=None)
tbd


tf.keras.losses.get(identifier)
get(...locs)


tf.keras.losses.hinge(y_true,y_pred)
tbd


tf.keras.losses.logcosh(y_true,y_pred)
tbd


tf.keras.losses.poisson(y_true,y_pred)
tbd


tf.keras.losses.serialize(loss)
tbd


tf.keras.losses.sparse_categorical_crossentropy(y_true,y_pred,from_logits=False,axis=-1)
tbd


tf.keras.losses.squared_hinge(y_true,y_pred)
tbd


tf.keras.metrics.binary_accuracy(y_true,y_pred,threshold=0.5)
tbd


tf.keras.metrics.categorical_accuracy(y_true,y_pred)
tbd


tf.keras.metrics.deserialize(config,custom_objects=None)
tbd


tf.keras.metrics.get(identifier)
get(...locs)


tf.keras.metrics.serialize(metric)
tbd


tf.keras.metrics.sparse_categorical_accuracy(y_true,y_pred)
tbd


tf.keras.metrics.sparse_top_k_categorical_accuracy(y_true,y_pred,k=5)
tbd


tf.keras.metrics.top_k_categorical_accuracy(y_true,y_pred,k=5)
tbd


tf.keras.mixed_precision.experimental.global_policy()
tbd


tf.keras.mixed_precision.experimental.set_policy('mixed_float16')model=tf.keras.models.Sequential(tf.keras.layers.Input((100,)),#Denselayersuseglobalpolicyof'mixed_float16',whichdoes#computationsinfloat16whilekeepingvariablesinfloat32.tf.keras.layers.Dense(10),tf.keras.layers.Dense(10),#Softmaxshouldbedoneinfloat32fornumericstability.Wepass#dtype='float32'tousefloat32insteadoftheglobalpolicy.tf.keras.layers.Activation('Softmax',dtype='float32'))model.fit(...)#Trainmodel
tbd


tf.keras.mixed_precision.experimental.set_policy(policy)
tbd


tf.keras.models.clone_model(model,input_tensors=None,clone_function=None)
tbd


tf.keras.models.load_model(filepath,custom_objects=None,compile=True)
tbd


tf.keras.models.model_from_config(config,custom_objects=None)
tbd


tf.keras.models.model_from_json(json_string,custom_objects=None)
tbd


tf.keras.models.model_from_yaml(yaml_string,custom_objects=None)
tbd


tf.keras.models.save_model(model,filepath,overwrite=True,include_optimizer=True,save_format=None,signatures=None,options=None)
tbd


tf.keras.optimizers.deserialize(config,custom_objects=None)
tbd


tf.keras.optimizers.get(identifier)
get(...locs)


tf.keras.optimizers.schedules.deserialize(config,custom_objects=None)
tbd


tf.keras.optimizers.schedules.serialize(learning_rate_schedule)
tbd


tf.keras.optimizers.serialize(optimizer)
tbd


tf.keras.preprocessing.image.apply_affine_transform(x,theta=0,tx=0,ty=0,shear=0,zx=1,zy=1,row_axis=0,col_axis=1,channel_axis=2,fill_mode='nearest',cval=0.0,order=1)
tbd


tf.keras.preprocessing.image.apply_brightness_shift(x,brightness)
tbd


tf.keras.preprocessing.image.apply_channel_shift(x,intensity,channel_axis=0)
tbd


tf.keras.preprocessing.image.array_to_img(x,data_format=None,scale=True,dtype=None)
tbd


tf.keras.preprocessing.image.img_to_array(img,data_format=None,dtype=None)
tbd


tf.keras.preprocessing.image.load_img(path,grayscale=False,color_mode='rgb',target_size=None,interpolation='nearest')
tbd


tf.keras.preprocessing.image.random_brightness(x,brightness_range)
tbd


tf.keras.preprocessing.image.random_channel_shift(x,intensity_range,channel_axis=0)
tbd


tf.keras.preprocessing.image.random_rotation(x,rg,row_axis=1,col_axis=2,channel_axis=0,fill_mode='nearest',cval=0.0,interpolation_order=1)
tbd


tf.keras.preprocessing.image.random_shear(x,intensity,row_axis=1,col_axis=2,channel_axis=0,fill_mode='nearest',cval=0.0,interpolation_order=1)
tbd


tf.keras.preprocessing.image.random_shift(x,wrg,hrg,row_axis=1,col_axis=2,channel_axis=0,fill_mode='nearest',cval=0.0,interpolation_order=1)
tbd


tf.keras.preprocessing.image.random_zoom(x,zoom_range,row_axis=1,col_axis=2,channel_axis=0,fill_mode='nearest',cval=0.0,interpolation_order=1)
tbd


tf.keras.preprocessing.image.save_img(path,x,data_format=None,file_format=None,scale=True,**kwargs)
tbd


tf.keras.preprocessing.sequence.make_sampling_table(size,sampling_factor=1e-05)
tbd


tf.keras.preprocessing.sequence.pad_sequences(sequences,maxlen=None,dtype='int32',padding='pre',truncating='pre',value=0.0)
tbd


tf.keras.preprocessing.sequence.skipgrams(sequence,vocabulary_size,window_size=4,negative_samples=1.0,shuffle=True,categorical=False,sampling_table=None,seed=None)
tbd


tf.keras.preprocessing.text.hashing_trick(text,n,hash_function=None,filters='!"#$%&()*+,-./:;<=>?@[\]^_`{
}~\t\n',lower=True,split='')


tf.keras.preprocessing.text.one_hot(text,n,filters='!"#$%&()*+,-./:;<=>?@[\]^_`{
}~\t\n',lower=True,split='')


tf.keras.preprocessing.text.text_to_word_sequence(text,filters='!"#$%&()*+,-./:;<=>?@[\]^_`{
}~\t\n',lower=True,split='')


tf.keras.regularizers.deserialize(config,custom_objects=None)
tbd


tf.keras.regularizers.get(identifier)
get(...locs)


tf.keras.regularizers.l1(l=0.01)
tf.regularizers.l1(config?)


tf.keras.regularizers.l1_l2(l1=0.01,l2=0.01)
tbd


tf.keras.regularizers.l2(l=0.01)
tf.regularizers.l2(config?)


tf.keras.regularizers.serialize(regularizer)
tbd


tf.keras.utils.convert_all_kernels_in_model(model)
tbd


tf.keras.utils.custom_object_scope(*args)
tbd


tf.keras.utils.deserialize_keras_object(identifier,module_objects=None,custom_objects=None,printable_module_name='object')
tbd


tf.keras.utils.get_custom_objects()
tbd


tf.keras.utils.get_file(fname,origin,untar=False,md5_hash=None,file_hash=None,cache_subdir='datasets',hash_algorithm='auto',extract=False,archive_format='auto',cache_dir=None)
tbd


tf.keras.utils.get_source_inputs(tensor,layer=None,node_index=None)
tbd


tf.keras.utils.model_to_dot(model,show_shapes=False,show_layer_names=True,rankdir='TB',expand_nested=False,dpi=96,subgraph=False)
tbd


tf.keras.utils.multi_gpu_model(model,gpus,cpu_merge=True,cpu_relocation=False)
tbd


tf.keras.utils.normalize(x,axis=-1,order=2)
tbd


tf.keras.utils.plot_model(model,to_file='model.png',show_shapes=False,show_layer_names=True,rankdir='TB',expand_nested=False,dpi=96)
tbd


tf.keras.utils.serialize_keras_object(instance)
tbd


tf.keras.utils.to_categorical(y,num_classes=None,dtype='float32')
tbd


tf.linalg.adjoint(matrix,name=None)
tbd


tf.linalg.band_part(input,num_lower,num_upper,name=None)
tbd


tf.linalg.cholesky(input,name=None)
tbd


tf.linalg.cholesky_solve(chol,rhs,name=None)
tbd


tf.linalg.cross(a,b,name=None)
tbd


tf.linalg.det(input,name=None)
tbd


tf.linalg.diag(diagonal,name='diag',k=0,num_rows=-1,num_cols=-1,padding_value=0)
tbd


tf.linalg.diag_part(input,name='diag_part',k=0,padding_value=0)
tbd


tf.linalg.eigh(tensor,name=None)
tbd


tf.linalg.eigvalsh(tensor,name=None)
tbd


tf.linalg.expm(input,name=None)
tbd


tf.linalg.global_norm(t_list,name=None)
tbd


tf.linalg.inv(input,adjoint=False,name=None)
tbd


tf.linalg.logdet(matrix,name=None)
tbd


tf.linalg.logm(input,name=None)
tbd


tf.linalg.lstsq(matrix,rhs,l2_regularizer=0.0,fast=True,name=None)
tbd


tf.linalg.lu(input,output_idx_type=tf.dtypes.int32,name=None)
tbd


tf.linalg.matmul(a,b,transpose_a=False,transpose_b=False,adjoint_a=False,adjoint_b=False,a_is_sparse=False,b_is_sparse=False,name=None)
tbd


tf.linalg.matrix_transpose(a,name='matrix_transpose',conjugate=False)
tbd


tf.linalg.matvec(a,b,transpose_a=False,adjoint_a=False,a_is_sparse=False,b_is_sparse=False,name=None)
tbd


tf.linalg.normalize(tensor,ord='euclidean',axis=None,name=None)
tbd


tf.linalg.qr(input,full_matrices=False,name=None)
tf.linalg.qr(x,fullMatrices?)


tf.linalg.set_diag(input,diagonal,name='set_diag',k=0)
tbd


tf.linalg.slogdet(input,name=None)
tbd


tf.linalg.solve(matrix,rhs,adjoint=False,name=None)
tbd


tf.linalg.sqrtm(input,name=None)
tbd


tf.linalg.svd(tensor,full_matrices=False,compute_uv=True,name=None)
tbd


tf.linalg.tensor_diag(diagonal,name=None)
tbd


tf.linalg.tensor_diag_part(input,name=None)
tbd


tf.linalg.trace(x,name=None)
tbd


tf.linalg.triangular_solve(matrix,rhs,lower=True,adjoint=False,name=None)
tbd


tf.linalg.tridiagonal_matmul(diagonals,rhs,diagonals_format='compact',name=None)
tbd


tf.linalg.tridiagonal_solve(diagonals,rhs,diagonals_format='compact',transpose_rhs=False,conjugate_rhs=False,name=None,partial_pivoting=True)
tbd


tf.linspace(start,stop,num,name=None)
tf.linspace(start,stop,num)


tf.lite.experimental.load_delegate(library,options=None)
tbd


tf.load_library(library_location)
tbd


tf.load_op_library(library_filename)
tbd


tf.make_ndarray(tensor)
tbd


tf.make_tensor_proto(values,dtype=None,shape=None,verify_shape=False,allow_broadcast=False)
tbd


tf.map_fn(fn,elems,dtype=None,parallel_iterations=None,back_prop=True,swap_memory=False,infer_shape=True,name=None)
tbd


tf.math.abs(x,name=None)
tf.abs(x)


tf.math.accumulate_n(inputs,shape=None,tensor_dtype=None,name=None)
tbd


tf.math.acos(x,name=None)
tf.acos(x)


tf.math.acosh(x,name=None)
tf.acosh(x)


tf.math.add(x,y,name=None)
tf.add(a,b)


tf.math.add_n(inputs,name=None)
tbd


tf.math.angle(input,name=None)
tbd


tf.math.argmax(input,axis=None,output_type=tf.dtypes.int64,name=None)
tbd


tf.math.argmin(input,axis=None,output_type=tf.dtypes.int64,name=None)
tbd


tf.math.asin(x,name=None)
tf.asin(x)


tf.math.asinh(x,name=None)
tf.asinh(x)


tf.math.atan(x,name=None)
tf.atan(x)


tf.math.atan2(y,x,name=None)
tf.atan2(a,b)


tf.math.atanh(x,name=None)
tf.atanh(x)


tf.math.bessel_i0(x,name=None)
tbd


tf.math.bessel_i0e(x,name=None)
tbd


tf.math.bessel_i1(x,name=None)
tbd


tf.math.bessel_i1e(x,name=None)
tbd


tf.math.betainc(a,b,x,name=None)
tbd


tf.math.bincount(arr,weights=None,minlength=None,maxlength=None,dtype=tf.dtypes.int32,name=None)
tbd


tf.math.ceil(x,name=None)
tf.ceil(x)


tf.math.confusion_matrix(labels,predictions,num_classes=None,weights=None,dtype=tf.dtypes.int32,name=None)
tbd


tf.math.conj(x,name=None)
tbd


tf.math.cos(x,name=None)
tf.cos(x)


tf.math.cosh(x,name=None)
tf.cosh(x)


tf.math.count_nonzero(input,axis=None,keepdims=None,dtype=tf.dtypes.int64,name=None)
tbd


tf.math.cumprod(x,axis=0,exclusive=False,reverse=False,name=None)
tbd


tf.math.cumsum(x,axis=0,exclusive=False,reverse=False,name=None)
tf.cumsum(x,axis?,exclusive?,reverse?)


tf.math.cumulative_logsumexp(x,axis=0,exclusive=False,reverse=False,name=None)
tbd


tf.math.digamma(x,name=None)
tbd


tf.math.divide(x,y,name=None)
tbd


tf.math.divide_no_nan(x,y,name=None)
tbd


tf.math.equal(x,y,name=None)
tf.equal(a,b)


tf.math.erf(x,name=None)
tf.erf(x)


tf.math.erfc(x,name=None)
tbd


tf.math.exp(x,name=None)
tf.exp(x)


tf.math.expm1(x,name=None)
tf.expm1(x)


tf.math.floor(x,name=None)
tf.floor(x)


tf.math.floordiv(x,y,name=None)
tbd


tf.math.floormod(x,y,name=None)
tbd


tf.math.greater(x,y,name=None)
tf.greater(a,b)


tf.math.greater_equal(x,y,name=None)
tbd


tf.math.igamma(a,x,name=None)
tbd


tf.math.igammac(a,x,name=None)
tbd


tf.math.imag(input,name=None)
tf.imag(input)


tf.math.in_top_k(targets,predictions,k,name=None)
tbd


tf.math.invert_permutation(x,name=None)
tbd


tf.math.is_finite(x,name=None)
tbd


tf.math.is_inf(x,name=None)
tbd


tf.math.is_nan(x,name=None)
tbd


tf.math.is_non_decreasing(x,name=None)
tbd


tf.math.is_strictly_increasing(x,name=None)
tbd


tf.math.l2_normalize(x,axis=None,epsilon=1e-12,name=None)
tbd


tf.math.lbeta(x,name=None)
tbd


tf.math.less(x,y,name=None)
tf.less(a,b)


tf.math.less_equal(x,y,name=None)
tbd


tf.math.lgamma(x,name=None)
tbd


tf.math.log(x,name=None)
tf.log(x)


tf.math.log1p(x,name=None)
tf.log1p(x)


tf.math.log_sigmoid(x,name=None)
tbd


tf.math.logical_and(x,y,name=None)
tbd


tf.math.logical_not(x,name=None)
tbd


tf.math.logical_or(x,y,name=None)
tbd


tf.math.logical_xor(x,y,name='LogicalXor')
tbd


tf.math.maximum(x,y,name=None)
tf.maximum(a,b)


tf.math.minimum(x,y,name=None)
tf.minimum(a,b)


tf.math.multiply(x,y,name=None)
tf.layers.multiply(args?)


tf.math.multiply_no_nan(x,y,name=None)
tbd


tf.math.negative(x,name=None)
tbd


tf.math.nextafter(x1,x2,name=None)
tbd


tf.math.not_equal(x,y,name=None)
tbd


tf.math.polygamma(a,x,name=None)
tbd


tf.math.polyval(coeffs,x,name=None)
tbd


tf.math.pow(x,y,name=None)
tf.pow(base,exp)


tf.math.real(input,name=None)
tf.real(input)


tf.math.reciprocal(x,name=None)
tf.reciprocal(x)


tf.math.reciprocal_no_nan(x,name=None)
tbd


tf.math.reduce_any(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_euclidean_norm(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_logsumexp(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_max(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_mean(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_min(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_prod(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_std(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_sum(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.reduce_variance(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.math.rint(x,name=None)
tbd


tf.math.round(x,name=None)
tf.round(x)


tf.math.rsqrt(x,name=None)
tf.rsqrt(x)


tf.math.scalar_mul(scalar,x,name=None)
tbd


tf.math.segment_max(data,segment_ids,name=None)
tbd


tf.math.segment_mean(data,segment_ids,name=None)
tbd


tf.math.segment_min(data,segment_ids,name=None)
tbd


tf.math.segment_prod(data,segment_ids,name=None)
tbd


tf.math.segment_sum(data,segment_ids,name=None)
tbd


tf.math.sigmoid(x,name=None)
tf.sigmoid(x)


tf.math.sign(x,name=None)
tf.sign(x)


tf.math.sin(x,name=None)
tf.sin(x)


tf.math.sinh(x,name=None)
tf.sinh(x)


tf.math.softplus(features,name=None)
tf.softplus(x)


tf.math.sqrt(x,name=None)
tf.sqrt(x)


tf.math.square(x,name=None)
tf.square(x)


tf.math.squared_difference(x,y,name=None)
tbd


tf.math.subtract(x,y,name=None)
tbd


tf.math.tan(x,name=None)
tf.tan(x)


tf.math.tanh(x,name=None)
tf.tanh(x)


tf.math.top_k(input,k=1,sorted=True,name=None)
tbd


tf.math.truediv(x,y,name=None)
tbd


tf.math.unsorted_segment_max(data,segment_ids,num_segments,name=None)
tbd


tf.math.unsorted_segment_mean(data,segment_ids,num_segments,name=None)
tbd


tf.math.unsorted_segment_min(data,segment_ids,num_segments,name=None)
tbd


tf.math.unsorted_segment_prod(data,segment_ids,num_segments,name=None)
tbd


tf.math.unsorted_segment_sqrt_n(data,segment_ids,num_segments,name=None)
tbd


tf.math.unsorted_segment_sum(data,segment_ids,num_segments,name=None)
tbd


tf.math.xdivy(x,y,name=None)
tbd


tf.math.xlogy(x,y,name=None)
tbd


tf.math.zero_fraction(value,name=None)
tbd


tf.math.zeta(x,q,name=None)
tbd


tf.meshgrid(*args,**kwargs)
tbd


tf.nest.assert_same_structure(nest1,nest2,check_types=True,expand_composites=False)
tbd


tf.nest.flatten(structure,expand_composites=False)
tf.util.flatten(arr,result?,skipTypedArray?)


tf.nest.is_nested(seq)
tbd


tf.nest.map_structure(func,*structure,**kwargs)
tbd


tf.nest.pack_sequence_as(structure,flat_sequence,expand_composites=False)
tbd


tf.nn.atrous_conv2d(value,filters,rate,padding,name=None)
tbd


tf.nn.atrous_conv2d_transpose(value,filters,output_shape,rate,padding,name=None)
tbd


tf.nn.avg_pool(input,ksize,strides,padding,data_format=None,name=None)
tbd


tf.nn.avg_pool1d(input,ksize,strides,padding,data_format='NWC',name=None)
tbd


tf.nn.avg_pool2d(input,ksize,strides,padding,data_format='NHWC',name=None)
tbd


tf.nn.avg_pool3d(input,ksize,strides,padding,data_format='NDHWC',name=None)
tbd


tf.nn.batch_norm_with_global_normalization(input,mean,variance,beta,gamma,variance_epsilon,scale_after_normalization,name=None)
tbd


tf.nn.batch_normalization(x,mean,variance,offset,scale,variance_epsilon,name=None)
tbd


tf.nn.bias_add(value,bias,data_format=None,name=None)
tbd


tf.nn.collapse_repeated(labels,seq_length,name=None)
tbd


tf.nn.compute_accidental_hits(true_classes,sampled_candidates,num_true,seed=None,name=None)
tbd


tf.nn.compute_average_loss(per_example_loss,sample_weight=None,global_batch_size=None)
tbd


tf.nn.conv1d(input,filters,stride,padding,data_format='NWC',dilations=None,name=None)
tf.conv1d(x,filter,stride,pad,dataFormat?,dilation?,dimRoundingMode?)


tf.nn.conv1d_transpose(input,filters,output_shape,strides,padding='SAME',data_format='NWC',dilations=None,name=None)
tbd


tf.nn.conv2d(input,filters,strides,padding,data_format='NHWC',dilations=None,name=None)
tf.conv2d(x,filter,strides,pad,dataFormat?,dilations?,dimRoundingMode?)


tf.nn.conv2d_transpose(input,filters,output_shape,strides,padding='SAME',data_format='NHWC',dilations=None,name=None)
tbd


tf.nn.conv3d(input,filters,strides,padding,data_format='NDHWC',dilations=None,name=None)
tf.conv3d(x,filter,strides,pad,dataFormat?,dilations?)


tf.nn.conv3d_transpose(input,filters,output_shape,strides,padding='SAME',data_format='NDHWC',dilations=None,name=None)
tbd


tf.nn.conv_transpose(input,filters,output_shape,strides,padding='SAME',data_format=None,dilations=None,name=None)
tbd


tf.nn.convolution(input,filters,strides=None,padding='VALID',data_format=None,dilations=None,name=None)
tbd


tf.nn.crelu(features,axis=-1,name=None)
tbd


tf.nn.ctc_beam_search_decoder(inputs,sequence_length,beam_width=100,top_paths=1)
tbd


tf.nn.ctc_greedy_decoder(inputs,sequence_length,merge_repeated=True)
tbd


tf.nn.ctc_loss(labels,logits,label_length,logit_length,logits_time_major=True,unique=None,blank_index=None,name=None)
tbd


tf.nn.ctc_unique_labels(labels,name=None)
tbd


tf.nn.depth_to_space(input,block_size,data_format='NHWC',name=None)
tbd


tf.nn.depthwise_conv2d(input,filter,strides,padding,data_format=None,dilations=None,name=None)
tbd


tf.nn.depthwise_conv2d_backprop_filter(input,filter_sizes,out_backprop,strides,padding,data_format='NHWC',dilations=[1,1,1,1],name=None)
tbd


tf.nn.depthwise_conv2d_backprop_input(input_sizes,filter,out_backprop,strides,padding,data_format='NHWC',dilations=[1,1,1,1],name=None)
tbd


tf.nn.dilation2d(input,filters,strides,padding,data_format,dilations,name=None)
tbd


tf.nn.dropout(x,rate,noise_shape=None,seed=None,name=None)
tf.dropout(x,rate,noiseShape?,seed?)


tf.nn.elu(features,name=None)
tf.elu(x)


tf.nn.embedding_lookup(params,ids,max_norm=None,name=None)
tbd


tf.nn.embedding_lookup_sparse(params,sp_ids,sp_weights,combiner=None,max_norm=None,name=None)
tbd


tf.nn.erosion2d(value,filters,strides,padding,data_format,dilations,name=None)
tbd


tf.nn.fractional_avg_pool(value,pooling_ratio,pseudo_random=False,overlapping=False,seed=0,name=None)
tbd


tf.nn.fractional_max_pool(value,pooling_ratio,pseudo_random=False,overlapping=False,seed=0,name=None)
tbd


tf.nn.l2_loss(t,name=None)
tbd


tf.nn.leaky_relu(features,alpha=0.2,name=None)
tbd


tf.nn.local_response_normalization(input,depth_radius=5,bias=1,alpha=1,beta=0.5,name=None)
tbd


tf.nn.log_poisson_loss(targets,log_input,compute_full_loss=False,name=None)
tbd


tf.nn.log_softmax(logits,axis=None,name=None)
tbd


tf.nn.max_pool(input,ksize,strides,padding,data_format=None,name=None)
tbd


tf.nn.max_pool1d(input,ksize,strides,padding,data_format='NWC',name=None)
tbd


tf.nn.max_pool2d(input,ksize,strides,padding,data_format='NHWC',name=None)
tbd


tf.nn.max_pool3d(input,ksize,strides,padding,data_format='NDHWC',name=None)
tbd


tf.nn.max_pool_with_argmax(input,ksize,strides,padding,data_format='NHWC',output_dtype=tf.dtypes.int64,include_batch_in_index=False,name=None)
tbd


tf.nn.moments(x,axes,shift=None,keepdims=False,name=None)
tf.moments(x,axis?,keepDims?)


tf.nn.nce_loss(weights,biases,labels,inputs,num_sampled,num_classes,num_true=1,sampled_values=None,remove_accidental_hits=False,name='nce_loss')
tbd


tf.nn.normalize_moments(counts,mean_ss,variance_ss,shift,name=None)
tbd


tf.nn.pool(input,window_shape,pooling_type,strides=None,padding='VALID',data_format=None,dilations=None,name=None)
tf.pool(input,windowShape,poolingType,pad,dilations?,strides?)


tf.nn.relu(features,name=None)
tf.relu(x)


tf.nn.relu6(features,name=None)
tf.relu6(x)


tf.nn.safe_embedding_lookup_sparse(embedding_weights,sparse_ids,sparse_weights=None,combiner='mean',default_id=None,max_norm=None,name=None)
tbd


tf.nn.sampled_softmax_loss(weights,biases,labels,inputs,num_sampled,num_classes,num_true=1,sampled_values=None,remove_accidental_hits=True,seed=None,name='sampled_softmax_loss')
tbd


tf.nn.scale_regularization_loss(regularization_loss)
tbd


tf.nn.selu(features,name=None)
tf.selu(x)


tf.nn.separable_conv2d(input,depthwise_filter,pointwise_filter,strides,padding,data_format=None,dilations=None,name=None)
tbd


tf.nn.sigmoid_cross_entropy_with_logits(labels=None,logits=None,name=None)
tbd


tf.nn.softmax(logits,axis=None,name=None)
tf.softmax(logits,dim?)


tf.nn.softmax_cross_entropy_with_logits(labels,logits,axis=-1,name=None)
tbd


tf.nn.softsign(features,name=None)
tbd


tf.nn.space_to_depth(input,block_size,data_format='NHWC',name=None)
tbd


tf.nn.sparse_softmax_cross_entropy_with_logits(labels,logits,name=None)
tbd


tf.nn.sufficient_statistics(x,axes,shift=None,keepdims=False,name=None)
tbd


tf.nn.weighted_cross_entropy_with_logits(labels,logits,pos_weight,name=None)
tbd


tf.nn.weighted_moments(x,axes,frequency_weights,keepdims=False,name=None)
tbd


tf.nn.with_space_to_batch(input,dilation_rate,padding,op,filter_shape=None,spatial_dims=None,data_format=None)
tbd


tf.no_gradient(op_type)
tbd


tf.no_op(name=None)
tbd


tf.nondifferentiable_batch_function(num_batch_threads,max_batch_size,batch_timeout_micros,allowed_batch_sizes=None,max_enqueued_batches=10,autograph=True)
tbd


tf.norm(tensor,ord='euclidean',axis=None,keepdims=None,name=None)
tf.norm(x,ord?,axis?,keepDims?)


tf.numpy_function(func,inp,Tout,name=None)
tbd


tf.one_hot(indices,depth,on_value=None,off_value=None,axis=None,dtype=None,name=None)
tbd


tf.ones(shape,dtype=tf.dtypes.float32,name=None)
tf.initializers.ones()


tf.ones_like(input,dtype=None,name=None)
tbd


tf.pad(tensor,paddings,mode='CONSTANT',constant_values=0,name=None)
tf.pad(x,paddings,constantValue?)


tf.parallel_stack(values,name='parallel_stack')
tbd


tf.print(*inputs,**kwargs)
print(verbose?)


tf.py_function(func,inp,Tout,name=None)
tbd


tf.quantization.dequantize(input,min_range,max_range,mode='MIN_COMBINED',name=None)
tbd


tf.quantization.fake_quant_with_min_max_args(inputs,min=-6,max=6,num_bits=8,narrow_range=False,name=None)
tbd


tf.quantization.fake_quant_with_min_max_args_gradient(gradients,inputs,min=-6,max=6,num_bits=8,narrow_range=False,name=None)
tbd


tf.quantization.fake_quant_with_min_max_vars(inputs,min,max,num_bits=8,narrow_range=False,name=None)
tbd


tf.quantization.fake_quant_with_min_max_vars_gradient(gradients,inputs,min,max,num_bits=8,narrow_range=False,name=None)
tbd


tf.quantization.fake_quant_with_min_max_vars_per_channel(inputs,min,max,num_bits=8,narrow_range=False,name=None)
tbd


tf.quantization.fake_quant_with_min_max_vars_per_channel_gradient(gradients,inputs,min,max,num_bits=8,narrow_range=False,name=None)
tbd


tf.quantization.quantize(input,min_range,max_range,T,mode='MIN_COMBINED',round_mode='HALF_AWAY_FROM_ZERO',name=None)
tbd


tf.quantization.quantize_and_dequantize(input,input_min,input_max,signed_input=True,num_bits=8,range_given=False,round_mode='HALF_TO_EVEN',name=None,narrow_range=False)
tbd


tf.quantization.quantized_concat(concat_dim,values,input_mins,input_maxes,name=None)
tbd


tf.ragged.boolean_mask(data,mask,name=None)
tbd


tf.ragged.constant(pylist,dtype=None,ragged_rank=None,inner_shape=None,name=None,row_splits_dtype=tf.dtypes.int64)
tf.initializers.constant(args)


tf.ragged.map_flat_values(op,*args,**kwargs)
tbd


tf.ragged.range(starts,limits=None,deltas=1,dtype=None,name=None,row_splits_dtype=tf.dtypes.int64)
tf.range(start,stop,step?,dtype?)


tf.ragged.row_splits_to_segment_ids(splits,name=None,out_type=None)
tbd


tf.ragged.segment_ids_to_row_splits(segment_ids,num_segments=None,out_type=None,name=None)
tbd


tf.ragged.stack(values,axis=0,name=None)
tf.stack(tensors,axis?)


tf.ragged.stack_dynamic_partitions(data,partitions,num_partitions,name=None)
tbd


tf.random.all_candidate_sampler(true_classes,num_true,num_sampled,unique,seed=None,name=None)
tbd


tf.random.categorical(logits,num_samples,dtype=None,seed=None,name=None)
tbd


tf.random.experimental.create_rng_state(seed,algorithm)
tbd


tf.random.experimental.get_global_generator()
tbd


tf.random.experimental.set_global_generator(generator)
tbd


tf.random.fixed_unigram_candidate_sampler(true_classes,num_true,num_sampled,unique,range_max,vocab_file='',distortion=1.0,num_reserved_ids=0,num_shards=1,shard=0,unigrams=(),seed=None,name=None)
tbd


tf.random.gamma(shape,alpha,beta=None,dtype=tf.dtypes.float32,seed=None,name=None)
tbd


tf.random.learned_unigram_candidate_sampler(true_classes,num_true,num_sampled,unique,range_max,seed=None,name=None)
tbd


tf.random.log_uniform_candidate_sampler(true_classes,num_true,num_sampled,unique,range_max,seed=None,name=None)
tbd


tf.random.normal(shape,mean=0.0,stddev=1.0,dtype=tf.dtypes.float32,seed=None,name=None)
tbd


tf.random.poisson(shape,lam,dtype=tf.dtypes.float32,seed=None,name=None)
tbd


tf.random.set_seed(seed)
tbd


tf.random.shuffle(value,seed=None,name=None)
tf.util.shuffle(array)


tf.random.stateless_categorical(logits,num_samples,seed,dtype=tf.dtypes.int64,name=None)
tbd


tf.random.stateless_normal(shape,seed,mean=0.0,stddev=1.0,dtype=tf.dtypes.float32,name=None)
tbd


tf.random.stateless_truncated_normal(shape,seed,mean=0.0,stddev=1.0,dtype=tf.dtypes.float32,name=None)
tbd


tf.random.stateless_uniform(shape,seed,minval=0,maxval=None,dtype=tf.dtypes.float32,name=None)
tbd


tf.random.truncated_normal(shape,mean=0.0,stddev=1.0,dtype=tf.dtypes.float32,seed=None,name=None)
tbd


tf.random.uniform(shape,minval=0,maxval=None,dtype=tf.dtypes.float32,seed=None,name=None)
tbd


tf.random.uniform_candidate_sampler(true_classes,num_true,num_sampled,unique,range_max,seed=None,name=None)
tbd


tf.rank(input,name=None)
tbd


tf.realdiv(x,y,name=None)
tbd


tf.recompute_grad(f)
tbd


tf.reduce_all(input_tensor,axis=None,keepdims=False,name=None)
tbd


tf.register_tensor_conversion_function(base_type,conversion_func,priority=100)
tbd


tf.required_space_to_batch_paddings(input_shape,block_shape,base_paddings=None,name=None)
tbd


tf.reshape(tensor,shape,name=None)
tf.layers.reshape(args)


tf.reverse(tensor,axis,name=None)
tf.reverse(x,axis?)


tf.reverse_sequence(input,seq_lengths,seq_axis=None,batch_axis=None,name=None)
tbd


tf.roll(input,shift,axis,name=None)
tbd


tf.saved_model.contains_saved_model(export_dir)
tbd


tf.saved_model.load(export_dir,tags=None)
tbd


tf.saved_model.save(obj,export_dir,signatures=None,options=None)
save(handlerOrURL,config?)


tf.scan(fn,elems,initializer=None,parallel_iterations=10,back_prop=True,swap_memory=False,infer_shape=True,reverse=False,name=None)
tbd


tf.scatter_nd(indices,updates,shape,name=None)
tbd


tf.searchsorted(sorted_sequence,values,side='left',out_type=tf.dtypes.int32,name=None)
tbd


tf.sequence_mask(lengths,maxlen=None,dtype=tf.dtypes.bool,name=None)
tbd


tf.sets.difference(a,b,aminusb=True,validate_indices=True)
tbd


tf.sets.intersection(a,b,validate_indices=True)
tbd


tf.sets.size(a,validate_indices=True)
tbd


tf.sets.union(a,b,validate_indices=True)
tbd


tf.shape(input,out_type=tf.dtypes.int32,name=None)
tbd


tf.shape_n(input,out_type=tf.dtypes.int32,name=None)
tbd


tf.signal.dct(input,type=2,n=None,axis=-1,norm=None,name=None)
tbd


tf.signal.fft(input,name=None)
tf.spectral.fft(input)


tf.signal.fft2d(input,name=None)
tbd


tf.signal.fft3d(input,name=None)
tbd


tf.signal.fftshift(x,axes=None,name=None)
tbd


tf.signal.frame(signal,frame_length,frame_step,pad_end=False,pad_value=0,axis=-1,name=None)
tf.signal.frame(signal,frameLength,frameStep,padEnd?,padValue?)


tf.signal.hamming_window(window_length,periodic=True,dtype=tf.dtypes.float32,name=None)
tbd


tf.signal.hann_window(window_length,periodic=True,dtype=tf.dtypes.float32,name=None)
tbd


tf.signal.idct(input,type=2,n=None,axis=-1,norm=None,name=None)
tbd


tf.signal.ifft(input,name=None)
tf.spectral.ifft(input)


tf.signal.ifft2d(input,name=None)
tbd


tf.signal.ifft3d(input,name=None)
tbd


tf.signal.ifftshift(x,axes=None,name=None)
tbd


tf.signal.inverse_stft(stfts,frame_length,frame_step,fft_length=None,window_fn=tf.signal.hann_window,name=None)
tbd


tf.signal.inverse_stft_window_fn(frame_step,forward_window_fn=tf.signal.hann_window,name=None)
tbd


tf.signal.irfft(input_tensor,fft_length=None,name=None)
tf.spectral.irfft(input)


tf.signal.irfft2d(input_tensor,fft_length=None,name=None)
tbd


tf.signal.irfft3d(input_tensor,fft_length=None,name=None)
tbd


tf.signal.linear_to_mel_weight_matrix(num_mel_bins=20,num_spectrogram_bins=129,sample_rate=8000,lower_edge_hertz=125.0,upper_edge_hertz=3800.0,dtype=tf.dtypes.float32,name=None)
tbd


tf.signal.mfccs_from_log_mel_spectrograms(log_mel_spectrograms,name=None)
tbd


tf.signal.overlap_and_add(signal,frame_step,name=None)
tbd


tf.signal.rfft(input_tensor,fft_length=None,name=None)
tf.spectral.rfft(input,fftLength?)


tf.signal.rfft2d(input_tensor,fft_length=None,name=None)
tbd


tf.signal.rfft3d(input_tensor,fft_length=None,name=None)
tbd


tf.signal.stft(signals,frame_length,frame_step,fft_length=None,window_fn=tf.signal.hann_window,pad_end=False,name=None)
tf.signal.stft(signal,frameLength,frameStep,fftLength?,windowFn?)


tf.size(input,out_type=tf.dtypes.int32,name=None)
tbd


tf.slice(input_,begin,size,name=None)
tf.slice(x,begin,size?)


tf.sort(values,axis=-1,direction='ASCENDING',name=None)
tbd


tf.space_to_batch(input,block_shape,paddings,name=None)
tbd


tf.space_to_batch_nd(input,block_shape,paddings,name=None)
tbd


tf.sparse.add(a,b,threshold=0)
tf.add(a,b)


tf.sparse.concat(axis,sp_inputs,expand_nonconcat_dims=False,name=None)
tf.concat(tensors,axis?)


tf.sparse.cross(inputs,name=None)
tbd


tf.sparse.cross_hashed(inputs,num_buckets=0,hash_key=None,name=None)
tbd


tf.sparse.expand_dims(sp_input,axis=None,name=None)
tbd


tf.sparse.eye(num_rows,num_columns=None,dtype=tf.dtypes.float32,name=None)
tf.eye(numRows,numColumns?,batchShape?,dtype?)


tf.sparse.fill_empty_rows(sp_input,default_value,name=None)
tbd


tf.sparse.from_dense(tensor,name=None)
tbd


tf.sparse.mask(a,mask_indices,name=None)
tbd


tf.sparse.maximum(sp_a,sp_b,name=None)
tf.maximum(a,b)


tf.sparse.minimum(sp_a,sp_b,name=None)
tf.minimum(a,b)


tf.sparse.reduce_max(sp_input,axis=None,keepdims=None,output_is_sparse=False,name=None)
tbd


tf.sparse.reduce_sum(sp_input,axis=None,keepdims=None,output_is_sparse=False,name=None)
tbd


tf.sparse.reorder(sp_input,name=None)
tbd


tf.sparse.reset_shape(sp_input,new_shape=None)
tbd


tf.sparse.reshape(sp_input,shape,name=None)
tf.layers.reshape(args)


tf.sparse.retain(sp_input,to_retain)
tbd


tf.sparse.segment_mean(data,indices,segment_ids,num_segments=None,name=None)
tbd


tf.sparse.segment_sqrt_n(data,indices,segment_ids,num_segments=None,name=None)
tbd


tf.sparse.segment_sum(data,indices,segment_ids,num_segments=None,name=None)
tbd


tf.sparse.slice(sp_input,start,size,name=None)
tf.slice(x,begin,size?)


tf.sparse.softmax(sp_input,name=None)
tf.softmax(logits,dim?)


tf.sparse.sparse_dense_matmul(sp_a,b,adjoint_a=False,adjoint_b=False,name=None)
tbd


tf.sparse.split(sp_input=None,num_split=None,axis=None,name=None)
tf.split(x,numOrSizeSplits,axis?)


tf.sparse.to_dense(sp_input,default_value=None,validate_indices=True,name=None)
tbd


tf.sparse.to_indicator(sp_input,vocab_size,name=None)
tbd


tf.sparse.transpose(sp_input,perm=None,name=None)
tf.transpose(x,perm?)


tf.split(value,num_or_size_splits,axis=0,num=None,name='split')
tf.split(x,numOrSizeSplits,axis?)


tf.squeeze(input,axis=None,name=None)
tf.squeeze(x,axis?)


tf.stack(values,axis=0,name='stack')
tf.stack(tensors,axis?)


tf.stop_gradient(input,name=None)
tbd


tf.strided_slice(input_,begin,end,strides=None,begin_mask=0,end_mask=0,ellipsis_mask=0,new_axis_mask=0,shrink_axis_mask=0,var=None,name=None)
tbd


tf.strings.as_string(input,precision=-1,scientific=False,shortest=False,width=-1,fill='',name=None)
tbd


tf.strings.bytes_split(input,name=None)
tbd


tf.strings.format(template,inputs,placeholder='{}',summarize=3,name=None)
tbd


tf.strings.join(inputs,separator='',name=None)
tbd


tf.strings.length(input,unit='BYTE',name=None)
tbd


tf.strings.lower(input,encoding='',name=None)
tbd


tf.strings.ngrams(data,ngram_width,separator='',pad_values=None,padding_width=None,preserve_short_sequences=False,name=None)
tbd


tf.strings.reduce_join(inputs,axis=None,keepdims=False,separator='',name=None)
tbd


tf.strings.regex_full_match(input,pattern,name=None)
tbd


tf.strings.regex_replace(input,pattern,rewrite,replace_global=True,name=None)
tbd


tf.strings.split(input,sep=None,maxsplit=-1,name=None)
tf.split(x,numOrSizeSplits,axis?)


tf.strings.strip(input,name=None)
tbd


tf.strings.substr(input,pos,len,unit='BYTE',name=None)
tbd


tf.strings.to_hash_bucket(input,num_buckets,name=None)
tbd


tf.strings.to_hash_bucket_fast(input,num_buckets,name=None)
tbd


tf.strings.to_hash_bucket_strong(input,num_buckets,key,name=None)
tbd


tf.strings.to_number(input,out_type=tf.dtypes.float32,name=None)
tbd


tf.strings.unicode_decode(input,input_encoding,errors='replace',replacement_char=65533,replace_control_characters=False,name=None)
tbd


tf.strings.unicode_decode_with_offsets(input,input_encoding,errors='replace',replacement_char=65533,replace_control_characters=False,name=None)
tbd


tf.strings.unicode_encode(input,output_encoding,errors='replace',replacement_char=65533,name=None)
tbd


tf.strings.unicode_script(input,name=None)
tbd


tf.strings.unicode_split(input,input_encoding,errors='replace',replacement_char=65533,name=None)
tbd


tf.strings.unicode_split_with_offsets(input,input_encoding,errors='replace',replacement_char=65533,name=None)
tbd


tf.strings.unicode_transcode(input,input_encoding,output_encoding,errors='replace',replacement_char=65533,replace_control_characters=False,name=None)
tbd


tf.strings.unsorted_segment_join(inputs,segment_ids,num_segments,separator='',name=None)
tbd


tf.strings.upper(input,encoding='',name=None)
tbd


tf.summary.audio(name,data,sample_rate,step=None,max_outputs=3,encoding=None,description=None)
tbd


tf.summary.create_file_writer(logdir,max_queue=None,flush_millis=None,filename_suffix=None,name=None)
tbd


tf.summary.create_noop_writer()
tbd


tf.summary.experimental.get_step()
tbd


tf.summary.experimental.set_step(step)
tbd


tf.summary.experimental.summary_scope(name,default_name='summary',values=None)
tbd


tf.summary.experimental.write_raw_pb(tensor,step=None,name=None)
tbd


tf.summary.flush(writer=None,name=None)
tbd


tf.summary.histogram(name,data,step=None,buckets=None,description=None)
tbd


tf.summary.image(name,data,step=None,max_outputs=3,description=None)
tbd


tf.summary.record_if(condition)
tbd


tf.summary.scalar(name,data,step=None,description=None)
tf.scalar(value,dtype?)


tf.summary.text(name,data,step=None,description=None)
tbd


tf.summary.trace_export(name,step=None,profiler_outdir=None)
tbd


tf.summary.trace_off()
tbd


tf.summary.trace_on(graph=True,profiler=False)
tbd


tf.summary.write(tag,tensor,step=None,metadata=None,name=None)
tbd


tf.switch_case(branch_index,branch_fns,default=None,name='switch_case')
tbd


tf.sysconfig.get_compile_flags()
tbd


tf.sysconfig.get_include()
tbd


tf.sysconfig.get_lib()
tbd


tf.sysconfig.get_link_flags()
tbd


tf.tensor_scatter_nd_add(tensor,indices,updates,name=None)
tbd


tf.tensor_scatter_nd_sub(tensor,indices,updates,name=None)
tbd


tf.tensor_scatter_nd_update(tensor,indices,updates,name=None)
tbd


tf.tensordot(a,b,axes,name=None)
tbd


tf.test.assert_equal_graph_def(expected,actual)
tbd


tf.test.benchmark_config()
tbd


tf.test.compute_gradient(f,x,delta=0.001)
tbd


tf.test.create_local_cluster(num_workers,num_ps,protocol='grpc',worker_config=None,ps_config=None)
tbd


tf.test.gpu_device_name()
tbd


tf.test.is_built_with_cuda()
tbd


tf.test.is_built_with_gpu_support()
tbd


tf.test.is_built_with_rocm()
tbd


tf.test.is_gpu_available(cuda_only=False,min_cuda_compute_capability=None)
tbd


tf.test.main(argv=None)
tbd


tf.tile(input,multiples,name=None)
tf.tile(x,reps)


tf.timestamp(name=None)
tbd


tf.tpu.experimental.initialize_tpu_system(cluster_resolver=None)
tbd


tf.train.checkpoints_iterator(checkpoint_dir,min_interval_secs=0,timeout=None,timeout_fn=None)
tbd


tf.train.experimental.disable_mixed_precision_graph_rewrite()
tbd


tf.train.experimental.enable_mixed_precision_graph_rewrite(opt,loss_scale='dynamic')
tbd


tf.train.get_checkpoint_state(checkpoint_dir,latest_filename=None)
tbd


tf.train.latest_checkpoint(checkpoint_dir,latest_filename=None)
tbd


tf.train.list_variables(ckpt_dir_or_file)
tbd


tf.train.load_checkpoint(ckpt_dir_or_file)
tbd


tf.transpose(a,perm=None,conjugate=False,name='transpose')
tf.transpose(x,perm?)


tf.truncatediv(x,y,name=None)
tbd


tf.truncatemod(x,y,name=None)
tbd


tf.tuple(tensors,control_inputs=None,name=None)
tbd


tf.unique(x,out_idx=tf.dtypes.int32,name=None)
tbd


tf.unique_with_counts(x,out_idx=tf.dtypes.int32,name=None)
tbd


tf.unravel_index(indices,dims,name=None)
tbd


tf.unstack(value,num=None,axis=0,name='unstack')
tf.unstack(x,axis?)


tf.variable_creator_scope(variable_creator)
tbd


tf.vectorized_map(fn,elems)
tbd


tf.where(condition,x=None,y=None,name=None)
tf.where(condition,a,b)


tf.while_loop(cond,body,loop_vars,shape_invariants=None,parallel_iterations=10,back_prop=True,swap_memory=False,maximum_iterations=None,name=None)
tbd


tf.xla.experimental.compile(computation,inputs=None)
compile(args)


tf.xla.experimental.jit_scope(*args,**kwds)
tbd


tf.zeros(shape,dtype=tf.dtypes.float32,name=None)
tf.initializers.zeros()


tf.zeros_like(input,dtype=None,name=None)
tbd