Ivy Framework Agnostic Machine Finding out Assemble, Transpile, And Benchmark All through All Foremost Backends

!pip arrange -q ivy tensorflow torch jax jaxlib


import ivy
import numpy as np
import time


print(f"Ivy mannequin: {ivy.__version__}")




class IvyNeuralNetwork:
   """A simple neural group 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(type=(input_dim, hidden_dim), low=-0.5, extreme=0.5)
       self.b1 = ivy.zeros((hidden_dim,))
       self.w2 = ivy.random_uniform(type=(hidden_dim, output_dim), low=-0.5, extreme=0.5)
       self.b2 = ivy.zeros((output_dim,))
      
   def forward(self, x):
       """Forward transfer using 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 teaching step with handbook gradients."""
       pred = self.forward(x)
      
       loss = -ivy.suggest(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.type[0]
       db2 = ivy.suggest(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 equivalent group engaged on fully completely different backends."""
   print("n" + "="*70)
   print("PART 1: Framework-Agnostic Neural Neighborhood")
   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:
       try:
           ivy.set_backend(backend)
          
           if backend == 'jax':
               import jax
               jax.config.change('jax_enable_x64', True)
          
           print(f"n🔄 Working with {backend.increased()} backend...")
          
           X_ivy = ivy.array(X)
           y_ivy = ivy.array(y)
          
           net = IvyNeuralNetwork()
          
           start_time = time.time()
           for epoch in range(50):
               loss = net.train_step(X_ivy, y_ivy, lr=0.1)
          
           elapsed = time.time() - start_time
          
           predictions = net.forward(X_ivy)
           accuracy = ivy.suggest(
               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")
          
       apart from Exception as e:
           print(f"   ⚠️ {backend} error: {str(e)[:80]}")
           outcomes[backend] = None
  
   ivy.unset_backend()
   return outcomes

def demo_transpilation():
   """Exhibit transpiling code from PyTorch to TensorFlow and JAX."""
   print("n" + "="*70)
   print("PART 2: Framework Transpilation")
   print("="*70)
  
   try:
       import torch
       import tensorflow as tf
      
       def pytorch_computation(x):
           """A simple PyTorch computation."""
           return torch.suggest(torch.relu(x * 2.0 + 1.0))
      
       x_torch = torch.randn(10, 5)
      
       print("n📦 Genuine PyTorch function:")
       result_torch = pytorch_computation(x_torch)
       print(f"   PyTorch end result: {result_torch.merchandise():.6f}")
      
       print("n🔄 Transpilation Demo:")
       print("   Observe: ivy.transpile() is very efficient nonetheless difficult.")
       print("   It actually works most interesting with traced/compiled options.")
       print("   For simple demonstrations, we'll current the unified API instead.")
      
       print("n✨ Equal computation all through frameworks:")
       x_np = x_torch.numpy()
      
       ivy.set_backend('numpy')
       x_ivy = ivy.array(x_np)
       result_np = ivy.suggest(ivy.relu(x_ivy * 2.0 + 1.0))
       print(f"   NumPy end result: {float(ivy.to_numpy(result_np)):.6f}")
      
       ivy.set_backend('tensorflow')
       x_ivy = ivy.array(x_np)
       result_tf = ivy.suggest(ivy.relu(x_ivy * 2.0 + 1.0))
       print(f"   TensorFlow end result: {float(ivy.to_numpy(result_tf)):.6f}")
      
       ivy.set_backend('jax')
       import jax
       jax.config.change('jax_enable_x64', True)
       x_ivy = ivy.array(x_np)
       result_jax = ivy.suggest(ivy.relu(x_ivy * 2.0 + 1.0))
       print(f"   JAX end result: {float(ivy.to_numpy(result_jax)):.6f}")
      
       print(f"n   ✅ All outcomes match inside numerical precision!")
      
       ivy.unset_backend()
          
   apart from Exception as e:
       print(f"⚠️ Demo error: {str(e)[:80]}")

def demo_unified_api():
   """Current how Ivy's unified API works all through fully completely different operations."""
   print("n" + "="*70)
   print("PART 3: Unified API All through 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']:
           try:
               ivy.set_backend(backend)
              
               if backend == 'jax':
                   import jax
                   jax.config.change('jax_enable_x64', True)
              
               x_ivy = ivy.array(X)
               end result = op_func(x_ivy)
               result_np = ivy.to_numpy(end result)
              
               if result_np.type == ():
                   print(f"   {backend:12s}: scalar value = {float(result_np):.4f}")
               else:
                   print(f"   {backend:12s}: type={result_np.type}, suggest={np.suggest(result_np):.4f}")
              
           apart from Exception as e:
               print(f"   {backend:12s}: ⚠️ {str(e)[:60]}")
      
       ivy.unset_backend()

def demo_advanced_features():
   """Exhibit superior Ivy choices."""
   print("n" + "="*70)
   print("PART 4: Superior Ivy Choices")
   print("="*70)
  
   print("n📦 Ivy Containers - Nested Info Constructions:")
   try:
       ivy.set_backend('torch')
      
       container = ivy.Container({
           'layer1': {'weights': ivy.random_uniform(type=(4, 8)), 'bias': ivy.zeros((8,))},
           'layer2': {'weights': ivy.random_uniform(type=(8, 3)), 'bias': ivy.zeros((3,))}
       })
      
       print(f"   Container keys: {report(container.keys())}")
       print(f"   Layer1 weight type: {container['layer1']['weights'].type}")
       print(f"   Layer2 bias type: {container['layer2']['bias'].type}")
      
       def scale_fn(x, _):
           return x * 2.0
      
       scaled_container = container.cont_map(scale_fn)
       print(f"   ✅ Utilized scaling to all tensors in container")
      
   apart from Exception as e:
       print(f"   ⚠️ Container demo: {str(e)[:80]}")
  
   print("n🔗 Array API Regular Compliance:")
   backends_tested = []
   for backend in ['numpy', 'torch', 'tensorflow', 'jax']:
       try:
           ivy.set_backend(backend)
          
           if backend == 'jax':
               import jax
               jax.config.change('jax_enable_x64', True)
          
           x = ivy.array([1.0, 2.0, 3.0])
           y = ivy.array([4.0, 5.0, 6.0])
          
           end result = ivy.sqrt(ivy.sq.(x) + ivy.sq.(y))
           print(f"   {backend:12s}: L2 norm operations work ✅")
           backends_tested.append(backend)
       apart from Exception as e:
           print(f"   {backend:12s}: {str(e)[:50]}")
  
   print(f"n   Effectively examined {len(backends_tested)} backends")
  
   print("n🎯 Superior Multi-step Operations:")
   try:
       ivy.set_backend('torch')
      
       x = ivy.random_uniform(type=(10, 5), low=0, extreme=1)
      
       end result = ivy.suggest(
           ivy.relu(
               ivy.matmul(x, ivy.permute_dims(x, axes=(1, 0)))
           ),
           axis=0
       )
      
       print(f"   Chained operations (matmul → relu → suggest)")
       print(f"   Enter type: (10, 5), Output type: {end result.type}")
       print(f"   ✅ Superior operation graph executed effectively")
      
   apart from Exception as e:
       print(f"   ⚠️ {str(e)[:80]}")
  
   ivy.unset_backend()

def benchmark_operation(op_func, x, iterations=50):
   """Benchmark an operation."""
   start = time.time()
   for _ in range(iterations):
       end result = op_func(x)
   return time.time() - start




def demo_performance():
   """Consider effectivity all through backends."""
   print("n" + "="*70)
   print("PART 5: Effectivity Benchmarking")
   print("="*70)
  
   X = np.random.randn(100, 100).astype(np.float32)
  
   def complex_operation(x):
       """A additional difficult computation."""
       z = ivy.matmul(x, ivy.permute_dims(x, axes=(1, 0)))
       z = ivy.relu(z)
       z = ivy.suggest(z, axis=0)
       return ivy.sum(z)
  
   print("n⏱️ Benchmarking matrix operations (50 iterations):")
   print("   Operation: matmul → relu → suggest → sum")
  
   for backend in ['numpy', 'torch', 'tensorflow', 'jax']:
       try:
           ivy.set_backend(backend)
          
           if backend == 'jax':
               import jax
               jax.config.change('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)")
          
       apart from 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 quickly as, Run Everywhere!                       ║
   ╚════════════════════════════════════════════════════════════════════╝
   """)
  
   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 permits writing ML code as quickly as that runs on any framework")
   print("   2. Comparable operations work identically all through NumPy, PyTorch, TF, JAX")
   print("   3. Unified API provides fixed operations all through backends")
   print("   4. Swap backends dynamically for optimum effectivity")
   print("   5. Containers help deal with difficult nested model constructions")
   print("n💡 Subsequent Steps:")
   print("   - Assemble your particular person framework-agnostic fashions")
   print("   - Use ivy.Container for managing model parameters")
   print("   - Uncover ivy.trace_graph() for computation graph optimization")
   print("   - Try fully completely different backends to go looking out optimum effectivity")
   print("   - Take a look at docs at: https://docs.ivy.dev/")
   print("="*70)