pyerualjetwork 3.3.2__tar.gz → 3.3.4__tar.gz

pyerualjetwork-3.3.4/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: pyerualjetwork
+Version: 3.3.4
+Summary: * PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques.
+Author: Hasan Can Beydili
+Author-email: tchasancan@gmail.com
+Keywords: model evaluation,classification,potentiation learning artificial neural networks,NEAT,genetic algorithms,reinforcement learning,neural networks
+Description-Content-Type: text/markdown
+
+# PyerualJetwork [![Socket Badge](https://socket.dev/api/badge/pypi/package/pyerualjetwork/3.3.4?artifact_id=tar-gz)](https://socket.dev/pypi/package/pyerualjetwork/overview/2.5.0/tar-gz) [![CodeFactor](https://www.codefactor.io/repository/github/hcb06/PyerualJetwork/badge)](https://www.codefactor.io/repository/github/hcb06/PyerualJetwork) [![PyPI Downloads](https://static.pepy.tech/badge/PyerualJetwork)](https://pepy.tech/projects/PyerualJetwork) + [![PyPI Downloads](https://static.pepy.tech/badge/anaplan)](https://pepy.tech/projects/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/PyerualJetwork/month)](https://pepy.tech/projects/PyerualJetwork) [![PyPI Downloads](https://static.pepy.tech/badge/anaplan/week)](https://pepy.tech/projects/anaplan) [![PyPI version](https://img.shields.io/pypi/v/PyerualJetwork.svg)](https://pypi.org/project/anaplan/)
+
+Note: anaplan old name of pyerualjetwork.
+
+The first version of PyerualJetwork was released on May 22, 2024, and its latest version was released on August 22, 2024, and no further versions will be released. Anaplan launched its first version on August 30, 2024, as a continuation of PyerualJetwork. Only the name has been changed.
+
+IMPORTAT CHANGE!
+
+I recently updated the name of the library I published as "pyerualjetwork" to "anaplan." However, due to copyright issues and branding concerns, I have decided to revert to the original name, "pyerualjetwork." From now on, you can access the library by installing version pyerualjetwork(3.3.4) using the command pip install pyerualjetwork, replacing the current "anaplan(2.5.3)" modules.
+
+https://libraries.io/pypi/pyerualjetwork
+
+https://libraries.io/pypi/anaplan (end of support)
+
+      pip install pyerualjetwork
+      
+      from pyerualjetwork import plan
+      from pyerualjetwork import planeat
+      from pyerualjetwork import data_operations
+      from pyerualjetwork import model_operations
+
+      Optimized for Visual Studio Code(Note: Improved for other ides in 1.5.8>.)
+      
+      requires=[
+        'setuptools==75.6.0'
+ 	    'scipy==1.13.1',
+	    'tqdm==4.66.4',
+	    'seaborn==0.13.2',
+	    'pandas==2.2.2',
+	    'networkx==3.3',
+	    'numpy==1.26.4',
+	    'matplotlib==3.9.0',
+	    'colorama==0.4.6'
+        ]
+
+     matplotlib, seaborn, networkx (optional).
+     PyerualJetwork checks and install all dependencies (with optional ones) for every runing.
+     If your version is higher or lower, PyerualJetwork automaticly delete other versions and installs this versions.
+          
+##############################
+
+ABOUT PYERUALJETWORK:
+
+PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques. Its most important component is the PLAN (Potentiation Learning Artificial Neural Network) https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4862342. (THIS ARTICLE IS FIRST VERSION OF PLAN.) MODERN VERSION OF PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+Both the PLAN algorithm and the PyerualJetwork library were created by Author, and all rights are reserved by Author.
+PyerualJetwork is free to use for commercial business and individual users. PyerualJetwork is written in fully functional programming with non-oop elements. PyerualJetwork consists of many functions that complement each other, which facilitates the learning process and debugging during use.
+As of 12/21/2024, the library includes PLAN and PLANEAT module, but other machine learning modules are expected to be added in the future.
+<br><br>
+
+PyerualJetwork includes Plan Vision, NLPlan, PLANEAT and at the between of both, Deep Plan:<br>
+
+![PyerualJetwork](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PyerualJetwork.jpg)<br><br><br>
+
+PLAN VISION:<br>
+
+![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PlanVision.jpg)
+
+You can create artificial intelligence models that perform computer vision tasks using the plan module:<br>
+
+![AUTONOMOUS](https://github.com/HCB06/PyerualJetwork/blob/main/Media/autonomous.gif)<br><br><br>
+![XRAY](https://github.com/HCB06/PyerualJetwork/blob/main/Media/chest_xray.png)<br><br><br>
+![GENDER](https://github.com/HCB06/PyerualJetwork/blob/main/Media/gender_classification.png)<br><br><br>
+
+NLPlan:<br>
+
+![NLPLAN](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLPlan.jpg)<br>
+
+You can create artificial intelligence models that perform natural language processing tasks using the plan module:
+
+![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLP.gif)
+
+PLANEAT:<br>
+
+You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the planeat module:
+
+![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_1.gif)<br>
+
+![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_2.gif)<br>
+
+
+HOW DO I IMPORT IT TO MY PROJECT?
+
+Anaconda users can access the 'Anaconda Prompt' terminal from the Start menu and add the necessary library modules to the Python module search queue by typing "pip install PyerualJetwork" and pressing enter. If you are not using Anaconda, you can simply open the 'cmd' Windows command terminal from the Start menu and type "pip install pyerualjetwork". (Visual Studio Code reccomended) After installation, it's important to periodically open the terminal of the environment you are using and stay up to date by using the command "pip install pyerualjetwork --upgrade".
+•
+After installing the module using "pip" you can now call the library module in your project environment. Use: “from pyerualjetwork import plan”. Now, you can call the necessary functions from the plan module.
+
+The PLAN algorithm will not be explained in this document. This document focuses on how professionals can integrate and use PyerualJetwork in their systems. However, briefly, the PLAN algorithm can be described as a classification algorithm. PLAN algorithm achieves this task with an incredibly energy-efficient, fast, and hyperparameter-free user-friendly approach. For more detailed information, you can check out ![PyerualJetwork USER MANUEL](https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf) file.

pyerualjetwork-3.3.4/README.md

@@ -0,0 +1,87 @@
+# PyerualJetwork [![Socket Badge](https://socket.dev/api/badge/pypi/package/pyerualjetwork/3.3.4?artifact_id=tar-gz)](https://socket.dev/pypi/package/pyerualjetwork/overview/2.5.0/tar-gz) [![CodeFactor](https://www.codefactor.io/repository/github/hcb06/PyerualJetwork/badge)](https://www.codefactor.io/repository/github/hcb06/PyerualJetwork) [![PyPI Downloads](https://static.pepy.tech/badge/PyerualJetwork)](https://pepy.tech/projects/PyerualJetwork) + [![PyPI Downloads](https://static.pepy.tech/badge/anaplan)](https://pepy.tech/projects/pyerualjetwork) [![PyPI Downloads](https://static.pepy.tech/badge/PyerualJetwork/month)](https://pepy.tech/projects/PyerualJetwork) [![PyPI Downloads](https://static.pepy.tech/badge/anaplan/week)](https://pepy.tech/projects/anaplan) [![PyPI version](https://img.shields.io/pypi/v/PyerualJetwork.svg)](https://pypi.org/project/anaplan/)
+
+Note: anaplan old name of pyerualjetwork.
+
+The first version of PyerualJetwork was released on May 22, 2024, and its latest version was released on August 22, 2024, and no further versions will be released. Anaplan launched its first version on August 30, 2024, as a continuation of PyerualJetwork. Only the name has been changed.
+
+IMPORTAT CHANGE!
+
+I recently updated the name of the library I published as "pyerualjetwork" to "anaplan." However, due to copyright issues and branding concerns, I have decided to revert to the original name, "pyerualjetwork." From now on, you can access the library by installing version pyerualjetwork(3.3.4) using the command pip install pyerualjetwork, replacing the current "anaplan(2.5.3)" modules.
+
+https://libraries.io/pypi/pyerualjetwork
+
+https://libraries.io/pypi/anaplan (end of support)
+
+      pip install pyerualjetwork
+      
+      from pyerualjetwork import plan
+      from pyerualjetwork import planeat
+      from pyerualjetwork import data_operations
+      from pyerualjetwork import model_operations
+
+      Optimized for Visual Studio Code(Note: Improved for other ides in 1.5.8>.)
+      
+      requires=[
+        'setuptools==75.6.0'
+ 	    'scipy==1.13.1',
+	    'tqdm==4.66.4',
+	    'seaborn==0.13.2',
+	    'pandas==2.2.2',
+	    'networkx==3.3',
+	    'numpy==1.26.4',
+	    'matplotlib==3.9.0',
+	    'colorama==0.4.6'
+        ]
+
+     matplotlib, seaborn, networkx (optional).
+     PyerualJetwork checks and install all dependencies (with optional ones) for every runing.
+     If your version is higher or lower, PyerualJetwork automaticly delete other versions and installs this versions.
+          
+##############################
+
+ABOUT PYERUALJETWORK:
+
+PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques. Its most important component is the PLAN (Potentiation Learning Artificial Neural Network) https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4862342. (THIS ARTICLE IS FIRST VERSION OF PLAN.) MODERN VERSION OF PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+Both the PLAN algorithm and the PyerualJetwork library were created by Author, and all rights are reserved by Author.
+PyerualJetwork is free to use for commercial business and individual users. PyerualJetwork is written in fully functional programming with non-oop elements. PyerualJetwork consists of many functions that complement each other, which facilitates the learning process and debugging during use.
+As of 12/21/2024, the library includes PLAN and PLANEAT module, but other machine learning modules are expected to be added in the future.
+<br><br>
+
+PyerualJetwork includes Plan Vision, NLPlan, PLANEAT and at the between of both, Deep Plan:<br>
+
+![PyerualJetwork](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PyerualJetwork.jpg)<br><br><br>
+
+PLAN VISION:<br>
+
+![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PlanVision.jpg)
+
+You can create artificial intelligence models that perform computer vision tasks using the plan module:<br>
+
+![AUTONOMOUS](https://github.com/HCB06/PyerualJetwork/blob/main/Media/autonomous.gif)<br><br><br>
+![XRAY](https://github.com/HCB06/PyerualJetwork/blob/main/Media/chest_xray.png)<br><br><br>
+![GENDER](https://github.com/HCB06/PyerualJetwork/blob/main/Media/gender_classification.png)<br><br><br>
+
+NLPlan:<br>
+
+![NLPLAN](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLPlan.jpg)<br>
+
+You can create artificial intelligence models that perform natural language processing tasks using the plan module:
+
+![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLP.gif)
+
+PLANEAT:<br>
+
+You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the planeat module:
+
+![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_1.gif)<br>
+
+![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_2.gif)<br>
+
+
+HOW DO I IMPORT IT TO MY PROJECT?
+
+Anaconda users can access the 'Anaconda Prompt' terminal from the Start menu and add the necessary library modules to the Python module search queue by typing "pip install PyerualJetwork" and pressing enter. If you are not using Anaconda, you can simply open the 'cmd' Windows command terminal from the Start menu and type "pip install pyerualjetwork". (Visual Studio Code reccomended) After installation, it's important to periodically open the terminal of the environment you are using and stay up to date by using the command "pip install pyerualjetwork --upgrade".
+•
+After installing the module using "pip" you can now call the library module in your project environment. Use: “from pyerualjetwork import plan”. Now, you can call the necessary functions from the plan module.
+
+The PLAN algorithm will not be explained in this document. This document focuses on how professionals can integrate and use PyerualJetwork in their systems. However, briefly, the PLAN algorithm can be described as a classification algorithm. PLAN algorithm achieves this task with an incredibly energy-efficient, fast, and hyperparameter-free user-friendly approach. For more detailed information, you can check out ![PyerualJetwork USER MANUEL](https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf) file.

pyerualjetwork-3.3.4/pyerualjetwork/__init__.py

@@ -0,0 +1,70 @@
+# pyerualjetwork/__init__.py
+
+import subprocess
+import pkg_resources
+
+print("Auto checking and installation dependencies for PyerualJetwork")
+
+package_names = [
+    'scipy==1.13.1',
+    'tqdm==4.66.4',
+    'seaborn==0.13.2',
+    'pandas==2.2.2',
+    'networkx==3.3',
+    'numpy==1.26.4',
+    'matplotlib==3.9.0',
+    'colorama==0.4.6'
+]
+
+installed_packages = pkg_resources.working_set
+installed = {pkg.key: pkg.version for pkg in installed_packages}
+err = 0
+
+for package_name in package_names:
+    package_name_only, required_version = package_name.split('==')
+    
+    if package_name_only not in installed:
+
+        try:
+            print(f"{package_name} Installing...")
+            subprocess.check_call(["pip", "install", package_name])
+        except Exception as e:
+            err += 1
+            print(f"Error installing {package_name} library, installation continues: {e}")
+    else:
+
+        installed_version = installed[package_name_only]
+        if installed_version != required_version:
+            print(f"Updating {package_name_only} from version {installed_version} to {required_version}...")
+            try:
+                subprocess.check_call(["pip", "install", package_name])
+            except Exception as e:
+                err += 1
+                print(f"Error updating {package_name} library, installation continues: {e}")
+        else:
+            print(f"{package_name} ready.")
+
+print(f"PyerualJetwork is ready to use with {err} errors")
+
+__version__ = "3.3.4"
+__update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES (This version equal to anaplan==2.5.3)\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf.\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
+
+def print_version(__version__):
+    print(f"PyerualJetwork Version {__version__}" + '\n')
+
+def print_update_notes(__update__):
+    print(f"Update Notes:\n{__update__}")
+
+print_version(__version__)
+print_update_notes(__update__)
+
+from .plan import *
+from .planeat import *
+from .activation_functions import *
+from .data_operations import *
+from .loss_functions import *
+from .metrics import *
+from .model_operations import *
+from .ui import *
+from .visualizations import *
+from .help import *

pyerualjetwork-3.3.4/pyerualjetwork/activation_functions.py

@@ -0,0 +1,367 @@
+import numpy as np
+from scipy.special import expit, softmax
+
+# ACTIVATION FUNCTIONS -----
+
+def all_activations():
+    
+    activations_list = ['linear', 'sigmoid', 'relu', 'tanh', 'circular', 'spiral', 'swish', 'sin_plus', 'mod_circular', 'tanh_circular', 'leaky_relu', 'softplus', 'elu', 'gelu', 'selu', 'sinakt', 'p_squared', 'sglu', 'dlrelu', 'exsig', 'acos', 'gla', 'srelu', 'qelu', 'isra', 'waveakt', 'arctan', 'bent_identity', 'sech', 'softsign', 'pwl', 'cubic', 'gaussian', 'sine', 'tanh_square', 'mod_sigmoid', 'quartic', 'square_quartic', 'cubic_quadratic', 'exp_cubic', 'sine_square', 'logarithmic', 'scaled_cubic', 'sine_offset']
+    
+    return activations_list
+
+def spiral_activation(x):
+
+    r = np.sqrt(np.sum(x**2))
+    
+    theta = np.arctan2(x[1:], x[:-1])
+
+    spiral_x = r * np.cos(theta + r)
+    spiral_y = r * np.sin(theta + r)
+    
+
+    spiral_output = np.concatenate(([spiral_x[0]], spiral_y))
+    
+    return spiral_output
+
+
+def Softmax(
+    x  # num: Input data to be transformed using softmax function.
+):
+    """
+    Applies the softmax function to the input data.
+
+    Args:
+        (num): Input data to be transformed using softmax function.
+
+    Returns:
+       (num): Transformed data after applying softmax function.
+    """
+
+    return softmax(x)
+
+
+def Sigmoid(
+    x  # num: Input data to be transformed using sigmoid function.
+):
+    """
+    Applies the sigmoid function to the input data.
+
+    Args:
+        (num): Input data to be transformed using sigmoid function.
+
+    Returns:
+        (num): Transformed data after applying sigmoid function.
+    """
+    return expit(x)
+
+
+def Relu(
+    x  # num: Input data to be transformed using ReLU function.
+):
+    """
+    Applies the Rectified Linear Unit (ReLU) function to the input data.
+
+    Args:
+        (num): Input data to be transformed using ReLU function.
+
+    Returns:
+        (num): Transformed data after applying ReLU function.
+    """
+
+    return np.maximum(0, x)
+
+
+def tanh(x):
+    return np.tanh(x)
+
+def swish(x):
+    return x * (1 / (1 + np.exp(-x)))
+
+def sin_plus(x):
+    return (np.sin(x) + 1) / 2
+
+def modular_circular_activation(x, period=2*np.pi):
+    return np.mod(x, period) / period
+
+def tanh_circular_activation(x):
+    return (np.tanh(x) + 1) / 2
+
+def leaky_relu(x, alpha=0.01):
+    return np.where(x > 0, x, alpha * x)
+
+def softplus(x):
+    return np.log(1 + np.exp(x))
+
+def elu(x, alpha=1.0):
+    return np.where(x > 0, x, alpha * (np.exp(x) - 1))
+
+def gelu(x):
+    return 0.5 * x * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+
+def selu(x, lambda_=1.0507, alpha=1.6733):
+    return lambda_ * np.where(x > 0, x, alpha * (np.exp(x) - 1))
+
+def sinakt(x):
+    return np.sin(x) + np.cos(x)
+
+def p_squared(x, alpha=1.0, beta=0.0):
+    return alpha * x**2 + beta * x
+
+def sglu(x, alpha=1.0):
+    return softmax(alpha * x) * x
+
+# 4. Double Leaky ReLU (DLReLU)
+def dlrelu(x):
+    return np.maximum(0.01 * x, x) + np.minimum(0.01 * x, 0.1 * x)
+
+# 5. Exponential Sigmoid (ExSig)
+def exsig(x):
+    return 1 / (1 + np.exp(-x**2))
+
+# 6. Adaptive Cosine Activation (ACos)
+def acos(x, alpha=1.0, beta=0.0):
+    return np.cos(alpha * x + beta)
+
+# 7. Gaussian-like Activation (GLA)
+def gla(x, alpha=1.0, mu=0.0):
+    return np.exp(-alpha * (x - mu)**2)
+
+# 8. Swish ReLU (SReLU)
+def srelu(x):
+    return x * (1 / (1 + np.exp(-x))) + np.maximum(0, x)
+
+# 9. Quadratic Exponential Linear Unit (QELU)
+def qelu(x):
+    return x**2 * np.exp(x) - 1
+
+# 10. Inverse Square Root Activation (ISRA)
+def isra(x):
+    return x / np.sqrt(np.abs(x) + 1)
+
+def waveakt(x, alpha=1.0, beta=2.0, gamma=3.0):
+    return np.sin(alpha * x) * np.cos(beta * x) * np.sin(gamma * x)
+
+def arctan(x):
+    return np.arctan(x)
+
+def bent_identity(x):
+    return (np.sqrt(x**2 + 1) - 1) / 2 + x
+
+def circular_activation(x, scale=2.0, frequency=1.0, shift=0.0):    
+    
+    n_features = x.shape[0]
+    
+    circular_output = np.zeros_like(x)
+    
+    for i in range(n_features):
+        
+        r = np.sqrt(np.sum(x**2))
+        theta = 2 * np.pi * (i / n_features) + shift
+        
+        circular_x = r * np.cos(theta + frequency * r) * scale
+        circular_y = r * np.sin(theta + frequency * r) * scale
+        
+        if i % 2 == 0:
+            circular_output[i] = circular_x
+        else:
+            circular_output[i] = circular_y
+    
+    return circular_output
+
+def sech(x):
+    return 2 / (np.exp(x) + np.exp(-x))
+
+def softsign(x):
+    return x / (1 + np.abs(x))
+
+def pwl(x, alpha=0.5, beta=1.5):
+    return np.where(x <= 0, alpha * x, beta * x)
+
+def cubic(x):
+    return x**3
+
+def gaussian(x, alpha=1.0, mu=0.0):
+    return np.exp(-alpha * (x - mu)**2)
+                
+def sine(x, alpha=1.0):
+    return np.sin(alpha * x)
+
+def tanh_square(x):
+    return np.tanh(x)**2
+
+def mod_sigmoid(x, alpha=1.0, beta=0.0):
+    return 1 / (1 + np.exp(-alpha * x + beta))
+
+def quartic(x):
+    return x**4
+
+def square_quartic(x):
+    return (x**2)**2
+
+def cubic_quadratic(x):
+    return x**3 * (x**2)
+
+def exp_cubic(x):
+    return np.exp(x**3)
+
+def sine_square(x):
+    return np.sin(x)**2
+
+def logarithmic(x):
+    return np.log(x**2 + 1)
+
+def scaled_cubic(x, alpha=1.0):
+    return alpha * x**3
+
+def sine_offset(x, beta=0.0):
+    return np.sin(x + beta)
+
+def apply_activation(Input, activation_list):
+   """
+    Applies a sequence of activation functions to the input.
+    
+    Args:
+        Input (numpy.ndarray): The input to apply activations to.
+        activation_list (list): A list of activation function names to apply.
+    
+    Returns:
+        numpy.ndarray: The input after all activations have been applied.
+   """
+    
+   origin_input = np.copy(Input)
+
+   for i in range(len(activation_list)):
+
+      if activation_list[i] == 'sigmoid':
+         Input += Sigmoid(origin_input)
+
+      elif activation_list[i] == 'swish':
+         Input += swish(origin_input)
+
+      elif activation_list[i] == 'mod_circular':
+         Input += modular_circular_activation(origin_input)
+
+      elif activation_list[i] == 'tanh_circular':
+         Input += tanh_circular_activation(origin_input)
+
+      elif activation_list[i] == 'leaky_relu':
+         Input += leaky_relu(origin_input)
+
+      elif activation_list[i] == 'relu':
+         Input += Relu(origin_input)
+
+      elif activation_list[i] == 'softplus':
+         Input += softplus(origin_input)
+
+      elif activation_list[i] == 'elu':
+         Input += elu(origin_input)
+
+      elif activation_list[i] == 'gelu':
+         Input += gelu(origin_input)
+
+      elif activation_list[i] == 'selu':
+         Input += selu(origin_input)
+
+      elif activation_list[i] == 'tanh':
+         Input += tanh(origin_input)
+
+      elif activation_list[i] == 'sinakt':
+         Input += sinakt(origin_input)
+
+      elif activation_list[i] == 'p_squared':
+         Input += p_squared(origin_input)
+
+      elif activation_list[i] == 'sglu':
+         Input += sglu(origin_input, alpha=1.0)
+
+      elif activation_list[i] == 'dlrelu':
+         Input += dlrelu(origin_input)
+
+      elif activation_list[i] == 'exsig':
+         Input += exsig(origin_input)
+
+      elif activation_list[i] == 'sin_plus':
+         Input += sin_plus(origin_input)
+
+      elif activation_list[i] == 'acos':
+         Input += acos(origin_input, alpha=1.0, beta=0.0)
+
+      elif activation_list[i] == 'gla':
+         Input += gla(origin_input, alpha=1.0, mu=0.0)
+
+      elif activation_list[i] == 'srelu':
+         Input += srelu(origin_input)
+
+      elif activation_list[i] == 'qelu':
+         Input += qelu(origin_input)
+
+      elif activation_list[i] == 'isra':
+         Input += isra(origin_input)
+
+      elif activation_list[i] == 'waveakt':
+         Input += waveakt(origin_input)
+
+      elif activation_list[i] == 'arctan':
+         Input += arctan(origin_input)
+
+      elif activation_list[i] == 'bent_identity':
+         Input += bent_identity(origin_input)
+
+      elif activation_list[i] == 'sech':
+         Input += sech(origin_input)
+
+      elif activation_list[i] == 'softsign':
+         Input += softsign(origin_input)
+
+      elif activation_list[i] == 'pwl':
+         Input += pwl(origin_input)
+
+      elif activation_list[i] == 'cubic':
+         Input += cubic(origin_input)
+
+      elif activation_list[i] == 'gaussian':
+         Input += gaussian(origin_input)
+
+      elif activation_list[i] == 'sine':
+         Input += sine(origin_input)
+
+      elif activation_list[i] == 'tanh_square':
+         Input += tanh_square(origin_input)
+
+      elif activation_list[i] == 'mod_sigmoid':
+         Input += mod_sigmoid(origin_input)
+
+      elif activation_list[i] == 'linear':
+         Input += origin_input
+
+      elif activation_list[i] == 'quartic':
+         Input += quartic(origin_input)
+
+      elif activation_list[i] == 'square_quartic':
+         Input += square_quartic(origin_input)
+
+      elif activation_list[i] == 'cubic_quadratic':
+         Input += cubic_quadratic(origin_input)
+
+      elif activation_list[i] == 'exp_cubic':
+         Input += exp_cubic(origin_input)
+
+      elif activation_list[i] == 'sine_square':
+         Input += sine_square(origin_input)
+
+      elif activation_list[i] == 'logarithmic':
+         Input += logarithmic(origin_input)
+
+      elif activation_list[i] == 'scaled_cubic':
+         Input += scaled_cubic(origin_input, 1.0)
+
+      elif activation_list[i] == 'sine_offset':
+         Input += sine_offset(origin_input, 1.0)
+
+      elif activation_list[i] == 'spiral':
+         Input += spiral_activation(origin_input)
+
+      elif activation_list[i] == 'circular':
+         Input += circular_activation(origin_input)
+
+   return Input