En utilisant la classe python, essayez de simuler très grossièrement et facilement le comportement de production et de consommation des agriculteurs autosuffisants ② Afficher le code et les résultats
Passons maintenant à l'examen de merde et jetons un coup d'œil au code et aux résultats. Veuillez vous référer à ① pour l'explication du paramètre de condition.
code
"""
subsistance.programme py
Les agriculteurs autosuffisants produisent
Les agriculteurs autonomes itèrent au hasard les plans de production et mettent en œuvre des plans qui maximisent l'utilité
Les agriculteurs autonomes utilisent leur propre travail et leur propre capital pour la production
1~10e terme: maximiser l'utilité au prix initial
11~20e trimestre:Le prix de B augmente une fois, et l'utilité est maximisée à ce prix.
21~30e trimestre:Le prix de o baisse une fois et l'utilité est maximisée à ce prix.
31~40e trimestre:Le prix de B augmente une fois, et o diminue une fois, et l'utilité est maximisée à ce prix.
"""
#Importation de module
import random
import numpy as np
import matplotlib.pyplot as plt
#Variables globales
alpha = 0.3 #Paramètres liés à la production du produit A
beta = 0.7 #Paramètres liés à la production du produit B
gamma1 = 0.2 #Paramètres liés à l'utilité que les consommateurs obtiennent lorsqu'ils consomment des aliments autosuffisants
gamma2 = 0.45 #Paramètres liés à l'utilité que les consommateurs obtiennent lorsqu'ils consomment d'autres biens (tels que la télévision et NETFLIX)
w = 200 #salaire
SEED = 1234 #Valeur des semences
R = 40 #Réglage du nombre de répétitions
#Définition de classe
class Autarky:
"""Définition d'une classe qui représente un agriculteur autosuffisant"""
def __init__(self, cat): #constructeur
self.category = cat
self.utility = 0 #Utilité maximale (0 pour le moment)
self.co = 0 #O consommation à l'utilité maximale
self.l = 0 #Temps de loisirs à l'utilité maximale
self.C = 0 #Consommation totale à l'utilité maximale
self.I = 5000 #Budget maximum des services publics(Gardez-le à 5000)
self.profit = 0 #Profiter à l'utilité maximale
self.qa = 0 #Un volume de production à l'utilité maximale
self.qb = 0 #Production B à l'utilité maximale
self.LA = 0 #Ci-dessous, la quantité de chaque élément de production utilisé à l'utilité maximale
self.KA = 0
self.LB = 0
self.KB = 0
self.Ln = 0
def solveUmax(self): #Produire A et B pour optimiser les profits
"""Réinitialisez la meilleure valeur d'utilité"""
self.utility = 0
"""Après avoir calculé le profit au hasard, résolvez le problème d'optimisation de l'utilité en fonction du profit."""
for i in range(nlimit):
self.calcprofit(Market) #Le profit est calculé
I = self.I + self.profit #Le revenu de l'agriculteur est la somme du revenu du travail agricole et du travail non agricole
self.calcutility(I, Market) #L'utilité est calculée
def calcprofit(self, Market): #Calcul des bénéfices
"""Obtenir au hasard des combinaisons qui satisfont à l'auto-contrainte des facteurs de production"""
LA = int(random.randrange(18)) #Choisissez un entier entre 0 et 18
LB = int(random.randrange(18 - LA)) #Choisissez un entier entre 0 et 18-LA
Ln = int(random.randrange(18 - LA - LB)) #Transférer le surplus de main-d'œuvre dans la main-d'œuvre non agricole
l = 18 - LA - LB - Ln
KA = int(random.randrange(10))
KB = 10 - KA
"""Fonction de production"""
qa = 3 * LA ** (alpha) * KA ** (1 - alpha)
qb = 1 * LB ** (beta) * KB ** (1 - beta)
"""Fonction de profit"""
profit = Market.pB * qb + w * Ln
"""Mettre à jour les informations"""
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): #Calculer l'utilité maximale
"""Choisissez au hasard la quantité de o consommée"""
maxco = I / Market.po
co = int(maxco)
"""Calculez les dépenses totales pour ce terme"""
C = Market.po * co
"""Fonction d'utilité"""
utility = self.qa ** (gamma1) + co ** (gamma2) + self.l ** (1 - gamma1 - gamma2)
"""Meilleure solution mise à jour pour l'utilité"""
if utility >= self.utility: #Mettre à jour la meilleure solution
self.utility = utility
self.co = co
self.C = C
self.I = I - C #Je vais calculer le budget pour le prochain trimestre, donc j'ai soustrait les dépenses
#Fin de la définition de la classe Autarky
#Marché de définition de classe
class Market:
def __init__(self):
self.pB = 100 #Prix initial du produit agricole
self.po = 300
def price_B(self): #Augmentation du prix pB de 50 yens
self.pB += 50
def price_o(self): #50 yens de réduction de prix pour po
self.po -= 50
#Fin de la définition de la classe Marché
#Définition de la fonction de sous-traitance
#Calcn qui supervise le prochain calcul lorsque le prix ne change pas_n()Définition des fonctions
def calcn_n(t, a, Market):
#① Mettez le prix au début de ce terme dans la liste
pBlist.append(Market.pB) #prix
polist.append(Market.po)
tlist.append(t) #temps
#② Optimiser l'utilité des agriculteurs autosuffisants
for i in range(len(a)):
a[i].solveUmax()
#Calcn qui contrôle le prochain calcul lorsque pB change une fois_B()Définition des fonctions
def calcn_B(t, a, Market):
#① Changement de prix pB
Market.price_B()
#② Ajouter le prix au début de ce trimestre à la liste
pBlist.append(Market.pB) #prix
polist.append(Market.po)
tlist.append(t) #temps
#③ Optimiser l'utilité des agriculteurs
for i in range(len(a)):
a[i].solveUmax()
#Calcn qui contrôle le prochain calcul lorsque po change une fois_o()Définition des fonctions
def calcn_o(t, a, Market):
#① Changement de prix po
Market.price_o()
#② Ajouter le prix au début de ce trimestre à la liste
pBlist.append(Market.pB) #prix
polist.append(Market.po)
tlist.append(t) #temps
#③ Optimiser l'utilité des agriculteurs
for i in range(len(a)):
a[i].solveUmax()
#Calcn qui contrôle le prochain calcul lorsque pB et po changent une fois_Bo()Définition des fonctions
def calcn_Bo(t, a, Market):
#① Modifications des prix pB et po
Market.price_B()
Market.price_o()
#② Ajouter le prix au début de ce trimestre à la liste
pBlist.append(Market.pB) #prix
polist.append(Market.po)
tlist.append(t) #temps
#③ Optimiser l'utilité des agriculteurs
for i in range(len(a)):
a[i].solveUmax()
#Calc qui calcule la valeur agrégée de l'élément et l'ajoute à la liste_list()Définition des fonctions
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)
#Exécutif principal
#Initialisation
random.seed(SEED) #Initialisation aléatoire
Market = Market() #Mettre une instance de la classe Market dans une variable
#Dupliquer une instance de la catégorie 0 Autarky dans la liste (prévu de le faire, une par une)
a = [Autarky(0)]
#Liste du statut d'agriculteur
utilitylistA = []
colistA = []
ClistA = []
IlistA = []
profitlistA = []
qalistA = []
qblistA = []
LAlistA = []
KAlistA = []
LBlistA = []
KBlistA = []
LnlistA = []
llistA = []
#Liste des prix et des restes de produits
pBlist = []
polist = []
#Liste des horaires
tlist = []
#Entrez le nombre d'essais
nlimit = int(input("Spécifiez le nombre de fois pour rechercher la meilleure solution. Plus le nombre est élevé, plus la solution optimale est proche. :"))
#simulation
for t in range(R):
if t <= 10: # 1~10e trimestre: prix initial
calcn_n(t, a, Market)
calc_list(a)
if t == 11: #11e trimestre: changement de prix B
calcn_B(t, a, Market)
calc_list(a)
if (t > 11) and (t <= 20): # 12~20ème terme: Stable après le changement de prix B
calcn_n(t, a, Market)
calc_list(a)
if t == 21: #21e trimestre: o Changement de prix
calcn_o(t, a, Market)
calc_list(a)
if (t > 21) and (t <= 30): # 22~30e trimestre: o Stable après changement de prix
calcn_n(t, a, Market)
calc_list(a)
if t == 31: #31e trimestre: changements de prix B et o
calcn_Bo(t, a, Market)
calc_list(a)
if (t > 31) and (t <= 40): # 32~40e période: Stable après les changements de prix B et o
calcn_n(t, a, Market)
calc_list(a)
#Fin de la partie simulation
#Afficher la liste des variables importantes telles quelles
print("profit",profitlistA,"\n","\n","Une production",qalistA,"\n","\n","Production B",qblistA,"\n","\n","LA",LAlistA,"\n","\n","LB",LBlistA,
"\n","\n","Ln",LnlistA,"\n","\n","l", llistA, "\n","\n",, "utilitaire",utilitylistA, "\n","\n", "o Consommation",colistA,"\n","\n","C",ClistA,
"\n","\n","pA",pBlist,"\n","\n","po",polist,"\n","\n", "le revenu",IlistA)
# sell&buy.py
résultat
Cette fois, nous avons fixé le nombre de fois pour rechercher la meilleure solution à 10 000. La valeur de départ est fixée à 1234.
prix
Comme prévu, les prix de B et o ont augmenté / diminué au cours des 10e, 20e et 30e périodes.
Production A et B
Le changement de A est gudaguda w
Le volume de production de A a changé en forme de U après les 10e, 20e et 30e périodes. Pourquoi ...? w
Le volume de production de B semble être relativement constant.
A, o, l consommation
La consommation d'o augmente progressivement. Sans surprise, car les prix baissent.
En revanche, la quantité de l (loisirs) consommée est constante.
Entrée des éléments de production
Difficile de voir w. J'aurais dû faire un graphique à barres empilées. peu importe.
D'une manière ou d'une autre, je sens qu'il y a une tendance à une autocorrélation négative avec le temps. Lorsque la quantité d'entrée dans le terme précédent est importante, elle diminuera au terme suivant. Qu'est-ce que c'est ça.
Bénéfice et consommation
Eh bien, c'est constant.
Le prix des cultures commerciales étant à la hausse, je me suis demandé si les bénéfices augmenteraient, mais l'augmentation de la production de céréales autosuffisantes a entravé l'augmentation des bénéfices. L'interprétation simple est que la production autosuffisante a stabilisé le revenu de l'agriculteur à un niveau bas. Je me demande s'il s'agit d'un piège de production autosuffisant.
utilitaire
Wow ww
Après tout, la quantité qui peut être consommée augmente, donc l'utilité augmente.
D'autant qu'elle est passée de 20, dans cette simulation, la baisse du prix du produit de luxe o a été un meilleur événement pour un agriculteur autosuffisant que l'augmentation du prix de la culture de rente B.
Je vois.
problème
Problème de maximisation
Comme je l'ai souligné la dernière fois, le problème de la méthode de maximisation n'est pas bon. En effet, la meilleure solution est trouvée en changeant aléatoirement la distribution d'entrée des éléments de production 10 000 fois et en adoptant le meilleur résultat, donc changer la valeur de départ changera le résultat. Il n'y a pas de problème si vous cherchez à maximiser les profits, mais si vous essayez de maximiser l'utilité à travers les calculs de profits, il ne sera pas stable. Après tout, je me demande si je dois résoudre le problème de maximisation mathématiquement. Je sais comment le résoudre avec du papier et un crayon, mais quel type de code dois-je utiliser? Aussi, à titre d'image, la méthode de Newton-Rahson est utilisée pour estimer les paramètres de l'équation de régression par la méthode la plus probable, mais je pense qu'il est possible d'approcher la solution progressivement avec ce genre de sentiment. Je pense que ça va comme ça.
Est-il acceptable que le système de fonctions soit du type Cobb-Douglas? De plus, les paramètres peuvent-ils être constants?
D'une manière ou d'une autre, j'ai l'impression que les agriculteurs deviennent plus productifs à mesure qu'ils maîtrisent mieux les méthodes agricoles. Les paramètres ne devraient-ils pas être améliorés dans ce cas également? Ou la productivité de tous les facteurs ne devrait-elle pas augmenter? Je suis préoccupé par ce point. De plus, le type fonctionnel est fixé au type Cobb-Douglas, mais ne devrait-il pas s'agir d'un système fonctionnel plus compliqué pour tenir compte de l'efficacité économique d'échelle et des fluctuations des paramètres? Eh bien, que dois-je faire?
N'est-il pas temps d'en faire un multi-agent?
Pour le moment, trois classes sont désormais disponibles. Ce sont des «agriculteurs», des «consommateurs» et des «agriculteurs autonomes». Il y a aussi une idée de modéliser un agriculteur de jardin amateur ou un agriculteur biologique qui trouve sa méthode agricole utile. Je veux créer un monde qui intègre ces personnes.
c'est tout. Ensuite, j'aimerais énumérer le modèle de production d'un agriculteur amateur ou d'un agriculteur biologique qui estime que sa méthode agricole vaut la peine sans simulation. Après cela, je me demande si je vais lancer une simulation multi-agents. Le problème de la méthode de maximisation restera tel quel pour le moment.
Recommended Posts