A while back I got curious about whether I could predict where an asset’s price might head next — nothing fancy, just me poking around with some free tools on a weekend. I’m not a data scientist, I don’t have a finance background, and I definitely don’t have some secret trading edge. What I do have is Google Colab, a free API for pulling price data, and a forecasting library that does most of the heavy lifting for me.

This post is basically my notes turned into something readable. I’m walking through exactly what I ran, in order, with the actual code and a plain-English explanation of what each part is doing and why. If you’ve ever wanted to try this yourself but felt like every tutorial out there assumes you already know what you’re doing — this one doesn’t. I figured it out by doing it, and you can too.

What you’ll need to follow along

Everything here runs in Google Colab, which is free and needs zero setup on your end — no installing Python, no fighting with environments. You just open a notebook in your browser and run cells.

The main tools involved:

yfinance — pulls historical price data (stocks, crypto, commodities, whatever has a ticker) straight from Yahoo Finance, for free
pandas — for wrangling the data into shape
Prophet (by Facebook/Meta) — the actual forecasting model. It’s built to be approachable even if you’ve never trained a model before
matplotlib — for plotting so you can actually see what’s going on

I split the work into two separate notebooks, and I’d honestly recommend doing the same if you try this. One notebook just collects and cleans the data. The other one loads that data and does the forecasting. Keeping them separate meant I could re-run the forecasting side over and over without re-downloading data every time, and it just kept things less messy in my head.

Step one: get the data before you even think about forecasting

This part matters more than it sounds. It’s tempting to jump straight to the “cool” part — training a model — but if the data underneath it is messy, missing chunks, or in the wrong shape, nothing downstream is going to work right. So the first notebook is entirely dedicated to pulling clean historical price data and saving it as a CSV I can reuse later.

I picked gold futures for this one, but the whole thing is written so you can swap in basically any ticker — a stock, Bitcoin, whatever you’re curious about.

Here’s notebook one, historical_asset_prices.ipynb, cell by cell.

1. Installing and importing what we need

!pip install yfinance --quiet

import yfinance as yf
import pandas as pd
from datetime import datetime
from google.colab import files

Just getting the tools in place. yfinance is the star here — it’s what actually talks to Yahoo Finance and pulls the price history. The google.colab.files import is so I can download the finished CSV straight to my computer at the end.

2. Setting the variables I actually care about

ASSET_NAME = "gold"
TICKER = "GC=F"
START_DATE = "2010-01-01"
END_DATE = datetime.today().strftime("%Y-%m-%d")
INTERVAL = "1d"

I like keeping all the “stuff I might want to change” at the top in one place instead of buried in code somewhere. GC=F is the ticker for gold futures — if you want a different asset, this is the only line you really need to touch. END_DATE just grabs today’s date automatically so I don’t have to remember to update it every time I run this.

3. A function to fetch and clean the price history

def fetch_price_history(ticker: str, start: str, end: str, interval: str = "1d") -> pd.DataFrame:
    """
    Downloads historical OHLCV data for any ticker via yfinance.
    Reusable for gold, BTC, stocks, etc. — just pass a different ticker.
    """
    df = yf.download(ticker, start=start, end=end, interval=interval,
                      progress=False, auto_adjust=False)

    if df.empty:
        raise ValueError(f"No data returned for ticker '{ticker}'. Check the symbol or date range.")

    # yfinance sometimes returns MultiIndex columns like ('Close', 'GC=F')
    # even for a single ticker — flatten to just the first level.
    if isinstance(df.columns, pd.MultiIndex):
        df.columns = df.columns.get_level_values(0)

    df = df.reset_index()
    df.columns = [str(c).replace(" ", "_") for c in df.columns]  # clean column names
    return df

I wrapped this in a function because I knew I’d want to reuse it for other tickers later, not just gold. A couple of things I ran into and had to handle: yfinance will sometimes hand back columns in a weird nested format even when you only asked for one ticker, so there’s a bit of code to flatten that out. I also added a check that throws a clear error if nothing comes back at all — better than getting a confusing crash three cells later.

4. Actually pulling the data

data = fetch_price_history(TICKER, START_DATE, END_DATE, INTERVAL)

print(f"Rows: {len(data)}")
print(f"Date range: {data['Date'].min()} → {data['Date'].max()}")
data.head()

This is the moment it either works or it doesn’t. I always print the row count and date range right after downloading — it’s a quick sanity check that I got what I expected (over a decade of daily gold prices, in this case) before moving on.

5. Cleaning it up

# Drop any rows with missing values, sort chronologically, reset index
data = data.dropna().sort_values("Date").reset_index(drop=True)

# Keep the columns most forecasting workflows use: Date + OHLCV
keep_cols = [c for c in ["Date", "Open", "High", "Low", "Close", "Adj_Close", "Volume"] if c in data.columns]
data = data[keep_cols]

data.info()

Nothing dramatic here — dropping any rows with gaps, making sure everything’s sorted by date (yfinance usually gives you this already, but I don’t like assuming), and trimming down to just the columns I’ll actually use. data.info() at the end is just me double-checking the data types look right before I save anything.

6. Saving it and downloading the CSV

filename = f"{ASSET_NAME}_price_history_{START_DATE}_to_{END_DATE}.csv"
data.to_csv(filename, index=False)

print(f"Saved: {filename}")
files.download(filename)

Last step of notebook one — save it as a CSV with a filename that tells me exactly what’s in it, and download it to my machine. This is the file I’ll upload into the second notebook.

Step two: the actual forecasting

Okay, now the part I was actually curious about. Notebook two, forecasting_with_facebook_prophet.ipynb, picks up with the CSV from the first notebook and runs it through Prophet, which is a forecasting library that’s genuinely pretty forgiving for someone who isn’t a machine learning person. It handles a lot of the tricky stuff (seasonality, trend changes) without you needing to know the math behind it.

1. Installing and importing

!pip install prophet --quiet

import pandas as pd
import matplotlib.pyplot as plt
from prophet import Prophet
from sklearn.metrics import mean_absolute_error, mean_squared_error
import numpy as np
from google.colab import files

Same idea as before — getting Prophet, plus a couple of metrics from scikit-learn so I can actually check later how far off the forecast was.

2. Uploading the CSV from notebook one

uploaded = files.upload()
filename = list(uploaded.keys())[0]
print(f"Loaded: {filename}")

This pops up a little file picker right in Colab. I just select the CSV I downloaded at the end of the first notebook.

3. A few settings up top

DATE_COL = "Date"
TARGET_COL = "Close"
FORECAST_DAYS = 30
TEST_DAYS = 30

Same idea as before — keeping the knobs I might want to turn in one visible spot. TARGET_COL is what I’m actually trying to forecast (closing price), and TEST_DAYS controls how much recent data I hold back to check the model’s accuracy against, before asking it to predict the real future.

4. Getting the data into the shape Prophet wants

df = pd.read_csv(filename)
df[DATE_COL] = pd.to_datetime(df[DATE_COL])
df = df.sort_values(DATE_COL).reset_index(drop=True)

# Prophet requires exactly two columns: 'ds' (date) and 'y' (target value)
prophet_df = df[[DATE_COL, TARGET_COL]].rename(columns={DATE_COL: "ds", TARGET_COL: "y"})
prophet_df = prophet_df.dropna()

print(prophet_df.shape)
prophet_df.tail()

Prophet is picky about one thing: it wants exactly two columns, named ds for the date and y for the value you’re predicting. Nothing else. So this cell is just renaming and trimming down to that shape.

5. Splitting into train and test

train_df = prophet_df.iloc[:-TEST_DAYS]
test_df = prophet_df.iloc[-TEST_DAYS:]

print(f"Train: {len(train_df)} rows, up to {train_df['ds'].max().date()}")
print(f"Test:  {len(test_df)} rows, {test_df['ds'].min().date()} → {test_df['ds'].max().date()}")

This was one of those “oh, that’s smart” moments for me when I first learned it. Instead of feeding the model every day of data and just trusting it, I hold back the most recent TEST_DAYS (30, in this case) and don’t let the model see them during training. That way, once it makes its predictions, I can actually compare them against what really happened.

6. Training the model

model = Prophet(
    daily_seasonality=False,
    weekly_seasonality=True,
    yearly_seasonality=True,
    changepoint_prior_scale=0.1  # controls flexibility of the trend line
)
model.fit(train_df)

This is the “training” step — Prophet looks at the historical data and learns the patterns (weekly rhythms, yearly cycles, overall trend). changepoint_prior_scale is a setting I honestly just experimented with — turn it up and the model bends more eagerly to recent trend shifts, turn it down and it stays steadier. 0.1 worked reasonably well for me, but I’d encourage playing with it.

7. Making the forecast

future = model.make_future_dataframe(periods=TEST_DAYS + FORECAST_DAYS)
forecast = model.predict(future)

forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail()

Here’s where it actually predicts. I ask for enough future days to cover both the test period (so I can check accuracy) and an extra stretch beyond that (the real, unseen future). yhat is the predicted value, and yhat_lower / yhat_upper give you a confidence range — which is a good reminder that this is a probability, not a promise.

8. Checking how accurate it actually was

merged = test_df.merge(forecast[["ds", "yhat"]], on="ds", how="left")

mae = mean_absolute_error(merged["y"], merged["yhat"])
rmse = np.sqrt(mean_squared_error(merged["y"], merged["yhat"]))
mape = (abs(merged["y"] - merged["yhat"]) / merged["y"]).mean() * 100

print(f"MAE:  {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"MAPE: {mape:.2f}%")

This is the reality-check cell. I compare the model’s predictions for those held-out test days against what actually happened, using a few standard error metrics. Honestly you don’t need to memorize what each one means mathematically — MAPE is the easiest to read since it’s just “on average, how many percent off was the forecast,” which is a pretty intuitive number to judge.

9. Plotting actual vs. forecast

fig, ax = plt.subplots(figsize=(14, 6))

ax.plot(prophet_df["ds"], prophet_df["y"], label="Actual", color="black", linewidth=1)
ax.plot(forecast["ds"], forecast["yhat"], label="Forecast", color="blue", linewidth=1)
ax.fill_between(forecast["ds"], forecast["yhat_lower"], forecast["yhat_upper"],
                 color="blue", alpha=0.15, label="Confidence interval")

ax.axvline(train_df["ds"].max(), color="red", linestyle="--", label="Train/Test split")
ax.set_title("Price Forecast vs Actual")
ax.set_xlabel("Date")
ax.set_ylabel("Price")
ax.legend()
plt.tight_layout()
plt.show()

This is honestly my favorite part — seeing it laid out visually just makes everything click in a way the numbers alone don’t. The black line is what really happened, the blue line is the forecast, the shaded area is the confidence range, and the red dashed line marks where training stopped and the model had to start predicting blind.

10. Peeking at the components

fig2 = model.plot_components(forecast)
plt.show()

One last thing Prophet gives you for free — a breakdown of the overall trend plus the weekly and yearly patterns it picked up on separately. I found this genuinely interesting even outside the forecasting itself, just as a way of seeing what rhythms the price actually follows.

Wrapping up

So that’s the whole thing, start to finish — pulling clean historical data in one notebook, then feeding it into Prophet in a second notebook to train, forecast, and sanity-check the results. None of it required me to understand the underlying math, and none of it cost anything beyond a bit of my Saturday.

I’m not claiming this makes me — or you — able to predict where gold, or anything else, is actually headed. Markets are messy and this is a fairly simple model. But as a way to actually get hands-on with forecasting and see a real result come out the other end, it was a genuinely fun rabbit hole.

If you’ve been curious about this kind of thing too, I’d honestly say just open a Colab notebook and try it with a ticker you’re interested in — swap in your own asset, mess with the settings, see what happens. Fingers crossed it goes well for you. Good luck, and happy forecasting! 🤞

Forecasting Gold Prices with Machine Learning

Table of contents

Table of contents