Correndo em python paralelo para a ciência de dados
A maioria dos computadores hoje são múltiplos núcleos (dois ou mais processadores em um único pacote), alguns com múltiplas CPUs físicas. Uma das limitações mais importantes de Python é que ele usa um único núcleo por padrão. (Foi criado em um momento em que os núcleos individuais eram a norma.)
projetos de ciência de dados exigem um monte de cálculos. Em particular, uma parte do aspecto científico da ciência de dados baseia-se em repetidos testes e experiências em diferentes matrizes de dados. Não se esqueça de que trabalhar com quantidades enormes de dados significa que a maioria das transformações demoradas repetir observação após observação (por exemplo, operações relacionadas idênticos e não em partes diferentes de uma matriz).
Usando mais núcleos de CPU acelera a computação por um fator que quase coincide com o número de núcleos. Por exemplo, ter quatro núcleos significaria trabalhar na melhor das quatro vezes mais rápido. Você não recebe um aumento de quatro vezes completo, pois há sobrecarga quando se inicia um processo paralelo - novas instâncias em execução Python tem que ser configurado com a informação certa na memória e launched- consequentemente, a melhoria será menor do que potencialmente viável, mas ainda significativo.
Saber usar mais de uma CPU é, portanto, uma habilidade avançada, mas incrivelmente útil para aumentar o número de análises realizadas, e para acelerar as operações de ambos ao configurar e quando usar seus produtos de dados.
Multiprocessamento funciona, replicando o mesmo conteúdo de código e memória em várias novas instâncias Python (os trabalhadores), o cálculo do resultado para cada um deles, e retornando os resultados agrupados para o principal console original. Se a instância original já ocupa grande parte da memória RAM disponível, não será possível criar novas instâncias, e sua máquina pode ficar sem memória.
Realizando multicore paralelismo
Para realizar o paralelismo multicore com o Python, você integrar o scikit-learn pacote com o pacote joblib para operações demoradas, como replicar modelos para validação dos resultados ou para procurar as melhores hiper-parâmetros. Em particular, scikit-learn permite multiprocessamento quando
Cross-validação: Testando os resultados de uma hipótese máquina-learning usando formação diferente e testando dados
Grid-pesquisa: Sistematicamente mudando as hiper-parâmetros de uma hipótese de aprendizado de máquina e testar os consequentes resultados
predição Multilabel: Executando um algoritmo várias vezes contra múltiplos alvos quando há muitos resultados alvo diferentes para prever, ao mesmo tempo
métodos de aprendizagem de máquina Ensemble: A modelagem de uma grande série de classificadores, cada um independente do outro, tal como quando se utiliza Floresta aleatória-modelagem baseada
Você não tem que fazer nada especial para tirar proveito de computações paralelas - você pode ativar o paralelismo definindo o n_jobs parâmetro para um número de núcleos de mais de 1 ou definindo o valor para -1, o que significa que pretende utilizar todas as instâncias de CPU disponíveis.
Se você não estiver executando o código a partir do console ou de um Notebook IPython, é extremamente importante que você separar o seu código a partir de qualquer importação pacote ou atribuição de variável global em seu script usando a se __name __ ==‘__a Principal__’: comando no início de qualquer código que executa multicore paralelismo. o E se instrução verifica se o programa é executado diretamente ou é chamado por um console Python já em execução, evitando qualquer confusão ou erro pelo processo multiparalela (como recursivamente chamar o paralelismo).
demonstrando multiprocessamento
É uma boa idéia usar IPython quando você executa uma demonstração de como multiprocessamento pode realmente lhe poupar tempo durante projetos de ciência de dados. Usando IPython proporciona a vantagem de utilizar o % timeit comando mágica para cronometrar a execução. Você começa por carregar um conjunto de dados multiclasse, um algoritmo de aprendizagem de máquina complexa (o Support Vector classificador, ou SVC), e um procedimento de validação cruzada para estimar pontuações resultantes de confiança de todos os procedimentos.
A coisa mais importante a saber é que os procedimentos se tornar muito grande porque o SVC produz 10 modelos, que se repete 10 vezes cada um usando validação cruzada, para um total de 100 modelos.
de sklearn.datasets importar load_digitsdigits = load_digits () X, Y = digits.data, digits.targetfrom sklearn.svm importação SVCfrom sklearn.cross_validation importação cross_val_score% timeit single_core_learning = cross_val_score (SVC (), X, Y, CV = 20, n_jobs = 1) Fora [1]: 1 loops, melhor de 3: 17.9 s por laço
Após este teste, você precisa ativar o paralelismo multicore e do tempo os resultados usando os seguintes comandos:
% Timeit multi_core_learning = cross_val_score (SVC (), X, Y, CV = 20, n_jobs = -1) Fora [2]: 1 loops, melhor de 3: 11,7 s por ciclo
A máquina de exemplo demonstra uma vantagem positiva utilizando o processamento multicore, apesar de usar um pequeno conjunto de dados onde Python passa a maior parte do tempo de partida consoles e executando uma parte do código em cada um. Esta sobrecarga, de alguns segundos, ainda é significativo, dado que o total de execução se estende para um pequeno número de segundos. Basta imaginar o que aconteceria se você trabalhou com grandes conjuntos de dados - o seu tempo de execução poderia ser facilmente cortadas por duas ou três vezes.
Embora o código funciona bem com IPython, colocando-o em um script e pedindo Python para executá-lo em um console ou usando um IDE pode causar erros por causa das operações internas de uma tarefa multicore. A solução é colocar todo o código no âmbito de um E se declaração, que verifica se o programa iniciado diretamente e não foi chamado depois. Aqui está um exemplo de script:
de sklearn.datasets importar load_digitsfrom sklearn.svm importação importação SVCfrom sklearn.cross_validation cross_val_scoreif __name__ == `__main __`: dígitos = load_digits () X, Y = digits.data, digits.targetmulti_core_learning = cross_val_score (SVC (), X, Y, CV = 20, n_jobs = -1)