B5G Network Planning Algorithms

Research software developed by Brianna Laird as part of the Bachelor of Cyber Security (Honours) program at Deakin University.

Code Repository

This repository contains the complete codebase for my Honours year project, based on research into cost-effective deployment and optimisation of next-generation (B5G/6G) reconfigurable RAN and optical X-haul networks. It includes implementations, datasets, and utilities for generating, analysing, and optimising network configurations.

Algorithms provided:

• Greedy Algorithm: Fast, heuristic-based solutions for initial network configurations.
• Graph Encoded Genetic Algorithm with Steiner Mutations (GEGASM): Evolutionary optimisation for exploring larger solution spaces, exploiting Steiner tree properties for efficient solution generation.
• Graph Encoded Genetic Algorithm (GEGA): Similar to GEGASM but without Steiner mutations, providing a more traditional genetic algorithm approach for comparison.
• Binary-encoded Genetic Algorithm (BEGA): An alternative genetic algorithm approach using binary encoding based on the MILP.
• Local Search: Iterative improvement for refining solutions.
• CPLEX Models: Exact mathematical programming approaches, including shortest-path and full graph optimisation.

Helper scripts are included for preprocessing data, running batch experiments, and analysing results.

The project explores deployment strategies for next-generation (B5G/6G) reconfigurable RAN and optical X-haul networks, balancing cost, scalability, and performance.

---

Associated Research Papers:

• Optical X-haul for Beyond 5G: Cost-effective Deployment Strategies
  Presented at the Optical Fiber Communication Conference (OFC) 2025.
  Focus: CPLEX shortest path model for efficient X-haul deployment.

• Cost Optimal Network Planning for Converged Optical X-haul in Beyond 5G Networks
  Published in the Journal of Optical Communications and Networking (JOCN).
  Focus: CPLEX full graph model with Steiner tree post-processing for optimal network design.

• Genetic Algorithm for Multi-layered Location-Allocation-Routing Problems in Network Planning
  Submitted to European Journal of Operations Research (under review).
  Focus: Establishes the Steiner tree theorem and demonstrates the genetic algorithm as a scalable alternative to CPLEX for large datasets.

Deakin Mathematics Yearbook Report:

• A cost effective framework fo the design and deployment of B5G in rural Australia - published in the Deakin Mathematics Yearbook 2024.

---

Citation

If you use this repository, datasets, or implementations in academic work, please cite this repository.

GitHub provides a built-in "Cite this repository" option via the repository sidebar.

BibTeX

@software{Laird_B5G_Network_Planning_2025,
author = {Laird, Brianna and Ranaweera, Chathurika and Ugon, Julien},
license = {GPL-3.0},
month = sep,
title = {{B5G Network Planning Algorithms}},
url = {https://github.com/breezy-codes/B5G-network-planning-algorithms},
version = {1.0.0},
year = {2025}
}

---

Repository Structure

The project is organised into modular components. Below is the folder layout, along with a description of each directory:

📂 Repository/

• 📁 code/ — Core source code

  • 📁 logs/ — Experiment logs
  • 📁 modules/ — Shared modules & utilities
    • 📁 algorithms/ — Algorithm-specific helpers
    • 📁 data-classes/ — Custom dataclasses for components
    • 📄 README.md — Guide to the modules and algorithms
  • 📁 results/ — Results from algorithm & CPLEX runs
  • 🐍 CPLEX_graph_model.py — CPLEX full graph model implementation
  • 🐍 CPLEX_shortest_path.py — CPLEX shortest-path model implementation
  • 🐍 GEGASM.py — Graph-Encoded Genetic algorithm with Steiner Mutations implementation
  • 🐍 GEGA.py — Graph-Encoded Genetic algorithm implementation
  • 🐍 BEGA.py — Binary-encoded Genetic Algorithm implementation
  • 📓 greedy_solution_generator.ipynb — Greedy algorithm implementation notebook
  • 🐍 local_search.py — Local search algorithm implementation
  • 📄 README.md — Guide to running algorithms

• 📁 dataset/ — Input datasets

  • 📁 full-dataset/ — Large-scale experiments
  • 📁 small-dataset/ — Debug & quick runs
  • 📄 README.md — Dataset format & usage

• 📁 figures/ — Diagrams, plots, and figures

• 📁 scripts/ — Processing & analysis tools

• 📄 LICENSE — Project license

• 📄 requirements.txt - Python requirements for the project

• 📄 README.md — Main repository documentation

---

Algorithms

Greedy Algorithm

• Purpose: Provides a fast, heuristic-based solution for initial network configurations.
• Advantages: Lightweight, quick to implement, and useful as a baseline.
• Implementation: See code/greedy_solution_generator.ipynb.

Graph Encoded Genetic Algorithm with Steiner Mutations (GEGASM)

• Purpose: Explores larger solution spaces through evolutionary optimisation.
• Advantages: Finds higher-quality solutions at the cost of runtime and computational resources.
• Implementation: See code/genetic_algorithm.py.
• Features:
  • Customisable crossover and mutation operators
  • Configurable selection strategies
  • Logging of population performance over time
• Note: For a simpler alternative, see the Binary-encoded Genetic Algorithm (BEGA) below.

Graph Encoded Genetic Algorithm (GEGA)

• Purpose: Similar to GEGASM but without Steiner mutations, while still using all the core functionality of GEGASM.
• Advantages: Provides a more traditional genetic algorithm approach, which may be preferable in certain scenarios or for comparison purposes.
• Implementation: See code/GEGA.py.
• Features:
  • Customisable crossover and mutation operators (without Steiner mutations)
  • Configurable selection strategies
  • Logging of population performance over time
• Note: Used to demonstrate the impact of Steiner mutations by providing a direct comparison to GEGASM, while still leveraging the same underlying genetic algorithm framework.

Binary-encoded Genetic Algorithm (BEGA)

• Purpose: An alternative genetic algorithm approach using binary encoding based on the MILP formulation.
• Advantages: Simpler encoding can lead to faster convergence in some cases, and may be easier to implement for certain problem structures.
• Disadvantages: May not capture complex solution structures as effectively as a more traditional genetic algorithm leading to suboptimal solutions in some cases.
• Implementation: See code/BEGA.py.

Local Search

• Purpose: Provides an alternative to genetic algorithms for refining solutions via iterative improvement.
• Advantages: Efficient for fine-tuning and escaping local optima.
• Implementation: See code/local_search.py.

CPLEX Models (Exact Solution Methods)

• CPLEX Shortest Path: Uses mathematical programming to find exact optimal network paths.
  • Implementation: See code/CPLEX_shortest_path.py.
• CPLEX Graph Model: Provides full graph-based optimisation for deployment strategies, delivering exact solutions.
  • Implementation: See code/CPLEX_graph_model.py.

---

Datasets

The repository includes two datasets designed on a region within rural Australia, each tailored for different testing scenarios:

• Full Dataset: Large-scale, complex data designed to fully test algorithms and evaluate scalability.

• Small Dataset: Simplified data for debugging, quick experiments, and verifying correctness.

See the README in dataset/ for details on dataset structure and usage.

I've also released a dataset generating tool as a separate repository, which can be found here. This tool allows users to create custom datasets based on specific parameters and requirements, making it easier to test algorithms under various conditions.

---

Scripts and Utilities

Located in the scripts/ directory, these tools support:

• Dataset Updates: Updating dataset files when changes are made.
• Visualisation: Viewing datasets on a map and plotting algorithm iteration results.

See the README in scripts/ for details on available scripts and their usage.

---

Figures

The figures/ folder stores images, diagrams, and charts used for documentation within this README. This includes dataset visualisations.

---

Results

Algorithm outputs are stored under heuristic-algorithm/results/, with logs in heuristic-algorithm/code/logs/.

---

Meet the Lead Developer (kidding!)

Phoebe: Lead Developer 🪽 Forever reviewing pull requests from above

Stanley: Budding New Developer Currently learning the sacred art of debugging

Contribution Rule: If you submit code, you must include a photo of your cat. No cat? No commit! (Phoebe enforces this strictly.)

---

Getting Started

1. Clone the repository:

   git clone https://github.com/breezy-codes/B5G-network-planning-algorithms.git
   cd B5G-network-planning-algorithms

2. Install dependencies (Python 3.9+ recommended):

   pip install -r requirements.txt

3. Explore the project:
   Review the folder structure and documentation to understand available algorithms, datasets, and utilities.

4. Run experiments:

   • For the Greedy Algorithm, open and run the notebook:

     jupyter notebook code/greedy_solution_generator.ipynb

   • For the Graph-Encoded Genetic Algorithm with Steiner Mutations (GEGASM), execute:

     python code/GEGASM.py

   • For the Graph-Encoded Genetic Algorithm (GEGA), execute:

     python code/GEGA.py

   • For the Binary-encoded Genetic Algorithm (BEGA), execute:

     python code/BEGA.py

   • For the Local Search, run:

     python code/local_search.py

   • For CPLEX models, execute either:

     python code/CPLEX_shortest_path.py

     or

     python code/CPLEX_graph_model.py

5. Inspect results:

   • Outputs will be saved in the results/ directory.
   • Logs can be found in code/logs/.
   • Use the provided scripts in scripts/ for further analysis or visualisation of results.

---

Contribution Guidelines

• Fork the repository and create a feature branch.
• Add documentation for all new scripts or algorithms.
• Include experiment logs and a summary of results for reproducibility.
• Optional (but encouraged): Share a photo of your cat colleague.

---

License

This project is released under the GPL-3.0 License. See the LICENSE file for details.