Ivy Framework Agnostic Machine Learning Build, Transpile, and Benchmark Across All Major Backends

!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):
       """Forward go 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):
       """Simple coaching step with guide 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():
   """Demonstrate the identical community working on completely different backends."""
   print("n" + "="*70)
   print("PART 1: Framework-Agnostic Neural Network")
   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:
       attempt:
           ivy.set_backend(backend)
          
           if backend == 'jax':
               import jax
               jax.config.replace('jax_enable_x64', True)
          
           print(f"n Running with {backend.higher()} backend...")
          
           X_ivy = ivy.array(X)
           y_ivy = ivy.array(y)
          
           internet = IvyNeuralNetwork()
          
           start_time = time.time()
           for epoch in vary(50):
               loss = internet.train_step(X_ivy, y_ivy, lr=0.1)
          
           elapsed = time.time() - start_time
          
           predictions = internet.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"   Final 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 outcomes

def demo_transpilation():
   """Demonstrate transpiling code from PyTorch to TensorFlow and JAX."""
   print("n" + "="*70)
   print("PART 2: Framework Transpilation")
   print("="*70)
  
   attempt:
       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 Original PyTorch operate:")
       result_torch = pytorch_computation(x_torch)
       print(f"   PyTorch consequence: {result_torch.merchandise():.6f}")
      
       print("n Transpilation Demo:")
       print("   Note: ivy.transpile() is highly effective however advanced.")
       print("   It works greatest with traced/compiled capabilities.")
       print("   For easy demonstrations, we'll present the unified API as an alternative.")
      
       print("n Equivalent 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 consequence: {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 consequence: {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 consequence: {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]}")

def demo_unified_api():
   """Show how Ivy's unified API works throughout completely different operations."""
   print("n" + "="*70)
   print("PART 3: Unified API Across 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']:
           attempt:
               ivy.set_backend(backend)
              
               if backend == 'jax':
                   import jax
                   jax.config.replace('jax_enable_x64', True)
              
               x_ivy = ivy.array(X)
               consequence = op_func(x_ivy)
               result_np = ivy.to_numpy(consequence)
              
               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()

def demo_advanced_features():
   """Demonstrate superior Ivy options."""
   print("n" + "="*70)
   print("PART 4: Advanced Ivy Features")
   print("="*70)
  
   print("n Ivy Containers - Nested Data Structures:")
   attempt:
       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"    Applied scaling to all tensors in container")
      
   besides Exception as e:
       print(f"    Container demo: {str(e)[:80]}")
  
   print("n Array API Standard Compliance:")
   backends_tested = []
   for backend in ['numpy', 'torch', 'tensorflow', 'jax']:
       attempt:
           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])
          
           consequence = 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   Successfully examined {len(backends_tested)} backends")
  
   print("n Complex Multi-step Operations:")
   attempt:
       ivy.set_backend('torch')
      
       x = ivy.random_uniform(form=(10, 5), low=0, excessive=1)
      
       consequence = 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"   Input form: (10, 5), Output form: {consequence.form}")
       print(f"    Complex operation graph executed efficiently")
      
   besides Exception as e:
       print(f"    {str(e)[:80]}")
  
   ivy.unset_backend()

def benchmark_operation(op_func, x, iterations=50):
   """Benchmark an operation."""
   begin = time.time()
   for _ in vary(iterations):
       consequence = op_func(x)
   return time.time() - begin




def demo_performance():
   """Compare efficiency throughout backends."""
   print("n" + "="*70)
   print("PART 5: Performance Benchmarking")
   print("="*70)
  
   X = np.random.randn(100, 100).astype(np.float32)
  
   def complex_operation(x):
       """A extra advanced 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']:
       attempt:
           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("""
   ╔════════════════════════════════════════════════════════════════════╗
   ║          Advanced Ivy Tutorial - Framework-Agnostic ML             ║
   ║                  Write Once, Run Everywhere!                       ║
   ╚════════════════════════════════════════════════════════════════════╝
   """)
  
   outcomes = demo_framework_agnostic_network()
   demo_transpilation()
   demo_unified_api()
   demo_advanced_features()
   demo_performance()
  
   print("n" + "="*70)
   print(" Tutorial Complete!")
   print("="*70)
   print("n Key Takeaways:")
   print("   1. Ivy permits writing ML code as soon as that runs on any framework")
   print("   2. Same operations work identically throughout NumPy, PyTorch, TF, JAX")
   print("   3. Unified API offers constant operations throughout backends")
   print("   4. Switch backends dynamically for optimum efficiency")
   print("   5. Containers assist handle advanced nested mannequin buildings")
   print("n Next Steps:")
   print("   - Build your individual framework-agnostic fashions")
   print("   - Use ivy.Container for managing mannequin parameters")
   print("   - Explore ivy.trace_graph() for computation graph optimization")
   print("   - Try completely different backends to search out optimum efficiency")
   print("   - Check docs at: https://docs.ivy.dev/")
   print("="*70)