Existe-t-il un équivalent de CTRL+C dans IPython Notebook dans Firefox pour interrompre les cellules en cours d'exécution ?

Question

J'ai commencé à utiliser le Notebook d'IPython et je l'apprécie. Parfois, j'écris du code bogué qui nécessite beaucoup de mémoire ou qui comporte une boucle infinie. Je trouve l'option "interrompre le noyau" lente ou peu fiable, et parfois je dois redémarrer le noyau, perdant tout ce qui est en mémoire.

Il m'arrive aussi d'écrire des scripts qui font qu'OS X se retrouve à court de mémoire, et je dois faire un redémarrage brutal. Je ne suis pas sûr à 100%, mais lorsque j'ai écrit des bugs de ce genre auparavant et que j'ai exécuté Python dans le terminal, je peux habituellement CTRL + C mes scripts.

J'utilise la distribution Anaconda de IPython notebook avec Firefox sur Mac OS X.

Answer 1

Vous pouvez appuyer sur I deux fois pour interrompre le noyau.

Cela ne fonctionne que si vous êtes en mode Commandement. Si ce n'est pas déjà fait, appuyez sur Esc pour l'activer.

Answer 2

Je peux me tromper, mais je suis presque sûr que le bouton "Interrompre le noyau" envoie simplement un signal SIGINT au code que vous êtes en train d'exécuter (cette idée est soutenue par le commentaire de Fernando aquí ), ce qui revient à faire la même chose que d'appuyer sur CTRL+C. Certains processus de python traitent les SIGINTs de manière plus abrupte que d'autres.

Si vous avez désespérément besoin d'arrêter quelque chose qui tourne dans iPython Notebook et que vous avez lancé iPython Notebook à partir d'un terminal, vous pouvez taper deux fois CTRL+C dans ce terminal pour interrompre l'ensemble du serveur iPython Notebook. Cela arrêtera complètement iPython Notebook, ce qui signifie qu'il ne sera pas possible de redémarrer ou de sauvegarder votre travail, donc ce n'est évidemment pas une bonne solution (vous devez taper deux fois CTRL+C parce que c'est un dispositif de sécurité pour que les gens ne le fassent pas par accident). En cas d'urgence, cependant, cette méthode permet généralement de tuer le processus plus rapidement que le bouton "Interrompre le noyau".

Answer 3

Ici sont des raccourcis pour le carnet de notes IPython.

Ctrl-m i interrompt le noyau. (c'est-à-dire la seule lettre i après Ctrl-m )

Selon ce réponse, I deux fois fonctionne également.

Answer 4

Pour ajouter à ce qui précède : Si l'interruption ne fonctionne pas, vous pouvez redémarrer le noyau.

Allez dans le menu déroulant du noyau >> redémarrer >> redémarrer et effacer la sortie. Cela fait généralement l'affaire. Si cela ne fonctionne toujours pas, arrêtez le noyau dans le terminal (ou le gestionnaire de tâches), puis redémarrez.

L'interruption ne fonctionne pas bien pour tous les processus. J'ai particulièrement ce problème en utilisant le noyau R.

Answer 5

UPDATE : Transformé ma solution en un script python autonome.

Cette solution m'a sauvé plus d'une fois. J'espère que d'autres la trouveront utile. Ce python script trouvera n'importe quel noyau jupyter utilisant plus que cpu_threshold CPU et invite l'utilisateur à envoyer un SIGINT au noyau (KeyboardInterrupt). Il continuera à envoyer SIGINT jusqu'à ce que l'utilisation du processeur du noyau passe en dessous de cpu_threshold . S'il y a plusieurs noyaux qui se comportent mal, il demandera à l'utilisateur d'interrompre chacun d'entre eux (classés de la plus forte utilisation du CPU à la plus faible). Un grand merci à gcbeltramini pour écrire du code pour trouver le nom d'un noyau jupyter en utilisant l'api jupyter. Ce script a été testé sur MACOS avec python3 et nécessite jupyter notebook, requests, json et psutil.

Mettez le script dans votre répertoire personnel et l'utilisation ressemble à ceci :

python ~/interrupt_bad_kernels.py
Interrupt kernel chews cpu.ipynb; PID: 57588; CPU: 2.3%? (y/n) y

script code ci-dessous :

from os import getpid, kill
from time import sleep
import re
import signal

from notebook.notebookapp import list_running_servers
from requests import get
from requests.compat import urljoin
import ipykernel
import json
import psutil

def get_active_kernels(cpu_threshold):
    """Get a list of active jupyter kernels."""
    active_kernels = []
    pids = psutil.pids()
    my_pid = getpid()

    for pid in pids:
        if pid == my_pid:
            continue
        try:
            p = psutil.Process(pid)
            cmd = p.cmdline()
            for arg in cmd:
                if arg.count('ipykernel'):
                    cpu = p.cpu_percent(interval=0.1)
                    if cpu > cpu_threshold:
                        active_kernels.append((cpu, pid, cmd))
        except psutil.AccessDenied:
            continue
    return active_kernels

def interrupt_bad_notebooks(cpu_threshold=0.2):
    """Interrupt active jupyter kernels. Prompts the user for each kernel."""

    active_kernels = sorted(get_active_kernels(cpu_threshold), reverse=True)

    servers = list_running_servers()
    for ss in servers:
        response = get(urljoin(ss['url'].replace('localhost', '127.0.0.1'), 'api/sessions'),
                       params={'token': ss.get('token', '')})
        for nn in json.loads(response.text):
            for kernel in active_kernels:
                for arg in kernel[-1]:
                    if arg.count(nn['kernel']['id']):
                        pid = kernel[1]
                        cpu = kernel[0]
                        interrupt = input(
                            'Interrupt kernel {}; PID: {}; CPU: {}%? (y/n) '.format(nn['notebook']['path'], pid, cpu))
                        if interrupt.lower() == 'y':
                            p = psutil.Process(pid)
                            while p.cpu_percent(interval=0.1) > cpu_threshold:
                                kill(pid, signal.SIGINT)
                                sleep(0.5)

if __name__ == '__main__':
    interrupt_bad_notebooks()