On this tutorial, we discover Ivy’s exceptional capability to unify machine studying growth throughout frameworks. We start by writing a totally framework-agnostic neural community that runs seamlessly on NumPy, PyTorch, TensorFlow, and JAX. We then dive into code transpilation, unified APIs, and superior options like Ivy Containers and graph tracing, all designed to make deep studying code transportable, environment friendly, and backend-independent. As we progress, we witness how Ivy simplifies mannequin creation, optimization, and benchmarking with out locking us into any single ecosystem. Take a look at the FULL CODES right here.
!pip set up -q ivy tensorflow torch jax jaxlib
import ivy
import numpy as np
import time
print(f"Ivy model: {ivy.__version__}")
class IvyNeuralNetwork:
"""A easy neural community written purely in Ivy that works with any backend."""
def __init__(self, input_dim=4, hidden_dim=8, output_dim=3):
self.w1 = ivy.random_uniform(form=(input_dim, hidden_dim), low=-0.5, excessive=0.5)
self.b1 = ivy.zeros((hidden_dim,))
self.w2 = ivy.random_uniform(form=(hidden_dim, output_dim), low=-0.5, excessive=0.5)
self.b2 = ivy.zeros((output_dim,))
def ahead(self, x):
"""Ahead move utilizing pure Ivy operations."""
h = ivy.matmul(x, self.w1) + self.b1
h = ivy.relu(h)
out = ivy.matmul(h, self.w2) + self.b2
return ivy.softmax(out)
def train_step(self, x, y, lr=0.01):
"""Easy coaching step with handbook gradients."""
pred = self.ahead(x)
loss = -ivy.imply(ivy.sum(y * ivy.log(pred + 1e-8), axis=-1))
pred_error = pred - y
h_activated = ivy.relu(ivy.matmul(x, self.w1) + self.b1)
h_t = ivy.permute_dims(h_activated, axes=(1, 0))
dw2 = ivy.matmul(h_t, pred_error) / x.form[0]
db2 = ivy.imply(pred_error, axis=0)
self.w2 = self.w2 - lr * dw2
self.b2 = self.b2 - lr * db2
return loss
def demo_framework_agnostic_network():
"""Exhibit the identical community working on completely different backends."""
print("n" + "="*70)
print("PART 1: Framework-Agnostic Neural Community")
print("="*70)
X = np.random.randn(100, 4).astype(np.float32)
y = np.eye(3)[np.random.randint(0, 3, 100)].astype(np.float32)
backends = ['numpy', 'torch', 'tensorflow', 'jax']
outcomes = {}
for backend in backends:
strive:
ivy.set_backend(backend)
if backend == 'jax':
import jax
jax.config.replace('jax_enable_x64', True)
print(f"n🔄 Operating with {backend.higher()} backend...")
X_ivy = ivy.array(X)
y_ivy = ivy.array(y)
web = IvyNeuralNetwork()
start_time = time.time()
for epoch in vary(50):
loss = web.train_step(X_ivy, y_ivy, lr=0.1)
elapsed = time.time() - start_time
predictions = web.ahead(X_ivy)
accuracy = ivy.imply(
ivy.astype(ivy.argmax(predictions, axis=-1) == ivy.argmax(y_ivy, axis=-1), 'float32')
)
outcomes[backend] = {
'loss': float(ivy.to_numpy(loss)),
'accuracy': float(ivy.to_numpy(accuracy)),
'time': elapsed
}
print(f" Remaining Loss: {outcomes[backend]['loss']:.4f}")
print(f" Accuracy: {outcomes[backend]['accuracy']:.2%}")
print(f" Time: {outcomes[backend]['time']:.3f}s")
besides Exception as e:
print(f" ⚠️ {backend} error: {str(e)[:80]}")
outcomes[backend] = None
ivy.unset_backend()
return outcomesWe construct and prepare a easy neural community totally with Ivy to reveal true framework-agnostic design. We run the identical mannequin seamlessly throughout NumPy, PyTorch, TensorFlow, and JAX backends, observing constant habits and efficiency. Via this, we expertise how Ivy abstracts away framework variations whereas sustaining effectivity and accuracy. Take a look at the FULL CODES right here.
def demo_transpilation():
"""Exhibit transpiling code from PyTorch to TensorFlow and JAX."""
print("n" + "="*70)
print("PART 2: Framework Transpilation")
print("="*70)
strive:
import torch
import tensorflow as tf
def pytorch_computation(x):
"""A easy PyTorch computation."""
return torch.imply(torch.relu(x * 2.0 + 1.0))
x_torch = torch.randn(10, 5)
print("n📦 Authentic PyTorch operate:")
result_torch = pytorch_computation(x_torch)
print(f" PyTorch outcome: {result_torch.merchandise():.6f}")
print("n🔄 Transpilation Demo:")
print(" Observe: ivy.transpile() is highly effective however complicated.")
print(" It really works finest with traced/compiled features.")
print(" For easy demonstrations, we'll present the unified API as a substitute.")
print("n✨ Equal computation throughout frameworks:")
x_np = x_torch.numpy()
ivy.set_backend('numpy')
x_ivy = ivy.array(x_np)
result_np = ivy.imply(ivy.relu(x_ivy * 2.0 + 1.0))
print(f" NumPy outcome: {float(ivy.to_numpy(result_np)):.6f}")
ivy.set_backend('tensorflow')
x_ivy = ivy.array(x_np)
result_tf = ivy.imply(ivy.relu(x_ivy * 2.0 + 1.0))
print(f" TensorFlow outcome: {float(ivy.to_numpy(result_tf)):.6f}")
ivy.set_backend('jax')
import jax
jax.config.replace('jax_enable_x64', True)
x_ivy = ivy.array(x_np)
result_jax = ivy.imply(ivy.relu(x_ivy * 2.0 + 1.0))
print(f" JAX outcome: {float(ivy.to_numpy(result_jax)):.6f}")
print(f"n ✅ All outcomes match inside numerical precision!")
ivy.unset_backend()
besides Exception as e:
print(f"⚠️ Demo error: {str(e)[:80]}")On this half, we discover how Ivy allows easy transpilation and interoperability between frameworks. We take a easy PyTorch computation and reproduce it identically in TensorFlow, NumPy, and JAX utilizing Ivy’s unified API. Via this, we see how Ivy bridges framework boundaries, enabling constant outcomes throughout completely different deep studying ecosystems. Take a look at the FULL CODES right here.
def demo_unified_api():
"""Present how Ivy's unified API works throughout completely different operations."""
print("n" + "="*70)
print("PART 3: Unified API Throughout Frameworks")
print("="*70)
operations = [
("Matrix Multiplication", lambda x: ivy.matmul(x, ivy.permute_dims(x, axes=(1, 0)))),
("Element-wise Operations", lambda x: ivy.add(ivy.multiply(x, x), 2)),
("Reductions", lambda x: ivy.mean(ivy.sum(x, axis=0))),
("Neural Net Ops", lambda x: ivy.mean(ivy.relu(x))),
("Statistical Ops", lambda x: ivy.std(x)),
("Broadcasting", lambda x: ivy.multiply(x, ivy.array([1.0, 2.0, 3.0, 4.0]))),
]
X = np.random.randn(5, 4).astype(np.float32)
for op_name, op_func in operations:
print(f"n🔧 {op_name}:")
for backend in ['numpy', 'torch', 'tensorflow', 'jax']:
strive:
ivy.set_backend(backend)
if backend == 'jax':
import jax
jax.config.replace('jax_enable_x64', True)
x_ivy = ivy.array(X)
outcome = op_func(x_ivy)
result_np = ivy.to_numpy(outcome)
if result_np.form == ():
print(f" {backend:12s}: scalar worth = {float(result_np):.4f}")
else:
print(f" {backend:12s}: form={result_np.form}, imply={np.imply(result_np):.4f}")
besides Exception as e:
print(f" {backend:12s}: ⚠️ {str(e)[:60]}")
ivy.unset_backend()On this part, we check Ivy’s unified API by performing varied mathematical, neural, and statistical operations throughout a number of backends. We seamlessly execute the identical code on NumPy, PyTorch, TensorFlow, and JAX, confirming constant outcomes and syntax. Via this, we notice how Ivy simplifies multi-framework coding right into a single, coherent interface that simply works in every single place. Take a look at the FULL CODES right here.
def demo_advanced_features():
"""Exhibit superior Ivy options."""
print("n" + "="*70)
print("PART 4: Superior Ivy Options")
print("="*70)
print("n📦 Ivy Containers - Nested Information Constructions:")
strive:
ivy.set_backend('torch')
container = ivy.Container({
'layer1': {'weights': ivy.random_uniform(form=(4, 8)), 'bias': ivy.zeros((8,))},
'layer2': {'weights': ivy.random_uniform(form=(8, 3)), 'bias': ivy.zeros((3,))}
})
print(f" Container keys: {record(container.keys())}")
print(f" Layer1 weight form: {container['layer1']['weights'].form}")
print(f" Layer2 bias form: {container['layer2']['bias'].form}")
def scale_fn(x, _):
return x * 2.0
scaled_container = container.cont_map(scale_fn)
print(f" ✅ Utilized scaling to all tensors in container")
besides Exception as e:
print(f" ⚠️ Container demo: {str(e)[:80]}")
print("n🔗 Array API Normal Compliance:")
backends_tested = []
for backend in ['numpy', 'torch', 'tensorflow', 'jax']:
strive:
ivy.set_backend(backend)
if backend == 'jax':
import jax
jax.config.replace('jax_enable_x64', True)
x = ivy.array([1.0, 2.0, 3.0])
y = ivy.array([4.0, 5.0, 6.0])
outcome = ivy.sqrt(ivy.sq.(x) + ivy.sq.(y))
print(f" {backend:12s}: L2 norm operations work ✅")
backends_tested.append(backend)
besides Exception as e:
print(f" {backend:12s}: {str(e)[:50]}")
print(f"n Efficiently examined {len(backends_tested)} backends")
print("n🎯 Advanced Multi-step Operations:")
strive:
ivy.set_backend('torch')
x = ivy.random_uniform(form=(10, 5), low=0, excessive=1)
outcome = ivy.imply(
ivy.relu(
ivy.matmul(x, ivy.permute_dims(x, axes=(1, 0)))
),
axis=0
)
print(f" Chained operations (matmul → relu → imply)")
print(f" Enter form: (10, 5), Output form: {outcome.form}")
print(f" ✅ Advanced operation graph executed efficiently")
besides Exception as e:
print(f" ⚠️ {str(e)[:80]}")
ivy.unset_backend()We dive into Ivy’s energy options past the fundamentals. We arrange parameters with ivy.Container, validate Array API–fashion ops throughout NumPy, PyTorch, TensorFlow, and JAX, and chain complicated steps (matmul → ReLU → imply) to see graph-like execution stream. We come away assured that Ivy scales from neat information constructions to strong multi-backend computation. Take a look at the FULL CODES right here.
def benchmark_operation(op_func, x, iterations=50):
"""Benchmark an operation."""
begin = time.time()
for _ in vary(iterations):
outcome = op_func(x)
return time.time() - begin
def demo_performance():
"""Evaluate efficiency throughout backends."""
print("n" + "="*70)
print("PART 5: Efficiency Benchmarking")
print("="*70)
X = np.random.randn(100, 100).astype(np.float32)
def complex_operation(x):
"""A extra complicated computation."""
z = ivy.matmul(x, ivy.permute_dims(x, axes=(1, 0)))
z = ivy.relu(z)
z = ivy.imply(z, axis=0)
return ivy.sum(z)
print("n⏱️ Benchmarking matrix operations (50 iterations):")
print(" Operation: matmul → relu → imply → sum")
for backend in ['numpy', 'torch', 'tensorflow', 'jax']:
strive:
ivy.set_backend(backend)
if backend == 'jax':
import jax
jax.config.replace('jax_enable_x64', True)
x_ivy = ivy.array(X)
_ = complex_operation(x_ivy)
elapsed = benchmark_operation(complex_operation, x_ivy, iterations=50)
print(f" {backend:12s}: {elapsed:.4f}s ({elapsed/50*1000:.2f}ms per op)")
besides Exception as e:
print(f" {backend:12s}: ⚠️ {str(e)[:60]}")
ivy.unset_backend()
if __name__ == "__main__":
print("""
╔════════════════════════════════════════════════════════════════════╗
║ Superior Ivy Tutorial - Framework-Agnostic ML ║
║ Write As soon as, Run All over the place! ║
╚════════════════════════════════════════════════════════════════════╝
""")
outcomes = demo_framework_agnostic_network()
demo_transpilation()
demo_unified_api()
demo_advanced_features()
demo_performance()
print("n" + "="*70)
print("🎉 Tutorial Full!")
print("="*70)
print("n📚 Key Takeaways:")
print(" 1. Ivy allows writing ML code as soon as that runs on any framework")
print(" 2. Similar operations work identically throughout NumPy, PyTorch, TF, JAX")
print(" 3. Unified API supplies constant operations throughout backends")
print(" 4. Swap backends dynamically for optimum efficiency")
print(" 5. Containers assist handle complicated nested mannequin constructions")
print("n💡 Subsequent Steps:")
print(" - Construct your individual framework-agnostic fashions")
print(" - Use ivy.Container for managing mannequin parameters")
print(" - Discover ivy.trace_graph() for computation graph optimization")
print(" - Attempt completely different backends to search out optimum efficiency")
print(" - Test docs at: https://docs.ivy.dev/")
print("="*70)We benchmark the identical complicated operation throughout NumPy, PyTorch, TensorFlow, and JAX to check real-world throughput. We heat up every backend, run 50 iterations, and log complete time and per-op latency so we are able to select the quickest stack for our workload.
In conclusion, we expertise firsthand how Ivy empowers us to “write as soon as and run in every single place.” We observe similar mannequin habits, seamless backend switching, and constant efficiency throughout a number of frameworks. By unifying APIs, simplifying interoperability, and providing superior graph optimization and container options, Ivy paves the way in which for a extra versatile, modular, and environment friendly way forward for machine studying growth. We now stand outfitted to construct and deploy fashions effortlessly throughout numerous environments, all utilizing the identical elegant Ivy codebase.
Take a look at the FULL CODES right here. Be at liberty to take a look at our GitHub Web page for Tutorials, Codes and Notebooks. Additionally, be at liberty to observe us on Twitter and don’t overlook to hitch our 100k+ ML SubReddit and Subscribe to our Publication. Wait! are you on telegram? now you’ll be able to be a part of us on telegram as nicely.
Asif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is dedicated to harnessing the potential of Synthetic Intelligence for social good. His most up-to-date endeavor is the launch of an Synthetic Intelligence Media Platform, Marktechpost, which stands out for its in-depth protection of machine studying and deep studying information that’s each technically sound and simply comprehensible by a large viewers. The platform boasts of over 2 million month-to-month views, illustrating its reputation amongst audiences.
Elevate your perspective with NextTech Information, the place innovation meets perception.
Uncover the most recent breakthroughs, get unique updates, and join with a world community of future-focused thinkers.
Unlock tomorrow’s traits immediately: learn extra, subscribe to our e-newsletter, and turn into a part of the NextTech neighborhood at NextTech-news.com
