# TensorFlow

An end-to-end open source platform for machine learning that provides a comprehensive ecosystem of tools, libraries, and community resources for both research and production deployment. TensorFlow supports stable APIs for Python and C++, along with experimental APIs for other languages, enabling developers to build and deploy ML-powered applications efficiently across various hardware accelerators (CPUs, GPUs, TPUs) and distributed training environments.

## Package Information

- **Package Name**: tensorflow
- **Language**: Python (with C++ core)
- **Installation**: `pip install tensorflow`
- **Version**: 2.20.0

## Core Imports

```python
import tensorflow as tf
```

For Keras high-level API:

```python
from tensorflow import keras
```

For specific modules:

```python
from tensorflow.keras import layers, models, optimizers
from tensorflow.data import Dataset
import tensorflow.nn as nn
```

## Basic Usage

```python
import tensorflow as tf
import numpy as np

# Create tensors
x = tf.constant([1.0, 2.0, 3.0])
y = tf.constant([4.0, 5.0, 6.0])

# Basic operations
z = tf.add(x, y)
print(z)  # tf.Tensor([5. 7. 9.], shape=(3,), dtype=float32)

# Create a simple neural network with Keras
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Create sample data
X_train = np.random.random((1000, 784))
y_train = np.random.randint(10, size=(1000,))

# Train the model
model.fit(X_train, y_train, epochs=5, batch_size=32)
```

## Architecture

TensorFlow's architecture is built around several key components:

- **Tensors**: Multi-dimensional arrays that flow through computational graphs
- **Operations**: Mathematical computations performed on tensors
- **Graphs**: Computational graphs that define the flow of data and operations
- **Sessions**: Runtime environments for executing graphs (TF 1.x) or eager execution (TF 2.x)
- **Keras**: High-level API for building and training neural networks
- **Estimators**: High-level API for distributed training and evaluation

The framework supports both eager execution (default in TF 2.x) for immediate operation evaluation and graph mode for optimized production deployment.

## Capabilities

### Core Tensor Operations

Fundamental tensor creation, manipulation, and mathematical operations that form the foundation of TensorFlow computations.

```python { .api }
def constant(value, dtype=None, shape=None, name="Const"): ...
def Variable(initial_value, trainable=None, validate_shape=True, 
             caching_device=None, name=None, variable_def=None, dtype=None, 
             import_scope=None, constraint=None, synchronization=tf.VariableSynchronization.AUTO, 
             aggregation=tf.VariableAggregation.NONE, shape=None, 
             experimental_enable_variable_lifting=True): ...
def convert_to_tensor(value, dtype=None, dtype_hint=None, name=None): ...
def cast(x, dtype, name=None): ...
def reshape(tensor, shape, name=None): ...
def transpose(a, perm=None, conjugate=False, name="transpose"): ...
def zeros(shape, dtype=tf.float32, name=None): ...
def ones(shape, dtype=tf.float32, name=None): ...
```

[Core Operations](./core.md)

### Math Operations

Comprehensive mathematical operations including arithmetic, trigonometric, linear algebra, and statistical functions.

```python { .api }
def add(x, y, name=None): ...
def subtract(x, y, name=None): ...
def multiply(x, y, name=None): ...
def divide(x, y, name=None): ...
def matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, 
           adjoint_b=False, a_is_sparse=False, b_is_sparse=False, output_type=None,
           grad_a=False, grad_b=False, name=None): ...
def reduce_sum(input_tensor, axis=None, keepdims=None, name=None): ...
def reduce_mean(input_tensor, axis=None, keepdims=None, name=None): ...
```

[Math Operations](./math.md)

### Neural Network Operations

Core neural network operations including activations, convolutions, pooling, normalization, and loss functions.

```python { .api }
def relu(features, name=None): ...
def softmax(logits, axis=None, name=None): ...
def conv2d(input, filters, strides, padding, use_cudnn_on_gpu=True, data_format="NHWC", 
           dilations=[1,1,1,1], name=None): ...
def max_pool2d(input, ksize, strides, padding, data_format="NHWC", name=None): ...
def batch_normalization(x, mean, variance, offset, scale, variance_epsilon, name=None): ...
def softmax_cross_entropy_with_logits(labels, logits, axis=-1, name=None): ...
```

[Neural Network Operations](./nn.md)

### Keras High-Level API

High-level neural network building blocks including models, layers, optimizers, losses, and metrics for rapid prototyping and production.

```python { .api }
class Sequential(Model): ...
class Model: ...
class Dense(Layer): ...
class Conv2D(Layer): ...
class LSTM(Layer): ...
class Adam(Optimizer): ...
class SGD(Optimizer): ...
```

[Keras API](./keras.md)

### Data Processing

Dataset creation, transformation, and preprocessing pipeline operations for efficient data handling and training workflows.

```python { .api }
class Dataset:
    @staticmethod
    def from_tensor_slices(tensors, name=None): ...
    @staticmethod
    def from_tensors(tensors, name=None): ...
    def map(self, map_func, num_parallel_calls=None, deterministic=None, name=None): ...
    def batch(self, batch_size, drop_remainder=False, num_parallel_calls=None, 
              deterministic=None, name=None): ...
    def shuffle(self, buffer_size, seed=None, reshuffle_each_iteration=None, name=None): ...
    def repeat(self, count=None, name=None): ...
```

[Data Processing](./data.md)

### Image Processing

Comprehensive image manipulation, transformation, and computer vision operations for preprocessing and augmentation.

```python { .api }
def decode_image(contents, channels=None, dtype=tf.uint8, name=None, expand_animations=True): ...
def resize(images, size, method=ResizeMethod.BILINEAR, preserve_aspect_ratio=False, 
           antialias=False, name=None): ...
def random_flip_left_right(image, seed=None): ...
def random_brightness(image, max_delta, seed=None): ...
def convert_image_dtype(image, dtype, saturate=False, name=None): ...
```

[Image Processing](./image.md)

### Model Saving and Loading

Complete model serialization, checkpointing, and deployment utilities for production and inference.

```python { .api }
def save(obj, export_dir, signatures=None, options=None): ...
def load(export_dir, tags=None, options=None): ...
class Checkpoint:
    def __init__(self, **kwargs): ...
    def save(self, file_prefix, session=None): ...
    def restore(self, save_path): ...
```

[Model Management](./saved-model.md)

### Distribution Strategies

Multi-device and multi-worker training strategies for scaling machine learning workloads across GPUs and TPUs.

```python { .api }
class MirroredStrategy(Strategy): ...
class MultiWorkerMirroredStrategy(Strategy): ...
class TPUStrategy(Strategy): ...
class ParameterServerStrategy(Strategy): ...
```

[Distribution](./distribute.md)

### Automatic Differentiation

Gradient computation and automatic differentiation functionality for training neural networks.

```python { .api }
class GradientTape:
    def __init__(self, persistent=False, watch_accessed_variables=True): ...
    def watch(self, tensor): ...
    def gradient(self, target, sources, output_gradients=None, 
                unconnected_gradients=UnconnectedGradients.NONE): ...
def gradient(target, sources, grad_ys=None, name="gradients", 
            gate_gradients=False, aggregation_method=None, 
            stop_gradients=None, unconnected_gradients=UnconnectedGradients.NONE): ...
```

### Random Operations

Random number generation and sampling operations for stochastic computations.

```python { .api }
def random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None): ...
def random_uniform(shape, minval=0, maxval=None, dtype=tf.float32, seed=None, name=None): ...
def random_shuffle(value, seed=None, name=None): ...
def set_seed(seed): ...
```

### Configuration and System

System configuration, device management, and runtime settings.

```python { .api }
def list_physical_devices(device_type=None): ...
def list_logical_devices(device_type=None): ...
def experimental_set_memory_growth(device, enable): ...
def experimental_get_memory_info(device): ...
```

### Input/Output Operations

File system operations, data serialization, and I/O utilities.

```python { .api }
def read_file(filename, name=None): ...
def write_file(filename, contents, name=None): ...
def matching_files(pattern, name=None): ...
def decode_raw(input_bytes, out_type, little_endian=True, fixed_length=None, name=None): ...
```

## Types

```python { .api }
class Tensor:
    """Multi-dimensional array with uniform data type."""
    @property
    def shape(self): ...
    @property
    def dtype(self): ...
    @property
    def device(self): ...
    def numpy(self): ...

class Variable(Tensor):
    """Mutable tensor for storing model parameters."""
    def assign(self, value, use_locking=None, name=None, read_value=True): ...
    def assign_add(self, delta, use_locking=None, name=None, read_value=True): ...

class Operation:
    """Computation node in a TensorFlow graph."""
    @property
    def name(self): ...
    @property
    def type(self): ...
    @property
    def inputs(self): ...
    @property
    def outputs(self): ...

# Data types
DType = tf.DType
float16 = tf.float16
float32 = tf.float32
float64 = tf.float64
int8 = tf.int8
int16 = tf.int16
int32 = tf.int32
int64 = tf.int64
uint8 = tf.uint8
uint16 = tf.uint16
uint32 = tf.uint32
uint64 = tf.uint64
bool = tf.bool
string = tf.string
complex64 = tf.complex64
complex128 = tf.complex128

# Enumerations
class VariableSynchronization:
    """Variable synchronization modes for distributed training."""
    NONE = "VariableSynchronization.NONE"
    ON_WRITE = "VariableSynchronization.ON_WRITE"
    ON_READ = "VariableSynchronization.ON_READ"
    AUTO = "VariableSynchronization.AUTO"

class VariableAggregation:
    """Variable aggregation modes for distributed training."""
    NONE = "VariableAggregation.NONE"
    SUM = "VariableAggregation.SUM"  
    MEAN = "VariableAggregation.MEAN"
    ONLY_FIRST_REPLICA = "VariableAggregation.ONLY_FIRST_REPLICA"

class UnconnectedGradients:
    """Gradient computation modes for unconnected inputs."""
    NONE = "UnconnectedGradients.NONE"
    ZERO = "UnconnectedGradients.ZERO"
```