Google Colab

Créer un cahier

Pour les TDs, nous nous servirons de Google Colab, un ensemble d'outils gérés par Google permettant d'exécuter du code python avec leurs serveurs de calcul. Cela vous permettra en particulier de ne rien avoir à installer en particulier sur vos machines. Colab vous permettra également de lancer vos calculs sur GPU, ce qui pourra accélerer énormément l'entraînement de vos réseaux de neurones.

La première étape est de vous créer un compte google si vous n'en avez pas déjà un.

La création de cahiers pour Colab passe par Google Drive:

Si l'option n'apparaît pas, il faut associer l'application Colaboratory à votre drive.

Activer le GPU

Pour activer le GPU dans un cahier, faites comme dans l'image:

Python 3

Dans les TDs, nous nous servirons de Python 3. Voici une très rapide introduction pour ceux qui n'ont jamais fait de Python.

Les bases

La principale différence entre Python et d'autres langages comme Java par exemple est que les blocs de code sont définis par des indentations (au lieu des usuelles accolades {,}). Voici un premier programme qui résume comment définir une fonction, affecter des variables etc:


# Tout ce qui est après un # sur une ligne est un commentaire
a = 5 # on affecte 5 à la variable a
a = 3*4+4 # on peut faire les opération usuelles avec +,-,*,/
a = 13//5 # division entière : résultat 2
a = 13%5 # reste de la division entière, le modulo : résultat 3

"""
On peut également faire des commentaires sur plusieurs lignes
avec les triples-quotes.

La fonction suivante illustre comment on définit une fonction et comment on peut
faire des conditionnelles (if,elif,else). On peut déterminer à quel bloc appartient
une instruction grâce à son indentation.
"""

def factorielle(n):
  if n<=0:
    return 1
  elif n==1:
    return 1
  else:
    return n*factorielle(n-1)

factorielle(a) # résultat 6

"""
Python a plusieurs types de données de base:
"""
un_entier = 5 # ints
un_float = 5. # floats
un_boolean = True # booléens : True, False
un_rien = None # Valeur équivalente à null ou à rien
une_chaine = "toto" # Une chaîne de caractères
une_autre_chaine = """Une chaîne de caractères sur
plusieurs lignes """ # les triple-quotes peuvent aussi servir à définir des chaînes de caractères.

"""
Des listes (ou tableaux dynamiquement alloués):
"""

tab = [1,2,3] 
tab[1] # valeur à la case 1: 2
tab.append(10) # ajouter 10 à la fin du tableau
tab # [1,2,3,10]
tab[2:4] # affichage des cases 2 (inclus) à 4 (exclu) du tableau : [3,10]
tab[-1] # première case en partant de la fin : 10
tab[:3] # premières cases jusqu'à 3 (exclu) : [1,2,3]
tab[2:] # cases de 2 (inclus) à la fin : [3,10]

"""
Des dictionnaires (tables de hachage):
"""
d = {
  "clef" : "valeur",
  12 : 13,
  3 : [1,2,3,[2,4]],
  4 : {
    "4":1234,
    4: 1234,
  }
}
"""
Les clefs sont n'importe quel type hashable (donc ni des listes, ni des dictionnaires),
les valeurs peuvent être de n'importe quel type.
"""

Importer des librairies

La popularité de Python est due principalement au fait que des centaines de librairies existent et permettent de faire en quelques lignes ce qui pourrait demander des centaines de lignes dans un autre langage. Une fois les librairies installées sur le système (normalement toutes les librairies dont vous aurez besoin sont déjà installées sur colab), il suffit de les importer:


import requests # importer requests
import requests as req # importer requests et renommer req

Voici un exemple d'utilisation de requests par exemple qui permet d'accéder à des pages web et d'en récupérer le contenu:


import requests

# les méthodes de requests sont maintenant disponibles:
r = requests.get("http://www.perdu.com")

Classes et objets

Dans certains TDs, vous aurez à créer des classes et des objets. Une classe est définie de la manière suivante en Python:


class MaClasse:

    variable_statique = 12 # cette variable a la même valeur pour tous les objets de cette classe

    def __init__(self,param1,param2="Toto"): # le constructeur
        self.param1 = param1
        self.param2 = param2
        self.param3 = 3

    def change_param3(self,param): #une méthode
        self.param3 = param

    def statique():
        print("ceci est une méthode statique")

o = MaClasse(1,2)
o.param1 # 1
o.param2 # 2
o.param3 # 3

o2 = MaClasse(1)
o.param1 # 1
o.param2 # "Toto"
o.change_param3("titi") # o.param3 = "titi"
o.param3 = "tata" # les variables sont publiques en python

o2.variable_statique = 14
o.variable_statique # 14

MaClasse.statique()

Syntaxes particulières : unpacking

Python permet de découpler facilement :


x = (10,5)
a,b = x  # a=10, b=5

Plus généralement, on peut voir les argments d'une fonction comme une liste ou un dictionnaire (selon si ils sont nommés ou pas):


def f(*args, **kwargs):
  # args est une liste contenant les valeurs des arguments
	# passés sans nom
	for a in args:
		print(a)
	# kwargs est un dictionnaire contenant les arguments
	# passés par nom : la clef est le nom et la valeur la valeur
	for k in kwargs.keys():
		print("nom argument : {}\n valeur : {}\n".format(k,kwargs[k]))

f(12,34,toto="blih",tata=42)
# Résultat :
# 12
# 34
# nom argument : toto
#  valeur : blih
# 
# nom argument : tata
#  valeur : 42

On peut mixer la syntaxe habituelle avec celle que l'on vient de voir :


def g(first,*args):
  # args est une liste contenant les valeurs des arguments
	# passés sans nom, après first
	for a in args:
		print(a)

g(12,34,42)
# Résultat :
# 34
# 42
# first aurait contenu 12, mais n'est pas inclus dans args

À l'inverse, on peut transformer une liste/dictionnaire en arguments pour une fonction :


d = {"h":78, "titi": 94} # un dictionnaire
l = ["rouge","vert","bleu"] # une liste

f(*l)
# rouge
# vert
# bleu

f(**d)
# nom argument : h
#  valeur : 78
# 
# nom argument : titi
#  valeur : 94

f(*l,**d)
# rouge
# vert
# bleu
# nom argument : h
#  valeur : 78
# 
# nom argument : titi
#  valeur : 94