He empezado a utilizar el IPython Notebook y estoy disfrutando. A veces, escribo código erróneo que lleva a enormes requisitos de memoria o tiene un bucle infinito. Me parece la «interrupción del núcleo» opción lento o poco fiables, y a veces tengo que reiniciar el kernel, perdiendo todo en la memoria.

A veces yo también la escritura de guiones de que la causa de OS X para que se ejecute fuera de la memoria, y tengo que hacer un reinicio. No estoy 100% seguro, pero cuando he escrito errores como esto antes, y corrió de Python en el terminal, por lo general se puede CTRL+C mis scripts.

Estoy usando la Anaconda distribución de IPython notebook con Firefox en Mac OS X.

  • Nunca he tenido éxito en la interrupción de un bucle infinito a través de la cntrl+m i acceso directo o el kernel>interrupción de la lista desplegable en la 0.13 (predeterminado para anaconda en MacOSX). El problema parece estar solucionado en la versión 1.0.
InformationsquelleAutor wwwilliam | 2013-07-10

6 Comentarios

  1. 52

    Yo podría estar equivocado, pero estoy bastante seguro de que la «interrupción del núcleo» botón envía una señal SIGINT para el código que se está ejecutando actualmente (esta idea es apoyada por Fernando el comentario de aquí), lo que es lo mismo que presionar CTRL+C iba a hacer. Algunos procesos dentro de python manejar SIGINTs más abruptamente que otros.

    Si usted necesita desesperadamente de detener algo que se está ejecutando en iPython Notebook y comenzó iPython Notebook desde un terminal, se puede pulsar CTRL+C dos veces en la terminal que interrumpir todo el iPython Notebook servidor. Esto va a dejar de iPython Notebook de manera consecutiva, lo que significa que no será posible reiniciar o guardar su trabajo, por lo que esta no es, obviamente, una gran solución (que usted necesita para golpear CTRL+C dos veces porque es una característica de seguridad para que la gente no lo hago por accidente). En caso de emergencia, sin embargo, generalmente se mata el proceso más rápidamente que la «interrupción del núcleo» botón.

    • Alternativamente, usted puede reiniciar o detener la ofensiva del núcleo – menos drástica que la de matar el ipython servidor. Esto se puede hacer desde el Kernel desplegable o de la notebook del servidor de la página (el Shutdown botón a la derecha del infractor de la notebook nombre).
    • Por desgracia parece que el navegador puede llegar a ser tan insensible, que es difícil llegar a la página del servidor.
    • Es allí una manera de interrumpir un proceso en el jupyter-console? II/control-c no funciona. Y no hay otro atajo para reiniciar el kernel.
  2. 62

    Puede pulsar I dos veces para interrumpir el kernel.

    Esto sólo funciona si usted está en el modo de Comando. Si no lo está, pulse Esc para activarla.

    • ¿Esto es para una versión específica de la gama de IPython o un sistema operativo específico?
    • Sólo funciona si estás en «escape modo».
  3. 4

    Aquí son accesos directos para el IPython Notebook.

    Ctrl-m i interrumpe el kernel. (que es, la única carta que después de Ctrl-m)

    Según este respuesta, I dos veces funciona igual de bien.

  4. 4

    Para agregar a la anterior: Si la interrupción no está funcionando, usted puede reiniciar el kernel.

    Ir al núcleo desplegable >> reiniciar >> reinicie y salida clara. Esto normalmente hace el truco. Si esto no funciona, matar el kernel en el terminal (o el administrador de tareas) y, a continuación, reinicie.

    De interrupción no funciona bien para todos los procesos. Yo, en particular, tienen este problema con la R del núcleo.

    • Este truco lo hizo por mí: totalmente de responder Jupyter Notebook debido a la multi-core kmeans la agrupación de 2 Millones de entradas (debería haber sabido antes)
    • No parece funcionar mejor que la interrupción para mí.
  5. 1

    ACTUALIZACIÓN: vuelta a mi de la solución en un stand-alone secuencia de comandos de python.

    Esta solución me ha salvado más de una vez. Esperemos que otros encuentran que es útil. Esta secuencia de comandos de python se encontró ninguna jupyter núcleo con más de cpu_threshold de la CPU y le pide al usuario enviar un SIGINT para el kernel (KeyboardInterrupt). Se mantendrá el envío de SIGINT hasta el núcleo de la cpu de la que va por debajo de cpu_threshold. Si hay varios desmanes de los kernels se solicitará al usuario la interrupción de cada uno de ellos (ordenado por uso de CPU más alto al más bajo). Un gran agradecimiento a gcbeltramini para la escritura del código para encontrar el nombre de un jupyter kernel usando el jupyter de la api. Este script ha sido probado en MACOS con python3 y requiere jupyter notebook, solicitudes, json y psutil.

    Poner el script en el directorio de inicio y, a continuación, el uso parece:

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

    Código de secuencia de comandos a continuación:

    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()
  6. -1

    Una alternativa más rápida será simplemente copie la dirección localhost, Ctrl C en cmd para detener el servidor, reiniciar el servidor, a continuación, pegue la dirección en una nueva pestaña.

Dejar respuesta

Please enter your comment!
Please enter your name here