Morocco Population Age Pyramid Forecast

Project Overview

This project analyzes and forecasts Morocco's demographic evolution by predicting age-specific population distributions over time. Using historical census data from Morocco's High Commission for Planning (HCP) and time series forecasting techniques, we predict how the country's age pyramid will transform in the coming decades, providing insights for policy planning and resource allocation.

What is an Age Pyramid?

An age pyramid (or population pyramid) is a graphical representation that displays the age and sex distribution of a population. The structure is typically shown with males on the left side and females on the right, with age groups stacked vertically from youngest (bottom) to oldest (top). The shape of the pyramid reveals crucial demographic characteristics and the stage of demographic transition a country is experiencing.

Data Source and Structure

The data is sourced from Morocco's High Commission for Planning (HCP), which conducts regular national censuses and demographic surveys. The dataset includes population counts broken down by:

Forecasting Methodology

Time series forecasting models are applied to predict future population distributions. The methodology involves several statistical techniques including exponential smoothing, ARIMA models, and trend analysis to capture both short-term fluctuations and long-term demographic trends.

Implementation Steps

1. Data Loading and Preprocessing — Import census data, handle missing values, and structure the dataset by age groups and time periods
2. Exploratory Data Analysis — Visualize historical trends, identify patterns, and analyze demographic shifts over time
3. Model Selection and Training — Test multiple time series models, evaluate performance metrics, and select the best-fitting model for each age group
4. Forecast Generation — Generate predictions for future years with confidence intervals to quantify uncertainty
5. Pyramid Visualization — Create animated age pyramids showing the demographic evolution from historical data through forecasted years
6. Validation and Interpretation — Validate forecasts against holdout data and interpret results in the context of demographic policy

Code Implementation

Below are the key implementation steps for forecasting Morocco's population structure:

Step 1: Data Loading and Preparation

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Load population data
data = pd.read_csv('morocco_population.csv')

# Pivot for age pyramid format
pyramid_data = data.pivot(
    index='age_group',
    columns='gender',
    values='population'
)

# Calculate percentages
total_population = pyramid_data.sum().sum()
pyramid_data = pyramid_data / total_population * 100

print(pyramid_data.head())

Step 2: Age Pyramid Visualization

def plot_age_pyramid(data, year, title='Morocco Population Pyramid'):
    """
    Plot a population pyramid for a given year.

    Args:
        data: DataFrame with age groups as index, Male/Female as columns
        year: Year of the data
        title: Plot title
    """
    fig, ax = plt.subplots(figsize=(10, 8))

    age_groups = data.index
    y_pos = np.arange(len(age_groups))

    # Males on left (negative values), females on right (positive)
    ax.barh(y_pos, -data['Male'], color='steelblue', label='Male')
    ax.barh(y_pos, data['Female'], color='salmon', label='Female')

    ax.set_yticks(y_pos)
    ax.set_yticklabels(age_groups)
    ax.set_xlabel('Population (%)')
    ax.set_title(f'{title} - {year}')
    ax.legend()

    # Center the x-axis at zero
    max_val = max(data['Male'].max(), data['Female'].max())
    ax.set_xlim(-max_val * 1.1, max_val * 1.1)

    plt.tight_layout()
    return fig

# Plot current pyramid
plot_age_pyramid(pyramid_data, 2024)
plt.show()

Step 3: Time Series Forecasting

from statsmodels.tsa.holtwinters import ExponentialSmoothing
from statsmodels.tsa.arima.model import ARIMA

def forecast_age_group(time_series, periods=10, method='exponential'):
    """
    Forecast population for a specific age group.

    Args:
        time_series: Historical population data for the age group
        periods: Number of future periods to forecast
        method: Forecasting method ('exponential', 'arima')

    Returns:
        Forecasted values
    """
    if method == 'exponential':
        model = ExponentialSmoothing(
            time_series,
            seasonal_periods=None,
            trend='add',
            seasonal=None
        )
        fitted_model = model.fit()
        forecast = fitted_model.forecast(periods)

    elif method == 'arima':
        model = ARIMA(time_series, order=(1, 1, 1))
        fitted_model = model.fit()
        forecast = fitted_model.forecast(steps=periods)

    return forecast

# Forecast each age group for next 20 years
forecasts = {}
for age_group in data['age_group'].unique():
    group_data = data[data['age_group'] == age_group]['population']
    forecasts[age_group] = forecast_age_group(group_data, periods=20)

# Combine forecasts into future pyramid structure
future_pyramid = pd.DataFrame(forecasts)

Step 4: Animated Pyramid Evolution

from matplotlib.animation import FuncAnimation
from IPython.display import HTML

def animate_pyramid_evolution(historical, forecasted, years):
    """
    Create an animated visualization showing demographic transition.

    Args:
        historical: Historical pyramid data
        forecasted: Forecasted pyramid data
        years: List of years to animate

    Returns:
        Animation object
    """
    fig, ax = plt.subplots(figsize=(10, 8))

    def update_frame(frame):
        ax.clear()
        year = years[frame]

        if frame < len(historical):
            data = historical[frame]
            ax.set_facecolor('#f0f7ff')
        else:
            data = forecasted[frame - len(historical)]
            ax.set_facecolor('#fff5f0')

        plot_pyramid(ax, data, year)
        return ax

    animation = FuncAnimation(
        fig,
        update_frame,
        frames=len(years),
        interval=500,
        repeat=True
    )

    return animation

# Generate animation from 2000 to 2050
years = range(2000, 2051)
anim = animate_pyramid_evolution(historical_data, forecast_data, years)

# Display in notebook
HTML(anim.to_html5_video())

Key Demographic Findings

Policy Applications

Understanding and forecasting demographic evolution provides critical insights for strategic planning across multiple sectors:

Model Performance Metrics