Executando em Python Paralelo para Ciência de Dados - dummies

A maioria dos computadores hoje são multicore (dois ou mais processadores em um único pacote), alguns com várias CPUs físicas. Uma das limitações mais importantes do Python é que ele usa um único núcleo por padrão. (Foi criado em um momento em que os núcleos únicos eram a norma.)

Os projetos de ciência de dados requerem bastante computação. Em particular, uma parte do aspecto científico da ciência dos dados depende de testes repetidos e experimentos em diferentes matrizes de dados. Não se esqueça de que trabalhar com enormes quantidades de dados significa que a maioria das transformações demoradas repete a observação após a observação (por exemplo, operações idênticas e não relacionadas em diferentes partes de uma matriz).

O uso de mais núcleos de CPU acelera uma computação por um fator que quase corresponde ao número de núcleos. Por exemplo, ter quatro núcleos significaria trabalhar o melhor quatro vezes mais rápido. Você não recebe um aumento total de quatro vezes porque há sobrecarga ao iniciar um processo paralelo - novas instâncias do Python em execução devem ser configuradas com as informações da memória direita e iniciadas; conseqüentemente, a melhoria será menor que potencialmente viável, mas ainda significativa.

Conhecer como usar mais de uma CPU é, portanto, uma habilidade avançada, mas incrivelmente útil, para aumentar o número de análises concluídas e para acelerar suas operações tanto na configuração como no uso de seus produtos de dados.

O multiprocessamento funciona replicando o mesmo código e conteúdo de memória em várias instâncias novas de Python (os trabalhadores), calculando o resultado para cada um deles e retornando os resultados agrupados ao console principal principal. Se sua 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 paralelismo multicore

Para realizar o paralelismo multicore com o Python, você integra o pacote Scikit-learn com o pacote joblib para operações que consomem tempo, como modelos de replicação para validação de resultados ou para procurar os melhores hiper-parâmetros. Em particular, Scikit-learn permite multiprocessamento quando

• validação cruzada: Testando os resultados de uma hipótese de aprendizado em máquina usando diferentes dados de treinamento e teste

• Grid-searching: Alterar sistematicamente os hiper-parâmetros de uma hipótese de aprendizagem em máquina e testando os resultados conseqüentes

• Predição de Multilabel: Executando um algoritmo várias vezes contra múltiplos destinos quando há muitos resultados alvo diferentes para prever ao mesmo tempo

• Ensemble métodos de aprendizagem mecânica: Modelando um grande número de classificadores, cada um independente do outro, como quando usa modelagem baseada em RandomForest

Você não precisa fazer nada de especial para aproveitar os cálculos paralelos - você pode ativar o paralelismo definindo O n_jobs -parameter a um número de núcleos mais de 1 ou ao definir o valor como -1, o que significa que você deseja usar todas as instâncias da CPU disponíveis.

Se você não estiver executando o seu código a partir do console ou de um notebook IPython, é extremamente importante que você separe seu código de qualquer importação de pacote ou atribuição de variável global em seu script, usando o if __name __ == '__ main__': comando no início de qualquer código que executa o paralelismo multicore. A instrução if verifica se o programa é executado diretamente ou é chamado por um console Python já executado, evitando qualquer confusão ou erro pelo processo multiparelário (como chamar recursivamente o paralelismo).

Demonstrando multiprocessamento

É uma boa idéia usar o IPython quando você executa uma demonstração de como o processamento múltiplo pode realmente lhe poupar tempo durante projetos de ciência de dados. O uso do IPython oferece a vantagem de usar o comando de% timeit magic para a execução de temporização. Você começa carregando um conjunto de dados multiclass, um algoritmo complexo de aprendizado de máquina (o Support Vector Classifier ou SVC) e um procedimento de validação cruzada para estimar pontuações resultantes confiáveis ​​de todos os procedimentos.

A coisa mais importante a saber é que os procedimentos tornam-se bastante amplos porque o SVC produz 10 modelos, que repete 10 vezes cada usando validação cruzada, para um total de 100 modelos.

da sklearn. conjuntos de dados importar dígitos load_digits = load_digits () X, y = dígitos. dados, dígitos. alvo de sklearn. svm importa SVC da sklearn. cross_validation importar cross_val_score% timeit single_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = 1) Out [1]: 1 loops, o melhor de 3: 17. 9 s por loop

Após este teste, você precisa ativar o paralelismo multicore e o tempo dos resultados usando os seguintes comandos:

% timeit multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1) Out [2]: 1 loops, o melhor de 3: 11. 7 s per loop

A máquina exemplo demonstra uma vantagem positiva usando o processamento multicore, apesar de usar um pequeno conjunto de dados onde o Python passa a maior parte do tempo iniciando consoles e executando uma parte do código em cada um deles. Esta sobrecarga, alguns segundos, ainda é significativa, uma vez que a execução total se estende por alguns segundos. Imagine o que aconteceria se você trabalhasse com conjuntos maiores de dados - seu tempo de execução poderia ser facilmente cortado duas ou três vezes.

Embora o código funcione bem com o IPython, colocá-lo em um script e pedir a Python para executá-lo em um console ou usar um IDE pode causar erros devido às operações internas de uma tarefa multicore. A solução é colocar todo o código sob uma instrução if, que verifica se o programa começou diretamente e não foi chamado posteriormente. Aqui está um exemplo de script:

da sklearn. conjuntos de dados importar valores de carga da sklearn. svm importa SVC da sklearn. cross_validation importar cross_val_score se __name__ == '__main__': digits = load_digits () X, y = digits. dados, dígitos. alvo multi_core_learning = cross_val_score (SVC (), X, y, cv = 20, n_jobs = -1)