i2i 2024

Mar 25, 2024, 9:00 AM → Apr 5, 2024, 5:40 PM Europe/Paris

200/1-139 - Salle 139 (IJCLab)

Every spring, IJCLab's Computer Science Department, in collaboration with the "Computation and Data" Transverse Group, and the PHENIICS Doctoral School, is offering a sequence of half-day training modules, primarily aimed at PhD students.

The 2024 session will be held from March 25 to April 5. We accept registrations from all IJCLab members and friends (LPP, IAS, LoOPS, ...), on a waiting list, subject to the availability of places left by PhD students.

If you are a PhD students, DO NOT REGISTER HERE, but rather on ADUM, till March 1. You will be given priority and certificate of attendance. In the ADUM catalog (https://adum.fr/script/catalogue.pl?site=psaclay), all i2i courses are in the section "Méthodes, outils, techniques et concepts mobilisables pour la réalisation des travaux de recherche doctoraux", except one in "Se former à la science ouverte et aux données de la recherche".

If you are not a PhD student, do register here, till March 15. The individual teacher of each half-day will let you know, once ADUM is closed, if there is still enough place for you, on a first-registered, first-accepted basis. If many candidates cannot be approved, we will try to replay some training later in the year.

A few final points of attention:

1. If you never used a Linux terminal before, we strongly advise to follow the opening "Unix Shell" module.
2. The "Using the VirtualData Cloud" course will teach you how to use the computing platform operated by IJCLab's operations department.
3. The "Make your code more robust" course is over 2 half-days: you must take both.
4. The "Make your code more efficient" course is over 2 half-days: you must take both.
5. The "Deep Learning" course requires you to have taken "Machine Learning" beforehand...

Monday, March 25

9:00 AM → 12:30 PM The Unix Shell

The Unix shell has been around longer than most of its users have been alive. It has survived because it’s a powerful tool that allows users to perform complex and powerful tasks, often with just a few keystrokes or lines of code. It helps users automate repetitive tasks and easily combine smaller tasks into larger, more powerful workflows.
1. Introducing the Shell
2. Navigating Files and Directories
3. Working With Files and Directories
4. Pipes and Filters
5. Loops
6. Shell Scripts
7. Finding Things

Speaker: Michel Jouvin (IJCLab)

Cours I2I - Shell Unix.pdf

2:00 PM → 5:30 PM Git Survival Guide

In this survival guide, we will explore how to effectively use Git to manage and access the version history of any set of text files (code, manuscripts written in LaTeX, etc.), both in the context of team an personal projects.
Specifically, we will cover the following points:
- Initializing a Git repository
- Tracking changes and managing branches
- Merging and rebasing
- Resolving conflicts
- Working with remotes and forges (GitHub/GitLab)
- Version control strategies
- Best practices for collaborating with Git

Speaker: Sonny Lion (IJCLab)

Gitlab Project

Tuesday, March 26

9:00 AM → 12:30 PM Paris-Saclay Computing Center Howto

This course is aimed at students wishing to learn how to use the scientific computing platforms at the Paris Saclay Computing Center (https://mesocentre.universite-paris-saclay.fr/). We will review the different existing computing architectures (cloud, supercomputer). We will then look at how to access the VirtualData cloud and the Ruche HPC computer, and how to use the resources effectively in a variety of situations. Finally, we will detail the use of services deployed in the cloud, such as the JupyterHub@Paris-Saclay (https://jupyterhub.ijclab.in2p3.fr/) and the GitLab instance (https://gitlab.dsi.universite-paris-saclay.fr).

Speakers: Etienne Fayen, Julien PELOTON (CNRS-IJCLab), Dr marco leoni

Materials

2:00 PM → 5:30 PM Python Traps & Pitfalls

First, we'll take a closer look at the basic mechanisms of the Python language, beyond what can be guessed by blindly copying and pasting examples, in order to avoid the most common traps and pitfalls. Then, we'll debate the interactions with Linux. In particular, we will talk about :
- variables semantic, duck typing,
- automatic memory management,
- builtin types and collections,
- shallow and deep copy,
- functions, local and global variables,
- differences between interpreter, scripts and notebooks,
- the import and distribution of modules and packages.

Prerequisites : to have practised Python regularly, to know Linux.

Speaker: David Chamont (IJCLab - IN2P3 - CNRS)

Gitlab Project

Wednesday, March 27

9:00 AM → 12:30 PM Computation accuracy

When using numbers of type float or double, are you aware that 0.1+0.2 does not equal 0.3 ? Let’s review the theory behind such pitfalls, and discuss some case studies :
- the quadratic equation in kinematics calculations
- variance calculations in data analysis
- calculations with complex numbers
- accurate summation in large Monte-Carlo calculations
- precision in matrix and geometry calculations (the interest of factoring)
- differential equations
Elements of numerical calculation
- solution of equations, minimisation
- scaling: combining accuracy and efficiency
Clean code for computation

Speaker: Dr Vincent LAFAGE (IJCLab)

Reprises_IJC_Precision_dual_i2i.pdf

2:00 PM → 5:30 PM Object-Oriented C++

Get familiar with the object-oriented programming with C++. The lectures and hands-on aim to prepare students to use and/or contribute to large C++-based projects, such as Geant4.
- Introduction to object-oriented methodology
- Class definition and implementation
- Class data members and member functions/methods
- Static data members, member functions/methods
- Base class and derived class
- Virtual, pure virtual functions
- C++11/17 features: auto, range for loop, …

Prerequisites : basic knowledge of the C++ syntax and standard library (if, loops, functions, pointers, references, iostream, string, vector).

The course web site:
https://geant4-ed-project.pages.in2p3.fr/oo-cpp-web/

Speaker: Ivana HRIVNACOVA

Thursday, March 28

9:00 AM → 12:30 PM Make Your Code More Robust 1/2

Discovery of software engineering tools and methodologies to write more tested,
documented code that is easier to understand and maintain.
- static analysis
- tests
- documentation
The examples will be based on the C++ and Python programming languages.

Prerequisites : some knowledge of C++ or Python.

Speakers: Hadrien Grasland (IJCLab), Julien PELOTON (CNRS-IJCLab)

Practicals handouts

Presentation.pdf

Raw material

2:00 PM → 5:30 PM Introduction to Machine Learning

We will describe the main concepts of Machine Learning (ML) and give some clues to address a problem of ML. In particular, we will talk about :
- the concepts of AI/Machine Learning/Deep Learning,
- supervised/unsupervised learning,
- the preprocessing of the data,
- the general principle of the algorithm,
- the main pitfalls,
- the evaluation of the training and the outcomes.
Some exercises will be provided to understand the basic concepts of standard ML methods.

Prerequisites : practice of Python and main libraries (numpy, pandas, matplotlib).

Speaker: Francoise BOUVET (IJCLab)

Friday, March 29

9:00 AM → 12:30 PM Make Your Code More Efficient 1/2

Most computer programs are inefficient and could serve the same purpose while using 10-1000x less resources (time, energy, memory…). However, achieving this result requires know-how that is not part of the typical programming curriculum. In this course, you will learn a general methodology to make any program use computing resources more efficiently:
1. Safety first
2. Set a useful benchmark
3. Identify the limiting hardware resource
4. Locate the code that most intensely uses it
5. Make the most of other people’s work
6. Optimize your own code
7. Know your programming language

Prerequisites : Shell Unix/Linux (files, make…) + C++ basics (C-like features, std::vector, iostream, virtual) or Python+numpy. Laptop capable of connecting to a Linux server via SSH, ideally configured to use eduroam.

Speaker: Hadrien Grasland (IJCLab)

Day1.pdf

Practicals handouts

Raw material

Tuesday, April 2

9:00 AM → 12:30 PM C++17 Initiation for Pythonists

First contact with C++, in its most used version in new physics projects : aka C++17.
The course is targeted at people who have programming experience, especially with Python. In particular, we will talk about :
- builtin types, variables, functions,
- passing arguments by value and by reference,
- type inference and templates,
- returning a tuple of values,
- std::vector vs std::array,
- compilation and libraries.

Prerequisites : to have practised Python regularly.

Speaker: David Chamont (IJCLab - IN2P3 - CNRS)

2:00 PM → 5:30 PM CMake Survival Guide

Introduction to CMake, which is the most widely used tool for managing C/C++ projects, especially in a cross platform context. The course is targeted at people who have some programming experience with C/C++ or Fortran.
In particular, we will talk about:
- building simple binaries and libraries
- build and running tests via ctest
- integrating third party applications
- modern cmake best practices
- most useful compilation/link commands

Prerequisites : have a basic understanding of C/C++ or Fortran.

Speaker: Philip Deegan (LPP)

CMake survival practicals

PHENICS_i2i_cmake_survival_2024.ppt

Wednesday, April 3

9:00 AM → 12:30 PM Make Your Code More Robust 2/2

Second part of "Make Your Code More Robust". See the contribution "Make Your Code More Robust 1/2".

Speakers: Hadrien Grasland (IJCLab), Julien PELOTON (CNRS-IJCLab)

Practicals handouts

Presentation

Raw material

2:00 PM → 5:30 PM GitLab Projects and Continuous Integration

This course is NOT ABOUT GIT; here, we will focus on using GitLab for software pro-ject management. You will learn how to leverage GitLab's features to facilitate collab-orative development, automate your tests, and publish code releases. Specifically, we will cover the following points:
- Creating a project in GitLab
- Managing members and permissions
- Working with issues: labels, milestones, templates
- Team collaboration: Branches and Merge requests
- Task automation through GitLab CI/CD: creating pipelines and jobs
- Managing environment variables and secrets
- Publishing packages and deploying documentation

Prerequisites : be able to communicate with a remote repository via Git (clone, fetch, push) and know how to manage branches.

Speaker: Sonny Lion (IJCLab)

Thursday, April 4

9:00 AM → 12:30 PM Open Code and Data

Research is based on reproducibility and an incremental improvement process. Open Science movement has been developed to facilitate this work and relies on 3 legs: open access to publications, open data and libre software.
Topics :
- open data
- their organization, the conditions of their publication and their reuse
- their valorization
- Free/libre software
- the software licences,
- their valorization,
- data management plan (DMP)
- the associated tools
- their lifecycle,

Speaker: Dr Philippe Gauron (IJCLab/CNRS-Université Paris-Sud)

2024-04-04 Philippe Gauron - Science ouverte, données ouvertes, logiciel libre (CC-BY-SA 4).pdf

2:00 PM → 5:30 PM Web Interfaces In a Nutshell

This course provides an introduction to web interface development. We will explore the fundamentals needed to design and develop interactive web user interfaces.
Specifically, the course covers the following aspects:
- Client-server architecture
- Markup languages (HTML)
- Cascading Style Sheets (CSS)
- JavaScript and client-side interactivity
- Server communication (AJAX)
- Front-end frameworks and libraries
- Best practices in web interface design

Prerequisites : knowledge of a programming language (Python, Javascript or other).

Speaker: Sonny Lion (IJCLab)

Friday, April 5

9:00 AM → 12:30 PM Make Your Code More Efficient 2/2

Second part of "Make Your Code More Efficient". See the contribution "Make Your Code More Efficient 1/2".

Speaker: Hadrien Grasland (IJCLab)

Day2.pdf

Practicals handouts

Raw material

2:00 PM → 5:30 PM Introduction to Deep Learning

We will describe the main concepts of Deep Learning (DL). We will focus on Multilayer Neural Network (MLP) and Convolution Neural Network (CNN).
In particular, we will talk about :
- artificial neuron,
- MLP : structure and how it works,
- CNN : structure and how it works,
- a brief review of other NN structures.
Some exercises will be provided to program simple MLP and CNN in Python with Keras.

Prerequisites :
- Practice of Python and main libraries (numpy, pandas, matplotlib).
- Priority will be given to the attendees of « Initiation to Machine Learning ».

Speaker: Francoise BOUVET (IJCLab)