[PYTHON] Farmer's Economy Simulation ② (Nettoverkäufer, autarker Landwirt, Aktion zur Maximierung des Nutzens des Nettokäufers) _
- Ich habe den Code ein wenig geändert. Ich habe vergessen, das Modul im zweiten Code anzupassen. Es tut uns leid
Dieser Artikel ist eine Fortsetzung von "Farmer Economy Simulation ①". Ich würde mich freuen, wenn Sie zuerst nur den einleitenden Teil dieses Artikels lesen könnten. In „…… ①“ haben wir das Modell innerhalb der Simulation und das Endziel erklärt.
Damit In diesem "... ②" werde ich den Code der von mir selbst erstellten Agrarwirtschaftssimulation vorstellen. Werfen wir einen Blick auf "Modellübersicht", "Code" und "Simulationsergebnisse"!
Umweltinformationen
Dieser Beitrag python 3.8.3 scipy 1.5.0 Wird auf dem Jupyter-Notebook verwendet. (Ist das der Weg zu schreiben ...?)
Modellübersicht
Erklärung des Verhaltens der Landwirte
Ein Landwirt hat "Arbeitskräfte" und ein "Ackerland", auf dem er Getreide A produziert, das er selbst isst, verkauft und kauft.
Getreide A hat das Bild von Mais als Futtermittel, und der Ort hat das Bild von ländlichem Mexiko.
Gleichzeitig sind Landwirte auch Verbraucher, so dass sie "Freizeit" und "andere Güter" konsumieren, um ihren Nutzen zu maximieren. Daher ist in dieser Simulation das "Problem der Maximierung des Nutzens der Landwirte unter Budgetbeschränkungen" der Kern der Logik.
Basierend auf Janvry (1991) wurden die Landwirte außerdem in die folgenden drei Muster unterteilt. ** Netto-Verkäufer ** = "Verkaufe den Überschuss nach autarkem Getreide A" ** Autarker Landwirt ** = "Völlig autark in Getreide A" ** Nettokäufer ** = "Autarkes Getreide A und kaufe den Mangel von anderen"
Die Details werden in "... ①" erklärt, bitte überprüfen Sie dort.
Code-Flow-Beschreibung
① Verwenden Sie Class, um 3 Muster des Farmverhaltens festzulegen. (2) Verwenden Sie Klasse, um den Markt festzulegen (Rolle, die Preisinformationen enthält). ③ Erstellen Sie eine Funktion, um den Preis von Getreide A mit dem 1,5-fachen zu multiplizieren. Erstellen Sie eine Funktion, die den Preis anderer Waren mit 0,9 multipliziert. Erstellen Sie eine Funktion, die den Preis für Getreide A um das 1,5-fache und gleichzeitig den Preis für andere Waren um das 0,9-fache erhöht. ④ Schwanken Sie den Preis für Getreide A und andere Waren wie folgt. ** Hinweis ** </ sup> 1-10 Zeitraum: Anfangspreis stabil 11. Amtszeit: Eine Preiserhöhung 12-20 Zeitraum: Preisstabilität 21. Amtszeit: Preisverfall bei anderen Waren 22-30 Zeitraum: Preisstabilität 31. Laufzeit: A und andere Warenpreisänderungen 32-40 Zeitraum: Preisstabilität ⑤ Fügen Sie das Ergebnis in eine Liste ein und geben Sie es aus.
** Hinweis ** </ sup> Der Grund für die lange Stabilitätsspanne ist, dass wir planen, in der nächsten Phase unserer Aktivitäten in diesem Blog nicht preisliche Variablen zu schwanken.
Code
Berechnen Sie die Parameter der Utility-Funktion
- Ich denke, es ist mühsam, die Daten herunterzuladen, daher habe ich es möglich gemacht, die endgültige Simulation durchzuführen, selbst wenn ich hier übersprungen habe.
Schauen Sie sich zunächst "trabajos_2018.csv", "poblacion_2018.csv" und "concentradohogar_2018.csv" aus der Haushaltsumfrage 2018 (ENIGH) an, die vom mexikanischen National Geographical Statistics Institute (INEGI) veröffentlicht wurde. Legen Sie es in dem Verzeichnis ab, das Sie gerade öffnen. https://www.inegi.org.mx/programas/enigh/nc/2018/
Führen Sie dann den folgenden Code aus.
#Modulimport
import numpy as np
import pandas as pd
from tqdm import tqdm_notebook as tqdm
#Schätzen der in der Utility-Funktion verwendeten Parameter
#Gesamtarbeitszeit pro Woche (wahrscheinlich die Gesamtarbeitszeit erwachsener Mitglieder)
tr_ori = pd.read_csv("trabajos_2018.csv", usecols=["folioviv", "htrab"])
#Das Folio viv wurde dupliziert. Vielleicht sind verschiedene Haushalte in derselben Frau getrennt. Füge das hinzu.
#Mach eine Kiste
tr = pd.DataFrame(np.arange(4).reshape(2,2), columns=["folioviv", "htrab"], index=[1, 2])
tr = tr.drop(tr.index[[0, 1]])
tr = tr.reset_index(drop=True)
#Berechnen Sie die Summe für jedes einzelne Folioviv und legen Sie sie in die Schachtel.
vivs = tr_ori["folioviv"].unique()
vivs = vivs.tolist()
for viv in tqdm(vivs):
trr = tr_ori[tr_ori["folioviv"]==viv]
htrab = trr["htrab"].sum()
#anhängen
tr = tr.append({"folioviv":viv, "htrab":htrab}, ignore_index=True)
#Kosten
"""
mayores:12 Jahre und älter, ing_cor:Monatliches Gesamteinkommen, Trabajo:Negocio, das Einkommen, das durch die Arbeit außerhalb von Selbständigen erzielt wird:Monatliches selbständiges Einkommen, vesti_calz:Gesamtkosten für Kleidung,
salud:Gesamtkosten für das medizinische System, Foraneo:Überseetransportkosten, mantenim:Automobilsystem, comunica:Informationsübertragung, Bildung_espa:Bildung und Fiesta etc.
"""
co = pd.read_csv("concentradohogar_2018.csv", usecols=["folioviv", "tam_loc", "mayores", "ing_cor", "trabajo", "negocio", "frutas", "azucar",
"cafe", "bebidas", "tabaco", "vesti_calz", "salud", "foraneo", "mantenim",
"comunica", "educa_espa"])
#Zustandskennung
pb = pd.read_csv("poblacion_2018.csv", usecols=["folioviv", "residencia"])
#Join df
df = pd.merge(co, pb, on="folioviv")
df = pd.merge(df, tr, on="folioviv")
df = df[~df.duplicated()] #Aus irgendeinem Grund gab es einen doppelten Auftrag, daher habe ich die doppelte Zeile gelöscht
df = df[df["residencia"]!=" "] #Der Status ist aus irgendeinem Grund leer""Ich habe diese Zeile gelöscht, weil es manchmal wurde
df = df[df["tam_loc"]!=1] #Das Zielgebiet ist auf die Landschaft beschränkt
df = df[df["tam_loc"]!=2]
#Der Gesamtverbrauch wird als relativ unterhaltsam eingestuft
df["sum_cons"] = df["frutas"] + df["azucar"] + df["cafe"] + df["bebidas"] + df["tabaco"] + df["vesti_calz"] + df["salud"] + df["foraneo"] + df["mantenim"] + df["comunica"] + df["educa_espa"]
#Identifizieren Sie, ob Sie selbstständig sind
df["self"] = (df["negocio"] > 0) * 1
#Finden Sie den Durchschnittslohn von Nicht-Selbständigen
nonself = df[df["self"]==0]
wage = (nonself["trabajo"].sum() / 30) / (nonself["htrab"].sum() / 7) #Der Umsatz ist monatlich und die Arbeitszeit wöchentlich. Passen Sie ihn daher an den Tag an
#Maßnahmen pro Haushalt, pro Tag und Freizeit. Freizeit = Anzahl der erwachsenen Haushaltsmitglieder x 24-Arbeitszeit im Haushalt/7 -Anzahl der erwachsenen Haushaltsmitglieder x Schlafstunden(6)
df["leisure"] = df["mayores"] * 24 - df["htrab"] / 7 - df["mayores"] * 6
#Berechnen Sie das monatliche Einkommen, das durch Freizeiteinbußen geopfert wird
df["opportunity"] = df["leisure"] * wage * 30
#Gesamteinkommen aus anderen Konsumgütern und in der Freizeit geopfertes Einkommen+Berechnen Sie, wie viel Prozent des geopferten Einkommens(Gesamtdurchschnitt)
income = df["ing_cor"].sum() + df["opportunity"].sum()
consumption = df["sum_cons"].sum()
opportunity = df["opportunity"].sum()
con_in = consumption / income
opp_in = opportunity / income
dadurch, "Durchschnittslohn (Stundenlohn) ohne Land- und Selbstständige" = 75.25114451327885 "Opportunitätskosten beim Verbringen von Freizeit / Gesamtverbrauch" = 0,7171948682330835 "Gesamtverbrauch nicht notwendiger Waren / Gesamtverbrauch" = 0,06287930254251227 Wurde erhalten.
In dieser Simulation wird der Nutzen durch ein quadratisches Modell dargestellt, und die beiden in ↑ erhaltenen beiden werden als Parameter der Nutzenfunktion verwendet. Einzelheiten, einschließlich der Tatsache, dass diese Methode theoretisch falsch ist, finden Sie unter "... ①".
Selbst wenn Sie sich nicht die Mühe machen, den oben gezeigten Code auszuführen, wird im folgenden Code der numerische Wert von ↑ selbst eingegeben.
Hauptausführungsteil
Die meisten der zu Beginn festgelegten globalen Variablen stammen aus tatsächlichen Daten. Bitte überprüfen Sie "... ①", welche Art von Daten Sie verwendet haben.
① Autarker Landwirt
↓ Ein wenig behoben (Ich habe vergessen, zuerst tqdm zu importieren, also habe ich es hinzugefügt)
#Modulimport
from tqdm import tqdm_notebook as tqdm
from scipy.optimize import minimize
#Globale Variable (4 Monate als 1 Zyklus)
ao = 0.06 #Faktor beim Verbrauch anderer Waren(0.06)
al = 0.72 #Faktor beim Freizeitkonsum(0.72)
aoo = 0.01 #Faktor beim Verzehr nur anderer Waren (niedrig, weil es schwierig ist, weil keine Zeit zum Ausruhen bleibt)
aLl = 0.01 #Faktor, wenn nur Freizeit verbraucht wird (niedrig, weil es nichts zu spielen gibt und Freizeit)
aol = 0.15 #Die Freude, es gleichmäßig zu nutzen
w = 75.3 #Lohn(Stundenlohn)
tw = 20 #Transaktionskosten pro Einheit beim Verkauf von Arbeitskräften auf dem Arbeitsmarkt
ta = 5024207380 / 8324248200 / 10 #Transaktionskosten beim Verkauf von A (leicht auf 1/10 des Preises eingestellt)
r = 2000 * 4 #Grundstückspreis (Grundstückspreis unter der Voraussetzung einer pauschalen Miete für 4 Monate)
SEED = 12345 #Startwert
R = 40 #Einstellen der Anzahl der Wiederholungen
L = (24 - 6) * 30 * 4 #Anfängliche Stiftungsarbeit (Stunden pro 4 Monate)
Yield = 5024207380 / 396397.92 #Einzelausbeute (kg/ ha）
Equip = 1 / 52 #Landausrüstungsrate (ha/Zeit)
appe = 0.25 * 30 * 4 #Sättigungsbeschränkung (Menge zu essen pro 4 Monate)
price0 = 5024207380 / 8324248200 #Erntepreis (Peso/ha）
milk_meat = 130/4 + 25/4 #Nahrungsmittelkosten
#Klassendefinition
class Autarky:
"""Definition einer Klasse, die einen autarken Landwirt darstellt"""
def __init__(self, cat): #Konstrukteur
self.category = cat
self.oriA = 2 #Eigene Landfläche(ha)
self.oriL = L #Besessene Arbeitszeiten
self.utility = 0 #Maximaler Nutzen (vorerst 0)
self.co = 0 #O Verbrauch bei maximalem Nutzen
self.l = 0 #Freizeit bei maximalem Nutzen
self.C = 0 #Gesamtverbrauch bei maximalem Nutzen
self.profit = 0 #Profitieren Sie bei maximalem Nutzen
self.qa = 0 #Ein Produktionsvolumen bei maximalem Nutzen
self.LA = 0 #Unten die Menge jedes Produktionselements, das bei maximalem Nutzen verwendet wird
self.AA = 0
self.Ln = 0
self.An = 0
"""
Dienstprogrammmaximierungsproblem
x = [co, La, Ln, l, Aa, An]
"""
def solveUmax(self, Market): #Produziere A und B, um die Gewinne zu optimieren
pA = Market.pA
po = Market.po
oriA = self.oriA
oriL = self.oriL
"""Utility-Funktion"""
def utility(x): #Sekundärmodell
return -1 * (ao*x[0] + al*x[3] + 1/2*(aoo*x[0]*x[0] + aLl*x[3]*x[3] + aol*x[0]*x[3]))
"""Liquiditätsengpässe"""
def cons_liquidity(x):
return (w - tw) * x[2] + r * x[5] - po * x[0] - milk_meat
"""Hungerzwang"""
def appetite(x):
return Yield * Equip * x[1] - appe
"""Verhältnis zwischen Landfläche und Arbeitskräften"""
def labor_land(x):
return x[4] - Equip * x[1]
"""Begabte Elementbeschränkungen"""
def labor_cons(x):
return oriL - x[1] - x[2] - x[3]
def land_cons(x):
return oriA - x[4] - x[5]
"""Vorzeichenbeschränkung jeder Variablen"""
def co(x):
return x[0]
def La(x):
return x[1]
def Ln(x):
return x[2]
def l(x):
return x[3]
def Aa(x):
return x[4]
def An(x):
return x[5]
cons = ({"type": "ineq", "fun": cons_liquidity}, {"type": "ineq", "fun": appetite}, {"type": "ineq", "fun": labor_land},
{"type": "ineq", "fun": co}, {"type": "ineq", "fun": La}, {"type": "ineq", "fun": Ln}, {"type": "ineq", "fun": l},
{"type": "ineq", "fun": Aa}, {"type": "ineq", "fun": An}, {"type": "eq", "fun": labor_cons},
{"type": "ineq", "fun": land_cons})
#Der Anfangswert ist der Zustand, in dem alle Elemente in der Produktion von A enthalten sind.
x0 = [0, oriL, 0, 0, oriA, 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP") #Befehl zur Lösung des Optimierungsproblems
#Was tun, wenn das Ergebnis negativ ist?
while (res.x[0] < 0) or (res.x[1] < 0) or (res.x[2] < 0) or (res.x[3] < 0) or (res.x[4] < 0) or (res.x[5] < 0):
x0 = []
for X in res.x:
if X < 0:
X = 0
x0.append(X)
res = minimize(utility, x0, constraints=cons, method="SLSQP")
"""Ich werde das berechnete Ergebnis weglegen"""
self.LA = res.x[1]
self.Ln = res.x[2]
self.AA = res.x[4]
self.An = res.x[5]
self.co = res.x[0]
self.l = res.x[3]
self.utility = - 1 * res.fun
self.profit = (w - tw) * res.x[2] + r * res.x[5]
self.qa = Yield * Equip * res.x[1]
self.C = po * res.x[0]
#
#
class Market:
def __init__(self):
self.pA = price0
self.po = 30
def price_A(self): #.
self.pA *= 1.5
def price_o(self): #%
self.po *= 0.9
#Klassendefinition Markt pA Preiserhöhung 15-fache Po-Preisreduzierung auf 90 Ende der Klassenmarktdefinition
#Definition der Funktion der Vergabe von Unteraufträgen
#Berechnung, die die nächste Berechnung überwacht, wenn sich der Preis nicht ändert_n()Funktionsdefinition
def calcn_n(t, a, Market):
#① Tragen Sie den Preis am Anfang dieses Begriffs in die Liste ein
pAlist.append(Market.pA)
polist.append(Market.po)
tlist.append(t) #Zeit
#② Optimierung des Nutzens autarker Landwirte
for i in range(len(a)):
a[i].solveUmax(Market)
#Berechnung, die die nächste Berechnung steuert, wenn sich pA einmal ändert_A()Funktionsdefinition
def calcn_A(t, a, Market):
#① Änderung des pB-Preises
Market.price_A()
#② Fügen Sie den Preis am Anfang dieses Begriffs zur Liste hinzu
pAlist.append(Market.pA) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#③ Optimierung des Nutzens der Landwirte
for i in range(len(a)):
a[i].solveUmax(Market)
#Berechnung, die die nächste Berechnung steuert, wenn sich po einmal ändert_o()Funktionsdefinition
def calcn_o(t, a, Market):
#① Änderung des Po-Preises
Market.price_o()
#② Fügen Sie den Preis am Anfang dieses Begriffs zur Liste hinzu
pAlist.append(Market.pA) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#③ Optimierung des Nutzens der Landwirte
for i in range(len(a)):
a[i].solveUmax(Market)
#Berechnung, die die nächste Berechnung steuert, wenn sich pA und po einmal ändern_Ao()Funktionsdefinition
def calcn_Ao(t, a, Market):
#① Änderungen der pA- und po-Preise
Market.price_A()
Market.price_o()
#② Fügen Sie den Preis am Anfang dieses Begriffs zur Liste hinzu
pAlist.append(Market.pA) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#③ Optimierung des Nutzens der Landwirte
for i in range(len(a)):
a[i].solveUmax(Market)
#Berechnung, die den aggregierten Wert des Elements berechnet und zur Liste hinzufügt_list()Funktionsdefinition
def calc_list(a):
qa = 0
profit = 0
LA = 0
Ln = 0
AA = 0
An = 0
l = 0
co = 0
utility = 0
C = 0
for i in range(len(a)):
qa += a[i].qa
profit += a[i].profit
LA += a[i].LA
AA += a[i].AA
Ln += a[i].Ln
An += a[i].An
l += a[i].l
co += a[i].co
utility += a[i].utility
C += a[i].C
utilitylistA.append(utility)
colistA.append(co)
ClistA.append(C)
profitlistA.append(profit)
qalistA.append(qa)
LAlistA.append(LA)
AAlistA.append(AA)
AnlistA.append(An)
LnlistA.append(Ln)
llistA.append(l)
#Hauptgeschäftsführer
#Initialisieren
Market = Market() #Fügen Sie eine Instanz der Klasse Market in eine Variable ein
#Duplizieren Sie eine Instanz von Autarkie der Kategorie 0 in der Liste (dies ist nacheinander geplant).
a = [Autarky(0)]
#Liste des Bauernstatus
utilitylistA = []
ca_plistA = []
colistA = []
ClistA = []
profitlistA = []
qalistA = []
qblistA = []
LAlistA = []
AAlistA = []
AnlistA = []
LnlistA = []
llistA = []
#Listenpreise und Produktreste
pAlist = []
polist = []
#Liste der Zeiten
tlist = []
#Simulation
for t in tqdm(range(R)):
if t <= 10: # 1~10. Amtszeit: Anfangspreis
calcn_n(t, a, Market)
calc_list(a)
if t == 11: #11. Amtszeit: Eine Preisänderung
calcn_A(t, a, Market)
calc_list(a)
if (t > 11) and (t <= 20): # 12~20. Amtszeit: A Stabil nach Preisänderung
calcn_n(t, a, Market)
calc_list(a)
if t == 21: #21. Amtszeit: o Preisänderung
calcn_o(t, a, Market)
calc_list(a)
if (t > 21) and (t <= 30): # 22~30. Amtszeit: o Stabil nach Preisänderung
calcn_n(t, a, Market)
calc_list(a)
if t == 31: #31. Amtszeit: A und O Preisänderungen
calcn_Ao(t, a, Market)
calc_list(a)
if (t > 31) and (t <= 40): # 32~40. Amtszeit: A und o Stabil nach Preisänderung
calcn_n(t, a, Market)
calc_list(a)
#Ende des Simulationsteils
#Zeigen Sie die Liste der wichtigen Variablen unverändert an
print("Einkommen",profitlistA,"\n","\n","Eine Produktion",qalistA,"\n","\n","LA",LAlistA,"\n","\n","Ln",LnlistA,"\n","\n","l", llistA, "\n","\n",
"Ein Ackerland", AAlistA, "\n","\n","Ackerland vermieten",AnlistA, "\n","\n","Nützlichkeit",utilitylistA, "\n","\n", "o Verbrauch",colistA,"\n","\n","C",ClistA, "\n","\n",
"pA",pAlist,"\n","\n","po",polist)
# sell&buy.py
②net-seller ① Bitte ändern Sie den Teil des Codes, der vom autarken Landwirt angezeigt wird, in "# Klassendefinition // Klassenautarkie: ~ # Ende der Definition der Klasse Autarkie" in den folgenden Code.
#Klassendefinition
class Seller:
"""Definition einer Klasse, die einen autarken Landwirt darstellt"""
def __init__(self, cat): #Konstrukteur
self.category = cat
self.oriA = 2 #Eigene Landfläche
self.oriL = L #Besessene Arbeitszeiten
self.utility = 0 #Maximaler Nutzen (vorerst 0)
self.co = 0 #O Verbrauch bei maximalem Nutzen
self.l = 0 #Freizeit bei maximalem Nutzen
self.C = 0 #Gesamtverbrauch bei maximalem Nutzen
self.profit = 0 #Profitieren Sie bei maximalem Nutzen
self.qa = 0 #Ein Produktionsvolumen bei maximalem Nutzen
self.LA = 0 #Unten die Menge jedes Produktionselements, das bei maximalem Nutzen verwendet wird
self.AA = 0
self.Ln = 0
self.An = 0
"""
Dienstprogrammmaximierungsproblem
x = [co, La, Ln, l, Aa, An]
"""
def solveUmax(self, Market): #Produziere A und B, um die Gewinne zu optimieren
pA = Market.pA
po = Market.po
oriA = self.oriA
oriL = self.oriL
"""Utility-Funktion"""
def utility(x): #Sekundärmodell
return -1 * (ao*x[0] + al*x[3] + 1/2*(aoo*x[0]*x[0] + aLl*x[3]*x[3] + aol*x[0]*x[3]))
"""Liquiditätsengpässe"""
def cons_liquidity(x):
return (pA - ta) * (Yield * Equip * x[1] - appe) - po * x[0] - (w + tw) * x[2] - r * x[5] - milk_meat
"""Hungerzwang"""
def appetite(x):
return Yield * Equip * x[1] - appe
"""Verhältnis zwischen Landfläche und Arbeitskräften"""
def labor_land(x):
return x[4] + x[5] - Equip * (x[1] + x[2])
"""Begabte Elementbeschränkungen"""
def labor_cons(x):
return oriL - x[1] - x[3]
def land_cons(x):
return oriA - x[4]
"""Vorzeichenbeschränkung jeder Variablen"""
def co(x):
return x[0]
def La(x):
return x[1]
def Ln(x):
return x[2]
def l(x):
return x[3]
def Aa(x):
return x[4]
def An(x):
return x[5]
def Anmax(x):
return 100 - x[5]
cons = ({"type": "ineq", "fun": cons_liquidity}, {"type": "ineq", "fun": appetite}, {"type": "ineq", "fun": labor_land},
{"type": "ineq", "fun": co}, {"type": "ineq", "fun": La}, {"type": "ineq", "fun": Ln}, {"type": "ineq", "fun": l},
{"type": "ineq", "fun": Aa}, {"type": "ineq", "fun": An}, {"type": "eq", "fun": labor_cons},
{"type": "ineq", "fun": land_cons}, {"type": "ineq", "fun": Anmax})
#Der Anfangswert ist der Zustand, in dem alle Elemente in der Produktion von A enthalten sind.
x0 = [0, oriL, 0, 0, oriA, 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP") #Befehl zur Lösung des Optimierungsproblems
#Was tun, wenn das Ergebnis negativ ist?
while (res.x[0] < 0) or (res.x[1] < 0) or (res.x[2] < 0) or (res.x[3] < 0) or (res.x[4] < 0) or (res.x[5] < 0):
x0 = []
for X in res.x:
if X < 0:
X = 0
x0.append(X)
res = minimize(utility, x0, constraints=cons, method="SLSQP")
#Was tun, wenn der Arbeitseinsatz 0 wird, obwohl der Ackerlandeinsatz ziemlich groß ist?(Ändern Sie den Anfangswert ein wenig und beginnen Sie von vorne)
if (res.x[1] <= 0) and (res.x[4] > 1):
x0 = [0, oriL - 1, 0, 1, Equip * (oriL - 1), 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP")
#Was tun, wenn das Ergebnis negativ ist? 2
while (res.x[0] < 0) or (res.x[1] < 0) or (res.x[2] < 0) or (res.x[3] < 0) or (res.x[4] < 0) or (res.x[5] < 0):
x0 = []
for X in res.x:
if X < 0:
X = 0
x0.append(X)
res = minimize(utility, x0, constraints=cons, method="SLSQP")
"""Ich werde das berechnete Ergebnis weglegen"""
self.LA = res.x[1]
self.Ln = res.x[2]
self.AA = res.x[4]
self.An = res.x[5]
self.co = res.x[0]
self.l = res.x[3]
self.utility = - 1 * res.fun
self.profit = (pA - ta) * (Yield * Equip * res.x[1] - appe)
self.qa = Yield * Equip * res.x[1]
self.C = po * res.x[0] + (w + tw) * res.x[2] + r * res.x[5]
#Ende der Definition der Klasse Verkäufer
Als nächstes die 4. Zeile unter "# Hauptausführungsabteilung"
a = [Autarky(0)]
Zu
a = [Seller(0)]
Bitte.
③net-buyer ① Bitte ändern Sie den Teil des Codes, der vom autarken Landwirt angezeigt wird, in "# Klassendefinition // Klassenautarkie: ~ # Ende der Definition der Klasse Autarkie" in den folgenden Code.
#Klassendefinition
class Buyer:
"""Definition einer Klasse, die einen autarken Landwirt darstellt"""
def __init__(self, cat): #Konstrukteur
self.category = cat
self.oriA = 2 #Eigene Landfläche
self.oriL = L #Besessene Arbeitszeiten
self.utility = 0 #Maximaler Nutzen (vorerst 0)
self.co = 0 #O Verbrauch bei maximalem Nutzen
self.ca = 0
self.l = 0 #Freizeit bei maximalem Nutzen
self.C = 0 #Gesamtverbrauch bei maximalem Nutzen
self.profit = 0 #Profitieren Sie bei maximalem Nutzen
self.qa = 0 #Ein Produktionsvolumen bei maximalem Nutzen
self.LA = 0 #Unten die Menge jedes Produktionselements, das bei maximalem Nutzen verwendet wird
self.AA = 0
self.Ln = 0
self.An = 0
"""
Dienstprogrammmaximierungsproblem
x = [co, La, Ln, l, Aa, An, ca]
"""
def solveUmax(self, Market): #Produziere A und B, um die Gewinne zu optimieren
pA = Market.pA
po = Market.po
oriA = self.oriA
oriL = self.oriL
"""Utility-Funktion"""
def utility(x): #Sekundärmodell
return -1 * (ao*x[0] + al*x[3] + 1/2*(aoo*x[0]*x[0] + aLl*x[3]*x[3] + aol*x[0]*x[3]))
"""Liquiditätsengpässe"""
def cons_liquidity(x):
return (w - tw) * x[2] + r * x[5] - po * x[0] - (pA + ta) * x[6] - milk_meat
"""Hungerzwang"""
def appetite(x):
return Yield * Equip * x[1] + x[6] - appe
"""Verhältnis zwischen Landfläche und Arbeitskräften"""
def labor_land(x):
return x[4] - Equip * x[1]
"""Begabte Elementbeschränkungen"""
def labor_cons(x):
return oriL - x[1] - x[2] - x[3]
def land_cons(x):
return oriA - x[4] - x[5]
"""Vorzeichenbeschränkung jeder Variablen"""
def co(x):
return x[0]
def La(x):
return x[1]
def Ln(x):
return x[2]
def l(x):
return x[3]
def Aa(x):
return x[4]
def An(x):
return x[5]
def ca(x):
return x[6]
cons = ({"type": "ineq", "fun": cons_liquidity}, {"type": "ineq", "fun": appetite}, {"type": "ineq", "fun": labor_land},
{"type": "ineq", "fun": co}, {"type": "ineq", "fun": La}, {"type": "ineq", "fun": Ln}, {"type": "ineq", "fun": l},
{"type": "ineq", "fun": Aa}, {"type": "ineq", "fun": An}, {"type": "ineq", "fun": ca}, {"type": "eq", "fun": labor_cons},
{"type": "ineq", "fun": land_cons})
#Der Anfangswert ist der Zustand, in dem alle Elemente in der Produktion von A enthalten sind.
x0 = [0, oriL, 0, 0, oriA, 0, 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP") #Befehl zur Lösung des Optimierungsproblems
#Was tun, wenn das Ergebnis negativ ist?
while (res.x[0] < 0) or (res.x[1] < 0) or (res.x[2] < 0) or (res.x[3] < 0) or (res.x[4] < 0) or (res.x[5] < 0):
x0 = []
for X in res.x:
if X < 0:
X = 0
x0.append(X)
res = minimize(utility, x0, constraints=cons, method="SLSQP")
"""Ich werde das berechnete Ergebnis weglegen"""
self.LA = res.x[1]
self.Ln = res.x[2]
self.AA = res.x[4]
self.An = res.x[5]
self.co = res.x[0]
self.ca = res.x[6]
self.l = res.x[3]
self.utility = - 1 * res.fun
self.profit = (w - tw) * res.x[2] + r * res.x[5]
self.qa = Yield * Equip * res.x[1]
self.C = po * res.x[0] + (pA + ta) * res.x[6]
#Ende der Definition der Klasse Käufer
Als nächstes die 4. Zeile unter "# Hauptausführungsabteilung"
a = [Autarky(0)]
Zu
a = [Buyer(0)]
Bitte.
Ergebnis
Wenn Sie den obigen Code ausführen, wird jeweils eine Liste der optimalen Lösungen für jede Auswahlvariable zurückgegeben.
Nachdem wir die Simulationsergebnisse erhalten haben, Vergleichen wir "autarke Landwirte", "Nettoverkäufer" und "Nettokäufer" mit Schwerpunkt auf Einkommen und Nutzen!
Vergleichsergebnis von Einkommen und Nutzen
In der Spalte, in der die drei Arten von Landwirten für "Einkommen" und "Nutzen" in der Tabelle verglichen werden, ist die Zelle mit dem höchsten Wert in jedem Zeitraum gelb dargestellt. Was wir aus dieser Tabelle sehen können, ist in "Einkommen" und "Nutzen" unterteilt.
〇 Fokus auf Einkommen: Der Nettoverkäufer reagiert auf Preisänderungen
Zuerst, Zu Beginn können wir sehen, dass das Einkommen des Nettoverkäufers nur etwa ein Sechstel des Einkommens der beiden anderen Arten von Landwirten beträgt. Der anfängliche Preis spiegelt die Realität gut wider. Dieses Ergebnis zeigt also, dass "Ein einzelner Landwirt, der auf 2 ha Ackerland Futtermais anbaut, verdient sechsmal mehr, wenn er die Landwirtschaft aufgibt." Tatsächlich macht der Landwirt, der ungefähr 2 ha Ackerland besitzt, auch Geldernten, daher ist die Situation etwas besser, aber Sie können sehen, wie schlecht die Situation des Landwirts ist. In der Tat gibt es viele verlassene Bauern.
Nächster, Wenn Sie sich "Einkommen" ansehen, können Sie sehen, dass der Wert des Nettoverkäufers steigt. Wenn der Preis um das 1,5-fache stieg, stieg das Einkommen um mehr als das 10-fache. Vor diesem Hintergrund rasieren die Nettoverkäufer ihre "Freizeit" ständig ab und setzen sie in den Getreideanbau ein. Der Preis für landwirtschaftliche Produkte ist gestiegen, also haben Sie Ihre Arbeit erledigt. Daher wurde festgestellt, dass Landwirte, die als Verkäufer landwirtschaftlicher Produkte am Markt teilnehmen, empfindlich auf die Preise landwirtschaftlicher Produkte reagieren.
Es ist ein natürliches Ergebnis, aber wenn ein Nettoverkäufer in einen "autarken Landwirt" oder einen "Nettokäufer" verwandelt werden kann, möchte dieser Landwirt weiterhin ein "Nettoverkäufer" sein, der anfällig für Preisschwankungen ist? Die Tatsache, dass der Nettoverkäufer zu empfindlich auf Preisänderungen reagiert, kann auch Mitglied der Landwirtschaft sein.
〇 Fokus auf Nutzen: Der Nettokäufer ist am effektivsten
Zunächst werde ich erklären, warum die Vorteile (und das Einkommen) autarker Landwirte und Nettokäufer nahezu gleich sind. Dies zeigt, dass es sehr einfach ist, in Getreide A für sich selbst autark zu sein. Obwohl in der Tabelle nicht aufgeführt, betrug das von autarken Landwirten für den Anbau von Getreide A zugewiesene Ackerland 0,0023 ha = 0,23 a = 23 m 2. Die aufgewendete Zeit betrug 0,12 Stunden = 7,2 Minuten. Da wir hier von Futtermais ausgegangen sind, besteht die Möglichkeit, dass dieser in größerem Maßstab produziert wird als der Mais, den Menschen mit großen Maschinen essen. Ich weiß auch nicht, ob die gleiche Situation in der Situation reproduziert wird, in der eine Person genug Mais für die Selbstversorgung herstellt. In jedem Fall kann man jedoch sagen, dass der Anbau von Mais recht einfach ist. Der Vorteil des Reisanbaus in Japan besteht darin, dass er in kurzer Zeit angebaut werden kann. Daher soll er für Nebenjobs geeignet sein.
Wenn Sie als nächstes den nächsten Netzverkäufer in der Mitte mit anderen Landwirten vergleichen, werden Sie eine erbärmliche Tatsache bemerken. Das Einkommen des Nettoverkäufers ist dreimal so hoch wie das anderer Landwirte, aber die Vorteile sind nahezu gleich. Dies deutet darauf hin, dass der Netzverkäufer überarbeitet ist und nur sehr wenig Freizeit hat.
In jedem Fall sollte der anfängliche Preis für Getreide A um das 1,5-fache erhöht werden, damit der weltweite Nettoverkäufer genauso effektiv ist wie andere Landwirte. Es stellt sich heraus, dass wir unsere Freizeit reduzieren und unser Einkommen verdreifachen müssen.
schließlich
Also habe ich diesmal den Code und das Ergebnis der Simulation der Agrarwirtschaft überprüft. An den Simulationsergebnissen können Sie erkennen, wie erbärmlich der Netzverkäufer ist (lacht).
Als zukünftige Aufgabe möchte ich versuchen, die Parameter etwas weiter anzupassen und die anfänglichen Einstellungen zu realisieren, die der Realität nahe kommen. Irgendwie habe ich das Gefühl, dass die Löhne zu hoch sind.
Danach werde ich prüfen, ob es möglich ist, den Anbau von Verbindungen und eine Subvention einzubeziehen, die einen festen Betrag pro bepflanzter Fläche erhält. Danach werde ich endlich anfangen, Multi-Agent-Simulationen durchzuführen.
Gegenwärtig ist die Antwort (Code) nicht sichtbar, aber wenn viele Landwirte ein Spiel machen, das sich auf demselben Feld bewegt, wird der Landepunkt = Preis und Vertrag im Austausch zwischen jedem Landwirt abgeglichen. Preise und Verträge sollten durch Nachfrage = Angebot, Gewinn von A = Gewinn von B bestimmt werden, aber welche Art von Code sollte geschrieben werden, um einen solchen Schritt zu machen?
Nun, vorerst werde ich versuchen, es so zu machen. Vielen Dank an alle, die bisher gelesen haben!