Add build

build/torch24-cxx11-cu118-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch24-cxx11-cu118-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2c0bafa8637ae28052747a180d880eade588382d690c39d37e8a86a6f399b58
+size 775048

build/torch24-cxx11-cu121-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch24-cxx11-cu121-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1b3ac478c39e2e7b7b8baf65bb3fbf1fb6aa577e83fa10b83a7f0492edefabc
+size 771184

build/torch24-cxx11-cu124-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch24-cxx11-cu124-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70c414b395dd4e9c0d69e9d7c2b6f836b18ac3efe6275a44ccd4ea72450b9df9
+size 807968

build/torch24-cxx98-cu118-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch24-cxx98-cu118-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62c78c86c1642c2dcd14801c116a2ee16d460504f37168ced78d59a9e72513bb
+size 761456

build/torch24-cxx98-cu121-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch24-cxx98-cu121-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3df5b3748a14214c1c86100f14f14e6125efada9079955dc0d65d7575a6debb6
+size 757400

build/torch24-cxx98-cu124-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch24-cxx98-cu124-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3c9e874d518d522c6fb3106515376eaa7151bdbba9b029f3c70448a65d6895d
+size 798360

build/torch25-cxx11-cu118-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch25-cxx11-cu118-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e7b40d071f2fdb422d1caee712e5d0328c3cd85dc17695923fc11885a397f75
+size 775048

build/torch25-cxx11-cu121-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch25-cxx11-cu121-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:865e5b0255dbc6566459444b9f2325f9f54e568213476a66992314ebb1a47e1d
+size 771184

build/torch25-cxx11-cu124-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch25-cxx11-cu124-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d0524c8b70ea4e427ca499312f076e834d06fe11bea9dd4decb2406a3094c8a
+size 807968

build/torch25-cxx98-cu118-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch25-cxx98-cu118-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1a3146807c8c7c97a5222dae8fe0aa186ee01d5bc466bf3b74b49e23ecd156a
+size 761456

build/torch25-cxx98-cu121-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch25-cxx98-cu121-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5536093e89b5707856d62f677da924c5e3c51e0a2868d3e7e11475508c97d5cf
+size 757400

build/torch25-cxx98-cu124-x86_64-linux/activation/__init__.py

@@ -0,0 +1,32 @@
+import torch
+
+import activation._activation
+
+def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.silu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                           
+    torch.ops._activation.gelu_and_mul(out, x)                                                                                                                                                                                                   
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                      
+    torch.ops._activation.gelu_tanh_and_mul(out, x)                                                                                                                                                                                              
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def fatrelu_and_mul(out: torch.Tensor,                                                                                                                                                                                                  
+                    x: torch.Tensor,                                                                                                                                                                                                    
+                    threshold: float = 0.0) -> None:                                                                                                                                                                                    
+    torch.ops._activation.fatrelu_and_mul(out, x, threshold)                                                                                                                                                                                     
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                              
+    torch.ops._activation.gelu_fast(out, x)                                                                                                                                                                                                      
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                               
+    torch.ops._activation.gelu_new(out, x)                                                                                                                                                                                                       
+                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                        
+def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:                                                                                                                                                                             
+    torch.ops._activation.gelu_quick(out, x)

build/torch25-cxx98-cu124-x86_64-linux/activation/_activation.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa6928c9ae395303ab136e1d9761316a77da82f0a0b000996b52d9667f0b1f84
+size 798360