Fonctions de test bidimensionnelles (2D) pour l'optimisation des fonctions
L'optimisation des fonctions est un domaine d'étude qui recherche une entrée dans une fonction qui aboutit au résultat maximum ou minimum de la fonction.
Il existe un grand nombre d’algorithmes d’optimisation et il est important d’étudier et de développer des intuitions d’algorithmes d’optimisation sur des fonctions de test simples et faciles à visualiser.
Les fonctions bidimensionnelles prennent deux valeurs d'entrée (x et y) et génèrent une seule évaluation de l'entrée. Elles font partie des types de fonctions de test les plus simples à utiliser lors de l’étude de l’optimisation des fonctions. L'avantage des fonctions bidimensionnelles est qu'elles peuvent être visualisées sous la forme d'un tracé de contour ou d'un tracé de surface qui montre la topographie du domaine problématique avec les optima et les échantillons du domaine marqués de points.
Dans ce didacticiel, vous découvrirez les fonctions bidimensionnelles standard que vous pouvez utiliser lors de l'étude de l'optimisation des fonctions.
Démarrez votre projet avec mon nouveau livre Optimization for Machine Learning, comprenant des tutoriels pas à pas et les fichiers code source Python pour tous exemples.
Présentation du didacticiel
Une fonction bidimensionnelle est une fonction qui prend deux variables d'entrée et calcule la valeur objective.
Nous pouvons considérer les deux variables d’entrée comme deux axes sur un graphique, x et y. Chaque entrée de la fonction est un point unique sur le graphique et le résultat de la fonction peut être considéré comme la hauteur sur le graphique.
Cela permet de conceptualiser la fonction comme une surface et nous pouvons caractériser la fonction en fonction de la structure de la surface. Par exemple, des collines pour les points d'entrée qui entraînent des résultats relatifs importants de la fonction objectif et des vallées pour les points d'entrée qui entraînent des résultats relatifs faibles de la fonction objectif.
Une surface peut avoir une caractéristique majeure ou des optima globaux, ou elle peut en avoir plusieurs avec de nombreux endroits où une optimisation peut rester bloquée. La surface peut être lisse, bruyante, convexe et toutes sortes d'autres propriétés qui peuvent nous intéresser lors des tests d'algorithmes d'optimisation.
Il existe de nombreux types différents de fonctions de test bidimensionnelles simples que nous pourrions utiliser.
Néanmoins, il existe des fonctions de test standards qui sont couramment utilisées dans le domaine de l'optimisation des fonctions. Il existe également des propriétés spécifiques des fonctions de test que nous pouvons souhaiter sélectionner lors du test de différents algorithmes.
Nous explorerons un petit nombre de fonctions de test bidimensionnelles simples dans ce didacticiel et les organiserons par leurs propriétés avec deux groupes différents ; ils sont:
Fonctions unimodales
- Fonction unimodale 1
- Fonction unimodale 2
- Fonction unimodale 3
Fonctions multimodales
- Fonction multimodale 1
Chaque fonction sera présentée à l'aide du code Python avec une implémentation de fonction de la fonction objectif cible et un échantillonnage de la fonction présenté sous forme de tracé de surface.
Toutes les fonctions sont présentées comme une fonction de minimisation, par ex. recherchez l'entrée qui donne la sortie minimale (la plus petite valeur) de la fonction. Toute fonction de maximisation peut devenir une fonction de minimisation en ajoutant un signe négatif à toutes les sorties. De même, toute fonction de minimisation peut être maximisée de la même manière.
Je n'ai pas inventé ces fonctions ; ils sont tirés de la littérature. Voir la section de lectures complémentaires pour les références.
Vous pouvez ensuite choisir et copier-coller le code d'une ou plusieurs fonctions à utiliser dans votre propre projet pour étudier ou comparer le comportement des algorithmes d'optimisation.
Fonctions unimodales
Unimodal signifie que la fonction a un seul optimal global.
Une fonction unimodale peut être convexe ou non. Une fonction convexe est une fonction dans laquelle une ligne peut être tracée entre deux points quelconques du domaine et la ligne reste dans le domaine. Pour une fonction bidimensionnelle représentée sous la forme d'un tracé de contour ou de surface, cela signifie que la fonction a la forme d'un bol et que la ligne entre deux reste au-dessus ou dans le bol.
Regardons quelques exemples de fonctions unimodales.
Fonction unimodale 1
La plage est limitée à -5,0 et 5,0 et un optimal global à [0,0, 0,0].
# unimodal test function
from numpy import arange
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
# objective function
def objective(x, y):
return x**2.0 + y**2.0
# define range for input
r_min, r_max = -5.0, 5.0
# sample input range uniformly at 0.1 increments
xaxis = arange(r_min, r_max, 0.1)
yaxis = arange(r_min, r_max, 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()L'exécution de l'exemple crée un tracé de surface de la fonction.
Fonction unimodale 2
La plage est limitée à -10,0 et 10,0 et un optimal global à [0,0, 0,0].
# unimodal test function
from numpy import arange
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
# objective function
def objective(x, y):
return 0.26 * (x**2 + y**2) - 0.48 * x * y
# define range for input
r_min, r_max = -10.0, 10.0
# sample input range uniformly at 0.1 increments
xaxis = arange(r_min, r_max, 0.1)
yaxis = arange(r_min, r_max, 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()L'exécution de l'exemple crée un tracé de surface de la fonction.
Fonction unimodale 3
La plage est limitée à -10,0 et 10,0 et un optimal global à [pi, pi]. Cette fonction est connue sous le nom de fonction d’Easom.
# unimodal test function
from numpy import cos
from numpy import exp
from numpy import pi
from numpy import arange
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
# objective function
def objective(x, y):
return -cos(x) * cos(y) * exp(-((x - pi)**2 + (y - pi)**2))
# define range for input
r_min, r_max = -10, 10
# sample input range uniformly at 0.01 increments
xaxis = arange(r_min, r_max, 0.01)
yaxis = arange(r_min, r_max, 0.01)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()L'exécution de l'exemple crée un tracé de surface de la fonction.
Fonctions multimodales
Une fonction multimodale signifie une fonction avec plus d'un « mode » ou optima (par exemple, vallée).
Les fonctions multimodales sont non convexes.
Il peut y avoir un optimal global et un ou plusieurs optimums locaux ou trompeurs. Alternativement, il peut y avoir plusieurs optima globaux, c'est-à-dire plusieurs entrées différentes qui aboutissent à la même sortie minimale de la fonction.
Regardons quelques exemples de fonctions multimodales.
Fonction multimodale 1
La plage est limitée à -5,0 et 5,0 et un optimal global à [0,0, 0,0]. Cette fonction est connue sous le nom de fonction d’Ackley.
# multimodal test function
from numpy import arange
from numpy import exp
from numpy import sqrt
from numpy import cos
from numpy import e
from numpy import pi
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
# objective function
def objective(x, y):
return -20.0 * exp(-0.2 * sqrt(0.5 * (x**2 + y**2))) - exp(0.5 * (cos(2 * pi * x) + cos(2 * pi * y))) + e + 20
# define range for input
r_min, r_max = -5.0, 5.0
# sample input range uniformly at 0.1 increments
xaxis = arange(r_min, r_max, 0.1)
yaxis = arange(r_min, r_max, 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()L'exécution de l'exemple crée un tracé de surface de la fonction.
Fonction multimodale 2
La plage est limitée à -5,0 et 5,0 et fonctionne comme quatre optima globaux à [3,0, 2,0], [-2,805118, 3,131312], [-3,779310, -3,283186], [3,584428, -1,848126]. Cette fonction est connue sous le nom de fonction de Himmelblau.
# multimodal test function
from numpy import arange
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
# objective function
def objective(x, y):
return (x**2 + y - 11)**2 + (x + y**2 -7)**2
# define range for input
r_min, r_max = -5.0, 5.0
# sample input range uniformly at 0.1 increments
xaxis = arange(r_min, r_max, 0.1)
yaxis = arange(r_min, r_max, 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()L'exécution de l'exemple crée un tracé de surface de la fonction.
Fonction multimodale 3
La plage est limitée à -10,0 et 10,0 et fonctionne comme quatre optima globaux à [8.05502, 9.66459], [-8.05502, 9.66459], [8.05502, -9.66459], [-8.05502, -9.66459]. Cette fonction est connue sous le nom de fonction de table de Holder.
# multimodal test function
from numpy import arange
from numpy import exp
from numpy import sqrt
from numpy import cos
from numpy import sin
from numpy import e
from numpy import pi
from numpy import absolute
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
# objective function
def objective(x, y):
return -absolute(sin(x) * cos(y) * exp(absolute(1 - (sqrt(x**2 + y**2)/pi))))
# define range for input
r_min, r_max = -10.0, 10.0
# sample input range uniformly at 0.1 increments
xaxis = arange(r_min, r_max, 0.1)
yaxis = arange(r_min, r_max, 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()L'exécution de l'exemple crée un tracé de surface de la fonction.
Lectures complémentaires
Cette section fournit plus de ressources sur le sujet si vous souhaitez approfondir.
Articles
- Fonctions de test pour l'optimisation, Wikipédia.
- Bibliothèque virtuelle d'expériences de simulation : fonctions de test et ensembles de données
- Index des fonctions de test
- GEA Toolbox – Exemples de fonctions objectives
Résumé
Dans ce didacticiel, vous avez découvert les fonctions bidimensionnelles standard que vous pouvez utiliser lors de l'étude de l'optimisation des fonctions.
Utilisez-vous l'une des fonctions ci-dessus ?
Faites-moi savoir laquelle dans les commentaires ci-dessous.
Avez-vous des questions ?
Posez vos questions dans les commentaires ci-dessous et je ferai de mon mieux pour y répondre.