[PYTHON] Simulation de l'économie des agriculteurs ② (vendeur net, agriculteur autosuffisant, action de maximisation de l'utilité de l'acheteur net) _ Il est temps de voir le code
- J'ai un peu modifié le code. J'ai oublié d'ajuster le module dans le deuxième code. Pardon
Cet article est une continuation de "Farmer Economy Simulation ①", donc j'apprécierais que vous lisiez d'abord seulement la partie introductive de cet article. Dans «…… ①», nous avons expliqué le modèle à l'intérieur de la simulation et l'objectif final.
Alors Dans ce "... ②", je présenterai le code de la simulation de l'économie agricole que j'ai réalisé moi-même. Jetons un œil à "Présentation du modèle", "Code" et "Résultats de la simulation"!
Informations environnementales
Cet article python 3.8.3 scipy 1.5.0 Est utilisé sur le notebook jupyter. (Est-ce cette façon d'écrire ...?)
Aperçu du modèle
Explication du comportement des agriculteurs
Un agriculteur a une «force de travail» et une «terre agricole» qu'il utilise pour produire le grain A, qu'il mange, vend et s'achète lui-même.
Le grain A a l'image du maïs pour l'alimentation, et l'endroit a l'image du Mexique rural.
En même temps, les agriculteurs sont également des consommateurs, donc ils consomment des «loisirs» et «d'autres biens» pour maximiser leur utilité. Par conséquent, dans cette simulation, le «problème de la maximisation de l'utilité des agriculteurs sous contraintes budgétaires» est au cœur de la logique.
De plus, sur la base de Janvry (1991), les agriculteurs ont été divisés selon les trois modèles suivants. ** net-seller ** = "Vendre le surplus après le grain A autosuffisant" ** Agriculteur autosuffisant ** = "Complètement autosuffisant en grain A" ** net-acheteur ** = "Grains A autosuffisants et acheter la pénurie à d'autres"
Les détails sont expliqués dans "... ①", veuillez donc vérifier ici.
Description du flux de code
① Utilisez Classe pour définir 3 modèles de comportement de la ferme. (2) Utilisez la classe pour définir le marché (rôle qui contient les informations sur les prix). ③ Créez une fonction pour multiplier le prix du grain A par 1,5. Créez une fonction qui multiplie le prix des autres biens par 0,9. Créez une fonction qui augmente le prix du grain A de 1,5 fois et en même temps le prix des autres biens de 0,9 fois. ④ Faites varier le prix du grain A et les prix des autres biens comme suit. ** Remarque ** </ sup> 1-10 période: prix initial stable 11e trimestre: une augmentation de prix Période 12-20: Stabilité des prix 21e trimestre: baisse des prix des autres biens Période 22-30: Stabilité des prix 31e terme: A et autres changements de prix des marchandises Période 32-40: Stabilité des prix ⑤ Mettez le résultat dans une liste et affichez-le.
** Note ** </ sup> La raison de la longue période de stabilité est que nous prévoyons de faire fluctuer les variables non liées aux prix dans la prochaine phase de ce que nous avons fait dans ce blog.
code
Calculer les paramètres de la fonction d'utilité
- Je pense que le téléchargement des données est gênant, j'ai donc rendu possible la simulation finale même si j'ai sauté ici.
Tout d'abord, consultez «trabajos_2018.csv», «poblacion_2018.csv» et «concentradohogar_2018.csv» de l'enquête 2018 sur la consommation des ménages (ENIGH) publiée par l'Institut national mexicain de statistiques géographiques (INEGI). Mettez-le dans le répertoire que vous ouvrez actuellement. https://www.inegi.org.mx/programas/enigh/nc/2018/
Exécutez ensuite le code suivant.
#Importation de module
import numpy as np
import pandas as pd
from tqdm import tqdm_notebook as tqdm
#Estimation des paramètres utilisés dans la fonction d'utilité
#Heures de travail totales par semaine (probablement les heures de travail totales des membres adultes)
tr_ori = pd.read_csv("trabajos_2018.csv", usecols=["folioviv", "htrab"])
#Le folio viv a été dupliqué. Peut-être que différents ménages d'une même épouse sont séparés. Ajoute ça.
#Faire une boîte
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)
#Calculez la somme pour chaque folioviv unique et mettez-la dans la boîte.
vivs = tr_ori["folioviv"].unique()
vivs = vivs.tolist()
for viv in tqdm(vivs):
trr = tr_ori[tr_ori["folioviv"]==viv]
htrab = trr["htrab"].sum()
#ajouter
tr = tr.append({"folioviv":viv, "htrab":htrab}, ignore_index=True)
#Coût
"""
mayores:12 ans et plus, ing_cor:Revenu total mensuel, trabajo:Negocio, le revenu gagné en travaillant en dehors des indépendants:Revenu mensuel indépendant, vesti_calz:Coût total des vêtements,
salud:Coût total consacré au système médical, foraneo:Frais de transport outre-mer, mantenim:Système automobile, comunica:Transmission d'informations, educa_espa:Education et 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"])
#Identifiant d'état
pb = pd.read_csv("poblacion_2018.csv", usecols=["folioviv", "residencia"])
#Rejoignez DF
df = pd.merge(co, pb, on="folioviv")
df = pd.merge(df, tr, on="folioviv")
df = df[~df.duplicated()] #Pour une raison quelconque, il y avait un travail en double, j'ai donc supprimé la ligne en double
df = df[df["residencia"]!=" "] #L'état est vide pour une raison quelconque""J'ai supprimé cette ligne parce qu'elle devenait parfois
df = df[df["tam_loc"]!=1] #La zone cible est limitée à la campagne
df = df[df["tam_loc"]!=2]
#Quantité totale de consommation jugée relativement proche du divertissement
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"]
#Identifiez si vous êtes indépendant
df["self"] = (df["negocio"] > 0) * 1
#Trouvez le salaire moyen des non-indépendants
nonself = df[df["self"]==0]
wage = (nonself["trabajo"].sum() / 30) / (nonself["htrab"].sum() / 7) #Les revenus sont mensuels et les heures de travail sont hebdomadaires, alors ajustez-vous au
#Mesures par ménage, par jour et temps de loisir. Temps libre = nombre de membres adultes du ménage x 24-Heures de travail des ménages/7 -Nombre de membres adultes du ménage x heures de sommeil(6)
df["leisure"] = df["mayores"] * 24 - df["htrab"] / 7 - df["mayores"] * 6
#Calculez le revenu mensuel sacrifié en prenant du temps libre
df["opportunity"] = df["leisure"] * wage * 30
#Revenu total des autres biens de consommation et revenus sacrifiés dans les loisirs+Calculez quel pourcentage du revenu sacrifié(Moyenne générale)
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
par ça, «Salaire moyen (salaire horaire) hors ruraux et indépendants» = 75,25114451327885 "Coût d'opportunité lors des loisirs / montant total de la consommation" = 0,7171948682330835 "Consommation totale de biens non nécessaires / Consommation totale" = 0,06287930254251227 A été obtenu.
Dans cette simulation, l'utilité est représentée par un modèle quadratique, et les deux derniers obtenus en ↑ sont utilisés comme paramètres de la fonction d'utilité. Pour plus de détails, y compris le fait que cette méthode est théoriquement incorrecte, veuillez vous reporter à "... ①".
De plus, même si vous ne prenez pas la peine d'exécuter le code ci-dessus, dans le code suivant, la valeur numérique de ↑ elle-même est entrée.
Partie principale d'exécution
La plupart des variables globales définies au début sont tirées de données réelles. Veuillez vérifier "... ①" pour le type de données que vous avez utilisé.
① Agriculteur autosuffisant
↓ Correction d'un peu (j'ai oublié d'importer d'abord tqdm, alors je l'ai ajouté)
#Importation de module
from tqdm import tqdm_notebook as tqdm
from scipy.optimize import minimize
#Variable globale (4 mois en 1 cycle)
ao = 0.06 #Facteur lors de la consommation d'autres biens(0.06)
al = 0.72 #Facteur lors de la consommation de loisirs(0.72)
aoo = 0.01 #Facteur lors de la consommation uniquement d'autres biens (faible car c'est difficile car il n'y a pas de temps pour se reposer)
aLl = 0.01 #Facteur lorsque vous ne consommez que du temps libre (faible car il n'y a rien à jouer et de temps libre)
aol = 0.15 #La joie de l'utiliser uniformément
w = 75.3 #salaire(Salaire horaire)
tw = 20 #Coûts de transaction par unité lors de la vente de main-d'œuvre sur le marché du travail
ta = 5024207380 / 8324248200 / 10 #Coût de transaction lors de la vente de A (facilement fixé à 1/10 du prix)
r = 2000 * 4 #Prix du terrain (prix du terrain sur la base de la location en une somme forfaitaire pour 4 mois)
SEED = 12345 #Valeur des semences
R = 40 #Réglage du nombre de répétitions
L = (24 - 6) * 30 * 4 #Travail doté initial (heures par 4 mois)
Yield = 5024207380 / 396397.92 #Rendement unique (kg/ ha）
Equip = 1 / 52 #Taux d'équipement terrestre (ha/temps)
appe = 0.25 * 30 * 4 #Restriction de satiété (quantité à manger par 4 mois)
price0 = 5024207380 / 8324248200 #Prix de la récolte (peso/ha）
milk_meat = 130/4 + 25/4 #Dépenses alimentaires
#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.oriA = 2 #Superficie des terres possédées(ha)
self.oriL = L #Heures de travail possédées
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.profit = 0 #Profiter à l'utilité maximale
self.qa = 0 #Un volume de production à l'utilité maximale
self.LA = 0 #Ci-dessous, la quantité de chaque élément de production utilisé à l'utilité maximale
self.AA = 0
self.Ln = 0
self.An = 0
"""
Problème de maximisation de l'utilité
x = [co, La, Ln, l, Aa, An]
"""
def solveUmax(self, Market): #Produire A et B pour optimiser les profits
pA = Market.pA
po = Market.po
oriA = self.oriA
oriL = self.oriL
"""Fonction d'utilité"""
def utility(x): #Modèle secondaire
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]))
"""Contrainte de liquidité"""
def cons_liquidity(x):
return (w - tw) * x[2] + r * x[5] - po * x[0] - milk_meat
"""Contrainte de la faim"""
def appetite(x):
return Yield * Equip * x[1] - appe
"""Relation entre la superficie des terres et la main-d’œuvre en entrée"""
def labor_land(x):
return x[4] - Equip * x[1]
"""Contraintes d'élément dotées"""
def labor_cons(x):
return oriL - x[1] - x[2] - x[3]
def land_cons(x):
return oriA - x[4] - x[5]
"""Contrainte de signe de chaque variable"""
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})
#La valeur initiale est l'état dans lequel tous les éléments sont inclus dans la production d'A.
x0 = [0, oriL, 0, 0, oriA, 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP") #Commande pour résoudre le problème d'optimisation
#Que faire lorsque le résultat est négatif
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")
"""Je vais ranger le résultat calculé"""
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]
#Fin de la définition de la classe Autarky
#Marché de définition de classe
class Market:
def __init__(self):
self.pA = price0
self.po = 30
def price_A(self): #pA vaut 1.Augmentation de prix 5 fois
self.pA *= 1.5
def price_o(self): #po vaut 90%Prix réduit à
self.po *= 0.9
#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
pAlist.append(Market.pA)
polist.append(Market.po)
tlist.append(t) #temps
#② Optimiser l'utilité des agriculteurs autosuffisants
for i in range(len(a)):
a[i].solveUmax(Market)
#Calcn qui contrôle le prochain calcul lorsque pA change une fois_A()Définition des fonctions
def calcn_A(t, a, Market):
#① Changement de prix pB
Market.price_A()
#② Ajouter le prix au début de ce trimestre à la liste
pAlist.append(Market.pA) #prix
polist.append(Market.po)
tlist.append(t) #temps
#③ Optimiser l'utilité des agriculteurs
for i in range(len(a)):
a[i].solveUmax(Market)
#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
pAlist.append(Market.pA) #prix
polist.append(Market.po)
tlist.append(t) #temps
#③ Optimiser l'utilité des agriculteurs
for i in range(len(a)):
a[i].solveUmax(Market)
#Calcn qui contrôle le prochain calcul lorsque pA et po changent une fois_Ao()Définition des fonctions
def calcn_Ao(t, a, Market):
#① Modifications des prix pA et po
Market.price_A()
Market.price_o()
#② Ajouter le prix au début de ce trimestre à la liste
pAlist.append(Market.pA) #prix
polist.append(Market.po)
tlist.append(t) #temps
#③ Optimiser l'utilité des agriculteurs
for i in range(len(a)):
a[i].solveUmax(Market)
#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
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)
#Exécutif principal
#Initialisation
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 = []
ca_plistA = []
colistA = []
ClistA = []
profitlistA = []
qalistA = []
qblistA = []
LAlistA = []
AAlistA = []
AnlistA = []
LnlistA = []
llistA = []
#Liste des prix et des restes de produits
pAlist = []
polist = []
#Liste des horaires
tlist = []
#simulation
for t in tqdm(range(R)):
if t <= 10: # 1~10e trimestre: prix initial
calcn_n(t, a, Market)
calc_list(a)
if t == 11: #11e trimestre: un changement de prix
calcn_A(t, a, Market)
calc_list(a)
if (t > 11) and (t <= 20): # 12~20e terme: une stabilité après le changement de prix
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 A et o
calcn_Ao(t, a, Market)
calc_list(a)
if (t > 31) and (t <= 40): # 32~40e trimestre: A et o Stables après changement de prix
calcn_n(t, a, Market)
calc_list(a)
#Fin de la partie simulation
#Afficher la liste des variables importantes telles quelles
print("le revenu",profitlistA,"\n","\n","Une production",qalistA,"\n","\n","LA",LAlistA,"\n","\n","Ln",LnlistA,"\n","\n","l", llistA, "\n","\n",
"Une terre agricole", AAlistA, "\n","\n","Location de terres agricoles",AnlistA, "\n","\n","utilitaire",utilitylistA, "\n","\n", "o Consommation",colistA,"\n","\n","C",ClistA, "\n","\n",
"pA",pAlist,"\n","\n","po",polist)
# sell&buy.py
②net-seller (1) Modifiez la partie du code affichée par l'agriculteur autonome jusqu'à "# Définition de classe // Autarcie de classe: ~ # Fin de la définition de classe Autarcie" par le code suivant.
#Définition de classe
class Seller:
"""Définition d'une classe qui représente un agriculteur autosuffisant"""
def __init__(self, cat): #constructeur
self.category = cat
self.oriA = 2 #Superficie des terres possédées
self.oriL = L #Heures de travail possédées
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.profit = 0 #Profiter à l'utilité maximale
self.qa = 0 #Un volume de production à l'utilité maximale
self.LA = 0 #Ci-dessous, la quantité de chaque élément de production utilisé à l'utilité maximale
self.AA = 0
self.Ln = 0
self.An = 0
"""
Problème de maximisation de l'utilité
x = [co, La, Ln, l, Aa, An]
"""
def solveUmax(self, Market): #Produire A et B pour optimiser les profits
pA = Market.pA
po = Market.po
oriA = self.oriA
oriL = self.oriL
"""Fonction d'utilité"""
def utility(x): #Modèle secondaire
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]))
"""Contrainte de liquidité"""
def cons_liquidity(x):
return (pA - ta) * (Yield * Equip * x[1] - appe) - po * x[0] - (w + tw) * x[2] - r * x[5] - milk_meat
"""Contrainte de la faim"""
def appetite(x):
return Yield * Equip * x[1] - appe
"""Relation entre la superficie des terres et la main-d’œuvre en entrée"""
def labor_land(x):
return x[4] + x[5] - Equip * (x[1] + x[2])
"""Contraintes d'élément dotées"""
def labor_cons(x):
return oriL - x[1] - x[3]
def land_cons(x):
return oriA - x[4]
"""Contrainte de signe de chaque variable"""
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})
#La valeur initiale est l'état dans lequel tous les éléments sont inclus dans la production d'A.
x0 = [0, oriL, 0, 0, oriA, 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP") #Commande pour résoudre le problème d'optimisation
#Que faire lorsque le résultat est négatif
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")
#Que faire lorsque l'apport de travail devient 0 alors que l'apport de terres agricoles est assez important(Changez un peu la valeur initiale et recommencez)
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")
#Que faire lorsque le résultat est négatif 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")
"""Je vais ranger le résultat calculé"""
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]
#Fin de la définition de la classe Vendeur
Ensuite, la 4ème ligne en dessous de "# Main Execution Department"
a = [Autarky(0)]
À
a = [Seller(0)]
S'il vous plaît.
③net-buyer (1) Modifiez la partie du code affichée par l'agriculteur autonome jusqu'à "# Définition de classe // Autarcie de classe: ~ # Fin de la définition de classe Autarcie" par le code suivant.
#Définition de classe
class Buyer:
"""Définition d'une classe qui représente un agriculteur autosuffisant"""
def __init__(self, cat): #constructeur
self.category = cat
self.oriA = 2 #Superficie des terres possédées
self.oriL = L #Heures de travail possédées
self.utility = 0 #Utilité maximale (0 pour le moment)
self.co = 0 #O consommation à l'utilité maximale
self.ca = 0
self.l = 0 #Temps de loisirs à l'utilité maximale
self.C = 0 #Consommation totale à l'utilité maximale
self.profit = 0 #Profiter à l'utilité maximale
self.qa = 0 #Un volume de production à l'utilité maximale
self.LA = 0 #Ci-dessous, la quantité de chaque élément de production utilisé à l'utilité maximale
self.AA = 0
self.Ln = 0
self.An = 0
"""
Problème de maximisation de l'utilité
x = [co, La, Ln, l, Aa, An, ca]
"""
def solveUmax(self, Market): #Produire A et B pour optimiser les profits
pA = Market.pA
po = Market.po
oriA = self.oriA
oriL = self.oriL
"""Fonction d'utilité"""
def utility(x): #Modèle secondaire
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]))
"""Contrainte de liquidité"""
def cons_liquidity(x):
return (w - tw) * x[2] + r * x[5] - po * x[0] - (pA + ta) * x[6] - milk_meat
"""Contrainte de la faim"""
def appetite(x):
return Yield * Equip * x[1] + x[6] - appe
"""Relation entre la superficie des terres et la main-d’œuvre en entrée"""
def labor_land(x):
return x[4] - Equip * x[1]
"""Contraintes d'élément dotées"""
def labor_cons(x):
return oriL - x[1] - x[2] - x[3]
def land_cons(x):
return oriA - x[4] - x[5]
"""Contrainte de signe de chaque variable"""
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})
#La valeur initiale est l'état dans lequel tous les éléments sont inclus dans la production d'A.
x0 = [0, oriL, 0, 0, oriA, 0, 0]
res = minimize(utility, x0, constraints=cons, method="SLSQP") #Commande pour résoudre le problème d'optimisation
#Que faire lorsque le résultat est négatif
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")
"""Je vais ranger le résultat calculé"""
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]
#Fin de la définition de la classe Acheteur
Ensuite, la 4ème ligne en dessous de "# Main Execution Department"
a = [Autarky(0)]
À
a = [Buyer(0)]
S'il vous plaît.
résultat
L'exécution du code ci-dessus renverra à chaque fois une liste des solutions optimales pour chaque variable de sélection.
Maintenant que nous avons obtenu les résultats de la simulation, Comparons les "agriculteurs autosuffisants", les "vendeurs nets" et les "acheteurs nets" axés sur le revenu et l'utilité!
Résultat de comparaison du revenu et de l'utilité
Dans la colonne comparant les trois types d'agriculteurs pour «revenu» et «utilité» dans le tableau, la cellule avec la valeur la plus élevée dans chaque période est peinte en jaune. Ce que nous pouvons voir de ce tableau est divisé en «revenu» et «utilité».
〇 Focus sur le revenu: le vendeur net est sensible aux variations de prix
Premier, Au début, on peut voir que le revenu du vendeur net ne représente qu'environ un sixième de celui des deux autres types d'agriculteurs. Le prix initial est un bon reflet de la réalité, donc ce que montre ce résultat est "Un seul agriculteur qui cultive du maïs fourrager sur 2 ha de terres agricoles gagnera six fois plus s'il abandonne l'agriculture." En fait, l'agriculteur qui possède environ 2 ha de terres agricoles fait aussi des cultures commerciales, donc la situation est un peu meilleure, mais vous pouvez voir à quel point la situation de l'agriculteur est mauvaise. En effet, il y a de nombreux agriculteurs abandonnés.
prochain, Si vous regardez le «revenu», vous pouvez voir que la valeur du vendeur net augmente. Lorsque le prix a augmenté de 1,5 fois, le revenu a augmenté de plus de 10 fois. En fait, dans ce contexte, les vendeurs en réseau réduisent régulièrement leur temps de «loisir» et le consacrent à la culture du grain A. Le prix des produits agricoles a augmenté, vous avez donc fait votre travail. Par conséquent, il a été constaté que les agriculteurs qui participent au marché en tant que vendeurs de produits agricoles sont sensibles aux prix des produits agricoles.
C'est un résultat naturel, mais si un vendeur net peut être transformé en un "agriculteur autosuffisant" ou un "acheteur net", cet agriculteur voudrait-il continuer à être un "vendeur net" vulnérable aux fluctuations de prix? Le fait que le vendeur net soit trop sensible aux variations de prix peut également être un membre de l'agriculture.
〇 Focus sur l'utilité: l'acheteur net est le plus efficace
Tout d'abord, j'expliquerai pourquoi les avantages (et les revenus) des agriculteurs autosuffisants et de l'acheteur net sont presque les mêmes. Cela montre qu'il est très facile de se suffire à soi-même en grain A. Bien que non répertoriées dans le tableau, les terres agricoles allouées par les agriculteurs autosuffisants à la culture du grain A étaient de 0,0023 ha = 0,23a = 23m ^ 2. Le temps passé était de 0,12 heure = 7,2 minutes. Puisque nous avons supposé ici le maïs fourrager, il est possible qu'il soit produit à une plus grande échelle que le maïs que les humains mangent en utilisant des machines à grande échelle. De plus, je ne sais pas si la même situation se reproduira dans la situation où une personne produit suffisamment de maïs pour être autonome. Cependant, dans tous les cas, on peut dire que la culture du maïs est assez facile. L'avantage de la culture du riz au Japon est qu'elle peut être cultivée en peu de temps, on dit donc qu'elle convient aux travaux secondaires.
Ensuite, si vous comparez le prochain vendeur net au milieu avec d'autres agriculteurs, vous remarquerez un fait pitoyable. Le revenu du vendeur net est trois fois supérieur à celui des autres agriculteurs, mais les avantages sont presque les mêmes. Cela suggère que le vendeur en ligne est surchargé de travail et dispose de très peu de temps libre.
Dans tous les cas, pour que le vendeur net dans ce monde soit aussi efficace que les autres agriculteurs, le prix initial du grain A devrait être multiplié par 1,5. Il s'avère que nous devons réduire notre temps libre et tripler nos revenus.
à la fin
Donc, cette fois, j'ai vérifié le code et le résultat de la simulation de l'économie agricole. À partir des résultats de la simulation, vous pouvez voir à quel point le vendeur en ligne est pitoyable (rires).
Comme tâche future, je voudrais essayer d'ajuster un peu plus les paramètres et réaliser les réglages initiaux qui sont proches de la réalité. D'une manière ou d'une autre, j'ai l'impression que les salaires sont trop élevés.
Après cela, j'examinerai s'il est possible d'incorporer la culture composée et une subvention versée d'un montant fixe par superficie plantée. Après cela, je vais enfin commencer à faire des simulations multi-agents.
À l'heure actuelle, la réponse (code) n'est pas visible, mais lorsque de nombreux agriculteurs font un jeu qui se déplace dans le même champ, le point d'atterrissage = prix et contrat dans l'échange entre chaque agriculteur est égalé. Les prix et les contrats devraient être déterminés par la demande = l'offre, le gain de A = le gain de B, mais quel type de code faut-il écrire pour faire un tel mouvement?
Eh bien, pour le moment, je vais essayer de faire comme ça. Merci à tous ceux qui ont lu jusqu'ici!
Recommended Posts