Ipython: Kernel / Interromper Kernel não encerra subprocessos presos no notebook

duplicado de # 514

Obrigado, eu não tinha localizado a duplicata. Dito isso, t # 514 está discutindo um cenário muito mais complexo, envolvendo a interação real com subprocessos (e parece ser baseado em Unix, já que se trata de interação no estilo pty). Para minhas necessidades, um meio simples de matar um subprocesso desonesto seria o suficiente. Considere algo tão simples como !sleep 50000 , onde apenas ser capaz de matar o sono é tudo o que você deseja. (Talvez Ctrl-C funcione para isso no Unix, mas não no Windows).

Desculpe, entendo o que você quer dizer agora. Reabertura como um problema separado - interromper, não interrompendo subprocessos no Windows.

Não tenho certeza se isso se limita a subprocessos. Tente executar input() ou raw_input() e então clicar no botão de interrupção - o kernel trava e precisa ser reiniciado.

@arijun em qual sistema operacional? interromper a entrada e raw_input aumenta o KeyboardInterrupt aqui (OS X).

Desculpe, windows. É por isso que pensei que provavelmente fosse o mesmo problema que @pfmoore tinha, já que isso também acontecia no Windows.

Ah, merda. Eu sei o que é esse bug. Eu acho que é um bug libzmq (ou pyzmq) que o impede de lidar com interrupções corretamente durante a votação em sockets zmq. Não é nada no IPython. _suspirar_

Acho que acabei de ser mordido por isso e vou precisar reiniciar o kernel, o que significa que acabei de perder muitos dados ...

Eu estava usando pdb para depurar uma função. Eu executei novamente a célula sem primeiro sair de pdb , e agora não posso interromper nada.

Aqui está um exemplo mínimo que reproduz isso:

def test():
    import pdb; pdb.set_trace()  # XXX BREAKPOINT
    return 0

test()

Execute esta célula duas vezes seguidas.

Este mesmo problema acontece comigo no Unix, palavra por palavra.

"Quando um subprocesso é executado a partir do notebook, se ele travar, o kernel ficará travado esperando por ele. Selecionar Kernel / Interromper no menu não encerra o subprocesso, mas deixa o kernel em um estado instável," parcialmente travado " , onde outras células não são executadas. A única resolução é reiniciar o kernel. "

Obrigado pelo bom exemplo de travamento de PDB, wmayner. Mas visto que o pdb não é executado em um subprocesso, abri um problema separado para o pdb: # 10516

Imprimir muitos dados, digamos, imprimir acidentalmente uma matriz numpy gigante, pode fazer com que o kernel pare de responder completamente e seja impossível encerrar

Já foi encontrada uma solução para esse problema? Acabei de executar um modelo de aprendizado de máquina que levou 14 horas para ser concluído e agora meu kernel está travado e não executa células. se eu reiniciar, terei que executar o modelo novamente por 14 horas. Então, existe alguma solução?

ainda não tentei, mas parece que pode ajudar: http://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/limit_output/readme.html

Se um subprocesso específico travou, você provavelmente pode encontrá-lo no gerenciador de tarefas e eliminá-lo à força dessa forma. Esperançosamente, isso permite que o kernel continue.

não, o problema é que o kernel spams o servidor da web até a morte ou algo assim. matar o servidor web mata o kernel afaik

Também estou lidando com um notebook preso: interromper, reiniciar, reconectar - nenhum deles faz nada. Os indicadores [*] permanecem próximos às células como se estivessem na fila para execução, mas nenhuma célula foi executada.

O comportamento começou após a execução de uma célula contendo:

filedir = "20161214_rooftest"

!ls -RC $filedir

O que é estranho porque tenho células análogas em outros lugares que funcionam com sucesso. Não tenho certeza de como / se ls pode travar, mas, de outra forma, minha situação parece corresponder a esse problema.

Há alguma solução para isso . Kernal não pode ser interrompido.
Para mim, isso está acontecendo com GridSearchCV no sklearn.

Houve um processo denominado conda.exe no gerenciador de tarefas. Eu matei aquele processo e consegui interromper com sucesso o kernel

A interrupção ainda está quebrada. Tenho que reiniciar e recarregar minhas importações todas as vezes.

mesmo problema no laboratório jupyter no kernel python 3.7

mesmo problema no Jupyter Notebook e não consigo encontrar o processo denominado conda.exe no Gerenciador de tarefas. Alguma atualização da solução ainda?

Não é uma solução
Às vezes, tentar reconectar ao kernel ajuda neste caso

Observando o mesmo, no Windows 10

Alguém teve sucesso nisso? Estou ficando louco

Houve um processo denominado conda.exe no gerenciador de tarefas. Eu matei aquele processo e consegui interromper com sucesso o kernel

@ahmedrao How ????

Este problema existe há seis anos e ainda não tem solução.

Este problema existe há seis anos e ainda não tem solução.

seis anos sem nenhuma solução, basta reiniciar o kernel

Tendo o mesmo problema cada vez mais frequente, quase ao ponto de os portáteis ficarem inutilizáveis, o que é uma verdadeira vergonha. No Anaconda 3.7, as células ficam penduradas com o asterisco e não consigo interromper o kernel.

Marcar o mesmo problema

Sempre tive esse problema principalmente com dbg e input.
Windows 10; Servidor de notebook 5.7.8; Python 3.6.6 .; Conda 4.7.5
Aprendi que basicamente não consigo depurar Notebooks de maneira confiável :(

sim, o problema ainda existe. Existe alguma maneira de superar isso ?? Não quero correr meu notebook de novo, porque demora muito para chegar onde estou !!

Acima!
Este problema tem sido uma dor para mim há anos, sempre que uso o PDB e me esqueço de sair antes de executar novamente o celular.

Eu criei uma recompensa no BountySource. Talvez isso seja finalmente consertado se conseguirmos juntar dinheiro suficiente.
https://www.bountysource.com/issues/44958889-hang-after-running-pdb-in-a-cell-kernel-interrupt-doesn-t-help

Para o problema do processo especificamente, especificamente no Windows, aqui está uma teoria (ainda não testada):

1. O processo é executado por meio de IPython.utils._process_win32.system , que chama _system_body , que chama p.wait() no objeto subprocess.Popen .
2. O Windows subprocess.Popen.wait() tem um problema conhecido em que não pode ser interrompido: https://bugs.python.org/issue28168

Se essa for a causa, alternar para loop ocupado a cada 100ms ou mais provavelmente o tornaria interrompível, ou se não, seguir a abordagem no patch.

Obrigada @Carreau!

Obrigado @Carreau! Quando isso chegará a um lançamento geral, e isso significa que poderemos usar o botão Interromper Kernel com sucesso?

Provavelmente farei um 7,13 amanhã. Isso pode corrigir o botão de interrupção.

Ei @Carreau
Estou enfrentando esse problema quando tento interromper a execução de uma célula em andamento, a interrupção continua indefinidamente e, finalmente, preciso reiniciar.

Então, para demonstrar, como @wmayner sugeriu uma maneira de replicar o problema. Anexei algumas imagens para o mesmo.

Versões do Jupyter na minha máquina.

@ Arpit-Gole pdb é um problema específico; Também espero consertar isso em breve: https://github.com/ipython/ipython/issues/10516

@itamarst , estou treinando um modelo da seguinte maneira:

forest_clf = RandomForestClassifier() cross_val_score(forest_clf, X_train, y_train, cv=3, scoring='accuracy', verbose=10, n_jobs=-1)

Agora eu sei que vai demorar, com base no meu conjunto de dados. Mas digamos que por algum motivo eu decida interromper o processamento na metade pressionando Kernel> Interromper Kernel .
Idealmente, deveria interromper, mas leva uma eternidade para parar.
Agora não quero reiniciar porque todo o meu progresso terá acabado.

Por favor ajude!

Se o que você está tentando interromper for implementado em C, não há nada a fazer. Depende da biblioteca que você usa para lidar com o sigint.

Também me deparo com isso às vezes ... Aqui está um exemplo reproduzível do laboratório jupyer:

CARREGAR DADOS

import requests
import pandas as pd

url='https://raw.githubusercontent.com/numenta/NAB/master/data/realKnownCause/nyc_taxi.csv'
r = requests.get(url, allow_redirects=True)
        with open('data/nyc_taxi.csv', 'wb') as f:
            f.write(r.content)
df_taxi = (
        pd.read_csv('data/nyc_taxi.csv')
        .assign(timestamp=lambda x: pd.to_datetime(x.timestamp))
)

df_train = df_taxi.iloc[:5000]
temp_train = df_train.set_index('timestamp')

Executar pesquisa de grade: ISSO NÃO PODE SER INTERROMPIDO

import itertools
#set parameter range
p = range(0,3)
q = range(1,3)
d = range(1,2)
s = [24,48]

# list of all parameter combos
pdq = list(itertools.product(p, d, q))
seasonal_pdq = list(itertools.product(p, d, q, s))
# SARIMA model pipeline
for param in pdq:
    for param_seasonal in seasonal_pdq:
        try:
            mod = sm.tsa.statespace.SARIMAX(temp_train[:240],
                                            order=param,
                                            seasonal_order=param_seasonal)

            results = mod.fit(max_iter = 50, method = 'powell')

            print('SARIMA{},{} - AIC:{}'.format(param, param_seasonal, results.aic))
        except as e:
            print(e)
            continue

Existe algum conselho?

me deparei com esse problema três vezes esta tarde, me lembra dos bons velhos tempos, quando eu ainda estava usando o urllib.
pensei que está no urllib, porque não há resposta ao meu pedido.
Eu estava trabalhando, mas programando, eu tenho que encontrar uma solução, mas uma resposta. Portanto, armazeno todas as variáveis ​​em um arquivo local.
realmente não quero ver isso acontecer novamente e novamente.

Estou enfrentando o mesmo problema ao usar tensorflow e gpu para o modelo de aprendizado profundo de treinamento.

Correr para isso com time.sleep e requests

Também tendo esse problema com solicitações time.sleep no Windows, mas funciona bem no Mac OS X

Tendo este problema com ThreadPoolExecutor ... Algo assim:

numberOfImageGatherers = 2

with concurrent.futures.ThreadPoolExecutor(max_workers=numberOfImageGatherers + 1) as executor:
        futures = []

        for imageGatherer in range(numberOfImageGatherers):
            imageDataGatherer = ImageDataGatherer(batch_size)
            futures.append(executor.submit(imageDataGatherer.gatherImageData, pipeline))

        modelTrainingConsumer = ModelTrainingConsumer(vae, plot_losses)    

        futures.append(executor.submit(modelTrainingConsumer.trainModel, pipeline))

        concurrent.futures.wait(futures)

A única maneira de interromper é reiniciar o kernel ... muito frustrante