Ingrese al experimento.
Decidí durante el fin de semana mostrar, no decir. Quería que Skip experimentara la nueva tecnología por sí mismo, no solo que me escuchara hablar sobre ella. ¿Y si pudiéramos hacer un plan de negocio para poner en marcha una hipotética nueva granja en menos de 40 minutos? Podría hacerlo usando un ChatGPT 4 con el Análisis de datos avanzado habilitado, compartiendo la pantalla con su iPhone; colaboraríamos juntos para construirlo.
Discutimos brevemente nuestras suposiciones:
- Tenemos 1,000 acres para cultivar en el este de Texas
- Tenemos $1 millón en capital inicial para comprar equipos con
- Necesitamos obtener una línea de crédito de un banco sobre los gastos operativos del año 1 para comenzar.
- Estamos interesados en cultivar trigo y soja (lo que Skip realmente cultivaba en su día)
Empezamos simple:
Pregunta 1: “Escríbame un esbozo de un plan de negocios para iniciar una nueva granja en el este de Texas para cultivar trigo y soja”.
Skip quedó inmediatamente impresionado con los resultados en formato largo. Pero espera, apenas estábamos comenzando…
Pregunta 2: “Dame una lista del equipo que necesito para comenzar”
Pregunta 3: “Ponlo en una tabla y priorízalo numéricamente según lo que se necesita con mayor urgencia y lo que es menos urgente”
Pregunta 4: “Ahora cree una nueva columna para la asignación de presupuesto. Suponga que voy a utilizar una combinación de arrendamientos y compras, cree una columna adicional para recomendar arrendamiento versus compra, suponga que tengo $1 millón en capital inicial”.
(Tiempo transcurrido 4 minutos)
Resultado:
Pregunta 5: “¿Cuánto debo apartar para pedir una línea de crédito de costo variable (semilla, fertilizante, mano de obra, etc.), supongamos 1000 hectáreas? Crea una nueva tabla”.
Resultado:
En ese punto, sentí como si Skip acabara de presenciar el Apolo 11 una vez más. Apenas pudo contener su emoción. Pero todavía no habíamos terminado…
Pregunta 6: “Escríbame una simulación de Monte Carlo en la que pueda ajustar mis suposiciones de entrada y probar el resultado en mi presupuesto”
Resultados:
import numpy as np
import matplotlib.pyplot as plt# Define number of simulations
n_simulations = 10000
# Assumptions with [mean, std deviation]
wheat_seed_cost = [20, 2] # Cost per acre
soybean_seed_cost = [50, 5]
fertilizer_wheat_cost = [50, 5]
fertilizer_soybean_cost = [40, 4]
labor_cost = [25, 3]
pesticide_cost = [30, 3]
fuel_maintenance_cost = [15, 2]
miscellaneous_cost = [10, 1]
def simulate_farm_costs():
wheat_seed = np.random.normal(wheat_seed_cost[0], wheat_seed_cost[1])
soybean_seed = np.random.normal(soybean_seed_cost[0], soybean_seed_cost[1])
fertilizer_wheat = np.random.normal(fertilizer_wheat_cost[0], fertilizer_wheat_cost[1])
fertilizer_soybean = np.random.normal(fertilizer_soybean_cost[0], fertilizer_soybean_cost[1])
labor = np.random.normal(labor_cost[0], labor_cost[1])
pesticide = np.random.normal(pesticide_cost[0], pesticide_cost[1])
fuel_maintenance = np.random.normal(fuel_maintenance_cost[0], fuel_maintenance_cost[1])
miscellaneous = np.random.normal(miscellaneous_cost[0], miscellaneous_cost[1])
total_cost = (wheat_seed + soybean_seed + fertilizer_wheat + fertilizer_soybean +
labor + pesticide + fuel_maintenance + miscellaneous) * 1000 # for 1000 acres
return total_cost
results = [simulate_farm_costs() for _ in range(n_simulations)]
# Visualization
plt.hist(results, bins=50, edgecolor='black', alpha=0.7)
plt.title('Distribution of Total Farm Costs')
plt.xlabel('Total Cost')
plt.ylabel('Frequency')
plt.grid(True, alpha=0.2)
plt.show()
Ahora, llega el momento de la verdad: ¿se ejecutará el código? Saltamos al cuaderno Jupyter para ejecutar el código. Y ahí está al primer intento:
En este punto, solo llevábamos entre 10 y 15 minutos. Todavía tenemos algo de tiempo de sobra… ¿Podríamos hacerlo interactivo?
Necesitamos crear una lista de parámetros que permitan al usuario ajustar dinámicamente las suposiciones en un control deslizante. Nuevamente utilizamos ChatGPT para obtener algunas recomendaciones sobre cuáles deben ser esos parámetros en función del Monte Carlo que construimos anteriormente:
Una vez que tenemos nuestra lista de parámetros creada, creamos una tabla de ‘medidas’ en Power BI vinculada a 16 elementos visuales de segmentación que permiten al usuario seleccionar manualmente sus entradas y actualizar dinámicamente la simulación de Monte Carlo. Para hacer esto, creamos un ‘Python Visual’ en Power BI, arrastramos todas nuestras medidas y luego actualizamos el código de la siguiente manera:
# The following code to create a dataframe and remove duplicated rows is always executed and acts as a preamble for your script: # dataset = pandas.DataFrame(fertilizer_soybean_cost_avg Value, fertilizer_soybean_cost_std Value, fertilizer_wheat_cost_avg Value, fertilizer_wheat_cost_std Value, fuel_maintenance_cost_avg Value, fuel_maintenance_cost_std Value, labor_cost_avg Value, labor_cost_std Value, miscellaneous_cost_avg Value, miscellaneous_cost_std Value, pesticide_cost_avg Value, pesticide_cost_std Value, soybean_seed_cost_avg Value, wheat_seed_cost_avg Value, wheat_seed_cost_std Value)
# dataset = dataset.drop_duplicates()
# Paste or type your script code here:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Assuming the data from Power BI is passed as 'dataset'
df = dataset
# Fetch values from the dataset
wheat_seed_cost_avg = df['wheat_seed_cost_avg Value'].iloc[0]
wheat_seed_cost_std = df['wheat_seed_cost_std Value'].iloc[0]
soybean_seed_cost_avg = df['soybean_seed_cost_avg Value'].iloc[0]
soybean_seed_cost_std = df['soybean_seed_cost_std Value'].iloc[0]
fertilizer_wheat_cost_avg = df['fertilizer_wheat_cost_avg Value'].iloc[0]
fertilizer_wheat_cost_std = df['fertilizer_wheat_cost_std Value'].iloc[0]
fertilizer_soybean_cost_avg = df['fertilizer_soybean_cost_avg Value'].iloc[0]
fertilizer_soybean_cost_std = df['fertilizer_soybean_cost_std Value'].iloc[0]
labor_cost_avg = df['labor_cost_avg Value'].iloc[0]
labor_cost_std = df['labor_cost_std Value'].iloc[0]
pesticide_cost_avg = df['pesticide_cost_avg Value'].iloc[0]
pesticide_cost_std = df['pesticide_cost_std Value'].iloc[0]
fuel_maintenance_cost_avg = df['fuel_maintenance_cost_avg Value'].iloc[0]
fuel_maintenance_cost_std = df['fuel_maintenance_cost_std Value'].iloc[0]
miscellaneous_cost_avg = df['miscellaneous_cost_avg Value'].iloc[0]
miscellaneous_cost_std = df['miscellaneous_cost_std Value'].iloc[0]
# Define number of simulations
n_simulations = 10000
# Assumptions with [mean, std deviation]
wheat_seed_cost = [wheat_seed_cost_avg, wheat_seed_cost_std]
soybean_seed_cost = [soybean_seed_cost_avg, soybean_seed_cost_std]
fertilizer_wheat_cost = [fertilizer_wheat_cost_avg, fertilizer_wheat_cost_std]
fertilizer_soybean_cost = [fertilizer_soybean_cost_avg, fertilizer_soybean_cost_std]
labor_cost = [labor_cost_avg, labor_cost_std]
pesticide_cost = [pesticide_cost_avg, pesticide_cost_std]
fuel_maintenance_cost = [fuel_maintenance_cost_avg, fuel_maintenance_cost_std]
miscellaneous_cost = [miscellaneous_cost_avg, miscellaneous_cost_std]
def simulate_farm_costs():
wheat_seed = np.random.normal(wheat_seed_cost[0], wheat_seed_cost[1])
soybean_seed = np.random.normal(soybean_seed_cost[0], soybean_seed_cost[1])
fertilizer_wheat = np.random.normal(fertilizer_wheat_cost[0], fertilizer_wheat_cost[1])
fertilizer_soybean = np.random.normal(fertilizer_soybean_cost[0], fertilizer_soybean_cost[1])
labor = np.random.normal(labor_cost[0], labor_cost[1])
pesticide = np.random.normal(pesticide_cost[0], pesticide_cost[1])
fuel_maintenance = np.random.normal(fuel_maintenance_cost[0], fuel_maintenance_cost[1])
miscellaneous = np.random.normal(miscellaneous_cost[0], miscellaneous_cost[1])
total_cost = (wheat_seed + soybean_seed + fertilizer_wheat + fertilizer_soybean +
labor + pesticide + fuel_maintenance + miscellaneous) * 1000 # for 1000 acres
return total_cost
results = [simulate_farm_costs() for _ in range(n_simulations)]
# Convert results into a dataframe
df_simulated_results = pd.DataFrame(results, columns=['Total Cost'])
# Calculate the Interquartile Range (IQR)
Q1 = df_simulated_results['Total Cost'].quantile(0.25)
Q3 = df_simulated_results['Total Cost'].quantile(0.75)
# Plotting the histogram
plt.figure(figsize=(10, 6))
n, bins, patches = plt.hist(df_simulated_results['Total Cost'], bins=50, color='blue', edgecolor='black', alpha=0.7)
plt.title('Distribution of Year 1 Variable Farm Costs from Simulation')
plt.xlabel('Year 1 Variable Cost')
plt.ylabel('Frequency')
plt.grid(True, which='both', linestyle='--', linewidth=0.5)
# Shade the IQR
for i in range(len(bins)):
if bins[i] > Q1 and bins[i] < Q3:
patches[i].set_facecolor('green')
plt.axvline(Q1, color='red', linestyle='dashed', linewidth=1)
plt.axvline(Q3, color='red', linestyle='dashed', linewidth=1)
plt.tight_layout()
plt.savefig('simulated_costs_histogram.png') # This will save the figure as an image file
plt.show()
Solo por diversión, solicitamos a ChatGPT que defina el rango intercuartil (IQR) y lo sombree con un color diferente; también actualizamos manualmente las etiquetas del gráfico y el eje x. El resto es simplemente limpiar un poco los elementos visuales en Power BI para hacerlo un poco más fácil de usar. El final resulto:
Ahora tenemos una simulación dinámica de Monte Carlo para jugar con diferentes supuestos de costos de insumos y proyectar el gasto operativo variable que necesitaríamos para que nuestra operación agrícola despegue. Aprovechando ChatGPT 4, prácticamente no escribimos código, solo lo modificamos un poco, hicimos la mayor parte del trabajo desde un iPhone a través de pantalla compartida, creamos la última pieza en el escritorio de PBI y la pantalla la compartimos a través de la aplicación de iPhone de PBI. Todo en unos 30-40 minutos de trabajo.
¿El veredicto de mi abuelo? “Logramos en 40 minutos lo que a él le habría llevado 2 años hacer por su cuenta en el pasado”. Sí, reconozco que hay mucho más. podríamos hacer – y su “simulación” está lejos de ser perfecta. (Por ejemplo, no delimitamos entre el porcentaje de cultivos dedicados a la soja y el trigo). ¿Pero durante 40 minutos? Incluso yo quedé impresionado. Y esta es la promesa de la Generación AI: democratizar la ciencia de datos, fomentar la experimentación y acelerar la capacidad de desarrollarlo, todo al alcance de la mano. Permitir que un abuelo y su nieto tengan la oportunidad de reconectarse a través de algunas estadísticas y aprovechar la tecnología de maneras nuevas e inesperadas.