Simulieren Sie mithilfe der Python-Klasse grob das Produktionsverhalten eines Landwirts und das Konsumverhalten eines Verbrauchers. ~ Zeit, um die Ergebnisse zu sehen ~
Letztes Mal habe ich erklärt, wie die Bedingungen mithilfe des Wirtschaftsmodells festgelegt werden. Dieses Mal werde ich erklären, welche Art von Code zur Erstellung der Situation verwendet wurde. Wenn Sie von den Bedingungseinstellungen zurückblicken möchten, überprüfen Sie bitte die vorherige Verwenden der Python-Klasse …… ①.
Bestätigung, was diesmal zu tun ist
(1) Ersetzen Sie die Parameter des zuletzt eingestellten Modells durch bestimmte numerische Werte. ② Überprüfen Sie den Code. ③ Überprüfen Sie das Ergebnis.
(1) Ersetzen Sie den Parameter durch einen bestimmten numerischen Wert
Umgang mit Parametern in anderen wirtschaftlichen Simulationen
Nach der "Empirischen Analyse der sich entwickelnden Ökonomie" in der Sonderausgabe des Wirtschaftsseminars (2016), die ich neulich gelesen habe, In einem kürzlich erschienenen makroökonomischen Artikel werden nach quantitativer Überprüfung, ob ein Wirtschaftsmodell die Realität darstellen kann, die geschätzten Parameter in das Wirtschaftsmodell und anschließend in eine anti-reale virtuelle Simulation (sofern Subventionen gewährt werden) eingesetzt. Was wäre mit der Produktion des Landwirts passiert, wenn es nicht getan worden wäre?). Taylor (2005) und Dyer (2006), die ich im vorherigen Artikel vorgestellt habe, haben auch die Parameter in der Produktionsfunktion und der Nutzfunktion (Cobb-Douglas-Typ) aus der ländlichen Erhebung in Mexiko leicht geschätzt und simuliert. Andererseits wurden in dieser Simulation die Parameter nicht geschätzt und die entsprechend ausgewählten numerischen Werte wurden ersetzt. Im Folgenden werden die numerischen Werte vorgestellt, die in dieser Simulation auf die Parameter angewendet werden.
Produktionsfunktion des Landwirts
\Pi = p_A*Q_A+p_B*Q_B+200*L_n...(1) \\ Q_A = 3*L_A^{0.3} *K_A^{0.7}...(2) \\ Q_B = L_B^{0.7} *K_B^{0.3}...(3) \\ 24 = L_A+L_B+L_n...(4) \\ 10 = K_A+K_B...(5)
$ p_A (Anfangspreis von A) $: 100 $ p_B (Anfangspreis von B) $: 300
- Die oben genannten Preise ändern sich im Laufe der Zeit.
Consumer Utility-Funktion
U = c_A^{0.4}+c_B^{0.6}...(1) \\ I_t = I_{t-1} + 5000 - C_{t-1} > C_t = p_A*c_A + p_B*c_B...(2:Budgetbeschränkungen) \\ Q_{A,t} + s_{A,t-1} > c_{A,t}...(3:Liefern+Rest> Verbrauch) \\ Q_{B,t} + s_{B,t-1} > c_{B,t}...(4:Liefern+Rest> Verbrauch) \\ c_A + c_B < 40...(5:Sättigungsbeschränkung)
$ p_A (Anfangspreis von A) $: 100 $ p_B (Anfangspreis von B) $: 300
Andere (Preisbildung und Übertragung des nächsten Produkts)
① Nächstes Budget: $ I_ {t + 1} = I_t + 5000 --c_t $
② Übertragungsbetrag für den nächsten Term: $ s_ {t + 1} = s_t + Q_t --c_t $
③ So bestimmen Sie den Preis für die nächste Laufzeit
if
Ich habe im vorherigen Artikel erklärt, warum ich es so eingestellt habe. Bitte überprüfen Sie dort.
② Code
"""
sell&buy.py Programm
Landwirte und Verbraucher wiederholen Produktion und Kauf
Landwirte maximieren die Gewinne, Verbraucher maximieren den Nutzen
Landwirte verwenden ihre eigene Arbeit und ihr eigenes Kapital für die Produktion
Der Preis der nächsten Laufzeit schwankt basierend auf dem Lagerbestand + Produktionsvolumen-Verbrauchsvolumen der vorherigen Laufzeit.
"""
#Modulimport
import random
import numpy as np
import matplotlib.pyplot as plt
#Globale Variablen
alpha = 0.3 #Parameter in Bezug auf die Herstellung von Produkt A.
beta = 0.7 #Parameter in Bezug auf die Herstellung von Produkt B.
gamma = 0.4 #Parameter in Bezug auf den Nutzen, den Verbraucher beim Konsum jedes Produkts erhalten
w = 200 #Lohn
appe = 40 #Die maximale Menge, die eine Person essen kann, ist auf 40 festgelegt
SEED = 32768 #Startwert
R = 100 #Anzahl der Transaktionswiederholungen
#Klassendefinition Landwirt
class Farmer:
"""Definition einer Klasse, die einen Landwirt darstellt"""
def __init__(self, cat): #Konstrukteur
self.category = cat
self.maxprofit = 0 #Maximaler Gewinn (vorerst 0)
self.mqa = 0 #Ein Produktionsvolumen bei maximalem Gewinn
self.mqb = 0 #B Produktion bei maximalem Gewinn
self.mLA = 0 #Unten die Menge jedes Produktionselements, die mit maximalem Gewinn verwendet wird
self.mKA = 0
self.mLB = 0
self.mKB = 0
self.mLn = 0
self.L = 24 #Selbstarbeit
self.K = 10 #Höhe des Eigenkapitals
def solvePmax(self): #Produziere A und B, um die Gewinne zu optimieren
"""Setzen Sie den besten Gewinn zurück"""
self.maxprofit = 0
"""Lösen Sie das Problem der Gewinnoptimierung"""
for i in range(nlimit):
self.calcprofit(Market) #Gewinn wird berechnet (Gewinn wird berechnet)
def calcprofit(self, Market): #Gewinnberechnung
"""Erhalten Sie nach dem Zufallsprinzip Kombinationen, die die Selbstbeschränkung der Produktionsfaktoren erfüllen"""
LA = int(random.randrange(24)) #Wählen Sie eine Ganzzahl zwischen 0 und 24
LB = int(random.randrange(24 - LA)) #Wählen Sie eine Ganzzahl zwischen 0 und 24-LA
Ln = self.L - LA - LB #Überschüssige Arbeitskräfte in nichtlandwirtschaftliche Arbeitskräfte umwandeln
KA = int(random.randrange(10))
KB = self.K - KA
"""Produktionsfunktion"""
qa = 3 * LA ** (alpha) * KA ** (1 - alpha)
qb = 1 * LB ** (beta) * KB ** (1 - beta)
"""Gewinnfunktion"""
profit = Market.pA * qa + Market.pB * qb + w * Ln
"""Aktualisieren Sie die beste Lösung"""
if profit >= self.maxprofit:
self.maxprofit = profit
self.mqa = qa
self.mqb = qb
self.mLA = LA
self.mKA = KA
self.mLB = LB
self.mKB = KB
self.mLn = Ln
#Ende der Definition der Klasse Farmer
#Klassendefinition Verbraucher
class Consumer:
"""Definition einer Klasse, die einen Verbraucher darstellt"""
def __init__(self, cat): #Konstrukteur
self.category = cat
self.maxutility = 0 #Maximaler Nutzen (vorerst 0)
self.mca = 0 #Produkt A Verbrauch
self.mcb = 0 #Produkt B Verbrauch
self.C = 0 #Gesamtausgaben
self.I = 5000 #Speichern von S als anfängliches Budget=Gab 5000
def solveUmax(self): #Verbrauchen Sie A und B, um den Nutzen zu maximieren
"""Setzen Sie die besten Dienstprogramm- und Budgetbeschränkungen zurück"""
self.maxutility = 0
I = self.I + 5000 #Das einmalige Einkommen beträgt 5000
"""Lösen Sie Probleme bei der Optimierung von Dienstprogrammen"""
for i in range(nlimit):
self.calcutil(I, Market) #Nutzen wird berechnet (Nutzen wird berechnet)
def calcutil(self, I, Market): #Dienstprogrammberechnung
"""Wählen Sie den Verbrauch der Produkte A und B nach dem Zufallsprinzip aus"""
ca = int(random.randrange(appe)) #0 zu appe=Wählen Sie eine Ganzzahl innerhalb von 40
cb = int(random.randrange(appe - ca)) #0 zu appe=40 -Wählen Sie eine Ganzzahl innerhalb von ca.
"""Berechnen Sie die Gesamtausgaben für diesen Zeitraum"""
C = Market.pA * ca + Market.pB * cb
"""Utility-Funktion"""
utility = ca ** (gamma) + cb ** (1 - gamma)
"""Aktualisieren Sie die beste Lösung"""
if I > C and Market.sa > ca and Market.sb > cb:
if utility >= self.maxutility: #Aktualisieren Sie die beste Lösung
self.maxutility = utility
self.mca = ca
self.mcb = cb
self.C = C
self.I = I - C #Ich werde das Budget für die nächste Amtszeit berechnen, also habe ich die Ausgaben abgezogen
#Ende des Unterrichts Verbraucher
#Klassendefinition Markt
class Market:
def __init__(self):
self.pA = 100 #Anfänglicher Preis für landwirtschaftliche Produkte
self.pB = 300
self.sa = 2 * (12 ** 0.3) * (5 ** 0.7) #Wir haben die Werte verwendet, als die Hälfte der eigenen Produktionselemente für die Produktion von A bzw. B verwendet wurde.
self.sb = 1 * (12 ** 0.7) * (5 ** 0.3)
def save(self, f): #Die vom Landwirt produzierte Menge wird eingelagert
for i in range(len(f)):
self.sa += f[i].mqa
self.sb += f[i].mqb
def eaten(self, c): #Die vom Verbraucher verbrauchte Menge wird aus dem Speicher gezogen und eine weitere/Nur 3 können von Mäusen gefressen werden
for i in range(len(c)): #Das Essen durch Menschen reduziert die Lagerung für die nächste Amtszeit
self.sa -= c[i].mca
self.sb -= c[i].mcb
self.sa *= 2 / 3 #Essen Sie von Mäusen und reduzieren Sie die Lagerung für die nächste Amtszeit
self.sb *= 2 / 3
def price(self, c): #Berechnen Sie den Preis für die nächste Laufzeit
Tca = 0
Tcb = 0
for i in range(len(c)):
Tca += c[i].mca
Tcb += c[i].mcb
if (self.sa * 3 / 2) / (self.sa * 3 / 2 + Tca) <= 0.3:
self.pA *= 1.01
else:
self.pA *= 0.99
if (self.sb * 3 / 2) / (self.sb * 3 / 2 + Tcb) <= 0.3:
self.pB *= 1.01
else:
self.pB *= 0.99
#Definition der Funktion der Vergabe von Unteraufträgen
#Berechnung, die die nächste Berechnung überwacht()Funktionsdefinition
def calcn(t, f, c, Market):
#(1) Auflistung der Zeit, des Preises der vorherigen Laufzeit und des Produktüberschusses der vorherigen Laufzeit.
pAlist.append(Market.pA) #Preis
pBlist.append(Market.pB)
salist.append(Market.sa) #Verbleibendes Produkt
sblist.append(Market.sb)
tlist.append(t + 1) #Zeit
#② Optimierung der landwirtschaftlichen Gewinne
for i in range(len(f)):
f[i].solvePmax()
#③ Gesamtwert des Produktionsvolumens der auf dem Markt befindlichen Produkte und anderer Faktoren
mqa = 0
mqb = 0
maxprofit = 0
mLA = 0
mKA = 0
mLB = 0
mKB = 0
mLn = 0
for i in range(len(f)):
mqa += f[i].mqa
mqb += f[i].mqb
maxprofit += f[i].maxprofit
mLA += f[i].mLA
mKA += f[i].mKA
mLB += f[i].mLB
mKB += f[i].mKB
mLn += f[i].mLn
#④ Tragen Sie den aggregierten Wert der Produktion jedes Landwirts in die Liste ein
maxprofitlistF.append(maxprofit)
mqalistF.append(mqa)
mqblistF.append(mqb)
mLAlistF.append(mLA)
mKAlistF.append(mKA)
mLBlistF.append(mLB)
mKBlistF.append(mKB)
mLnlistF.append(mLn)
#⑤ Landwirtschaftliche Produkte sind auf dem Markt
Market.save(f)
#⑥ Optimierung des Nutzens der Verbraucher
for i in range(len(c)):
c[i].solveUmax()
#⑦ Gesamtwert des Produktverbrauchs und anderer auf dem Markt auftretender Faktoren
mca = 0
mcb = 0
maxutility = 0
C = 0
mI = 0
for i in range(len(c)):
mca += c[i].mca
mcb += c[i].mcb
maxutility += c[i].maxutility
C += c[i].C
mI += c[i].I
#⑧ Fügen Sie den aggregierten Wert jeder Verbraucherausgabe in die Liste ein
maxutilitylistC.append(maxutility)
mcalistC.append(mca)
mcblistC.append(mcb)
ClistC.append(C)
IlistC.append(mI)
#⑨ Produktüberschuss auf die nächste Laufzeit übertragen
Market.eaten(c)
#⑩ Nächster Preis
Market.price(c)
#Hauptgeschäftsführer
#Initialisieren
random.seed(SEED) #Zufällige Initialisierung
Market = Market() #Fügen Sie eine Instanz der Klasse Market in eine Variable ein
#Duplizieren Sie die Farmer- und Consumer-Instanzen der Kategorie 0 in der Liste (dies ist nacheinander geplant). Wenn Sie eine Instanz mit einer Liste erstellen, können Sie die Variable anscheinend nicht alleine verwenden.
f = [Farmer(0)]
c = [Consumer(0)]
#Liste des Bauernstatus
maxprofitlistF = []
mqalistF = []
mqblistF = []
mLAlistF = []
mKAlistF = []
mLBlistF = []
mKBlistF = []
mLnlistF = []
#Auflistung des Verbraucherstatus
maxutilitylistC = []
mcalistC = []
mcblistC = []
ClistC = []
IlistC = []
#Listenpreise und Produktreste
pAlist = []
pBlist = []
salist = []
sblist = []
#Liste der Zeiten
tlist = []
#Geben Sie die Anzahl der Versuche ein
nlimit = int(input("Geben Sie an, wie oft die beste Lösung gefunden werden soll. Je größer die Zahl, desto näher an der optimalen Lösung. ::"))
#Agentensimulation
for t in range(R):
calcn(t, f, c, Market) #Berechnen Sie den Status beim nächsten Mal
#Ende des Simulationsteils
#Anpassen von Zahlen nach dem Dezimalpunkt in einer bestimmten Liste
#Passen Sie Gewinn, Produktion, Nutzen, C, s, Einkommen an
maxprofitlistF = [round(maxprofitlistF[n]) for n in range(len(maxprofitlistF)) ]
mqalistF = [round(mqalistF[n], 1) for n in range(len(mqalistF))]
mqblistF = [round(mqblistF[n], 1) for n in range(len(mqblistF))]
maxutilitylistC = [round(maxutilitylistC[n], 1) for n in range(len(maxutilitylistC))]
ClistC = [round(ClistC[n]) for n in range(len(ClistC))]
IlistC = [round(IlistC[n]) for n in range(len(IlistC))]
salist = [round(salist[n], 2) for n in range(len(salist))]
sblist = [round(sblist[n], 2) for n in range(len(sblist))]
#Grafik anzeigen
print("profitieren","\n",maxprofitlistF,"\n","\n","Ein Produktionsvolumen","\n",mqalistF,"\n","\n","B Produktion","\n",mqblistF,"\n","\n","LA","\n",mLAlistF,"\n","\n","LB","\n",mLBlistF,"\n","\n","Ln","\n",mLnlistF,"\n","\n","Nützlichkeit","\n",maxutilitylistC, "\n","\n","Ein Verbrauch","\n",mcalistC,"\n","\n","B Verbrauch","\n",mcblistC,"\n","\n","C","\n",ClistC,"\n","\n","pA","\n",pAlist,"\n","\n","pB","\n",pBlist,"\n","\n","sa","\n",salist,"\n","\n","sb","\n",sblist,"\n","\n","Einkommen","\n",IlistC)
pA = plt.plot(tlist, pAlist)
pB = plt.plot(tlist, pBlist)
plt.title("the price change of product A and B")
plt.xlabel("time")
plt.ylabel("price")
plt.legend((pA[0], pB[0]), ("pA", "pB"), loc=4)
plt.show()
# sell&buy.py
Gesamtstruktur
Ich habe Unterricht benutzt
Wie im Titel geschrieben, habe ich versucht, Klasse zu verwenden. Hier werden drei Arten von Klassen erstellt: "Farmer", "Consumer" und "Market". Landwirt produziert A und B, um Gewinne zu maximieren, Verbraucher verbrauchen A und B, um den Nutzen unter Einschränkungen zu maximieren. Market verwaltet das A- und B-Inventar und passt die Preise an.
So lösen Sie das Optimierungsproblem
Ich weiß nicht, wie das Optimierungsproblem in anderen wirtschaftlichen Simulationen gelöst wird. Hier haben wir zufällig die Kombination ausgewählter Variablen eine bestimmte Anzahl von Malen ausprobiert und die Kombination aktualisiert, wenn der Nutzen oder Gewinn am größten war und die Randbedingungen erfüllt waren.
Ein Buch, auf das ich mich beim Schreiben von Code bezogen habe
Der Code wurde gemäß Tomohiro Odaka (2018) geschrieben: "Numerische Berechnung und Simulation durch Python", aber es kann einen Teil geben, in dem Herr Odaka die verwendeten Wörter falsch interpretiert hat.
Ich habe eine Instanz von Farmer and Consumer in eine Listenvariable eingefügt, obwohl ich nur einen Agenten habe
Der Grund dafür ist, dass ich später die Anzahl der Agenten erhöhen wollte. In Zukunft werde ich die Anzahl der Agenten mit unterschiedlichen Parametern erhöhen, wenn ich es mehr wie einen Multi-Agenten mache. Bei Dispergiermittelparametern ① Haben Sie das Gefühl, dass die Parameter entsprechend der Wahrscheinlichkeitsverteilung fein abgestimmt sind? (2) Ich mache mir Sorgen, ob ich die Struktur so gestalten soll, dass sich die Parameter unter dem Einfluss anderer exogener Variablen ändern.
③ Bestätigung der Ergebnisse
Als ich lief, wurde das Ergebnis wie folgt ausgegeben. Da es lang ist, werden einige Teile weggelassen.
Ergebnis
Geben Sie an, wie oft die beste Lösung gefunden werden soll. Je größer die Zahl, desto näher an der optimalen Lösung. : 100 Ein Produktionsvolumen [11.7, 21.2, 22.0, 16.3, 11.4, 21.2, 17.2, 17.9, 19.4, 14.4, 17.9, 17.2, 23.9, 19.4, 15.8, 22.6, 19.5, 19.4, 15.8, 15.8, 19.4, 19.5, 21.2, 17.2, 17.9, 22.0, 14.6, 22.6, 16.3, 17.2, 19.5, 19.4, 25.0, 17.8, 19.5, 23.9, 23.9, 25.0, 17.9, 27.0, 22.6, 14.4, 19.5, 21.2, 19.5, 19.4, 23.9, 15.8, 17.2, 26.1, 17.9, 19.4, 21.2, 17.2, 21.2, 26.1, 19.4, 22.6, 26.1, 22.6, 23.9, 21.2, 23.9, 22.6, 19.0, 26.1, 25.0, 27.9, 19.5, 22.6, 21.2, 25.0, 19.5, 22.6, 22.0, 21.2, 19.4, 27.0, 25.0, 27.0, 24.0, 19.4, 27.9, 21.2, 22.6, 19.5, 27.9, 27.0, 25.0, 27.0, 20.8, 30.1, 25.0, 23.9, 23.9, 26.1, 29.4, 19.4, 17.2, 25.0]
B Produktion [5.4, 0.0, 3.8, 4.9, 6.3, 1.6, 1.0, 3.2, 0.0, 2.3, 3.2, 2.2, 1.0, 2.6, 3.2, 1.6, 2.0, 1.0, 3.2, 2.0, 2.6, 2.7, 2.2, 0.0, 2.0, 1.2, 5.9, 1.6, 4.3, 1.0, 3.2, 1.0, 1.6, 3.0, 1.2, 1.6, 2.6, 2.6, 1.2, 1.6, 2.2, 3.0, 5.7, 2.6, 1.2, 3.1, 1.6, 3.2, 1.6, 0.0, 1.2, 1.6, 2.6, 0.0, 2.6, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.6, 1.0, 2.3, 2.6, 0.0, 2.2, 3.8, 2.2, 1.0, 2.2, 1.2, 1.0, 3.8, 1.0, 3.9, 0.0, 3.1, 1.0, 2.0, 2.2, 3.1, 1.0, 1.6, 3.2, 1.0, 1.0, 1.6, 0.0, 1.2, 1.0, 0.0, 2.6, 2.2, 1.6, 0.0, 2.2, 1.0, 1.6]
LA [1, 4, 6, 3, 2, 4, 2, 3, 3, 2, 3, 2, 6, 3, 2, 5, 4, 3, 2, 2, 3, 4, 4, 2, 3, 6, 3, 5, 3, 2, 4, 3, 7, 4, 4, 6, 6, 7, 3, 9, 5, 2, 4, 4, 4, 3, 6, 2, 2, 8, 3, 3, 4, 2, 4, 8, 3, 5, 8, 5, 6, 4, 6, 5, 5, 8, 7, 10, 4, 5, 4, 7, 4, 5, 6, 4, 3, 9, 7, 9, 8, 3, 10, 4, 5, 4, 10, 9, 7, 9, 5, 13, 7, 6, 6, 8, 12, 3, 2, 7]
LB [7, 0, 5, 6, 7, 2, 1, 4, 0, 2, 4, 3, 1, 4, 4, 2, 2, 1, 4, 2, 4, 3, 3, 0, 2, 1, 7, 2, 5, 1, 4, 1, 2, 3, 1, 2, 4, 4, 1, 2, 3, 3, 9, 4, 1, 5, 2, 4, 2, 0, 1, 2, 4, 0, 4, 0, 1, 1, 0, 0, 0, 1, 2, 1, 2, 4, 0, 3, 5, 3, 1, 3, 1, 1, 5, 1, 7, 0, 5, 1, 2, 3, 5, 1, 2, 4, 1, 1, 2, 0, 1, 1, 0, 4, 3, 2, 0, 3, 1, 2]
Ln [16, 20, 13, 15, 15, 18, 21, 17, 21, 20, 17, 19, 17, 17, 18, 17, 18, 20, 18, 20, 17, 17, 17, 22, 19, 17, 14, 17, 16, 21, 16, 20, 15, 17, 19, 16, 14, 13, 20, 13, 16, 19, 11, 16, 19, 16, 16, 18, 20, 16, 20, 19, 16, 22, 16, 16, 20, 18, 16, 19, 18, 19, 16, 18, 17, 12, 17, 11, 15, 16, 19, 14, 19, 18, 13, 19, 14, 15, 12, 14, 14, 18, 9, 19, 17, 16, 13, 14, 15, 15, 18, 10, 17, 14, 15, 14, 12, 18, 21, 15]
Ein Verbrauch [23, 11, 28, 16, 12, 14, 19, 17, 21, 7, 23, 16, 23, 20, 16, 12, 26, 17, 16, 7, 20, 21, 19, 19, 15, 21, 10, 22, 10, 23, 16, 22, 20, 20, 16, 26, 20, 24, 16, 25, 23, 9, 13, 28, 19, 20, 20, 6, 22, 24, 20, 19, 20, 20, 12, 28, 14, 25, 26, 1, 39, 21, 13, 29, 18, 24, 20, 32, 17, 24, 20, 26, 15, 17, 25, 23, 11, 23, 20, 34, 16, 21, 22, 18, 27, 11, 33, 23, 28, 28, 28, 28, 28, 15, 25, 27, 27, 10, 22, 26]
B Verbrauch [12, 1, 3, 5, 5, 2, 1, 3, 0, 2, 3, 2, 1, 1, 3, 2, 2, 0, 2, 3, 1, 1, 4, 0, 0, 2, 6, 1, 4, 1, 2, 2, 1, 1, 1, 2, 3, 2, 1, 2, 1, 3, 6, 2, 1, 3, 1, 2, 2, 0, 0, 2, 3, 3, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 2, 3, 0, 2, 3, 2, 1, 2, 1, 1, 4, 1, 2, 1, 3, 1, 2, 1, 3, 1, 2, 3, 0, 1, 2, 2, 2, 2, 2, 0, 2, 1, 0, 2, 0, 2]
C [5900, 1414, 3700, 3101, 2724, 2048, 2244, 2660, 2185, 1341, 3310, 2299, 2753, 2459, 2668, 1930, 3438, 1859, 2391, 1707, 2520, 2651, 3363, 2161, 1723, 3042, 3006, 2861, 2394, 2977, 2486, 3209, 2696, 2717, 2250, 3795, 3368, 3608, 2330, 3797, 3276, 2066, 3479, 4192, 2764, 3521, 2946, 1405, 3502, 3200, 2693, 3165, 3627, 3627, 1681, 3884, 2255, 3468, 3642, 141, 5463, 3256, 2145, 4387, 3135, 4317, 2915, 5279, 3389, 4184, 3326, 4563, 2614, 2947, 5039, 3890, 2334, 3889, 4052, 5613, 3134, 3588, 4385, 3176, 4869, 2676, 5205, 3972, 5115, 5115, 5115, 5115, 5115, 2537, 4867, 4959, 4704, 2351, 3833, 5166]
Einkommen [4100, 7686, 8986, 10886, 13162, 16114, 18870, 21210, 24025, 27684, 29374, 32075, 34322, 36863, 39195, 42265, 43827, 46968, 49578, 52870, 55350, 57700, 59337, 62176, 65452, 67410, 69404, 71543, 74149, 76171, 78685, 80477, 82781, 85064, 87813, 89018, 90650, 92042, 94712, 95916, 97639, 100573, 102095, 102902, 105138, 106617, 108672, 112267, 113764, 115565, 117872, 119707, 121080, 121080, 124399, 125515, 128260, 129792, 131150, 136009, 135546, 137290, 140145, 140758, 142623, 143307, 145392, 145112, 146723, 147539, 149212, 149649, 152036, 154089, 154050, 155160, 157827, 158937, 159885, 159272, 161138, 162550, 163164, 164989, 165120, 167444, 167239, 168267, 168152, 168152, 168152, 168152, 168152, 170616, 170748, 170789, 171085, 173734, 174901, 174735]
Eindrücke von den Ergebnissen
Wenn Sie wirklich versuchen, die Ergebnisse Ihrer Überlegungen zusammenzufassen, dauert es länger, daher möchte ich Ihre Eindrücke von den Ergebnissen kurz beschreiben.
① So zeigen Sie (Diagramm)
Ich fand es ziemlich schwierig, das Ergebnis mit matplotlib auszugeben. Dieses Mal habe ich nur ein Diagramm der Preisänderungen erstellt und die Änderungen anderer Variablen angezeigt, indem ich eine Liste entsprechend eingefügt habe. Ich wünschte jedoch, ich könnte alle Variablen zu einem Balkendiagramm machen. Die nächste Herausforderung.
② Preisänderung
Der Grund, warum ich nur die Preisänderungen tabellarisch aufgeführt habe, war, dass ich mich gefragt habe, ob die Preise zu einem ausgeglichenen Preis konvergieren würden. Betrachtet man die Figur, Sie sehen, dass der Preis für Produkt A (das Bild von preisgünstigem, kapitalintensivem Getreide) stetig gestiegen ist. Und der Verbrauch von A ist nahezu konstant, und die Produktion scheint allmählich zugenommen zu haben. Es ist normal, dass Landwirte mit höheren Preisen mehr A produzieren, aber es ist seltsam, dass sich die von den Verbrauchern konsumierte Menge an A nicht geändert hat. Vielleicht liegt der Grund darin, dass aufgrund von Sättigungsbeschränkungen der Anstieg des Verbrauchs zu gering für den Anstieg des Einkommens ist und das Budget so stark gestiegen ist, dass die Budgetbeschränkungen keinen Sinn ergeben. In diesem Fall kann die Verteilung des Verbrauchs zu einer Verbrauchsbilanz konvergieren (die Verteilung des Verbrauchs, die Ihnen am besten gefällt, wenn sich der Preis nicht ändert), die unabhängig vom Budget durch die Parameter der Versorgungsfunktion bestimmt wird. Nun, es ist tiefgreifend ... Ist es besser, die Sättigungsbeschränkung aufzuheben? Oder vielleicht wäre es besser, die Anzahl der Agenten zu erhöhen ...
③ Trend der Eingabe von Produktionselementen
Die Eingabetendenz von Produktionselementen in einem Wort erklären "Die Löhne für nichtlandwirtschaftliche Arbeitskräfte sind so hoch, dass jeder nur für Nebenjobs arbeitet." Es stellt sich heraus, dass die meiste Zeit in Ln investiert wurde, aber der Lohn von 200 war möglicherweise zu hoch. Darüber hinaus wurde Produkt B (ein Bild von hochpreisigen und arbeitsintensiven Früchten) selten hergestellt, und nur A wurde in großen Stückzahlen hergestellt. Mit dieser Zustandseinstellung kann gesagt werden, dass die Landwirte dazu neigten, viel A zu produzieren, das eine hohe Inputproduktivität der Produktionselemente aufweist, anstatt B, das einen leicht hohen Anfangspreis aufweist. Es sieht aus wie ein japanischer Teilzeit-Reisbauer. Übrigens, wenn Sie unterschiedliche Zahlen in die Parameter eingeben, werden völlig unterschiedliche Ergebnisse ausgegeben. Schließlich kann es notwendig sein, etwas mehr am Wert des Parameters festzuhalten.
⑤ Ich fand die Welt kompliziert
Wie mein Freund sagte, weiß der Designer des Zellautomaten nicht, welche Art von Muster am Ende gezeichnet wird, bis das Programm ausgeführt wird. Dieses Mal habe ich (der Gott dieses Programms) versucht, ein Modell zu erstellen, das das Verhalten von Landwirten und Verbrauchern imitieren kann, aber ich wusste nicht, was das Ergebnis vor dem Lauf sein würde, und nachdem ich das Ergebnis gesehen hatte, warum? Ich konnte nicht einmal den Grund für das Ergebnis bestimmen. Ich bin der Meinung, dass sich Wissenschaftler einer rücksichtslosen Herausforderung stellen könnten. Die Realität ist komplizierter als diese Simulation. Schließlich kann der Mensch nur "(1) eine grundlegende Theorie finden, die ein Knochen ist, wenn er ein Phänomen erklärt. (2) verschiedene Knochen zusammenkleben, um Fleisch zu machen, wenn er ein bestimmtes Phänomen erklärt." Überlegen.
Es ist also abrupt, aber es endet hier. Als nächstes denke ich daran, eine Simulation eines autarken Bauern zu machen oder Pygame zu studieren und ein einfaches Spiel zu machen, das den Bauern in Bewegung bringt.
Verweise
~ Papier ~ [1]Alain de Janvry, Marcel Fafchamps and Elisabeth Sadoulet(1991) “Peasant household behavior with missing markets: some paradoxes explained” Economic Journal. Vol.101, pp.1400-1417. [2]George A. Dyer, Steve Boucher, and J. Edward Taylor(2006) “Subsistence response to market shocks” American journal of agricultural economics. Vol. 88, pp. 279-291. [3]J.Edward Taylor, George A. Dyer, Antonio Yu'nez-Naude(2005) "Disaggregated Rural Economywide Models for Policy Analysis" World Development. vol. 33, pp. 1671-1688
~ Lehrbuch ~ [1] Tomohiro Odaka (2018): "Numerische Berechnung und Simulation mit Python", Ohm [2]Jake VanderPlas(2016) "Python Data Science Handbook: Essential Tools for Working with Data", O'Reilly Media
Recommended Posts