Welcome!
TensorFlow Core contains :
- 44 Modules
- 32 Classes
- 178 Functions and more are coming…
I am Paras, and I will be explaining to you every module, classes, and functions of TensorFlow. Here, I will be giving the links of my all posts where you can find the explanations. I am taking this structured content information from TensorFlow official documentation and later on, I will be explaining them. Let’s start…
Modules
- tf Module
- audio module: Public API for tf.audio namespace.
- autograph module: Conversion of plain Python into TensorFlow graph code.
- bitwise module: Operations for manipulating the binary representations of integers.
- compat module: Functions for Python 2 vs. 3 compatibility.
- config module: Public API for tf.config namespace.
- data module: tf.data.Dataset API for input pipelines.
- debugging module: Public API for tf.debugging namespace.
- distribute module: Library for running a computation across multiple devices.
- dtypes module: Public API for tf.dtypes namespace.
- errors module: Exception types for TensorFlow errors.
- estimator module: Estimator: High level tools for working with models.
- experimental module: Public API for tf.experimental namespace.
- feature_column module: Public API for tf.feature_column namespace.
- graph_util module: Helpers to manipulate a tensor graph in python.
- image module: Image processing and decoding ops.
- initializers module: Keras initializer serialization / deserialization.
- io module: Public API for tf.io namespace.
- keras module: Implementation of the Keras API meant to be a high-level API for TensorFlow.
- linalg module: Operations for linear algebra.
- lite module: Public API for tf.lite namespace.
- lookup module: Public API for tf.lookup namespace.
- losses module: Built-in loss functions.
- math module: Math Operations.
- metrics module: Built-in metrics.
- nest module: Public API for tf.nest namespace.
- nn module: Wrappers for primitive Neural Net (NN) Operations.
- optimizers module: Built-in optimizer classes.
- quantization module: Public API for tf.quantization namespace.
- queue module: Public API for tf.queue namespace.
- ragged module: Ragged Tensors.
- random module: Public API for tf.random namespace.
- raw_ops module: Public API for tf.raw_ops namespace.
- saved_model module: Public API for tf.saved_model namespace.
- sets module: Tensorflow set operations.
- signal module: Signal processing operations.
- sparse module: Sparse Tensor Representation.
- strings module: Operations for working with string Tensors.
- summary module: Operations for writing summary data, for use in analysis and visualization.
- sysconfig module: System configuration library.
- test module: Testing.
- tpu module: Ops related to Tensor Processing Units.
- train module: Support for training models.
- version module: Public API for tf.version namespace.
- xla module: Public API for tf.xla namespace.
Classes
- class AggregationMethod: A class listing aggregation methods used to combine gradients.
- class CriticalSection: Critical section.
- class DType: Represents the type of the elements in a Tensor.
- class DeviceSpec: Represents a (possibly partial) specification for a TensorFlow device.
- class GradientTape: Record operations for automatic differentiation.
- class Graph: A TensorFlow computation, represented as a dataflow graph.
- class IndexedSlices: A sparse representation of a set of tensor slices at given indices.
- class IndexedSlicesSpec: Type specification for a tf.IndexedSlices.
- class Module: Base neural network module class.
- class Operation: Represents a graph node that performs computation on tensors.
- class OptionalSpec: Represents an optional potentially containing a structured value.
- class RaggedTensor: Represents a ragged tensor.
- class RaggedTensorSpec: Type specification for a tf.RaggedTensor.
- class RegisterGradient: A decorator for registering the gradient function for an op type.
- class SparseTensor: Represents a sparse tensor.
- class SparseTensorSpec: Type specification for a tf.SparseTensor.
- class Tensor: Represents one of the outputs of an Operation.
- class TensorArray: Class wrapping dynamic-sized, per-time-step, write-once Tensor arrays.
- class TensorArraySpec: Type specification for a tf.TensorArray.
- class TensorShape: Represents the shape of a Tensor.
- class TensorSpec: Describes a tf.Tensor.
- class TypeSpec: Specifies a TensorFlow value type.
- class UnconnectedGradients: Controls how gradient computation behaves when y does not depend on x.
- class Variable: See the Variables Guide.
- class VariableAggregation: Indicates how a distributed variable will be aggregated.
- class VariableSynchronization: Indicates when a distributed variable will be synced.
- class constant_initializer: Initializer that generates tensors with constant values.
- class name_scope: A context manager for use when defining a Python op.
- class ones_initializer: Initializer that generates tensors initialized to 1.
- class random_normal_initializer: Initializer that generates tensors with a normal distribution.
- class random_uniform_initializer: Initializer that generates tensors with a uniform distribution.
- class zeros_initializer: Initializer that generates tensors initialized to 0.
Functions
- Assert(…): Asserts that the given condition is true.
- abs(…): Computes the absolute value of a tensor.
- acos(…): Computes acos of x element-wise.
- acosh(…): Computes inverse hyperbolic cosine of x element-wise.
- add(…): Returns x + y element-wise.
- add_n(…): Adds all input tensors element-wise.
- argmax(…): Returns the index with the largest value across axes of a tensor.
- argmin(…): Returns the index with the smallest value across axes of a tensor.
- argsort(…): Returns the indices of a tensor that give its sorted order along an axis.
- as_dtype(…): Converts the given type_value to a DType.
- as_string(…): Converts each entry in the given tensor to strings.
- asin(…): Computes the trignometric inverse sine of x element-wise.
- asinh(…): Computes inverse hyperbolic sine of x element-wise.
- assert_equal(…): Assert the condition x == y holds element-wise.
- assert_greater(…): Assert the condition x > y holds element-wise.
- assert_less(…): Assert the condition x < y holds element-wise.
- assert_rank(…): Assert that x has rank equal to rank.
- atan(…): Computes the trignometric inverse tangent of x element-wise.
- atan2(…): Computes arctangent of y/x element-wise, respecting signs of the arguments.
- atanh(…): Computes inverse hyperbolic tangent of x element-wise.
- batch_to_space(…): BatchToSpace for N-D tensors of type T.
- bitcast(…): Bitcasts a tensor from one type to another without copying data.
- boolean_mask(…): Apply boolean mask to tensor.
- broadcast_dynamic_shape(…): Computes the shape of a broadcast given symbolic shapes.
- broadcast_static_shape(…): Computes the shape of a broadcast given known shapes.
- broadcast_to(…): Broadcast an array for a compatible shape.
- case(…): Create a case operation.
- cast(…): Casts a tensor to a new type.
- clip_by_global_norm(…): Clips values of multiple tensors by the ratio of the sum of their norms.
- clip_by_norm(…): Clips tensor values to a maximum L2-norm.
- clip_by_value(…): Clips tensor values to a specified min and max.
- complex(…): Converts two real numbers to a complex number.
- concat(…): Concatenates tensors along one dimension.
- cond(…): Return true_fn() if the predicate pred is true else false_fn().
- constant(…): Creates a constant tensor.
- control_dependencies(…): Wrapper for Graph.control_dependencies() using the default graph.
- convert_to_tensor(…): Converts the given value to a Tensor.
- cos(…): Computes cos of x element-wise.
- cosh(…): Computes hyperbolic cosine of x element-wise.
- cumsum(…): Compute the cumulative sum of the tensor x along axis.
- custom_gradient(…): Decorator to define a function with a custom gradient.
- device(…): Specifies the device for ops created/executed in this context.
- divide(…): Computes Python style division of x by y.
- dynamic_partition(…): Partitions data into num_partitions tensors using indices from partitions.
- dynamic_stitch(…): Interleave the values from the data tensors into a single tensor.
- edit_distance(…): Computes the Levenshtein distance between sequences.
- einsum(…): A generalized contraction between tensors of arbitrary dimension.
- ensure_shape(…): Updates the shape of a tensor and checks at runtime that the shape holds.
- equal(…): Returns the truth value of (x == y) element-wise.
- executing_eagerly(…): Returns True if the current thread has eager execution enabled.
- exp(…): Computes exponential of x element-wise. y=ex
- expand_dims(…): Inserts a dimension of 1 into a tensor’s shape.
- extract_volume_patches(…): Extract patches from input and put them in the “depth” output dimension. 3D extension of extract_image_patches.
- eye(…): Construct an identity matrix, or a batch of matrices.
- fill(…): Creates a tensor filled with a scalar value.
- fingerprint(…): Generates fingerprint values.
- floor(…): Returns element-wise largest integer not greater than x.
- foldl(…): foldl on the list of tensors unpacked from elems on dimension 0.
- foldr(…): foldr on the list of tensors unpacked from elems on dimension 0.
- function(…): Creates a callable TensorFlow graph from a Python function.
- gather(…): Gather slices from params axis axis according to indices.
- gather_nd(…): Gather slices from params into a Tensor with shape specified by indices.
- get_logger(…): Return TF logger instance.
- get_static_value(…): Returns the constant value of the given tensor, if efficiently calculable.
- grad_pass_through(…): Creates a grad-pass-through op with the forward behavior provided in f.
- gradients(…): Constructs symbolic derivatives of sum of ys w.r.t. x in xs.
- greater(…): Returns the truth value of (x > y) element-wise.
- greater_equal(…): Returns the truth value of (x >= y) element-wise.
- group(…): Create an op that groups multiple operations.
- guarantee_const(…): Gives a guarantee to the TF runtime that the input tensor is a constant.
- hessians(…): Constructs the Hessian of sum of ys with respect to x in xs.
- histogram_fixed_width(…): Return histogram of values.
- histogram_fixed_width_bins(…): Bins the given values for use in a histogram.
- identity(…): Return a tensor with the same shape and contents as input.
- identity_n(…): Returns a list of tensors with the same shapes and contents as the input
- import_graph_def(…): Imports the graph from graph_def into the current default Graph. (deprecated arguments)
- init_scope(…): A context manager that lifts ops out of control-flow scopes and function-building graphs.
- is_tensor(…): Checks whether x is a tensor or “tensor-like”.
- less(…): Returns the truth value of (x < y) element-wise.
- less_equal(…): Returns the truth value of (x <= y) element-wise.
- linspace(…): Generates values in an interval.
- load_library(…): Loads a TensorFlow plugin.
- load_op_library(…): Loads a TensorFlow plugin, containing custom ops and kernels.
- logical_and(…): Returns the truth value of x AND y element-wise.
- logical_not(…): Returns the truth value of NOT x element-wise.
- logical_or(…): Returns the truth value of x OR y element-wise.
- make_ndarray(…): Create a numpy ndarray from a tensor.
- make_tensor_proto(…): Create a TensorProto.
- map_fn(…): map on the list of tensors unpacked from elems on dimension 0.
- matmul(…): Multiplies matrix a by matrix b, producing a * b.
- matrix_square_root(…): Computes the matrix square root of one or more square matrices:
- maximum(…): Returns the max of x and y (i.e. x > y ? x : y) element-wise.
- meshgrid(…): Broadcasts parameters for evaluation on an N-D grid.
- minimum(…): Returns the min of x and y (i.e. x < y ? x : y) element-wise.
- multiply(…): Returns x * y element-wise.
- negative(…): Computes numerical negative value element-wise.
- no_gradient(…): Specifies that ops of type op_type is not differentiable.
- no_op(…): Does nothing. Only useful as a placeholder for control edges.
- nondifferentiable_batch_function(…): Batches the computation done by the decorated function.
- norm(…): Computes the norm of vectors, matrices, and tensors.
- not_equal(…): Returns the truth value of (x != y) element-wise.
- numpy_function(…): Wraps a python function and uses it as a TensorFlow op.
- one_hot(…): Returns a one-hot tensor.
- ones(…): Creates a tensor with all elements set to 1.
- ones_like(…): Creates a tensor with all elements set to one.
- pad(…): Pads a tensor.
- parallel_stack(…): Stacks a list of rank-R tensors into one rank-(R+1) tensor in parallel.
- pow(…): Computes the power of one value to another.
- print(…): Print the specified inputs.
- py_function(…): Wraps a python function into a TensorFlow op that executes it eagerly.
- range(…): Creates a sequence of numbers.
- rank(…): Returns the rank of a tensor.
- realdiv(…): Returns x / y element-wise for real types.
- recompute_grad(…): An eager-compatible version of recompute_grad.
- reduce_all(…): Computes the “logical and” of elements across dimensions of a tensor.
- reduce_any(…): Computes the “logical or” of elements across dimensions of a tensor.
- reduce_logsumexp(…): Computes log(sum(exp(elements across dimensions of a tensor))).
- reduce_max(…): Computes the maximum of elements across dimensions of a tensor.
- reduce_mean(…): Computes the mean of elements across dimensions of a tensor.
- reduce_min(…): Computes the minimum of elements across dimensions of a tensor.
- reduce_prod(…): Computes the product of elements across dimensions of a tensor.
- reduce_sum(…): Computes the sum of elements across dimensions of a tensor.
- register_tensor_conversion_function(…): Registers a function for converting objects of base_type to Tensor.
- required_space_to_batch_paddings(…): Calculate padding required to make block_shape divide input_shape.
- reshape(…): Reshapes a tensor.
- reverse(…): Reverses specific dimensions of a tensor.
- reverse_sequence(…): Reverses variable length slices.
- roll(…): Rolls the elements of a tensor along an axis.
- round(…): Rounds the values of a tensor to the nearest integer, element-wise.
- saturate_cast(…): Performs a safe saturating cast of value to dtype.
- scalar_mul(…): Multiplies a scalar times a Tensor or IndexedSlices object.
- scan(…): scan on the list of tensors unpacked from elems on dimension 0.
- scatter_nd(…): Scatter updates into a new tensor according to indices.
- searchsorted(…): Searches input tensor for values on the innermost dimension.
- sequence_mask(…): Returns a mask tensor representing the first N positions of each cell.
- shape(…): Returns the shape of a tensor.
- shape_n(…): Returns shape of tensors.
- sigmoid(…): Computes sigmoid of x element-wise.
- sign(…): Returns an element-wise indication of the sign of a number.
- sin(…): Computes sine of x element-wise.
- sinh(…): Computes hyperbolic sine of x element-wise.
- size(…)
- slice(…): Extracts a slice from a tensor.
- sort(…): Sorts a tensor.
- space_to_batch(…): SpaceToBatch for N-D tensors of type T.
- space_to_batch_nd(…): SpaceToBatch for N-D tensors of type T.
- split(…): Splits a tensor into sub tensors.
- sqrt(…): Computes square root of x element-wise.
- square(…): Computes square of x element-wise.
- squeeze(…): Removes dimensions of size 1 from the shape of a tensor.
- stack(…): Stacks a list of rank-R tensors into one rank-(R+1) tensor.
- stop_gradient(…): Stops gradient computation.
- strided_slice(…): Extracts a strided slice of a tensor (generalized python array indexing).
- subtract(…): Returns x – y element-wise.
- switch_case(…): Create a switch/case operation, i.e. an integer-indexed conditional.
- tan(…): Computes tan of x element-wise.
- tanh(…): Computes hyperbolic tangent of x element-wise.
- tensor_scatter_nd_add(…): Adds sparse updates to an existing tensor according to indices.
- tensor_scatter_nd_sub(…): Subtracts sparse updates from an existing tensor according to indices.
- tensor_scatter_nd_update(…): Scatter updates into an existing tensor according to indices.
- tensordot(…): Tensor contraction of a and b along specified axes.
- tile(…): Constructs a tensor by tiling a given tensor.
- timestamp(…): Provides the time since epoch in seconds.
- transpose(…): Transposes a.
- truediv(…): Divides x / y elementwise (using Python 3 division operator semantics).
- truncatediv(…): Returns x / y element-wise for integer types.
- truncatemod(…): Returns element-wise remainder of division. This emulates C semantics in that
- tuple(…): Group tensors together.
- unique(…): Finds unique elements in a 1-D tensor.
- unique_with_counts(…): Finds unique elements in a 1-D tensor.
- unravel_index(…): Converts a flat index or array of flat indices into a tuple of
- unstack(…): Unpacks the given dimension of a rank-R tensor into rank-(R-1) tensors.
- variable_creator_scope(…): Scope which defines a variable creation function to be used by variable().
- vectorized_map(…): Parallel map on the list of tensors unpacked from elems on dimension 0.
- where(…): Return the elements, either from x or y, depending on the condition.
- while_loop(…): Repeat body while the condition cond is true.
- zeros(…): Creates a tensor with all elements set to zero.
- zeros_like(…): Creates a tensor with all elements set to zero.