Top Related Projects
Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more
Tensors and Dynamic neural networks in Python with strong GPU acceleration
ONNX Runtime: cross-platform, high performance ML inferencing and training accelerator
Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Scala, Go, Javascript and more
Open standard for machine learning interoperability
🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.
Quick Overview
The tensorflow/community repository is a central hub for TensorFlow-related RFCs (Requests for Comments), designs, and community discussions. It serves as a platform for proposing and discussing changes to the TensorFlow ecosystem, fostering collaboration between developers, researchers, and users.
Pros
- Provides a transparent and organized process for proposing and discussing TensorFlow improvements
- Encourages community involvement and feedback in the development of TensorFlow
- Offers a historical record of design decisions and rationales
- Facilitates better communication between TensorFlow maintainers and the community
Cons
- May be overwhelming for newcomers due to the technical nature of discussions
- The process of submitting and reviewing RFCs can be time-consuming
- Some proposals may not gain traction or be implemented, potentially leading to frustration
- Requires active moderation to maintain focus and productivity in discussions
This repository is not a code library, so code examples and getting started instructions are not applicable.
Competitor Comparisons
Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more
Pros of JAX
- More flexible and composable API for numerical computing
- Better support for automatic differentiation and vectorization
- Faster compilation and execution on GPUs and TPUs
Cons of JAX
- Smaller community and ecosystem compared to TensorFlow
- Less comprehensive documentation and tutorials
- Fewer high-level abstractions for deep learning tasks
Code Comparison
JAX:
import jax.numpy as jnp
from jax import grad, jit
def f(x):
return jnp.sum(jnp.sin(x))
grad_f = jit(grad(f))
TensorFlow:
import tensorflow as tf
def f(x):
return tf.reduce_sum(tf.sin(x))
with tf.GradientTape() as tape:
y = f(x)
grad_f = tape.gradient(y, x)
JAX offers a more concise and functional approach to defining and computing gradients, while TensorFlow uses a more imperative style with the GradientTape context manager. JAX's jit decorator allows for easy compilation of functions, potentially improving performance.
Tensors and Dynamic neural networks in Python with strong GPU acceleration
Pros of PyTorch
- More intuitive and Pythonic API, easier for beginners to learn
- Dynamic computational graphs allow for more flexible model architectures
- Better integration with Python debugging tools
Cons of PyTorch
- Smaller ecosystem and fewer pre-built models compared to TensorFlow
- Less support for production deployment and mobile/edge devices
- Steeper learning curve for those coming from a TensorFlow background
Code Comparison
PyTorch:
import torch
x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])
z = torch.add(x, y)
TensorFlow:
import tensorflow as tf
x = tf.constant([1, 2, 3])
y = tf.constant([4, 5, 6])
z = tf.add(x, y)
Both frameworks offer similar functionality for basic operations, but PyTorch's syntax is often considered more intuitive and closer to standard Python. TensorFlow's approach is more verbose but can be more explicit in defining computational graphs. The choice between the two often comes down to personal preference, project requirements, and existing ecosystem compatibility.
ONNX Runtime: cross-platform, high performance ML inferencing and training accelerator
Pros of ONNX Runtime
- Broader model support: Works with models from various frameworks, not just TensorFlow
- Performance optimizations: Offers advanced runtime optimizations for faster inference
- Cross-platform compatibility: Supports a wide range of hardware and operating systems
Cons of ONNX Runtime
- Less community-driven: Primarily maintained by Microsoft, with less community involvement
- Narrower focus: Primarily for inference, while TensorFlow Community covers a broader range of topics
- Steeper learning curve: May require more technical expertise to use effectively
Code Comparison
ONNX Runtime example:
import onnxruntime as ort
session = ort.InferenceSession("model.onnx")
input_name = session.get_inputs()[0].name
output = session.run(None, {input_name: input_data})
TensorFlow example:
import tensorflow as tf
model = tf.saved_model.load("model")
output = model(input_data)
Both repositories serve different purposes. ONNX Runtime focuses on providing a high-performance inference engine for various AI models, while TensorFlow Community is a hub for discussions, proposals, and community-driven development of the TensorFlow ecosystem. The choice between them depends on specific project requirements and the desired level of community engagement.
Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Scala, Go, Javascript and more
Pros of MXNet
- More lightweight and flexible architecture
- Better support for multiple programming languages (Python, R, Scala, Julia)
- Stronger focus on distributed and multi-GPU training
Cons of MXNet
- Smaller community and ecosystem compared to TensorFlow
- Less comprehensive documentation and tutorials
- Fewer pre-trained models and high-level APIs
Code Comparison
MXNet:
import mxnet as mx
from mxnet import nd, autograd, gluon
x = nd.array([[1, 2], [3, 4]])
y = nd.array([[5, 6], [7, 8]])
z = x + y
TensorFlow:
import tensorflow as tf
x = tf.constant([[1, 2], [3, 4]])
y = tf.constant([[5, 6], [7, 8]])
z = tf.add(x, y)
Both frameworks offer similar basic operations, but MXNet's syntax is often more concise. TensorFlow's community repository focuses on discussions, RFCs, and community-driven development, while MXNet's repository contains the actual framework code. This makes direct code comparisons less relevant, as the repositories serve different purposes.
Open standard for machine learning interoperability
Pros of ONNX
- Broader ecosystem support, with compatibility across multiple frameworks
- More focused on model interoperability and portability
- Simpler, more streamlined repository structure
Cons of ONNX
- Smaller community and fewer contributors compared to TensorFlow
- Less comprehensive documentation and tutorials
- Narrower scope, primarily focused on model exchange
Code Comparison
ONNX example (model definition):
import onnx
from onnx import helper, TensorProto
# Create an ONNX model
node = helper.make_node('Relu', inputs=['x'], outputs=['y'])
graph = helper.make_graph([node], 'test-model', [helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 3, 224, 224])], [helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 3, 224, 224])])
model = helper.make_model(graph)
TensorFlow example (model definition):
import tensorflow as tf
model = tf.keras.Sequential([
tf.keras.layers.Input(shape=(224, 224, 3)),
tf.keras.layers.ReLU()
])
Both repositories serve different purposes, with TensorFlow Community focusing on community engagement and project governance, while ONNX emphasizes model interoperability across various deep learning frameworks.
🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.
Pros of transformers
- Extensive library of pre-trained models for various NLP tasks
- Easy-to-use API for fine-tuning and deploying models
- Active community with frequent updates and new model implementations
Cons of transformers
- Focused primarily on NLP tasks, less versatile for other domains
- Can be resource-intensive for large models
- Steeper learning curve for beginners compared to TensorFlow's high-level APIs
Code comparison
transformers:
from transformers import BertTokenizer, BertForSequenceClassification
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
community:
import tensorflow as tf
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
The transformers code demonstrates loading a pre-trained BERT model, while the community code shows creating a simple neural network using TensorFlow's Keras API. transformers focuses on providing ready-to-use models, while community offers more flexibility in building custom architectures.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Welcome to the TensorFlow Developer Community
This Repository
The community repository stores documents used by the developer community.
rfcs- design documents used by the design review processsigs- documentation for each TensorFlow Special Interest group (SIG)governance- operating processes for the TensorFlow project
Contact
For questions about this repository, please file an issue or reach out to Thea Lamkin: thealamkin@google.com.
Further Community Resources
For a complete overview of the TensorFlow community resources, please visit tensorflow.org/community.
Top Related Projects
Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more
Tensors and Dynamic neural networks in Python with strong GPU acceleration
ONNX Runtime: cross-platform, high performance ML inferencing and training accelerator
Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Scala, Go, Javascript and more
Open standard for machine learning interoperability
🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot