%scala import org.apache.spark.sql.{DataFrame, SparkSession} import…
- User
%scala import org.apache.spark.sql.{DataFrame, SparkSession} import scala.collection.mutable
class CategoriaKeyword(spark: SparkSession) { def buscar_palavras_chave(categories_df: DataFrame, text_df: DataFrame): Array[(String, String, Int)] = { // Processar categorias e criar um mapa para agilizar as buscas posteriores val categoriasProcessadas = mutable.Map.empty[String, String] categories_df.foreach(row => { val categoria = row.getAsString val palavrasChaveCsv = row.getAsString if (palavrasChaveCsv != null && !palavrasChaveCsv.isEmpty) { val palavrasChaveArray = palavrasChaveCsv.split(", ") palavrasChaveArray.foreach(palavraChave => { categoriasProcessadas.put(palavraChave.toLowerCase, categoria.toLowerCase) }) } }) println("Categorias processadas: " + categoriasProcessadas)
// Procure por palavras-chave no DataFrame de texto e atribua a categoria mais provável do DataFrame de categorias. val resultado = text_df.map(row => { val texto = row.getAs[String](0).toLowerCase var maxPontuacao = 0 var categoriaMaiorPontuacao = "" categoriasProcessadas.foreach { case (palavraChave, categoria) => if (texto.contains(palavraChave)) { val pontuacao = texto.split("\\\\s+").count(_.equals(palavraChave)) if (pontuacao > maxPontuacao) { maxPontuacao = pontuacao categoriaMaiorPontuacao = categoria } } } (row.getAs[String](0), categoriaMaiorPontuacao, maxPontuacao) }) println("Resultado: " + resultado) resultado.collect()} }
object Main { def main(args: Array[String]) { val spark = SparkSession.builder .appName("CategoriaKeyword") .master("local") .getOrCreate() // Definir dados da tabela val categoriesDf = spark.createDataFrame(Seq( ("Cartões - Anuidade - Negociação", "anuidade, negociação"), ("Cartões - Anuidade - Estorno", "anuidade, estorno"), ("Cartões - Bloqueio", "bloqueio"), ("Cartões - Contestação - Lançamento não reconhecido", "contestação, lançamento"), ("Cartões - Contestação - Desacordo comercial", "contestação, desacordo"), ("Cartões - Desbloqueio", "desbloqueio"), ("Cartões - Fatura - segunda via", "fatura, segunda via"), ("Cartões - Fatura - Detalhamento", "fatura, detalhamento"), ("Cartões - Fatura - Pagamento", "fatura, pagamento"), ("Cartões - Limite - Aumento", "limite, aumento"), ("Cartões - Limite - Redução", "limite, redução"), ("Cartões - Não Recebimento do cartão, Emissão segunda via", "não recebimento, emissão"), ("Cartões - Solicitação de segunda via do cartão", "solicitação, segunda via"), ("Cartões - Cancelamento", "cancelamento"), ("Cartões - Compra não autorizada", "compra, não autorizada"), ("Cartões - Fatura - Recalculo", "fatura, recalculo"), ("Cartões - Parcelamento - Contratação", "parcelamento, contratação"), ("Cartões - Fatura - Antecipação de Parcelas", "fatura, antecipação") )).toDF("categoria", "palavras_chave")
val textoDf = spark.createDataFrame(Seq( ("Estou com problemas com a fatura e a segunda via do cartão.", None), ("Preciso de um bloqueio imediato no meu cartão.", None), ("Qual o procedimento para contestar uma cobrança?", None), ("Gostaria de solicitar a emissão de uma segunda via.", None), ("Minha fatura foi recalculada e não está correta.", None) )).toDF("texto", "categoria") // Criar instância do CategoriaKeyword val categorizador = new CategoriaKeyword(spark) // Executar a busca por palavras-chave val resultadoDf = categorizador.buscar_palavras_chave(categoriesDf, textoDf) // Mostrar o resultado println("Resultado:") resultadoDf.foreach(println)} }cmd12.sc:45: value appName is not a member of org.apache.spark.sql.SparkSession.Builder possible cause: maybe a semicolon is missing before `value appName'? .appName("CategoriaKeyword") ^Compilation Failed Compilation Failed
- Assistant
The error message indicates that you're trying to call
appNameon an object that doesn't have this method. This is likely due to a missing import or incorrect Spark version configuration. However, if you're confident that you are using the correct version of Spark, let's make sure that other potential issues are resolved. I'll also suggest a few improvements and corrections to your script:- Ensure you have imported
org.apache.spark.sql.SparkSession. - Verify that your Spark environment is set up correctly.
- Ensure that the
sparkobject is created correctly.
Here's the corrected Scala code:
import org.apache.spark.sql.{DataFrame, SparkSession} import scala.collection.mutable class CategoriaKeyword(spark: SparkSession) { def buscar_palavras_chave(categories_df: DataFrame, text_df: DataFrame): Array[(String, String, Int)] = { // Processar categorias e criar um mapa para agilizar as buscas posteriores val categoriasProcessadas = mutable.Map.empty[String, String] categories_df.collect().foreach(row => { val categoria = row.getAs[String]("categoria") val palavrasChaveCsv = row.getAs[String]("palavras_chave") if (palavrasChaveCsv != null && !palavrasChaveCsv.isEmpty) { val palavrasChaveArray = palavrasChaveCsv.split(", ") palavrasChaveArray.foreach(palavraChave => { categoriasProcessadas.put(palavraChave.toLowerCase, categoria.toLowerCase) }) } }) println("Categorias processadas: " + categoriasProcessadas) // Procure por palavras-chave no DataFrame de texto e atribua a categoria mais provável do DataFrame de categorias. import spark.implicits._ val resultado = text_df.map(row => { val texto = row.getAs[String]("texto").toLowerCase var maxPontuacao = 0 var categoriaMaiorPontuacao = "" categoriasProcessadas.foreach { case (palavraChave, categoria) => if (texto.contains(palavraChave)) { val pontuacao = texto.split("\\s+").count(_.equals(palavraChave)) if (pontuacao > maxPontuacao) { maxPontuacao = pontuacao categoriaMaiorPontuacao = categoria } } } (row.getAs[String]("texto"), categoriaMaiorPontuacao, maxPontuacao) }) println("Resultado: " + resultado) resultado.collect() } } object Main { def main(args: Array[String]) { val spark = SparkSession.builder .appName("CategoriaKeyword") .master("local[*]") // Using local[*] to specify using all local cores .getOrCreate() import spark.implicits._ val categoriesDf = Seq( ("Cartões - Anuidade - Negociação", "anuidade, negociação"), ("Cartões - Anuidade - Estorno", "anuidade, estorno"), ("Cartões - Bloqueio", "bloqueio"), ("Cartões - Contestação - Lançamento não reconhecido", "contestação, lançamento"), ("Cartões - Contestação - Desacordo comercial", "contestação, desacordo"), ("Cartões - Desbloqueio", "desbloqueio"), ("Cartões - Fatura - segunda via", "fatura, segunda via"), ("Cartões - Fatura - Detalhamento", "fatura, detalhamento"), ("Cartões - Fatura - Pagamento", "fatura, pagamento"), ("Cartões - Limite - Aumento", "limite, aumento"), ("Cartões - Limite - Redução", "limite, redução"), ("Cartões - Não Recebimento do cartão, Emissão segunda via", "não recebimento, emissão"), ("Cartões - Solicitação de segunda via do cartão", "solicitação, segunda via"), ("Cartões - Cancelamento", "cancelamento"), ("Cartões - Compra não autorizada", "compra, não autorizada"), ("Cartões - Fatura - Recalculo", "fatura, recalculo"), ("Cartões - Parcelamento - Contratação", "parcelamento, contratação"), ("Cartões - Fatura - Antecipação de Parcelas", "fatura, antecipação") ).toDF("categoria", "palavras_chave") val textoDf = Seq( ("Estou com problemas com a fatura e a segunda via do cartão.", None), ("Preciso de um bloqueio imediato no meu cartão.", None), ("Qual o procedimento para contestar uma cobrança?", None), ("Gostaria de solicitar a emissão de uma segunda via.", None), ("Minha fatura foi recalculada e não está correta.", None) ).toDF("texto", "categoria") val categorizador = new CategoriaKeyword(spark) val resultado = categorizador.buscar_palavras_chave(categoriesDf, textoDf) println("Resultado:") resultado.foreach(println) // Stop the Spark session spark.stop() } }This solution ensures the
foreachon a DataFrame is used correctly and collects values into thecategoriasProcessadasmap. It creates the necessary Spark session configurations, uses appropriate Spark APIs, and correctly processes the data. Remember to check your Scala and Spark versions compatibility to avoid other configuration issues. - Ensure you have imported
- User
(console):23:5 expected (
this| Id) val resultado = text_df.map(row => { ^ (console):23:5 expected (this| Id) - Assistant
The error message you're seeing is likely due to the context in which you're running your Scala code. The
(console)indicates that you're likely using a REPL (Read-Eval-Print Loop) environment or a similar interactive shell that might have restrictions or require slightly different syntax.Let's focus on making sure the code is structured correctly for use in such an environment, and I'll guide you on running it properly:
Modified Version for REPL:
When using a REPL or executing script files, some features like defining classes or objects behave slightly differently. Here's a version of the code broken down into steps that should work well interactively:
import org.apache.spark.sql.{DataFrame, SparkSession} import scala.collection.mutable val spark = SparkSession.builder .appName("CategoriaKeyword") .master("local[*]") // Use local cores .getOrCreate() import spark.implicits._ // Define the class class CategoriaKeyword(spark: SparkSession) { def buscar_palavras_chave(categories_df: DataFrame, text_df: DataFrame): Array[(String, String, Int)] = { val categoriasProcessadas = mutable.Map.empty[String, String] categories_df.collect().foreach(row => { val categoria = row.getAs[String]("categoria") val palavrasChaveCsv = row.getAs[String]("palavras_chave") if (palavrasChaveCsv != null && !palavrasChaveCsv.isEmpty) { val palavrasChaveArray = palavrasChaveCsv.split(", ") palavrasChaveArray.foreach(palavraChave => { categoriasProcessadas.put(palavraChave.toLowerCase, categoria.toLowerCase) }) } }) println("Categorias processadas: " + categoriasProcessadas) val resultado = text_df.collect().map(row => { val texto = row.getAs[String]("texto").toLowerCase var maxPontuacao = 0 var categoriaMaiorPontuacao = "" categoriasProcessadas.foreach { case (palavraChave, categoria) => if (texto.contains(palavraChave)) { val pontuacao = texto.split("\\s+").count(_.equals(palavraChave)) if (pontuacao > maxPontuacao) { maxPontuacao = pontuacao categoriaMaiorPontuacao = categoria } } } (row.getAs[String]("texto"), categoriaMaiorPontuacao, maxPontuacao) }) println("Resultado: " + resultado.mkString(", ")) resultado } } // Prepare the DataFrames val categoriesDf = Seq( ("Cartões - Anuidade - Negociação", "anuidade, negociação"), ("Cartões - Anuidade - Estorno", "anuidade, estorno"), ("Cartões - Bloqueio", "bloqueio"), ("Cartões - Contestação - Lançamento não reconhecido", "contestação, lançamento"), ("Cartões - Contestação - Desacordo comercial", "contestação, desacordo"), ("Cartões - Desbloqueio", "desbloqueio"), ("Cartões - Fatura - segunda via", "fatura, segunda via"), ("Cartões - Fatura - Detalhamento", "fatura, detalhamento"), ("Cartões - Fatura - Pagamento", "fatura, pagamento"), ("Cartões - Limite - Aumento", "limite, aumento"), ("Cartões - Limite - Redução", "limite, redução"), ("Cartões - Não Recebimento do cartão, Emissão segunda via", "não recebimento, emissão"), ("Cartões - Solicitação de segunda via do cartão", "solicitação, segunda via"), ("Cartões - Cancelamento", "cancelamento"), ("Cartões - Compra não autorizada", "compra, não autorizada"), ("Cartões - Fatura - Recalculo", "fatura, recalculo"), ("Cartões - Parcelamento - Contratação", "parcelamento, contratação"), ("Cartões - Fatura - Antecipação de Parcelas", "fatura, antecipação") ).toDF("categoria", "palavras_chave") val textoDf = Seq( ("Estou com problemas com a fatura e a segunda via do cartão.", None), ("Preciso de um bloqueio imediato no meu cartão.", None), ("Qual o procedimento para contestar uma cobrança?", None), ("Gostaria de solicitar a emissão de uma segunda via.", None), ("Minha fatura foi recalculada e não está correta.", None) ).toDF("texto", "categoria") // Create instance and run val categorizador = new CategoriaKeyword(spark) val resultado = categorizador.buscar_palavras_chave(categoriesDf, textoDf) println("Resultado final:") resultado.foreach(println) // Once finished, stop Spark spark.stop()Notes:
- When working in a REPL, you don't typically define
object Mainwith amainmethod, as this is more applicable for standalone applications. Instead, commands are run sequentially. - DataFrames are built directly with
Seq(...).toDF(...); ensure you importedspark.implicits._to utilizetoDF. - Remove any existing REPL session import issues or configurations to ensure the environment is clean and ready for a fresh start.
- When working in a REPL, you don't typically define
- User
(console):12:1 expected (
this| Id) class CategoriaKeyword(spark: SparkSession) { ^ (console):12:1 expected (this| Id) - Assistant
In a REPL environment, especially if you're using something like the Spark shell (
spark-shell) or a similar interactive Scala REPL, there can be restrictions on defining Scala classes or objects using theclassandobjectkeywords directly in certain console inputs or interactive scripts. Let's address this issue step by step.Given these restrictions, you'll want to handle this by declaring classes and objects in a separate scope or using functions within the REPL if that's supported. Alternatively, you can run your code from a script file, which allows more structuring freedom.
Here's how you can work interactively within a REPL:
Step-by-Step Interactive Execution
-
Start by setting up your Spark session:
import org.apache.spark.sql.{SparkSession, DataFrame} import scala.collection.mutable val spark = SparkSession.builder .appName("CategoriaKeyword") .master("local[*]") // Local execution .getOrCreate() import spark.implicits._ -
Prepare the data frames:
val categoriesDf = Seq( ("Cartões - Anuidade - Negociação", "anuidade, negociação"), ("Cartões - Anuidade - Estorno", "anuidade, estorno"), ("Cartões - Bloqueio", "bloqueio"), ("Cartões - Contestação - Lançamento não reconhecido", "contestação, lançamento"), ("Cartões - Contestação - Desacordo comercial", "contestação, desacordo"), ("Cartões - Desbloqueio", "desbloqueio"), ("Cartões - Fatura - segunda via", "fatura, segunda via"), ("Cartões - Fatura - Detalhamento", "fatura, detalhamento"), ("Cartões - Fatura - Pagamento", "fatura, pagamento"), ("Cartões - Limite - Aumento", "limite, aumento"), ("Cartões - Limite - Redução", "limite, redução"), ("Cartões - Não Recebimento do cartão, Emissão segunda via", "não recebimento, emissão"), ("Cartões - Solicitação de segunda via do cartão", "solicitação, segunda via"), ("Cartões - Cancelamento", "cancelamento"), ("Cartões - Compra não autorizada", "compra, não autorizada"), ("Cartões - Fatura - Recalculo", "fatura, recalculo"), ("Cartões - Parcelamento - Contratação", "parcelamento, contratação"), ("Cartões - Fatura - Antecipação de Parcelas", "fatura, antecipação") ).toDF("categoria", "palavras_chave") val textoDf = Seq( ("Estou com problemas com a fatura e a segunda via do cartão.", None), ("Preciso de um bloqueio imediato no meu cartão.", None), ("Qual o procedimento para contestar uma cobrança?", None), ("Gostaria de solicitar a emissão de uma segunda via.", None), ("Minha fatura foi recalculada e não está correta.", None) ).toDF("texto", "categoria") -
Implement and use the functionality as a method or function:
def buscarPalavrasChave(categories_df: DataFrame, text_df: DataFrame): Array[(String, String, Int)] = { val categoriasProcessadas = mutable.Map.empty[String, String] categories_df.collect().foreach(row => { val categoria = row.getAs[String]("categoria") val palavrasChaveCsv = row.getAs[String]("palavras_chave") if (palavrasChaveCsv != null && palavrasChaveCsv.nonEmpty) { val palavrasChaveArray = palavrasChaveCsv.split(", ") palavrasChaveArray.foreach(palavraChave => { categoriasProcessadas.put(palavraChave.toLowerCase, categoria.toLowerCase) }) } }) println("Categorias processadas: " + categoriasProcessadas) val resultado = text_df.collect().map(row => { val texto = row.getAs[String]("texto").toLowerCase var maxPontuacao = 0 var categoriaMaiorPontuacao = "" categoriasProcessadas.foreach { case (palavraChave, categoria) => if (texto.contains(palavraChave)) { val pontuacao = texto.split("\\s+").count(_.equals(palavraChave)) if (pontuacao > maxPontuacao) { maxPontuacao = pontuacao categoriaMaiorPontuacao = categoria } } } (row.getAs[String]("texto"), categoriaMaiorPontuacao, maxPontuacao) }) println("Resultado: " + resultado.mkString(", ")) resultado } val resultado = buscarPalavrasChave(categoriesDf, textoDf) println("Resultado final:") resultado.foreach(println) -
Clean up resources:
spark.stop()
Explanation:
- The code is written step-by-step with commands piece by piece, suitable for executing in a REPL.
- Instead of using a class, the logic for keyword matching and categorizing is encapsulated inside a function.
- Use
collect()only where necessary due to the limitations of manipulating distributed datasets directly in a REPL.
You may adapt this code into a proper script or application if the REPL environment is too restrictive for your use case.
-
- User
%scala import spark.sql
val df = spark.sql("SELECT * FROM prd.s_stbr_dcr_dcr_stt.stt_trsc")
val dfFiltrada = df.filter(df("ma_liga") === "202408" && (df("tx_trsc_segm").like("%cartao%") || df("tx_trsc_segm").like("%cartões%")))
val result = dfFiltrada.head
println(result) salve csv
- Assistant
It looks like you're attempting to perform a series of operations using Spark SQL in a Scala environment and then save the resulting DataFrame as a CSV. Here’s how you can achieve these steps correctly, addressing each part of your requirement:
-
Read and Filter Data:
Assuming you have a table
prd.s_stbr_dcr_dcr_stt.stt_trscand you’re filtering on specific conditions, you typically start with acquiring the data into a DataFrame. -
Filter DataFrame:
You have a specific condition to filter rows based on a value in the
ma_ligacolumn and a pattern in thetx_trsc_segmcolumn. -
Save Result as CSV:
Use the appropriate Spark function to save the DataFrame as a CSV file.
Here is how you can put all of these steps together:
import spark.implicits._ // Assume SparkSession (spark) is already created and configured // Select the relevant data from the table val df = spark.sql("SELECT * FROM prd.s_stbr_dcr_dcr_stt.stt_trsc") // Apply filters to the DataFrame val dfFiltrada = df.filter(df("ma_liga") === "202408" && (df("tx_trsc_segm").contains("cartao") || df("tx_trsc_segm").contains("cartões"))) println("Filtered Results:") // Show some parts of the result dfFiltrada.show(10) // Show the first 10 rows for visualization // Saving the filtered DataFrame to CSV val outputPath = "/path/to/output/directory" // Specify the output path dfFiltrada.write .option("header", "true") // Include a header row .csv(outputPath) println(s"Data saved successfully to: $outputPath")Key Points:
-
Import: Ensure that you've imported necessary Spark SQL functions (e.g.,
spark.implicits._) and have yourSparkSessionset up asspark. -
Filtering: Adjust the filter conditions as necessary using DataFrame transformations, like
filterandcontains. -
CSV Saving: Use the
writemethod with options to specify the output directory path and ensure it includes a header. -
Output Path: Replace
"/path/to/output/directory"with the actual path where you want the CSV files to be saved. Ensure that the file path is accessible by your Spark environment.
Ensure that the Spark cluster or your local environment has the correct file system permissions to write to the output directory specified. This script, when executed, will filter and save the results into a CSV format as requested.
-
- User
import pandas as pd import unicodedata import collections
class CategoriaKeyword: def init(self, categories_df, text_df, category_col='Categoria', keywords_col='Palavras-Chave', text_col='Texto'): """ Inicializa o CategoriaKeyword com dois DataFrames e nomes de colunas específicados.
:param categories_df: DataFrame contendo categorias e palavras-chave. :param text_df: DataFrame contendo dados de texto a serem analisados. :param category_col: Nome da coluna em categories_df que contém os nomes de categoria. :param keywords_col: Nome da coluna em categories_df que contém as palavras-chave. :param text_col: Nome da coluna em text_df que contém os dados de texto. """ self.categories_df = categories_df self.text_df = text_df self.category_col = category_col self.keywords_col = keywords_col self.text_col = text_col # Processamento de pré-palavras-chave em um dicionário para busca mais rápida self.keyword_to_category = {} for _, category_row in self.categories_df.iterrows(): # Recuperar palavras-chave, garantindo que sejam processadas corretamente keywords = category_row[self.keywords_col] if isinstance(keywords, str): keywords = keywords.split(', ') elif isinstance(keywords, list): # Se as palavras-chave já forem uma lista, apenas remover espaços em branco keywords = [keyword.strip() for keyword in keywords] else: continue # Pulverizar se for outro tipo de dados for keyword in keywords: self.keyword_to_category[keyword] = category_row[self.category_col] def buscar_palavras_chave(self): """ Procura por palavras-chave no DataFrame de texto e atribui a categoria mais provável do DataFrame de categorias. :return: DataFrame contendo o texto original, categoria encontrada, palavras-chave localizadas e contagem de palavras-chave. """ resultados = [] for index, row in self.text_df.iterrows(): texto = unicodedata.normalize('NFKD', row[self.text_col]).lower() # Normalizar e Converter para minúsculas word_count = collections.Counter(texto.split()) # Contar frequências de palavras category_scores = {} # Dicionário para armazenar Scores de categoria for keyword in self.keyword_to_category.keys(): keyword_count = word_count.get(keyword, 0) if keyword_count > 0: categoria = self.keyword_to_category[keyword] if categoria in category_scores: category_scores[categoria] += keyword_count else: category_scores[categoria] = keyword_count # Determinar a categoria mais provável categoria_mais_provavel = None max_score = 0 for categoria, score in category_scores.items(): if score > max_score: max_score = score categoria_mais_provavel = categoria # Obter palavras-chave localizadas palavras_localizadas = [keyword for keyword in self.keyword_to_category.keys() if keyword in texto] # Contar quantidade de palavras-chave localizadas exclusivas contador_palavras_localizadas = len(set(palavras_localizadas)) resultados.append({ self.text_col: row[self.text_col], 'Categoria Encontrada': categoria_mais_provavel, # Categoria mais provável 'Palavras Localizadas': list(set(palavras_localizadas)), # Palavras-chave localizadas exclusivas 'Contador Palavras Localizadas': contador_palavras_localizadas # Contagem de palavras-chave localizadas }) return pd.DataFrame(resultados)# Data preparation for categories DataFrame (df1)
data1 = {
'Categoria': [
'Cartões - Anuidade - Negociação', 'Cartões - Anuidade - Estorno', 'Cartões - Bloqueio',
'Cartões - Contestação - Lançamento não reconhecido', 'Cartões - Contestação - Desacordo comercial',
'Cartões - Desbloqueio', 'Cartões - Fatura - segunda via', 'Cartões - Fatura - Detalhamento',
'Cartões - Fatura - Pagamento', 'Cartões - Limite - Aumento', 'Cartões - Limite - Redução',
'Cartões - Não Recebimento do cartão, Emissão segunda via', 'Cartões - Solicitação de segunda via do cartão',
'Cartões - Cancelamento', 'Cartões - Compra não autorizada', 'Cartões - Fatura - Recalculo',
'Cartões - Parcelamento - Contratação', 'Cartões - Fatura - Antecipação de Parcelas'
],
'Keywords': [
'anuidade, negociação', 'anuidade, estorno', 'bloqueio', 'contestação, lançamento, não reconhecido',
'contestação, desacordo, comercial', 'desbloqueio', 'fatura, segunda via', 'fatura, detalhamento',
'fatura, pagamento', 'limite, aumento', 'limite, redução', 'não recebimento, emissão, segunda via',
'solicitação, segunda via', 'cancelamento', 'compra, não autorizada', 'fatura, recalculo',
'parcelamento, contratação', 'fatura, antecipação, parcelas'
]
}
df = pd.DataFrame(data1)
# Create the second DataFrame (df2) with example text data
data2 = {
'tx_trsc_segm': [
'Estou com problemas com a fatura e a segunda via do cartão.',
'Preciso de um bloqueio imediato no meu cartão.',
'Qual o procedimento para contestar uma cobrança?',
'Gostaria de solicitar a emissão de uma segunda via.',
'Minha fatura foi recalculada e não está correta.'
]
}
filtered_temp = pd.DataFrame(data2)
Create an instance of KeywordCategorizer
categorizer = KeywordCategorizer(categories_df=df, text_df=filtered_temp)
Execute the keyword search
result_df = categorizer.search_keywords()
Display the result
print(result_df) coloque em scala
- Assistant
Converting your Python class into Scala involves mapping the logic and data processing techniques from Python to an equivalent Scala implementation. Here's a step-by-step approach to convert your Python class into a Scala class using Spark DataFrame APIs:
Step-by-Step Scala Conversion
-
Define the Class and Constructor: Define a Scala class that accepts the necessary data
DataFrames and column names. -
Process Keywords: Convert the category and keywords mapping into a Scala collection for efficient lookup.
-
Iterate through Text and Perform Keyword Matching: Use DataFrame transformations and actions to implement the keyword searching logic.
-
Return Results: Create a new DataFrame with the results of keyword matching.
Here's a direct Scala translation:
import org.apache.spark.sql.{DataFrame, SparkSession} import org.apache.spark.sql.functions._ import scala.collection.mutable class CategoriaKeyword(spark: SparkSession, categoriesDF: DataFrame, textDF: DataFrame, categoryCol: String = "Categoria", keywordsCol: String = "Palavras-Chave", textCol: String = "Texto") { // Convert categories and keywords into a Map for quick lookup private val keywordToCategory = mutable.Map[String, String]() categoriesDF.collect().foreach { row => val category = row.getAs[String](categoryCol) val keywordsString = row.getAs[String](keywordsCol) if (keywordsString != null) { keywordsString.split(", ").foreach { keyword => keywordToCategory.put(keyword.trim.toLowerCase, category) } } } def buscarPalavrasChave(): DataFrame = { import spark.implicits._ val resultados = textDF.map { row => val texto = row.getAs[String](textCol).toLowerCase // Count occurrences of each keyword in the text val wordCount = texto.split("\\s+").groupBy(identity).mapValues(_.length) val categoryScores = mutable.Map[String, Int]() keywordToCategory.keys.foreach { keyword => val keywordCount = wordCount.getOrElse(keyword, 0) if (keywordCount > 0) { val categoria = keywordToCategory(keyword) categoryScores(categoria) = categoryScores.getOrElse(categoria, 0) + keywordCount } } // Determine the highest scoring category val categoriaMaisProvavel = categoryScores.maxByOption(_._2).map(_._1).getOrElse("Nenhuma categoria encontrada") // Find unique keywords present in the text val palavrasLocalizadas = keywordToCategory.keys.filter(texto.contains).toSet // Create the result row (row.getAs[String](textCol), categoriaMaisProvavel, palavrasLocalizadas.toList, palavrasLocalizadas.size) }.toDF("Texto", "Categoria Encontrada", "Palavras Localizadas", "Contador Palavras Localizadas") resultados } } // Example usage assuming SparkSession is already created as `spark`: // Categories DataFrame val categoriesDF = Seq( ("Cartões - Anuidade - Negociação", "anuidade, negociação"), // ... add all the categories ).toDF("Categoria", "Palavras-Chave") // Text DataFrame - placeholder data to match your example val textDF = Seq( ("Estou com problemas com a fatura e a segunda via do cartão."), // ... other example texts ).toDF("Texto") // Initialize and run the keyword search val categorizador = new CategoriaKeyword(spark, categoriesDF, textDF) val resultDF = categorizador.buscarPalavrasChave() // Display the result resultDF.show(false)Key Adaptations:
-
String Operations: Scala uses different string manipulation methods compared to Python. Note the conversion of keyword splits and comparisons are done using Scala collections methods.
-
DataFrame Operations: Boosted by Spark operations,
collect()and transformations such asmapandtoDFare used to emulate pandas-like processing. -
Handling Empty/Null Values: Extra care is taken in handling potential
nullvalues in the DataFrames.
This provided code should align well with both Scala and Spark's idioms, but ensure you adapt the placeholder data sections to fit your actual data structure and logic requirements.
-