Programmation linéaire Scipy
Dans le monde d'aujourd'hui où toutes les autres tâches nécessitent une puissance ou une main-d'œuvre informatique élevée, les systèmes artificiellement intelligents remplacent la main-d'œuvre manuelle. Par conséquent, toutes les autres tâches quotidiennes basées sur la vie sont converties en systèmes autonomes. Pour créer de tels systèmes autonomes, nous devons créer une interaction avec les ordinateurs pour leur faire apprendre à exécuter le programme et à prendre des décisions. Nous utilisons certains langages compréhensibles informatiques, également appelés langages de programmation, pour permettre cette interaction.
Parmi toutes les langages informatiques actuellement utilisés, Python est l'un des plus connus. La langue est construite avec plusieurs bibliothèques qui permettent le fonctionnement de plusieurs tâches en utilisant leurs modules et fonctionnalités intégrés. Python est également crédité comme une langue pour débutants en raison de son script facile à comprendre puisque le script de Python est écrit principalement en anglais. Scipy est la célèbre bibliothèque de Pythons qui est construite sur une autre bibliothèque célèbre, "Numpy", par Python. Le Scipy fonctionne en fournissant les fonctions intégrées et les modules pour les tâches où nous travaillons avec la formation des réseaux de neurones artificiels en profondeur et des algorithmes d'apprentissage automatique à des fins mathématiques et informatiques et d'optimisation.
Le module de «programmation linéaire» de Scipy représente ces outils et les techniques qui sont utilisées comme outils mathématiques pour les optimisations mathématiques pour résoudre les équations du système linéaire, y compris les égalités et les inégalités. Il aide à maximiser ou à minimiser le système ou la fonction linéaire. Les systèmes linéaires peuvent avoir de nombreuses solutions, nous utilisons donc la programmation linéaire afin que nous finissons par trouver une solution particulière pour le système d'inégalités.
Procédure:
Cet article couvre l'introduction du sujet de la programmation linéaire Scipy. Ensuite, nous aurons la connaissance de la syntaxe de la déclaration de cette fonction dans le script Python avec ses paramètres tout possibles. Et puis la fonction est implémentée à l'aide d'exemples.
Syntaxe:
La syntaxe de la fonction de programmation linéaire Scipy dans le script Python peut être écrite comme suit:
$ scipy.optimiser.LANPROG (c, a_ub = aucun, b_ub = aucun, a_eq = aucun, b_eq = non, bounds = non, méthode = 'highs', callback = non, options = non, x0 = non, tout, intégralité = aucun)
Dans la fonction mentionnée précédemment, le paramètre «C» est le tableau 1 dimension qui a les informations sur les coefficients de cette fonction linéaire que nous voulons minimiser par programmation linéaire. Les paramètres suivants, «A_UB» et le «B_UB», sont les paramètres facultatifs. Tous deux sont respectivement les tableaux bidimensionnels et 1 dimension. Alors que B-UB est un vecteur de contrainte d'inégalité pour la valeur de A_UB en correspondance avec le x.
Le paramètre «séquence» montre la limite supérieure et la limite inférieure pour la maximisation ou la minimisation de chaque élément dans le x. Le paramètre final est la «méthode» qui est facultative, mais cela spécifie l'algorithme standard pour résoudre le problème. Sa valeur est «élevée» par défaut.
Valeur de retour:
La fonction de programmation linéaire renvoie les valeurs comme le tableau unidimensionnel qui est le résultat de la solution particulière pour minimiser la fonction objectif après avoir satisfait les contraintes possibles sur la fonction.
Exemple 1:
Résolvons un système linéaire d'inégalités et utilisons la programmation linéaire de Scipy pour trouver la solution pour minimiser la fonction objectif de ce système. Avant de déménager pour écrire le code, gardez à l'esprit que nous rédigerons le programme dans la «collaboration Google» qui est reconnue comme une plate-forme Python en ligne open source avec tous les packages Python préinstallés.
Commençons par créer un nouveau cahier dans le programme. Avant d'écrire le programme, nous devons définir ou prendre le système des équations linéaires. À cette fin, nous prenons le système linéaire suivant et travaillons pour minimiser cette fonction avec toutes ses contraintes en utilisant la programmation linéaire:
Minimiser y = 5x1 + 10x2 +15x3
tel que :
Nous devons minimiser le «y» avec toutes ses contraintes. Nous sommes tenus d'importer les informations pertinentes pour la programmation linéaire et le tableau à notre programme. Pour cela, nous importons les deux packages importants à partir de t «Numpy» qui traite de la définition et des fonctions du tableau. Le second est «l'attribut Optimiser Attribut» de Scipy à partir de laquelle nous importons la fonction «LANPROG».
Lorsque nous avons fini avec ces bibliothèques, nous déclarons et définissons les équations du système linéaire mentionné précédemment un par un. D'abord et avant tout, nous définissons le «Y» qui agit comme le coefficient du vecteur d'objectif linéaire, «Y». Appelez le «NP. array »et passez tous les coefficients de y aux éléments du tableau comme« np. Array ([5, 10, 15]) ».
Maintenant, nous définissons la matrice de contraintes d'inégalité pour ce système linéaire. Qui est défini sous la forme en utilisant le «NP de Numpy. Méthode Array ([]) ”. Cette matrice a les éléments comme «NP. Array ([- 1, -1, -1], [- 1, 1, 0], [0, 0, 15], [- 1, 0, 0], [0, -1, 0], [0 , 0, -1]) ". Nous enregistrons ce tableau sous «A_UB». Après cela, nous définissons le "b_ub". Les valeurs de b_ub sont «np.Array ([-1050, 0, -340, 0, 0, 0]) ». Pour trouver la solution optimale pour cet exemple, nous appelons la fonction «Linear Programming ()» et passons la matrice «A_UB», le vecteur «B_UB» et le coefficient «C» au paramètre de la fonction comme «LANPROG (C, a_ub, b_ub) ". Ensuite, nous affichons les résultats. Le programme de cet exemple est écrit sous la forme de code Python avec sa sortie comme suit:
Importer Numpy comme NP
de Scipy.Optimiser l'importation LANPROG
c = np.Array ([10, 15, 25])
a_ub = np.Array ([[- 1, -1, -1], [-1, 2, 0], [0, 0, -1], [-1, 0, 0], [0, -1, 0], [0, 0, -1]])
b_ub = np.Array ([- 1000, 0, -340, 0, 0, 0])
result = LinProg (C, A_UB, B_UB)
Print ('Valeur optimale:', Round (résultat.amusant, ndigits = 2),
'\ nx valeurs:', résultat.X,
'\ nnumber des itérations:', résultat.lente,
'\ nstatus:', résultat.message)
Conclusion
Dans cet éditorial, nous avons couvert le sujet de la «programmation linéaire Scipy». Nous avons discuté de ce qu'est la programmation linéaire et pourquoi nous en avons besoin. Ensuite, nous avons parlé de la syntaxe de cette fonction et appliquée cette fonction à un système linéaire d'inégalités pour trouver sa solution optimisée.