{% extends "base.html" %} {% block title %}Upload Algorithm - MHA Flow{% endblock %} {% block content %}
Upload Custom Algorithm
How it works:
  1. Upload your algorithm file (.py)
  2. Auto-mapping — your custom variable names are automatically mapped to standard parameters
  3. Use locally — algorithm is available on your system immediately
  4. Review — submitted to GitHub for admin review
  5. Credit — when approved for release, you get full credit as contributor
Requirements:
  • Python file (.py) with a class (preferably inheriting from BaseOptimizer)
  • Must implement optimize() or _optimize() method
  • Variables can use any names — the system auto-maps them (e.g., N → population_size)
Upload a Python file containing your algorithm
Parameter Mapping
Your variables have been auto-mapped. Adjust if needed.
My Custom Algorithms

Loading your algorithms...

Contributor Credits

Loading contributor credits...

Example Template
from mha_toolbox.base import BaseOptimizer
import numpy as np

class MyCustomAlgorithm(BaseOptimizer):
    """Custom Optimization Algorithm"""
    
    def __init__(self, population_size=30, max_iterations=100, **kwargs):
        super().__init__(population_size, max_iterations, **kwargs)
        self.algorithm_name = "My Custom Algorithm"
    
    def _optimize(self, objective_function, X=None, y=None, **kwargs):
        # Get dimensions and bounds
        if X is not None:
            dimension = X.shape[1]
            lb, ub = 0.0, 1.0
        else:
            dimension = kwargs.get('dimensions', 10)
            lb = kwargs.get('lower_bound', -100.0)
            ub = kwargs.get('upper_bound', 100.0)
        
        # Initialize population
        population = np.random.uniform(lb, ub, (self.population_size_, dimension))
        fitness = np.array([objective_function(ind) for ind in population])
        
        # Find best solution
        best_idx = np.argmin(fitness)
        best_position = population[best_idx].copy()
        best_fitness = fitness[best_idx]
        
        # Tracking
        global_fitness = [best_fitness]
        local_fitness = [fitness.copy()]
        local_positions = [population.copy()]
        
        # Main optimization loop
        for iteration in range(self.max_iterations_):
            for i in range(self.population_size_):
                # Your optimization logic here
                # Update population[i]
                population[i] = np.clip(population[i], lb, ub)
                fitness[i] = objective_function(population[i])
                
                if fitness[i] < best_fitness:
                    best_position = population[i].copy()
                    best_fitness = fitness[i]
            
            global_fitness.append(best_fitness)
            local_fitness.append(fitness.copy())
            local_positions.append(population.copy())
        
        return best_position, best_fitness, global_fitness, local_fitness, local_positions
Or with custom variable names (auto-mapped!):
import numpy as np

class MySwarmOptimizer:
    """Custom algorithm with non-standard parameter names"""
    
    def __init__(self, N=30, T=100, D=10, lb=-100, ub=100):
        # N = population_size (auto-mapped)
        # T = max_iterations (auto-mapped)
        # D = dimensions (auto-mapped)
        self.N = N
        self.T = T
        self.D = D
        self.lb = lb
        self.ub = ub
    
    def optimize(self, fitness_func, **kwargs):
        population = np.random.uniform(self.lb, self.ub, (self.N, self.D))
        fitness = np.array([fitness_func(x) for x in population])
        
        best_idx = np.argmin(fitness)
        best_pos = population[best_idx].copy()
        best_fit = fitness[best_idx]
        history = [best_fit]
        
        for t in range(self.T):
            for i in range(self.N):
                # Your logic here
                new_pos = population[i] + np.random.randn(self.D) * 0.1
                new_pos = np.clip(new_pos, self.lb, self.ub)
                new_fit = fitness_func(new_pos)
                if new_fit < fitness[i]:
                    population[i] = new_pos
                    fitness[i] = new_fit
                    if new_fit < best_fit:
                        best_pos = new_pos.copy()
                        best_fit = new_fit
            history.append(best_fit)
        
        return best_pos, best_fit, history, None, None
{% endblock %}