[PYTHON]

Wenn Sie einen Fehler machen, weisen Sie bitte darauf hin. Ruby, Map, Paiza, Standardeingabe, Standardausgabe Mathematische Optimierung, die von Python + PuLP Addendum (2020/05/25) kostenlos verwendet werden kann. Mathematischer Optimierungslöser (1 Thread), der in PuLP enthalten ist und standardmäßig verwendet wird Die Version von COIN-CBC unterstützt kein Multithreading (zumindest für Windows), daher kann es einige Zeit dauern, bis Probleme bei der Ganzzahloptimierung gelöst sind. Es gab einen Artikel, in dem beschrieben wurde, wie die Multithread-Version von COIN-CBC installiert wird, daher werde ich den Link veröffentlichen. Natürlich ist es für den kommerziellen Gebrauch kostenlos erhältlich. --Windows: Beschleunigen Sie die Berechnungs-Engine des Python-Pakets zur mathematischen Optimierung PuLP (einfache Version für Windows) und geben Sie die Berechnungszeit an --Mac: Verwenden Sie Ihren eigenen CBC-Solver mit PuLP

Nachtrag (2020/05/11)

Ein anderer freier Löser namens "MIPCL" scheint das Problem schneller zu lösen als PuLP (die mitgelieferte Version von COIN-CBC mit einem Thread).

(Referenzeintrag) Endlich ein kostenloser mathematischer Optimierungslöser, der verwendet werden kann? MIPCL

MIPCL scheint jedoch eine gewisse Besonderheit in Bezug auf Installation und Grammatik zu haben. Daher denke ich, dass Sie im Moment MIPCL verwenden können, wenn Sie Geschwindigkeit wünschen, und PuLP, wenn Sie Leichtigkeit wünschen. Wenn das Schreiben und Lösen mit PuLP einige Zeit in Anspruch nimmt, ist es eine Möglichkeit, es in MIPCL ~ ~ umzuschreiben. Angesichts des Zeit- und Arbeitsaufwands ist es auch eine Möglichkeit, MIPCL von Anfang an einzuführen und sich daran zu gewöhnen ~ ~ Ich denke.

Einführung

Ein solches mathematisches Problem nennt man mathematische Optimierung oder mathematische Planung

Problem (1): Lineares Optimierungsproblem (Lineares Planungsproblem)

\begin{alignat}{2}
 &\mbox{Maximieren} 
 &\qquad x + y & \\
 &\mbox{Zwang} 
 & 2x + y &\leq 2 \\
 &
 & x + 2y &\leq 2 \\
 &
 & x &\geq 0 \\
 &
 & y &\geq 0 \\
\end{alignat}

Und so ein mathematisches Problem

Problem (2): Integer-Optimierungsproblem (Integer-Planungsproblem)

\begin{alignat}{3}
 &\mbox{Minimize} 
 &\qquad \sum_{i \in I} \sum_{j \in J} c_{ij} x_{ij} & 
 &\qquad & \\
 &\mbox{subject to} 
 & \sum_{j \in J} x_{ij} &\leq 1 
 & &\forall i \in I \\
 &
 &\sum_{i \in I} x_{ij} &= 1
 & &\forall j \in J \\
 &
 & x_{ij} &\in \{0,1\}
 & &\forall i \in I, \quad \forall j \in J
\end{alignat}

Einführung in das PuLP-Paket von Python, das sich löst.

Es ist ein Ziel, aber es wird angenommen, dass die Zielfunktion und der Einschränkungsausdruck in linearer Form (linearer Ausdruck) beschrieben werden können und die Variable als kontinuierlicher Wert oder diskreter Wert oder eine Mischung davon beschrieben werden kann.

Abgesehen davon wird Problem (2) manchmal als ganzzahliges lineares Optimierungsproblem (ganzzahliges lineares Planungsproblem) bezeichnet. Probleme mit einer Mischung aus kontinuierlichen und diskreten Variablen werden auch als gemischte ganzzahlige Optimierungsprobleme bezeichnet (gemischte ganzzahlige Planungsprobleme, gemischte ganzzahlige lineare Optimierungsprobleme, gemischte ganzzahlige lineare Planungsprobleme).

Was ist PuLP?

Sie sollten sich PuLP selbst als ** Modellierungs-API **, ** Modellierungssprache ** vorstellen, die es einfach macht, mathematische Optimierungsprobleme in Python zu codieren. Es unterscheidet sich von dem ** Löser **, der die Formel tatsächlich löst, aber da er mit einem Löser namens COIN geliefert wird, können Sie das Problem einfach durch Installieren von PuLP lösen. PuLP selbst unterstützt mehrere andere Solver als COIN. Wenn diese Solver separat installiert werden, können Sie den Solver (einfach) so umschalten, dass er von PuLP aus aufruft.

Referenz

Qiita-Eintrag der Vorfahren

• Python in Optimierung
• Einführung in die Lösung linearer Planungsprobleme mit PuLP

Kopf Familienseite

• https://pypi.python.org/pypi/PuLP
• http://pythonhosted.org/PuLP/ --https: //www.coin-or.org/ (Solver COIN enthalten)

Warum Python + PuLP?

Es ist nur eine ** persönliche Meinung **, aber ...

Preis

Gurobi Optimizer, IBM ILOG CPLEX Optimization Studio, FICO Xpress Optimization Suite und Numerical Optimizer sind teuer ... ** → PuLP ist kostenlos! Die gleiche Löser-MÜNZE ist auch kostenlos! !! ** **.

Geschwindigkeit

GLPK und lp_solve sind langsam ... Microsoft Excel ist langsam und kann eine kleine Anzahl von Variablen und Einschränkungsausdrücken verarbeiten ... ** → Die in PuLP enthaltene MÜNZE ist für einen freien Löser nicht schlecht! Sie können einen kommerziellen Löser aufrufen, indem Sie den Code ändern! !! ** **.

Kommerzielle Benutzung

Wenn Sie SCIP für kommerzielle Zwecke verwenden möchten, senden Sie mir bitte eine E-Mail ... ** → PuLP & COIN ist für den kommerziellen Gebrauch in Ordnung! Es besteht keine Verpflichtung, den Quellcode des eingebauten Produkts zu veröffentlichen! !! ** **.

Modellbeschreibungssprache

Die Modellierungssprache AMPL, an deren Entwicklung Herr K von K & R, der für die Sprache C bekannt ist, beteiligt war, und die ursprüngliche Modellierungssprache wie IBM ILOG CPLEX Optimization Studio, FICO Xpress Optimization Suite und Numerical Optimizer modellieren wie eine mathematische Formel Es ist leicht zu verstehen, weil man es beschreiben kann. Aber es kann nirgendwo anders verwendet werden, und wenn Sie etwas Kompliziertes tun möchten, müssen Sie sich das Handbuch ansehen, und selbst wenn Sie googeln, gibt es nur wenige Informationen ... ** → PuLP kann auch ein Modell wie eine mathematische Formel schreiben! Da es sich um Python handelt, ist es einfach, eine Verknüpfung mit anderen Algorithmen herzustellen. Wenn Sie es nicht verstehen, können Sie über Google viele Informationen abrufen! !! Da die Beschreibung des Modellteils unverändert geändert werden kann und nur der aufzurufende Löser geändert werden kann, kann PuLP tatsächlich zu einer gemeinsamen Sprache werden! !! !! ** **.

Entwicklungsumgebung

In der integrierten Entwicklungsumgebung, die mit IBM ILOG CPLEX Optimization Studio und FICO Xpress Optimization Suite geliefert wird, können verschiedene Informationen angezeigt werden, und es ist bequem, mit der Maus klicken zu können. Aber ich kann es nirgendwo anders benutzen ... ** → Da es sich um Python handelt, kann es für Visual Studio Code, Visual Studio (auch für die kostenlose Community Edition und Express Edition), Jupyter Notebook und Spyder verwendet werden! Funktioniert auf verschiedenen Maschinen und Umgebungen! !! Jeder kann überall mitentwickeln und testen! !! !! ** **.

---

An Forscher und Studenten

Forscher und Studenten können kommerzielle Löser für Forschungs- und Lernzwecke billig oder kostenlos erhalten.

Wenn der Forschungsinhalt in Zukunft für den kommerziellen Gebrauch bestimmt zu sein scheint, sollten Forscher unter Berücksichtigung der damit verbundenen Kosten von nun an die Verwendung von Python + PuLP in Betracht ziehen. Ich habe es schon oft geschrieben, aber es ist einfach, Solver auf Aufruf von PuLP umzustellen. Wenn Sie also nicht die Tiefen kommerzieller Solver berühren müssen (z. B. Optimierungsparameter für die Ganzzahloptimierung), ist PuLP eine gute Modellierungs-API. Überlegen. Außerdem ist der Codierungsaufwand für die Portierung und Kompatibilität von kommerziellen Solvern mit APIs für Python nicht so groß.

Die Schüler sollten von nun an über die Verwendung von Python + PuLP (COIN) nachdenken und dabei die mathematische Optimierung in ihrem aktuellen Teilzeitjob, ihrer zukünftigen Beschäftigung und ihren Kunden in Betracht ziehen. Natürlich hängt es vom Umfang des Projekts ab, aber es ist eine ziemliche Hürde, die Kosteneffizienz der Erhöhung der Kosten für den Kauf und die Wartung eines kommerziellen Lösers zu erklären. Gleiches gilt auch dann, wenn Sie Auftragsrecherchen oder gemeinsame Recherchen eines Unternehmens durchführen. Denken Sie an Optionen, die Unternehmen nutzen können.

---

Das war meine persönliche Meinung.

• Ich bin mir über den aktuellen Free Solver MIPCL nicht sicher, daher habe ich ihn nicht berührt. Es tut mir Leid.

Angenommene Umgebung

Im Folgenden werde ich unter der Annahme schreiben, dass ** Anaconda ** Python 3.7 ** unter ** Windows ** unterstützt (unterstützt). Ersetzen Sie es entsprechend auf Mac oder Linux.

• Die Python 2-Serie (2.7 usw.) ist alt, verwenden Sie sie also nicht.

Installation

Im Voraus!

Wenn Sie in der Vergangenheit zusätzlich zu dem von Ihnen selbst installierten Python Gurobi Optimizer oder eine Simulationssoftware installiert haben, besteht die Möglichkeit, dass das Python-Verarbeitungssystem nicht mehr funktioniert. Starten Sie in diesem Fall die Eingabeaufforderung (Windows-Startschaltfläche → Windows-Systemtools → Eingabeaufforderung) und geben Sie "where python" oder "where pip" ein, um zu überprüfen, welches Verarbeitungssystem priorisiert ist. ..

Wenn der Ordner "Anaconda3" wie unten gezeigt zuerst angezeigt wird, bedeutet dies, dass Anaconda wie in diesem Artikel erwartet Priorität hat.

C:\Users\(Nutzername)>where python
C:\Users\(Nutzername)\Anaconda3\python.exe
C:\Users\(Nutzername)\AppData\Local\Microsoft\WindowsApps\python.exe

C:\Users\(Nutzername)>where pip
C:\Users\(Nutzername)\Anaconda3\Scripts\pip.exe

C:\Users\(Nutzername)>

Wenn zuerst etwas angezeigt wird, das nicht der Ordner "Anaconda3" ist, bedeutet dies, dass das Verarbeitungssystem, das nicht Anaconda ist, priorisiert wird. Bitte entscheiden Sie selbst, ob es in Ordnung ist, es so zu belassen, wie es ist, und ändern Sie gegebenenfalls die Reihenfolge der unter "Pfad" unter "Umgebungsvariablen" aufgeführten Elemente.

Wenn Folgendes angezeigt wird oder wenn andere Verarbeitungssysteme angezeigt werden, der Ordner "Anaconda3" jedoch nicht angezeigt wird,

C:\Users\(Nutzername)>where python
Information:Die Datei mit dem angegebenen Muster wurde nicht gefunden.

C:\Users\(Nutzername)>

Dies ist der sogenannte "Pass nicht bestanden" -Zustand von Anaconda. Wahrscheinlich, weil ich bei der Installation von Anaconda nicht "Anaconda zu meiner PATH-Umgebungsvariablen hinzufügen" aktiviert habe. (Referenz) https://weblabo.oscasierra.net/python-anaconda-install-windows/ Übergeben Sie in diesem Fall entweder den Pfad (entweder selbst oder durch Deinstallieren und erneutes Installieren von Anaconda) oder führen Sie die folgenden Arbeiten mit Anaconda Prompt (Windows-Startschaltfläche → Anaconda3 (64 Bit) → Anaconda Prompt) anstelle der Eingabeaufforderung aus. Bitte gib mir.

War gut. Aktuelle Arbeit von

Schließen Sie für alle Fälle (da dies beim Neuanordnen der Umgebungsvariablen erforderlich ist) die Eingabeaufforderung und öffnen Sie sie erneut. Wenn Python in einem Ordner installiert ist, für den das Schreiben mit Administratorrechten erforderlich ist (z. B. wenn Sie bei der Installation von Anaconda "Alle Benutzer (erfordert Administratorrechte)" auswählen), wählen Sie "Als Administrator ausführen". Anlaufen.

Wenn Sie versuchen, von ** innerhalb des Unternehmens ** zu installieren und ** Proxy ** im Weg zu stehen, können Sie den Proxy an der Eingabeaufforderung vorübergehend wie folgt einstellen (IP-Adresse und Portnummer). Bitte ersetzen Sie durch den Wert in Ihrer Umgebung.

set HTTP_PROXY=111.222.111.222:3333
set HTTPS_PROXY=111.222.111.222:3333

Referenz: http://d.hatena.ne.jp/showhey810/20140905/1409892787

Geben Sie "pip install pulp" ein, um den Zellstoff herunterzuladen und zu installieren. Wenn ** Sicherheitssoftware ** um Kommunikationserlaubnis bittet, tun Sie dies bitte. Wenn alles gut geht, sollten Sie so etwas sehen:

C:\Users\(Nutzername)>pip install pulp
Collecting pulp
  Downloading PuLP-2.1-py3-none-any.whl (40.6 MB)
    |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■| 40.6 MB 6.4 MB/s
Requirement already satisfied: pyparsing>=2.0.1 in c:\users\(Nutzername)\anaconda3\lib\site-packages (from pulp) (2.4.6)
Installing collected packages: pulp
Successfully installed pulp-2.1
C:\Users\(Nutzername)>

Wenn es bereits installiert ist, sollte Folgendes angezeigt werden: Es ist bereits installiert, es gibt also kein Problem.

C:\Users\(Nutzername)>pip install pulp
Requirement already satisfied: pulp in c:\users\(Nutzername)\anaconda3\lib\site-packages (2.1)
Requirement already satisfied: pyparsing>=2.0.1 in c:\users\(Nutzername)\anaconda3\lib\site-packages (from pulp) (2.4.6)
C:\Users\(Nutzername)>

(Memo)

• Sie können auch mit python -m pip install pulp installieren.
• Sie können Pulp mit "pip install -U pulp" oder "python -m pip install -U pulp" aktualisieren.

Beispiel 1)

Löse das Öffnungsproblem (1).

\begin{alignat}{2}
 &\mbox{Maximieren} 
 &\qquad x + y & \\
 &\mbox{Zwang} 
 & 2x + y &\leq 2 \\
 &
 & x + 2y &\leq 2 \\
 &
 & x &\geq 0 \\
 &
 & y &\geq 0. \\
\end{alignat}

Code

pulp_problem_1.py

# coding: UTF-8

#linear/Importieren Sie PuLP, um ganzzahlige lineare Optimierungsprobleme zu lösen
import pulp
# sys.Importieren, um den Maximalwert der Ganzzahl (int) zu erhalten, der von Python mit maxsize verarbeitet werden kann
import sys

#Erklärung des mathematischen Optimierungsproblems (Maximierung)
problem = pulp.LpProblem("Problem-1", pulp.LpMaximize)

#Variablen deklarieren (kontinuierlich)
#   *Variables Objekt selbst (x,y) und
#Eine Zeichenfolgendarstellung einer Variablen ("xx", "yy") Zu unterscheiden
#Ich wage es, den Zeichenfolgenausdruck zu verwenden"xx", "yy"Ist geschrieben
x = pulp.LpVariable("xx", 0, sys.maxsize, pulp.LpContinuous)
y = pulp.LpVariable("yy", 0, sys.maxsize, pulp.LpContinuous)

#Deklarieren Sie die Zielfunktion
#   *Keine Klammern erforderlich, aber der Übersichtlichkeit halber aufgeführt
problem += ( x + y, "Objective" )

#Einschränkungen deklarieren
problem += ( 2 * x + y <= 2 , "Constraint_1" )
problem += ( x + 2 * y <= 2 , "Constraint_2" )

#Alle Problemausdrücke anzeigen
#   *Die Zeichenfolgendarstellung der Variablen wird verwendet, wenn das Problem in einer print-Anweisung gedruckt wird
print("Die fragliche Formel")
print("-" * 8)
print(problem)
print("-" * 8)

#Berechnung
result_status = problem.solve()

#Anzeigen des Zielfunktionswerts und der Lösung (falls eine Lösung verfügbar ist)
print("")
print("Berechnungsergebnis")
print("*" * 8)
print(f"Optimalität= {pulp.LpStatus[result_status]}")
print(f"Objektiver Funktionswert= {pulp.value(problem.objective)}")
print(f"Lösung x= {pulp.value(x)}")
print(f"　 y = {pulp.value(y)}")
print("*" * 8)

Ausgabe

Die fragliche Formel
--------
Problem-1:
MAXIMIZE
1*xx + 1*yy + 0
SUBJECT TO
Constraint_1: 2 xx + yy <= 2

Constraint_2: xx + 2 yy <= 2

VARIABLES
xx <= 9.22337203685e+18 Continuous
yy <= 9.22337203685e+18 Continuous

--------

Berechnungsergebnis
********
Optimalität= Optimal
Objektiver Funktionswert= 1.33333334
Lösung x= 0.66666667
　 y = 0.66666667
********

---

Neben (1)

Sprachen, die Operatorüberladung verwenden können, können leicht mathematische Optimierungsausdrücke schreiben. Andere Sprachen sind ... Java ...

---

Beispiel (2)

Löse das Öffnungsproblem (2).

\begin{alignat}{3}
 &\mbox{Minimize} 
 &\qquad \sum_{i \in I} \sum_{j \in J} c_{ij} x_{ij} & 
 &\qquad & \\
 &\mbox{subject to} 
 & \sum_{j \in J} x_{ij} &\leq 1 
 & &\forall i \in I \\
 &
 &\sum_{i \in I} x_{ij} &= 1
 & &\forall j \in J \\
 &
 & x_{ij} &\in \{0,1\}
 & &\forall i \in I, \quad \forall j \in J.
\end{alignat}

---

Neben (2)

Sie verwenden $ \ sum $ oft in mathematischen Optimierungsformeln, nicht wahr? Modellierungssprachen für die mathematische Optimierung basieren darauf, wie Sie $ \ sum $ schreiben können. In dieser Hinsicht ist PuLP sicher. Übrigens ist im Einführungstext der mathematischen Optimierung die Menge $ I $ und $ J $ in diesem Problem $ I: = \ {1, \ ldots, m \} $ und $ J: = \ Nummerierung von 1 mit Gewalt, wie z. B. {1, \ ldots, n \} $, z. B. Einschränkungsbedingungen

\sum_{j = 1}^{n} x_{ij} \leq 1 \quad \mbox{for} \;\; i = 1, \ldots, m

Es gibt etwas, das sagt, aber ich bin verwirrt darüber, was die Elemente von $ I $ und $ J $ darstellen und welches Element der Zahl $ 2 $ $ I $ oder $ J $ ist. Es wird empfohlen, die Menge nicht durch eine Spalte positiver Ganzzahlen zu ersetzen und die Namen der Elemente in der Menge unverändert zu verwenden. Mit PuLP können Sie auf natürliche Weise mithilfe von Sprachspezifikationen wie Python-Wörterbüchern und Taples modellieren.

Wie bei der Formel, die in diesem Problem mit dem Befehl $ \ LaTeX $ geschrieben wurde, wäre es auch hilfreich, die Höhe jeder Formel auszurichten, um die Anzeige zu erleichtern.

Danach wird dieses Problem von der 0-1-Variablen $ x_ {ij} \ in \ {0,1 \} $ zur kontinuierlichen Variablen $ 0 \ leq x_ {ij} \ leq 1 $ (geändert in einen lockeren Zustand) behoben. Es ist bekannt, dass selbst wenn Sie das Problem lösen, es aufgrund der völligen Unimodularität des Problems eine optimale Lösung für ganze Zahlen gibt, die Sie erhalten können. Wenn Sie es jedoch tatsächlich bei der Arbeit modellieren, nehmen die Einschränkungen stetig zu, und in den meisten Fällen gilt nicht jede Unimodularität.

---

Code

pulp_problem_2.py

# coding: UTF-8

#linear/Importieren Sie PuLP, um ganzzahlige lineare Optimierungsprobleme zu lösen
import pulp
#Importieren Sie die Zeit, um die Berechnungszeit zu messen
import time



#Gruppe von Arbeitnehmern (verwenden Sie eine Liste zur Vereinfachung)
I = ["Herr A.", "Herr B.", "Herr C."]

print(f"Versammlung der Arbeiter I.= {I}")


#Aufgabenstellung (zur Vereinfachung eine Liste verwenden)
J = ["Arbeite ich", "Arbeit b", "Arbeit c"]

print(f"Aufgabensatz J.= {J}")


#Kostensatz (temporäre Liste), wenn Arbeiter i Aufgabe j zugeordnet ist
cc = [
      [ 1,  2,  3],
      [ 4,  6,  8],
      [10, 13, 16],
     ]

#Weil cc eine Liste ist und der Index eine Zahl ist
#Definieren Sie das Wörterbuch c, zum Beispiel cc[0][0]Ist c["Herr A.","Arbeite ich"]Machen Sie es zugänglich mit
c = {} #Leeres Wörterbuch
for i in I:
    for j in J:
        c[i,j] = cc[I.index(i)][J.index(j)]

print("Kosten c[i,j]: ")
for i in I:
    for j in J:
        print(f"c[{i},{j}] = {c[i,j]:2d},  ", end = "")
    print("")
print("")



#Deklarieren Sie ein mathematisches Optimierungsproblem (Minimierung)
problem = pulp.LpProblem("Problem-2", pulp.LpMinimize)
# pulp.LpMinimize :Minimieren
# pulp.LpMaximize :Maximieren


#Wörterbuch, das den Variablensatz darstellt
x = {} #Leeres Wörterbuch
       # x[i,j]Oder x[(i,j)]damit,(i,j)Lesen und schreiben Sie Werte mit dem Taple als Schlüssel

# 0-1 Variable deklarieren
for i in I:
    for j in J:
        x[i,j] = pulp.LpVariable(f"x({i},{j})", 0, 1, pulp.LpInteger)
        #Auf dem Variablenetikett'['Oder']'Oder'-'Aus irgendeinem Grund'_'Es ändert sich zu ...?
# lowBound,Wenn Sie upBound nicht angeben, jeweils-Unendlichkeit, +Unendlichkeit になる

#Inklusive Notation kann ebenfalls verwendet werden
# x_suffixes = [(i,j) for i in I for j in J]
# x = pulp.LpVariable.dicts("x", x_suffixes, cat = pulp.LpBinary) 

# pulp.LpContinuous :Kontinuierliche Variable
# pulp.LpInteger    :Ganzzahlige Variable
# pulp.LpBinary     : 0-1 Variable


#Deklarieren Sie die Zielfunktion
problem += pulp.lpSum(c[i,j] * x[i,j] for i in I for j in J), "TotalCost"
# problem += sum(c[i,j] * x[i,j] for i in I for j in J)
#OK


#Einschränkungen deklarieren
#Für jeden Arbeiter i kann nicht mehr als eine Aufgabe zugewiesen werden
for i in I:
    problem += sum(x[i,j] for j in J) <= 1, f"Constraint_leq_{i}"
    #Auf dem Constraint-Label'['Oder']'Oder'-'Aus irgendeinem Grund'_'Es ändert sich zu ...?

#Für jede Aufgabe j ist genau ein Arbeiter zugeordnet
for j in J:
    problem += sum(x[i,j] for i in I) == 1, f"Constraint_eq_{j}"


#Alle Problemausdrücke anzeigen
print("Die fragliche Formel")
print(f"-" * 8)
print(problem)
print(f"-" * 8)
print("")



#Berechnung
#Solver-Bezeichnung
solver = pulp.PULP_CBC_CMD()
# pulp.PULP_CBC_CMD() :Münze an PuLP befestigt-CBC
# pulp.GUROBI_CMD()   :Starten Sie Gurobi über die Befehlszeile(.LP-Datei vorübergehend generieren)
# pulp.GUROBI()       :Starten Sie Gurobi aus der Bibliothek(Bibliotheksstandort erforderlich)
#Unterstützt mehrere andere Löser
# (Anwendungsbeispiel)
# if pulp.GUROBI_CMD().available():
#     solver = pulp.GUROBI_CMD()

#Startzeitmessung
time_start = time.perf_counter()

result_status = problem.solve(solver)
# solve()von()Sie können den Solver in angeben
#Zellstoff, wenn nichts angegeben ist.PULP_CBC_CMD()

#Zeitmessung beendet
time_stop = time.perf_counter()



#Anzeigen des Zielfunktionswerts und der Lösung (falls eine Lösung verfügbar ist)
print("Berechnungsergebnis")
print(f"*" * 8)
print(f"Optimalität= {pulp.LpStatus[result_status]}, ", end="")
print(f"Objektiver Funktionswert= {pulp.value(problem.objective)}, ", end="")
print(f"Berechnungszeit= {time_stop - time_start:.3f} (Sekunden)")
print("Lösung x[i,j]: ")
for i in I:
    for j in J:
        print(f"{x[i,j].name} = {x[i,j].value()},  ", end="")
    print("")
print(f"*" * 8)

Ausgabe

Versammlung der Arbeiter I.= ['Herr A.', 'Herr B.', 'Herr C.']
Aufgabensatz J.= ['Arbeite ich', 'Arbeit b', 'Arbeit c']
Kosten c[i,j]:
c[Herr A.,Arbeite ich] =  1,  c[Herr A.,Arbeit b] =  2,  c[Herr A.,Arbeit c] =  3,  
c[Herr B.,Arbeite ich] =  4,  c[Herr B.,Arbeit b] =  6,  c[Herr B.,Arbeit c] =  8,  
c[Herr C.,Arbeite ich] = 10,  c[Herr C.,Arbeit b] = 13,  c[Herr C.,Arbeit c] = 16,  

Die fragliche Formel
--------
Problem-2:
MINIMIZE
1*x(Herr A.,Arbeite ich) + 3*x(Herr A.,Arbeit c) + 2*x(Herr A.,Arbeit b) + 4*x(Herr B.,Arbeite ich) + 8*x(Herr B.,Arbeit c) + 6*x(Herr B.,Arbeit b) + 10*x(Herr C.,Arbeite ich) + 16*x(Herr C.,Arbeit c) + 13*x(Herr C.,Arbeit b) + 0
SUBJECT TO
Constraint_leq_Herr A.: x(Herr A.,Arbeite ich) + x(Herr A.,Arbeit c) + x(Herr A.,Arbeit b) <= 1

Constraint_leq_Herr B.: x(Herr B.,Arbeite ich) + x(Herr B.,Arbeit c) + x(Herr B.,Arbeit b) <= 1

Constraint_leq_Herr C.: x(Herr C.,Arbeite ich) + x(Herr C.,Arbeit c) + x(Herr C.,Arbeit b) <= 1

Constraint_eq_Arbeite ich: x(Herr A.,Arbeite ich) + x(Herr B.,Arbeite ich) + x(Herr C.,Arbeite ich) = 1

Constraint_eq_Arbeit b: x(Herr A.,Arbeit b) + x(Herr B.,Arbeit b) + x(Herr C.,Arbeit b) = 1

Constraint_eq_Arbeit c: x(Herr A.,Arbeit c) + x(Herr B.,Arbeit c) + x(Herr C.,Arbeit c) = 1

VARIABLES
0 <= x(Herr A.,Arbeite ich) <= 1 Integer
0 <= x(Herr A.,Arbeit c) <= 1 Integer
0 <= x(Herr A.,Arbeit b) <= 1 Integer
0 <= x(Herr B.,Arbeit c) <= 1 Integer
0 <= x(Herr B.,Arbeit b) <= 1 Integer
0 <= x(Herr C.,Arbeite ich) <= 1 Integer
0 <= x(Herr C.,Arbeit c) <= 1 Integer
0 <= x(Herr C.,Arbeit b) <= 1 Integer

--------

Berechnungsergebnis
********
Optimalität= Optimal,Objektiver Funktionswert= 19.0,Berechnungszeit= 0.040 (Sekunden)
Lösung x[i,j]:
x(Herr A.,Arbeite ich) = 0.0,  x(Herr A.,Arbeit b) = 0.0,  x(Herr A.,Arbeit c) = 1.0,
x(Herr B.,Arbeite ich) = 0.0,  x(Herr B.,Arbeit b) = 1.0,  x(Herr B.,Arbeit c) = 0.0,
x(Herr C.,Arbeite ich) = 1.0,  x(Herr C.,Arbeit b) = 0.0,  x(Herr C.,Arbeit c) = 0.0,
********

abschließend

Ich denke, es ist einfacher als Bobs Malunterricht, also versuchen Sie es bitte mit Python + PuLP. Wenn die Berechnung des zu lösenden Problems ** lange dauert, lesen Sie den Multithread-Solver-Artikel ** mit dem Link oben und probieren Sie es aus.