Generative AI

Fine-tuning Open Source LLMs in Mauritania

Explore Fine-Tuning Open Source LLMs training to learn model customisation, supervised fine-tuning, parameter-efficient techniques, and dataset preparation. Gain practical experience with Python, Hugging Face Transformers, PyTorch, and Low-Rank Adaptation (LoRA) to adapt language models for specialised applications. Understand model evaluation, performance optimisation, and responsible AI practices. Join StepMerit's Fine-Tuning Open Source LLMs course in Mauritania, to strengthen your Generative AI development skills and build customised AI solutions.

40 Hours/5 daysIntermediate3.8 · 1,000 reviews
Share:

Training calendar

Upcoming four-month course schedule

A new weekday and weekend batch starts every week. Each batch runs for 5 training days, based on the course duration of 40 Hours/5 days.

Weekend batches

October 2026

09:00–15:00 · flexible hours

$819per learner

24 Oct 2026

4 of 25 seats available

31 Oct 2026

10 of 25 seats available

Weekend batches

November 2026

09:00–15:00 · flexible hours

$819per learner

07 Nov 2026

25 of 25 seats available

14 Nov 2026

25 of 25 seats available

21 Nov 2026

25 of 25 seats available

28 Nov 2026

25 of 25 seats available

Weekend batches

December 2026

09:00–15:00 · flexible hours

$819per learner

05 Dec 2026

25 of 25 seats available

12 Dec 2026

25 of 25 seats available

19 Dec 2026

25 of 25 seats available

26 Dec 2026

25 of 25 seats available

Weekend batches

January 2027

09:00–15:00 · flexible hours

$819per learner

02 Jan 2027

25 of 25 seats available

09 Jan 2027

25 of 25 seats available

16 Jan 2027

25 of 25 seats available

23 Jan 2027

25 of 25 seats available

30 Jan 2027

25 of 25 seats available

Course curriculum

What you’ll learn

40 Hours/5 daysIntermediate
  • Module 1: Introduction to Open Source Large Language Models
    • Understanding large language models and their capabilities
    • Overview of open source and openly available LLMs
    • Popular models and ecosystems, including Llama, Mistral, and Hugging Face
    • Use cases and limitations of open source LLMs
  • Module 2: Transformer Architecture and LLM Fundamentals
    • Transformer architecture and attention mechanisms
    • Tokenisation, embeddings, and positional information
    • Pretraining, inference, and text generation
    • Understanding model parameters and context windows
  • Module 3: Development Environment Setup
    • Setting up Python, Jupyter Notebook, and required libraries
    • Working with PyTorch and Hugging Face Transformers
    • Configuring GPU, cloud notebook, or local computing environments
    • Managing dependencies and model files
  • Module 4: Working with Pretrained Open Source Models
    • Accessing pretrained models from Hugging Face Hub
    • Loading tokenisers and model checkpoints
    • Selecting models based on task requirements and hardware capacity
    • Running inference and evaluating baseline outputs
  • Module 5: Dataset Preparation and Preprocessing
    • Collecting and validating task-specific training data
    • Cleaning, deduplication, and text normalisation
    • Formatting instruction-response datasets
    • Splitting datasets into training, validation, and test sets
    • Identifying privacy risks and sensitive information in datasets
  • Module 6: Fundamentals of LLM Fine-Tuning
    • Understanding transfer learning and supervised fine-tuning
    • Comparing prompting, retrieval-augmented generation (RAG), and fine-tuning
    • Defining training objectives and evaluation criteria
    • Understanding loss functions, epochs, batch sizes, and learning rates
  • Module 7: Supervised Fine-Tuning (SFT)
    • Preparing instruction-tuning datasets
    • Configuring training arguments and model checkpoints
    • Training a pretrained model using supervised examples
    • Tracking training loss and validation performance
    • Saving and loading fine-tuned model checkpoints
  • Module 8: Parameter-Efficient Fine-Tuning (PEFT)
    • Introduction to parameter-efficient adaptation techniques
    • Understanding Low-Rank Adaptation (LoRA)
    • Exploring Quantised LoRA (QLoRA)
    • Configuring adapters and trainable parameters
    • Comparing full fine-tuning with parameter-efficient approaches
  • Module 9: Fine-Tuning with Hugging Face Tools
    • Using Transformers and the Trainer API
    • Working with the Datasets and PEFT libraries
    • Configuring tokenisers, collators, and training pipelines
    • Managing checkpoints, logs, and model artefacts
  • Module 10: GPU Memory and Training Optimisation
    • Understanding GPU memory consumption during training
    • Using quantisation and gradient accumulation
    • Exploring mixed-precision training and gradient checkpointing
    • Adjusting batch sizes and sequence lengths
    • Identifying common training bottlenecks
  • Module 11: Model Evaluation and Quality Assessment
    • Establishing baseline and post-training performance
    • Evaluating generated responses for relevance and accuracy
    • Using task-specific metrics and human evaluation
    • Testing for hallucinations, bias, and inconsistent outputs
    • Performing regression tests across representative prompts
  • Module 12: Experiment Tracking and Troubleshooting
    • Monitoring training metrics and experiment configurations
    • Identifying overfitting and underfitting
    • Troubleshooting dataset, tokenisation, and memory errors
    • Comparing model checkpoints and training runs
    • Documenting experiments for reproducibility
  • Module 13: Fine-Tuned Model Inference and Deployment
    • Loading fine-tuned models and adapter weights
    • Configuring generation parameters and inference settings
    • Serving models through Python applications or APIs
    • Understanding model quantisation for inference
    • Reviewing deployment, latency, and resource requirements
  • Module 14: Responsible AI, Security, and Model Governance
    • Reviewing training data quality, consent, and licensing considerations
    • Assessing bias, privacy, and potential misuse risks
    • Protecting model artefacts and sensitive datasets
    • Documenting model limitations and intended use
    • Establishing human review and ongoing evaluation practices
  • Module 15: Capstone Project and Practical Assessment
    • Selecting an open source LLM for a defined use case
    • Preparing a domain-specific dataset and baseline model
    • Implementing supervised fine-tuning or LoRA/QLoRA
    • Evaluating and comparing model performance before and after fine-tuning
    • Demonstrating the adapted model and documenting results
    • Presenting project findings, limitations, and future improvements
  • Training Delivery and Learning Support
    • Instructor-led learning with practical demonstrations and guided exercises
    • Hands-on labs using suitable open source models and tools
    • Project-based learning focused on real-world LLM customisation
    • StepMerit training support for learners in Mauritania

Entry requirements and prerequisites

  • Python Programming: Basic knowledge of Python, including functions, classes, libraries, and data handling.
  • Machine Learning Fundamentals: Understanding of model training, validation, evaluation, and basic machine learning concepts.
  • Deep Learning Knowledge: Familiarity with neural networks, gradient descent, loss functions, and backpropagation is recommended.
  • Large Language Model Fundamentals: Basic understanding of LLMs, transformer architecture, tokens, embeddings, and text generation.
  • Transformer Models: Familiarity with attention mechanisms, pretrained models, and tokenization is beneficial.
  • Python AI Libraries: Basic experience with PyTorch and familiarity with the Hugging Face Transformers library.
  • Datasets and Data Preparation: Understanding of text preprocessing, dataset cleaning, formatting, and training-data preparation.
  • Fine-Tuning Concepts: Introductory knowledge of supervised fine-tuning and transfer learning is helpful but not mandatory.
  • Hardware and Computing Resources: Awareness of GPU computing, memory requirements, and cloud notebook environments such as Google Colab is recommended.
  • Development Environment: Access to Python, Jupyter Notebook or Google Colab, and a suitable code editor for practical exercises.
  • Command-Line and Package Management: Basic familiarity with terminals, virtual environments, and Python package installation.
  • Training Location: Join StepMerit's Fine-Tuning Open Source LLMs training in Mauritania, to develop practical skills in customising open-source language models for specialised AI applications.

Career value

Reasons to choose this course

Customise Open Source LLMs

Learn to adapt pretrained language models to specific business requirements, industry needs, and specialised tasks.

Gain Hands-On Practical Experience

Work with Python, PyTorch, and Hugging Face Transformers to develop practical fine-tuning skills.

Master Parameter-Efficient Fine-Tuning

Explore LoRA and QLoRA techniques to customise models while reducing computational and memory requirements.

Develop Domain-Specific AI Solutions

Learn to prepare datasets and fine-tune models for applications such as customer support, healthcare, finance, and enterprise knowledge management.

Improve Model Performance

Understand model evaluation, hyperparameter tuning, and optimisation techniques to improve task-specific results.

Learn Cost-Effective AI Development

Discover how open source models can support flexible AI development while helping manage model hosting and infrastructure costs.

Advantages

Turn learning into practical capability

Greater Control Over AI Model Selection

Understand how to compare open source language models based on architecture, parameter size, licensing, hardware requirements, and suitability for specific application needs.

Enhanced Data Preparation Capabilities

Learn to organise, clean, format, and validate training datasets to support consistent model behaviour and improve the quality of fine-tuning workflows.

Better Understanding of Model Adaptation Strategies

Explore when to use instruction tuning, supervised fine-tuning, and other adaptation approaches to align language models with defined tasks and expected outputs.

Improved AI Integration Readiness

Develop an understanding of how fine-tuned models can be incorporated into chatbots, internal knowledge assistants, content processing systems, and other AI-powered applications.

Stronger Model Governance and Maintenance

Learn the importance of version control, reproducible experiments, performance monitoring, model documentation, and regression testing throughout the model lifecycle.

Practical Preparation for Enterprise AI Projects

Build knowledge that supports collaboration with AI engineering teams, evaluation of implementation requirements, and planning of open source LLM solutions through StepMerit's training in Mauritania.

Exam format & assessment

  • Exam Level: Intermediate – Fine-Tuning Open Source LLMs
  • Exam Type: Online computer-based examination consisting of multiple-choice questions and practical, scenario-based questions.
  • Number of Questions: 40 questions.
  • Exam Duration: 90 minutes.
  • Passing Score: 70% (28 out of 40 questions).
  • Exam Delivery: Online assessment through the StepMerit learning and assessment platform.
  • Practical Assessment: Learners may be assessed on dataset preparation, fine-tuning configuration, model evaluation, and interpretation of training results.
  • Certification: Learners who meet the assessment requirements may receive a StepMerit Certificate of Course Completion. This is a StepMerit course certificate, not an official certification issued by a model provider.
  • Exam Preparation: Review course modules, practise fine-tuning workflows, complete hands-on exercises, and understand model evaluation techniques.
  • Training and Assessment Support: StepMerit provides course-related learning support for participants in Mauritania.

Bring your learning together

Course conclusion

The Fine-Tuning Open Source LLMs course equips learners with practical knowledge of large language model customisation, supervised fine-tuning, parameter-efficient techniques, and model performance evaluation. Through hands-on exercises using Python, PyTorch, Hugging Face Transformers, LoRA, and QLoRA, participants learn to adapt pretrained models for specialised AI applications. This training helps aspiring AI engineers, machine learning professionals, developers, and data scientists strengthen their Generative AI skills and prepare for real-world LLM development projects. Enrol in StepMerit's Fine-Tuning Open Source LLMs training in Mauritania, to enhance your technical expertise and build a foundation for developing customised, efficient, and responsible AI solutions.

Target audience

  • AI Engineers
  • Machine Learning Engineers
  • Generative AI Developers
  • Data Scientists
  • Python Developers
  • NLP Engineers and Practitioners
  • Deep Learning Professionals
  • LLM Application Developers
  • AI Researchers and Research Scholars
  • Software Developers Exploring Open Source LLMs
  • IT Professionals Upskilling in Generative AI
  • Technical Professionals seeking Fine-Tuning Open Source LLMs training in Mauritania

Verified learning evidence

Expertise, recognition and learner outcomes

Course-specific expertise

  • Industry Experience: 5 years in AI, machine learning, deep learning, and Generative AI-related technologies.
  • Training Experience: 120+ hours of technical training delivered in Python, machine learning, NLP, and LLM development.
  • Candidates Trained: 150+ learners trained across AI, machine learning, deep learning, and Generative AI courses.
  • Course-Specific Expertise: Experience with open source LLMs, Hugging Face Transformers, PyTorch, supervised fine-tuning, LoRA, QLoRA, and PEFT workflows.
  • Practical Project Experience: Hands-on experience with dataset preparation, model configuration, fine-tuning experiments, training optimisation, inference, and model performance evaluation.
  • Tools and Technologies: Python, PyTorch, Hugging Face Transformers, Hugging Face Datasets, PEFT, tokenizers, Jupyter Notebook, and GPU-based development environments.
  • Training Methodology: Instructor-led sessions, demonstrations, guided coding exercises, practical labs, troubleshooting, and project-based learning.
  • Assessment and Mentoring: Guidance on fine-tuning workflows, model evaluation, debugging, experiment tracking, and developing portfolio-ready LLM projects.
  • Learning Outcome Focus: Helping learners build practical skills to customise pretrained language models for domain-specific applications while understanding performance, computational costs, and responsible AI considerations.

Documented learner outcomes

  • Problem Statement: Healthcare organisations manage large volumes of patient education materials, hospital guidelines, frequently asked questions, clinical information documents, and administrative resources. General-purpose large language models may not consistently follow healthcare-specific terminology, response formats, or approved communication guidelines. Healthcare teams need AI systems that can provide clear, accessible, and consistent general health information while protecting sensitive data and avoiding unsupported medical claims. The organisation wanted to explore fine-tuning open source LLMs to support healthcare education and information services.
  • How We Overcame the Problem: Learners designed an AI-powered healthcare information assistant using an open source pretrained LLM and fine-tuning techniques. They explored supervised fine-tuning (SFT), Parameter-Efficient Fine-Tuning (PEFT), Low-Rank Adaptation (LoRA), and Quantised LoRA (QLoRA), selecting suitable methods according to model requirements, dataset quality, computing resources, and project objectives. They prepared healthcare education examples and evaluated model outputs against predefined quality and safety criteria.
  • Overall Implementation: Learners implemented an end-to-end LLM fine-tuning workflow covering use-case definition, dataset collection, data cleaning, instruction formatting, pretrained model selection, baseline evaluation, fine-tuning configuration, model training, output evaluation, and application integration. The prototype processed general healthcare education questions and generated structured responses about preventive care, hospital procedures, appointment preparation, and approved patient education materials.
  • Evidence of Learning: Learners demonstrated the ability to explore open source model repositories, load pretrained LLMs, prepare instruction-response datasets, configure supervised fine-tuning, apply LoRA or QLoRA where appropriate, monitor training metrics, evaluate generated responses, and integrate a fine-tuned model into a Python application.
  • Healthcare AI Workflow:
    Approved Healthcare Education Materials → Data Cleaning and Validation → Instruction Dataset Preparation → Tokenization → Pretrained Open Source LLM → Fine-Tuning (SFT/LoRA/QLoRA) → Model Evaluation → Safety Testing → Healthcare Education Application
  • Healthcare Dataset Preparation Implementation: Learners prepared structured instruction-response examples using approved patient education materials, general health FAQs, and hospital procedure information. They removed duplicates, standardised formatting, checked data quality, and used synthetic or appropriately de-identified data. Training, validation, and test datasets were separated to support meaningful evaluation and reduce data leakage.
  • Pretrained Model Selection Implementation: Learners explored suitable open source LLMs and reviewed model documentation, licensing terms, parameter sizes, supported languages, hardware requirements, and intended use cases. They selected a model appropriate for healthcare education tasks and established a baseline by testing its responses before fine-tuning.
  • Supervised Fine-Tuning Implementation: Learners formatted healthcare education examples as instruction-response pairs and configured a supervised fine-tuning workflow using tools such as Hugging Face Transformers and PyTorch. They adjusted training parameters, including learning rate, batch size, epochs, and sequence length, and monitored training and validation loss to identify potential overfitting.
  • Parameter-Efficient Fine-Tuning Evidence: Learners explored LoRA and QLoRA to adapt selected pretrained models while reducing the number of trainable parameters and, where supported, memory requirements. They compared the practical setup, resource consumption, and output quality of the chosen adaptation approach against the baseline or another suitable configuration.
  • Healthcare Response Generation Implementation: Learners tested the fine-tuned model using representative questions about preventive healthcare, preparation for appointments, hospital admission procedures, and general patient education. They assessed whether the responses were understandable, relevant to the supplied material, consistently formatted, and appropriately limited to general information.
  • Model Evaluation and Comparison Evidence: Learners compared the base model and fine-tuned model using held-out test examples and predefined evaluation criteria. They assessed relevance, readability, consistency with approved educational content, factual support, and appropriate handling of uncertainty. Quantitative metrics were recorded where suitable, while healthcare subject-matter review was used for qualitative assessment. Any claimed improvement was supported by actual test results rather than assumed in advance.
  • Problem-Solving Evidence: Learners addressed challenges such as inconsistent training examples, lengthy input documents, GPU memory limitations, overfitting, repetitive responses, unsupported medical statements, and variation in output quality. They applied data cleaning, appropriate input-length management, parameter-efficient fine-tuning, training-parameter adjustments, checkpoint comparison, and structured evaluation to improve the prototype.
  • Inference and Application Integration Evidence: Learners loaded the fine-tuned model or its adapter weights into a Python-based application and configured text-generation settings. They demonstrated how the model could support a basic healthcare education interface or API, while documenting inference latency, hardware requirements, model-loading considerations, and deployment limitations.
  • Responsible AI Evidence: Learners considered healthcare data privacy, consent, dataset licensing, model bias, output reliability, and risks associated with inaccurate medical information. They used synthetic or appropriately de-identified data, restricted access to project artefacts, documented model limitations, and added safeguards to prevent the prototype from presenting itself as a diagnostic or treatment authority. Personal medical concerns and urgent symptoms were directed to qualified healthcare professionals or appropriate emergency services.
  • Comparative Evidence: Learners compared the base and fine-tuned models, and where appropriate, different fine-tuning configurations, based on response quality, consistency, resource consumption, training time, inference speed, and suitability for the defined healthcare education task. Findings were recorded to justify model and technique selection.
  • Overall Outcome: By completing the implementation, learners demonstrated practical skills in adapting open source LLMs for a specialised healthcare education scenario. The resulting prototype could support general health information responses, patient education content, and explanations of hospital procedures. The project also helped learners understand the importance of dataset quality, model evaluation, resource optimisation, and safety controls when developing domain-specific Generative AI applications.
  • Final Evidence: A working healthcare education prototype, Python source code, model and tokenizer details, dataset preparation documentation, fine-tuning configuration, training logs, model checkpoints or adapter weights, sample generated responses, baseline-versus-fine-tuned evaluation reports, safety test cases, model comparison findings, and implementation documentation provide evidence of learners' practical competency in Fine-Tuning Open Source LLMs.

Important: This scenario demonstrates educational and technical model-development skills. The prototype is not a clinically validated medical system and should not be used for autonomous diagnosis, treatment recommendations, or other clinical decisions without the necessary clinical validation, professional oversight, and regulatory review.

Helpful answers for planning your training

Frequently asked questions

It is the process of adapting pretrained language models for specialised tasks using relevant training data.

You will learn dataset preparation, supervised fine-tuning, LoRA, QLoRA, and model evaluation.

Learner reviews

Rated by 1,000 learners

Rating and review totals are controlled per course in the CRM.

3.8out of 5

Compare city information, course curriculum, exam details and ways to enquire.

Book with clarity

Clear pricing, protected approval and learner support

Approval before payment

A secure payment link is shared only after the CRM team confirms the request.

Live instructor-led delivery

Ask questions during the session and learn alongside a scheduled cohort.

Verified learner feedback

Published course feedback is linked to completed learner records and CRM approval.

Visible schedules

Review weekday and weekend dates, duration, timezone and seat availability before booking.

Related Generative AI courses

Fine-tuning Open Source LLMs

$819 USD / learner · Next: 24 Oct 2026 · Approval before payment

View dates