Versuchen Sie mit der Python-Klasse, das Produktions- und Konsumverhalten autarker Landwirte sehr grob und einfach zu simulieren. ② Zeigen Sie den Code und die Ergebnisse an
Lassen Sie uns nun die beschissene Überprüfung überspringen und einen Blick auf den Code und die Ergebnisse werfen. Die Erläuterung der Bedingungseinstellung finden Sie unter ①.
Code
"""
subsistance.py Programm
Autarke Landwirte produzieren
Autarke Landwirte durchlaufen Produktionspläne nach dem Zufallsprinzip und implementieren Pläne, die den Nutzen maximieren
Autarke Landwirte nutzen ihre eigene Arbeit und ihr eigenes Kapital für die Produktion
1~10. Amtszeit: Maximieren Sie den Nutzen zum ursprünglichen Preis
11~20. Amtszeit:Der Preis von B steigt einmal und der Nutzen wird zu diesem Preis maximiert.
21~30. Amtszeit:Der Preis von o fällt einmal und der Nutzen wird zu diesem Preis maximiert.
31~40. Amtszeit:Der Preis von B steigt einmal und o fällt einmal, und der Nutzen wird zu diesem Preis maximiert.
"""
#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.
gamma1 = 0.2 #Parameter im Zusammenhang mit den Vorteilen, die Verbraucher beim Verzehr autarker Lebensmittel erhalten
gamma2 = 0.45 #Parameter in Bezug auf den Nutzen, den Verbraucher beim Konsum anderer Waren erhalten (z. B. TV und NETFLIX)
w = 200 #Lohn
SEED = 1234 #Startwert
R = 40 #Einstellen der Anzahl der Wiederholungen
#Klassendefinition
class Autarky:
"""Definition einer Klasse, die einen autarken Landwirt darstellt"""
def __init__(self, cat): #Konstrukteur
self.category = cat
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.I = 5000 #Maximales Versorgungsbudget(Halten Sie es bei 5000)
self.profit = 0 #Profitieren Sie bei maximalem Nutzen
self.qa = 0 #Ein Produktionsvolumen bei maximalem Nutzen
self.qb = 0 #B Produktion bei maximalem Nutzen
self.LA = 0 #Unten die Menge jedes Produktionselements, das bei maximalem Nutzen verwendet wird
self.KA = 0
self.LB = 0
self.KB = 0
self.Ln = 0
def solveUmax(self): #Produziere A und B, um die Gewinne zu optimieren
"""Setzen Sie den besten Wert des Dienstprogramms zurück"""
self.utility = 0
"""Lösen Sie nach zufälliger Berechnung des Gewinns das Problem der Versorgungsoptimierung basierend auf dem Gewinn."""
for i in range(nlimit):
self.calcprofit(Market) #Der Gewinn wird berechnet
I = self.I + self.profit #Das Einkommen der Landwirte ist die Summe der Einkünfte aus landwirtschaftlichen und nichtlandwirtschaftlichen Arbeitskräften
self.calcutility(I, Market) #Nutzen 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(18)) #Wählen Sie eine Ganzzahl zwischen 0 und 18
LB = int(random.randrange(18 - LA)) #Wählen Sie eine Ganzzahl zwischen 0 und 18-LA
Ln = int(random.randrange(18 - LA - LB)) #Überschüssige Arbeitskräfte in nichtlandwirtschaftliche Arbeitskräfte umwandeln
l = 18 - LA - LB - Ln
KA = int(random.randrange(10))
KB = 10 - KA
"""Produktionsfunktion"""
qa = 3 * LA ** (alpha) * KA ** (1 - alpha)
qb = 1 * LB ** (beta) * KB ** (1 - beta)
"""Gewinnfunktion"""
profit = Market.pB * qb + w * Ln
"""Informationen aktualisieren"""
self.profit = profit
self.qa = qa
self.qb = qb
self.LA = LA
self.KA = KA
self.LB = LB
self.KB = KB
self.Ln = Ln
self.l = l
def calcutility(self, I, Market): #Berechnen Sie den maximalen Nutzen
"""Wählen Sie nach dem Zufallsprinzip die Menge an verbrauchtem o"""
maxco = I / Market.po
co = int(maxco)
"""Berechnen Sie die Gesamtausgaben für diesen Zeitraum"""
C = Market.po * co
"""Utility-Funktion"""
utility = self.qa ** (gamma1) + co ** (gamma2) + self.l ** (1 - gamma1 - gamma2)
"""Die beste Lösung für das Dienstprogramm wurde aktualisiert"""
if utility >= self.utility: #Aktualisieren Sie die beste Lösung
self.utility = utility
self.co = co
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 der Definition der Klasse Autarkie
#Klassendefinition Markt
class Market:
def __init__(self):
self.pB = 100 #Anfänglicher Preis für landwirtschaftliche Produkte
self.po = 300
def price_B(self): #pB Preiserhöhung um 50 Yen
self.pB += 50
def price_o(self): #50 Yen Preissenkung für po
self.po -= 50
#Ende der Definition der Klasse Markt
#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
pBlist.append(Market.pB) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#② Optimierung des Nutzens autarker Landwirte
for i in range(len(a)):
a[i].solveUmax()
#Berechnung, die die nächste Berechnung steuert, wenn sich pB einmal ändert_B()Funktionsdefinition
def calcn_B(t, a, Market):
#① Änderung des pB-Preises
Market.price_B()
#② Fügen Sie den Preis am Anfang dieses Begriffs zur Liste hinzu
pBlist.append(Market.pB) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#③ Optimierung des Nutzens der Landwirte
for i in range(len(a)):
a[i].solveUmax()
#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
pBlist.append(Market.pB) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#③ Optimierung des Nutzens der Landwirte
for i in range(len(a)):
a[i].solveUmax()
#Berechnung, die die nächste Berechnung steuert, wenn sich pB und po einmal ändern_Bo()Funktionsdefinition
def calcn_Bo(t, a, Market):
#① Änderungen der pB- und po-Preise
Market.price_B()
Market.price_o()
#② Fügen Sie den Preis am Anfang dieses Begriffs zur Liste hinzu
pBlist.append(Market.pB) #Preis
polist.append(Market.po)
tlist.append(t) #Zeit
#③ Optimierung des Nutzens der Landwirte
for i in range(len(a)):
a[i].solveUmax()
#Berechnung, die den aggregierten Wert des Elements berechnet und zur Liste hinzufügt_list()Funktionsdefinition
def calc_list(a):
qa = 0
qb = 0
profit = 0
LA = 0
KA = 0
LB = 0
KB = 0
Ln = 0
l = 0
cb = 0
co = 0
utility = 0
C = 0
I = 0
for i in range(len(a)):
qa += a[i].qa
qb += a[i].qb
profit += a[i].profit
LA += a[i].LA
KA += a[i].KA
LB += a[i].LB
KB += a[i].KB
l += a[i].l
Ln += a[i].Ln
co += a[i].co
utility += a[i].utility
C += a[i].C
I += a[i].I
utilitylistA.append(utility)
colistA.append(co)
ClistA.append(C)
IlistA.append(I)
profitlistA.append(profit)
qalistA.append(qa)
qblistA.append(qb)
LAlistA.append(LA)
KAlistA.append(KA)
LBlistA.append(LB)
KBlistA.append(KB)
LnlistA.append(Ln)
llistA.append(l)
#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 eine Instanz von Autarkie der Kategorie 0 in der Liste (dies ist nacheinander geplant).
a = [Autarky(0)]
#Liste des Bauernstatus
utilitylistA = []
colistA = []
ClistA = []
IlistA = []
profitlistA = []
qalistA = []
qblistA = []
LAlistA = []
KAlistA = []
LBlistA = []
KBlistA = []
LnlistA = []
llistA = []
#Listenpreise und Produktreste
pBlist = []
polist = []
#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. ::"))
#Simulation
for t in range(R):
if t <= 10: # 1~10. Amtszeit: Anfangspreis
calcn_n(t, a, Market)
calc_list(a)
if t == 11: #11. Amtszeit: B Preisänderung
calcn_B(t, a, Market)
calc_list(a)
if (t > 11) and (t <= 20): # 12~20. Amtszeit: Stabil nach B-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: B und O Preisänderungen
calcn_Bo(t, a, Market)
calc_list(a)
if (t > 31) and (t <= 40): # 32~40. Periode: Stabil nach B & O Preisänderungen
calcn_n(t, a, Market)
calc_list(a)
#Ende des Simulationsteils
#Zeigen Sie die Liste der wichtigen Variablen unverändert an
print("profitieren",profitlistA,"\n","\n","Eine Produktion",qalistA,"\n","\n","B Produktion",qblistA,"\n","\n","LA",LAlistA,"\n","\n","LB",LBlistA,
"\n","\n","Ln",LnlistA,"\n","\n","l", llistA, "\n","\n",, "Nützlichkeit",utilitylistA, "\n","\n", "o Verbrauch",colistA,"\n","\n","C",ClistA,
"\n","\n","pA",pBlist,"\n","\n","po",polist,"\n","\n", "Einkommen",IlistA)
# sell&buy.py
Ergebnis
Dieses Mal haben wir festgelegt, wie oft die beste Lösung auf 10.000 verfolgt werden soll. Der Startwert ist auf 1234 festgelegt.
Preis
Wie festgelegt, stiegen / fielen die Preise für B und O im 10., 20. und 30. Zeitraum.
A und B Produktion
Die Änderung von A ist gudaguda w
Das Produktionsvolumen von A änderte sich nach der 10., 20. und 30. Periode in U-Form. Warum ...? w
Das Produktionsvolumen von B scheint relativ konstant zu sein.
A, o, l Verbrauch
Der Verbrauch von o steigt allmählich an. Kein Wunder, da die Preise sinken.
Andererseits ist die Menge an verbrauchtem l (Freizeit) konstant.
Eingabe von Produktionselementen
Schwer zu sehen w. Ich hätte ein gestapeltes Balkendiagramm erstellen sollen. was auch immer.
Irgendwie habe ich das Gefühl, dass im Laufe der Zeit eine Tendenz zur negativen Autokorrelation besteht. Wenn die Menge an Eingaben im vorherigen Term groß ist, wird sie im nächsten Term abnehmen. was ist das.
Gewinn und Verbrauch
Nun, es ist konstant.
Da der Preis für Cash Crops steigt, habe ich mich gefragt, ob die Gewinne steigen würden, aber die Steigerung der Produktion autarker Körner hat die Gewinnsteigerung behindert. Die einfache Interpretation ist, dass die autarke Produktion das Einkommen des Landwirts auf einem niedrigen Niveau stabilisiert hat. Ich frage mich, ob dies eine autarke Produktionsfalle ist.
Nützlichkeit
Wow ww
Immerhin steigt die Menge, die verbraucht werden kann, und der Nutzen steigt.
Zumal es in dieser Simulation von 20 auf 20 gestiegen ist, war der Preisverfall bei Luxusgütern o für einen autarken Landwirt ein besseres Ereignis als der Preisanstieg bei Geldernte B.
Aha.
Problem
Maximierungsproblem
Wie ich letztes Mal betont habe, ist die Methode des Maximierungsproblems nicht gut. Dies liegt daran, dass die beste Lösung gefunden wird, indem die Eingabeverteilung der Produktionselemente 10.000 Mal zufällig geändert und das beste Ergebnis übernommen wird. Wenn Sie also den Startwert ändern, ändert sich das Ergebnis. Es ist kein Problem, wenn Sie den Gewinn maximieren möchten, aber wenn Sie versuchen, den Nutzen über Gewinnberechnungen hinweg zu maximieren, ist er nicht stabil. Schließlich frage ich mich, ob ich das Maximierungsproblem mathematisch lösen muss. Ich weiß, wie man es mit Papier und Bleistift löst, aber welche Art von Code sollte ich verwenden? Als Bild wird auch die Newton-Rahson-Methode verwendet, wenn die Parameter der Regressionsgleichung mit der wahrscheinlichsten Methode geschätzt werden, aber ich denke, dass es möglich ist, sich der Lösung schrittweise mit dieser Art von Gefühl zu nähern. Ich denke es ist okay wie es ist.
Ist es in Ordnung, wenn das Funktionssystem vom Typ Cobb-Douglas ist? Können die Parameter auch konstant sein?
Irgendwie habe ich das Gefühl, dass die Landwirte produktiver werden, wenn sie die Anbaumethoden besser beherrschen. Sollten die Parameter auch in diesem Fall nicht verbessert werden? Oder sollten nicht alle Faktoren die Produktivität steigern? Ich bin besorgt über diesen Punkt. Der Funktionstyp ist ebenfalls auf den Cobb-Douglas-Typ festgelegt. Sollte es sich jedoch nicht um ein komplizierteres Funktionssystem handeln, um die Wirtschaftlichkeit der Skalierung und Schwankungen der Parameter zu berücksichtigen? Was soll ich tun?
Ist es nicht an der Zeit, daraus einen Multi-Agent zu machen?
Derzeit können wir drei Arten von Klassen vorbereiten. Sie sind "Bauern", "Verbraucher" und "autarke Bauern". Es gibt auch die Idee, einen Hobby-Hausgartenbauern oder einen Biobauern zu modellieren, der seine Anbaumethode für lohnenswert hält. Ich möchte eine Welt schaffen, die diese Menschen einbezieht.
das ist alles. Als nächstes möchte ich das Produktionsmodell eines Hobby-Hausgartenbauern oder eines Biobauern auflisten, der seine Anbaumethode ohne Simulation für sinnvoll hält. Danach frage ich mich, ob ich eine Multi-Agent-Simulation ausführen werde. Die Methode des Maximierungsproblems bleibt vorerst unverändert.
Recommended Posts