Articles

Faísca Acumulador

Spark-Accumulator

Spark-Accumulator

Introdução a Faísca Acumulador

variáveis Compartilhadas são usados pelo Apache Faísca. Quando um executor de cluster é enviado uma tarefa pelo driver, cada nó do cluster recebe uma cópia das variáveis compartilhadas. Existem dois tipos básicos suportados pelo Apache Spark de variáveis compartilhadas-Acumulador e transmissão. O Apache Spark é amplamente utilizado e é uma estrutura de computação de cluster de código aberto. Isso vem com recursos como aprendizado de máquina de computação, streaming de APIs e algoritmos de processamento de gráficos. Variáveis que são adicionadas por meio de operações associadas são acumuladores. A implementação de somas e contadores é um dos exemplos de tarefas de acumulador e há muitas outras tarefas como tal. Os tipos numéricos são suportados pelo spark facilmente do que qualquer outro tipo, mas o suporte pode ser adicionado a outros tipos pelos programadores.

sintaxe:

comece seu curso gratuito de Ciência de dados

Hadoop, Ciência de Dados, Estatística & outros

o código acima compartilha os detalhes do Acumulador de classe do PySpark.

val acc = sc.accumulator(v)

inicialmente v é definido como zero mais preferencialmente quando se executa soma r uma operação de contagem.

por que usamos Acumulador de faísca?

quando um usuário deseja realizar operações comunicativas ou associadas nos dados, usamos o Acumulador Spark. Eles podem ser criados sem ou com um nome. A interface do usuário do Sparks ajuda a visualizar o nome criado com o acumulador e isso também pode ser útil para entender o progresso dos estágios em execução. Chamando SparkContext.acumulador (v), O acumulador pode ser criado tomando o valor inicial como v, assim como semelhante ao Spark broadcast. Usado na implementação de somas e operações de contador como em funções MapReduce. Acumuladores não são suportados em Python.

Código:

package org.spark.accumulator.crowd.now.aggregator.sample2
var lalaLines: Int = 0
sc.textFile("some log file", 4)
.forech { line =>
if (line.length() == 0) lalaLines += 1
}
println (s " Lala Lines are from the above code = $lalaLines")

no código acima, o valor será zero quando a saída do código de linhas em branco for impressa. Mudança de código pelo Spark para cada executor, as variáveis são locais para esse executor e o valor mais recente e atualizado não é devolvido ao driver. Fazer as linhas em branco como acumulador pode resolver o problema acima. E isso ajudará a atualizar todas as alterações em cada variável em cada executor.

curso Popular nesta categoria
Apache Spark Training (3 cursos) 3 Cursos Online / 13 + horas / Certificado verificável de conclusão / acesso vitalício
4.5 (5,391 classificações)

Preço
Ver Curso de

Cursos Relacionados

PySpark Tutoriais (3 Cursos)Apache Tempestade de Formação (1 Cursos)

O código acima é escrito desta forma:

Código:

package org.spark.accumulator.crowd.now.aggregator.sample2
var lalaLines = sc.accumulator(, "lala Lines")
sc.textFile("some log file", 4)
.forech { line =>
if (line.length() == 0) lalaLines += 1
}
println (s "\tlala Lines are from the above code = $lalaLines.value")
This code makes sure that the accumulator blankLine is up to date across each executor and relays back to the driver.

Como Faísca Acumulador de Trabalho?

variáveis de transmissão permitem que os desenvolvedores do Spark mantenham uma variável em cache somente leitura segura em nós diferentes. Com as tarefas necessárias, apenas enviando uma cópia meramente. Sem ter que perder muito tempo e transferência de entrada e saída de rede, eles podem ser usados para fornecer a um nó uma grande cópia do conjunto de dados de entrada. As variáveis de transmissão podem ser distribuídas pelo Spark usando uma variedade de algoritmos de acumulador que podem se transformar em grande parte e o custo da comunicação é reduzido.

existem diferentes estágios na execução das ações do Spark. Os estágios são então separados por operação-shuffle. Em cada estágio, o Spark accumulator automaticamente os dados comuns precisam estar no cache e devem ser serializados a partir dos quais novamente serão desserializados por cada nó antes que cada tarefa seja executada. E por essa causa, se as variáveis da transmissão forem criadas explicitamente, as várias tarefas encenadas todas as necessárias com os mesmos dados, o acima deve ser feito.

a criação de variável de transmissão acima mencionada envolvendo a função SparkConext.acumulador, o código para ele é:

Código:

val accum = sc.accumulator(0)
accum: spark.Accumulator = 0
sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum += x)
accum.value
res2: Int = 20
package org.spark.accumulator.crowd.now.aggregator.sample2
object Boot {
import util.is
def main(args: Array): Unit = {
val sparkConfigiration = new Spark.Configuration(true)
.setMaster_("L")
.setNameOfApp("Analyzer Spark")
val sparkContext = new Spark.Context(spark.Configuration)
val httpStatusList = sparkContext broadcast populateHttpStatusList
val Info_http = sparkContext accumulator(0, "HTTP a")
val Success_http = sparkContext accumulator(0, "HTTP b")
val Redirect_http = sparkContext accumulator(0, "HTTP c")
val Client.Error_http = sparkContext accumulator(0, "HTTP d")
val Server.Error_http = sparkContext accumulator(0, "HTTP e")
sparkContext.tf(gClass.gRes("log").gPath,
println("THE_START")
println("HttpStatusCodes are going to be printed in result from access the log parse")
println("Http Status Info")
println("Status Success")
println("Status Redirect")
println("Client Error")
println("Server Error")
println("THE_END")
spark.Context.stop()
}
}
}

a variável da transmissão é chamada de valor e armazena os dados do Usuário. A variável também retorna um valor de transmissão.

accumulator_ = sc.accumulator(0)
rdd = sc.parallelize()
def f(x):
global accumulator_
accum += x
rdd.foreach(f)
accum.value

O acumulador de linha de comando é dado abaixo:

$SPARK_HOME/bin/spark-submit accumulator.py

Saída:

Faísca Acumulador Exemplo

Faísca Acumulador Exemplo

Vantagens e Utilizações de Faísca Acumulador

Memória de acesso é muito direta.

  1. os valores de lixo são menos coletados na sobrecarga de processamento.
  2. o formato de memória é colunar compacto.
  3. otimização do catalisador de consulta.
  4. a geração de código é todo o estágio.
  5. vantagens de compilar o tipo de bloco por conjuntos de dados sobre os quadros de dados.

conclusão

vimos o conceito do Acumulador de faísca. O Spark usa variáveis compartilhadas, para processamento e paralelo. Para agregações de informações e associações e operações comunicativas, são utilizadas variáveis acumuladoras. no mapa-reduzir, para somar o contador ou operação, podemos usar um acumulador. Enquanto no spark, as variáveis são mutáveis. O valor do acumulador não pode ser lido pelos executores. Mas apenas o programa de driver pode. O contador no Map reduce java é semelhante a isso.

artigos recomendados

este é um guia para Acumulador de faísca. Aqui discutimos Introdução ao acumulador de faísca e como ele funciona junto com suas vantagens e usos. Você também pode ler nossos outros artigos sugeridos para saber mais–

  1. funções matemáticas JavaScript(exemplos)
  2. Top 9 tipos de compiladores Java
  3. Arquitetura Android | O Que É Arquitetura Android?
  4. Top 9 Android Ad Blocker
1 Shares

Deixe uma resposta

O seu endereço de email não será publicado.