Datasets:

kamel-usp
/

aes_enem_dataset

	# Copyright 2023 Andre Barbosa, Igor Caetano Silveira & The HuggingFace Datasets Authors
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	# TODO: Address all TODOs and remove all explanatory comments
	"""TODO: Add a description here."""


	import csv
	import math
	import os
	import re

	import datasets
	import numpy as np
	import pandas as pd
	from bs4 import BeautifulSoup
	from tqdm.auto import tqdm

	np.random.seed(42) # Set the seed

	# TODO: Add BibTeX citation
	# Find for instance the citation on arxiv or on the dataset repo/website
	_CITATION = """\
	TODO
	"""

	# TODO: Add description of the dataset here
	# You can copy an official description
	_DESCRIPTION = """\
	This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
	"""

	# TODO: Add a link to an official homepage for the dataset here
	_HOMEPAGE = ""

	# TODO: Add the licence for the dataset here if you can find it
	_LICENSE = ""

	_URLS = {
	"sourceAOnly": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/sourceAWithGraders.tar.gz?download=true",
	"sourceAWithGraders": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/sourceAWithGraders.tar.gz?download=true",
	"sourceB": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/sourceB.tar.gz?download=true",
	"PROPOR2024": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/propor2024.tar.gz?download=true"
	}

	PROMPTS_TO_IGNORE = [
	"brasileiros-tem-pessima-educacao-argumentativa-segundo-cientista",
	"carta-convite-discutir-discriminacao-na-escola",
	"informacao-no-rotulo-de-produtos-transgenicos",
	]

	# Essays to Ignore
	ESSAY_TO_IGNORE = [
	"direitos-em-conflito-liberdade-de-expressao-e-intimidade/2.html",
	"terceirizacao-avanco-ou-retrocesso/2.html",
	"artes-e-educacao-fisica-opcionais-ou-obrigatorias/2.html",
	"violencia-e-drogas-o-papel-do-usuario/0.html",
	"internacao-compulsoria-de-dependentes-de-crack/0.html",
	]

	CSV_HEADER = [
	"id",
	"id_prompt",
	"title",
	"essay",
	"grades",
	"general",
	"specific",
	"essay_year",
	]

	SOURCE_A_DESC = """
	Source A have 860 essays available from August 2015 to March 2020.
	For each month of that period, a new prompt together with supporting texts were given, and the graded essays from the previous month were made available.
	Of the 56 prompts, 12 had no associated essays available (at the time of download).
	Additionally, there were 3 prompts that asked for a text in the format of a letter. We removed those 15 prompts and associated texts from the corpus.
	For an unknown reason, 414 of the essays were graded using a five-point scale of either {0, 50, 100, 150, 200} or its scaled-down version going from 0 to 2.
	To avoid introducing bias, we also discarded such instances, resulting in a dataset of 386 annotated essays with prompts and supporting texts (with each component being clearly identified).
	Some of the essays used a six-point scale with 20 points instead of 40 points as the second class. As we believe this introduces minimal bias, we kept such essays and relabeled class 20 as class 40.
	The original data contains comments from the annotators explaining their per-competence scores. They are included in our dataset.
	"""

	SOURCE_A_WITH_GRADERS = "Same as SourceA but augmented with reviwers contractors grade's. Each essay then have three grades: the downloaded one and each grader's feedback. "

	SOURCE_B_DESC = """
	Source B is very similar to Source A: a new prompt and supporting texts are made available every month along with the graded essays submitted in the previous month.
	We downloaded HTML sources from 7,700 essays from May 2009 to May 2023. Essays released prior to June 2016 were graded on a five-point scale and consequently discarded.
	This resulted in a corpus of approx. 3,200 graded essays on 83 different prompts.

	Although in principle, Source B also provides supporting texts for students, none were available at the time the data was downloaded.
	To mitigate this, we extracted supporting texts from the Essay-Br corpus, whenever possible, by manually matching prompts between the two corpora.
	We ended up with approx. 1,000 essays containing both prompt and supporting texts, and approx. 2,200 essays containing only the respective prompt.
	"""

	PROPOR2024 = """
	Splits used for PROPOR paper. It is a variation of sourceAWithGraders dataset. Post publication we noticed that there was an issue in the reproducible setting.

	We fix that and set this config to keep reproducibility w.r.t. numbers reported in the paper.
	"""


	class AesEnemDataset(datasets.GeneratorBasedBuilder):
	"""
	AES Enem Dataset. For full explanation about generation process, please refer to: https://aclanthology.org/2024.propor-1.23/

	We realized in our experiments that there was an issue in the determistic process regarding how the dataset is generated.
	To reproduce results from PROPOR paper, please refer to "PROPOR2024" config. Other configs are reproducible now.
	"""

	VERSION = datasets.Version("0.1.0")

	# You will be able to load one or the other configurations in the following list with
	BUILDER_CONFIGS = [
	datasets.BuilderConfig(name="sourceAOnly", version=VERSION, description=SOURCE_A_DESC),
	datasets.BuilderConfig(
	name="sourceAWithGraders", version=VERSION, description=SOURCE_A_WITH_GRADERS
	),
	datasets.BuilderConfig(
	name="sourceB",
	version=VERSION,
	description=SOURCE_B_DESC,
	),
	datasets.BuilderConfig(name="PROPOR2024", version=VERSION, description=PROPOR2024),
	]

	def _info(self):
	features = datasets.Features(
	{
	"id": datasets.Value("string"),
	"id_prompt": datasets.Value("string"),
	"essay_title": datasets.Value("string"),
	"essay_text": datasets.Value("string"),
	"grades": datasets.Sequence(datasets.Value("int16")),
	"essay_year": datasets.Value("int16"),
	}
	)

	return datasets.DatasetInfo(
	# This is the description that will appear on the datasets page.
	description=_DESCRIPTION,
	# This defines the different columns of the dataset and their types
	features=features, # Here we define them above because they are different between the two configurations
	# If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
	# specify them. They'll be used if as_supervised=True in builder.as_dataset.
	# supervised_keys=("sentence", "label"),
	# Homepage of the dataset for documentation
	homepage=_HOMEPAGE,
	# License for the dataset if available
	license=_LICENSE,
	# Citation for the dataset
	citation=_CITATION,
	)

	def _post_process_dataframe(self, filepath):
	def map_year(year):
	if year <= 2017:
	return "<=2017"
	return str(year)

	def normalize_grades(grades):
	grades = grades.strip("[]").split(", ")
	grade_mapping = {"0.0": 0, "20": 40}

	# We will remove the rows that match the criteria below
	if any(
	single_grade
	in grades[:-1] # we ignore the sum, and only check the concetps
	for single_grade in ["50", "100", "150", "0.5", "1.0", "1.5"]
	):
	return None
	# Use the mapping to transform grades, ignoring the last grade
	mapped_grades = [
	int(grade_mapping.get(grade_concept, grade_concept))
	for grade_concept in grades[:-1]
	]
	# Calculate and append the sum of the mapped grades as the last element
	mapped_grades.append(sum(mapped_grades))
	return mapped_grades

	df = pd.read_csv(filepath)
	df["general"] = df["general"].fillna("")
	df["essay_year"] = df["essay_year"].astype("int")
	df["mapped_year"] = df["essay_year"].apply(map_year)
	df["grades"] = df["grades"].apply(normalize_grades)
	df = df.dropna(subset=["grades"])
	df = df[
	~(df["id_prompt"] + "/" + df["id"]).isin(ESSAY_TO_IGNORE)
	] # arbitrary removal of zero graded essays
	df.to_csv(filepath, index=False)

	def _split_generators(self, dl_manager):
	urls = _URLS[self.config.name]
	extracted_files = dl_manager.download_and_extract({self.config.name: urls})
	if "PROPOR2024" == self.config.name:
	base_path = extracted_files["PROPOR2024"]
	return [
	datasets.SplitGenerator(
	name=datasets.Split.TRAIN,
	# These kwargs will be passed to _generate_examples
	gen_kwargs={
	"filepath": os.path.join(base_path, "propor2024/train.csv"),
	"split": "train",
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.VALIDATION,
	# These kwargs will be passed to _generate_examples
	gen_kwargs={
	"filepath": os.path.join(base_path, "propor2024/validation.csv"),
	"split": "validation",
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.TEST,
	gen_kwargs={
	"filepath": os.path.join(base_path, "propor2024/test.csv"),
	"split": "test",
	},
	),
	]
	html_parser = self._process_html_files(extracted_files)
	if "sourceA" in self.config.name:
	self._post_process_dataframe(html_parser.sourceA)
	self._generate_splits(html_parser.sourceA)
	folder_sourceA = "/".join((html_parser.sourceA).split("/")[:-1])
	return [
	datasets.SplitGenerator(
	name=datasets.Split.TRAIN,
	# These kwargs will be passed to _generate_examples
	gen_kwargs={
	"filepath": os.path.join(folder_sourceA, "train.csv"),
	"split": "train",
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.VALIDATION,
	# These kwargs will be passed to _generate_examples
	gen_kwargs={
	"filepath": os.path.join(folder_sourceA, "validation.csv"),
	"split": "validation",
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.TEST,
	gen_kwargs={
	"filepath": os.path.join(folder_sourceA, "test.csv"),
	"split": "test",
	},
	),
	]
	elif self.config.name == "sourceB":
	self._post_process_dataframe(html_parser.sourceB)
	return [
	datasets.SplitGenerator(
	name="full",
	gen_kwargs={
	"filepath": html_parser.sourceB,
	"split": "full",
	},
	),
	]

	def _process_html_files(self, paths_dict):
	html_parser = HTMLParser(paths_dict)
	html_parser.parse(self.config.name)
	return html_parser

	def _parse_graders_data(self, dirname):
	map_grades = {"0": 0, "1": 40, "2": 80, "3": 120, "4": 160, "5": 200}

	def map_list(grades_list):
	result = [map_grades.get(item, None) for item in grades_list]
	sum_grades = sum(result)
	result.append(sum_grades)
	return result

	grader_a = pd.read_csv(f"{dirname}/GraderA.csv")
	grader_b = pd.read_csv(f"{dirname}/GraderB.csv")

	for grader in [grader_a, grader_b]:
	grader.grades = grader.grades.apply(lambda x: x.strip("[]").split(", "))
	grader.grades = grader.grades.apply(map_list)

	return grader_a, grader_b

	def _generate_splits(self, filepath: str, train_size=0.7):
	df = pd.read_csv(filepath)
	buckets = df.groupby("mapped_year")["id_prompt"].unique().to_dict()
	df.drop("mapped_year", axis=1, inplace=True)
	train_set = []
	val_set = []
	test_set = []
	for year, prompts in buckets.items():
	np.random.shuffle(prompts)
	num_prompts = len(prompts)

	# All prompts go to the test if less than 3
	if num_prompts <= 3:
	train_set.append(df[df["id_prompt"].isin([prompts[0]])])
	val_set.append(df[df["id_prompt"].isin([prompts[1]])])
	test_set.append(df[df["id_prompt"].isin([prompts[2]])])
	continue

	# Determine the number of prompts for each set based on train_size and remaining prompts
	num_train = math.floor(num_prompts * train_size)
	num_val_test = num_prompts - num_train
	num_val = num_val_test // 2
	num_test = num_val_test - num_val

	# Assign prompts to each set
	train_set.append(df[df["id_prompt"].isin(prompts[:num_train])])
	val_set.append(
	df[df["id_prompt"].isin(prompts[num_train : (num_train + num_val)])]
	)
	test_set.append(
	df[
	df["id_prompt"].isin(
	prompts[
	(num_train + num_val) : (num_train + num_val + num_test)
	]
	)
	]
	)

	# Convert lists of groups to DataFrames
	train_df = pd.concat(train_set)
	val_df = pd.concat(val_set)
	test_df = pd.concat(test_set)
	dirname = os.path.dirname(filepath)
	if self.config.name == "sourceAWithGraders":
	grader_a, grader_b = self._parse_graders_data(dirname)
	grader_a_data = pd.merge(
	train_df[["id", "id_prompt","essay"]],
	grader_a.drop(columns=['essay']),
	on=["id", "id_prompt"],
	how="inner",
	)
	grader_b_data = pd.merge(
	train_df[["id", "id_prompt","essay"]],
	grader_b.drop(columns=['essay']),
	on=["id", "id_prompt"],
	how="inner",
	)
	train_df = pd.concat([train_df, grader_a_data])
	train_df = pd.concat([train_df, grader_b_data])

	grader_a_data = pd.merge(
	val_df[["id", "id_prompt","essay"]],
	grader_a.drop(columns=['essay']),
	on=["id", "id_prompt"],
	how="inner",
	)
	grader_b_data = pd.merge(
	val_df[["id", "id_prompt","essay"]],
	grader_b.drop(columns=['essay']),
	on=["id", "id_prompt"],
	how="inner",
	)
	val_df = pd.concat([val_df, grader_a_data])
	val_df = pd.concat([val_df, grader_b_data])

	grader_a_data = pd.merge(
	test_df[["id", "id_prompt","essay"]],
	grader_a.drop(columns=['essay']),
	on=["id", "id_prompt"],
	how="inner",
	)
	grader_b_data = pd.merge(
	test_df[["id", "id_prompt","essay"]],
	grader_b.drop(columns=['essay']),
	on=["id", "id_prompt"],
	how="inner",
	)
	test_df = pd.concat([test_df, grader_a_data])
	test_df = pd.concat([test_df, grader_b_data])
	# Data Validation Assertions
	assert (
	len(set(train_df["id_prompt"]).intersection(set(val_df["id_prompt"]))) == 0
	), "Overlap between train and val id_prompt"
	assert (
	len(set(train_df["id_prompt"]).intersection(set(test_df["id_prompt"]))) == 0
	), "Overlap between train and test id_prompt"
	assert (
	len(set(val_df["id_prompt"]).intersection(set(test_df["id_prompt"]))) == 0
	), "Overlap between val and test id_prompt"
	train_df.to_csv(f"{dirname}/train.csv", index=False)
	val_df.to_csv(f"{dirname}/validation.csv", index=False)
	test_df.to_csv(f"{dirname}/test.csv", index=False)

	# method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
	def _generate_examples(self, filepath, split):
	with open(filepath, encoding="utf-8") as csvfile:
	next(csvfile)
	csv_reader = csv.DictReader(csvfile, fieldnames=CSV_HEADER)
	for i, row in enumerate(csv_reader):
	grades = row["grades"].strip("[]")
	if self.config.name == "PROPOR2024":
	grades = grades.strip().split()
	else:
	grades = grades.split(", ")
	yield i, {
	"id": row["id"],
	"id_prompt": row["id_prompt"],
	"essay_title": row["title"],
	"essay_text": row["essay"],
	"grades": grades,
	"essay_year": row["essay_year"],
	}


	class HTMLParser:
	def __init__(self, paths_dict):
	self.paths_dict = paths_dict
	self.sourceA = None
	self.sourceB = None

	def apply_soup(self, filepath, num):
	# recebe uma URL, salva o HTML dessa página e retorna o soup dela
	file = open(os.path.join(filepath, num), "r", encoding="utf8")
	conteudo = file.read()
	soup = BeautifulSoup(conteudo, "html.parser")
	return soup

	def _get_title(self, soup):
	if self.sourceA:
	title = soup.find("div", class_="container-composition")
	if title is None:
	title = soup.find("h1", class_="pg-color10").get_text()
	else:
	title = title.h2.get_text()
	title = title.replace("\xa0", "")
	return title.replace(";", ",")
	elif self.sourceB:
	title = soup.find("h1", class_="titulo-conteudo").get_text()
	return title.strip("- Banco de redações").strip()

	def _get_grades(self, soup):
	if self.sourceA:
	grades = soup.find("section", class_="results-table")
	final_grades = []
	if grades is not None:
	grades = grades.find_all("span", class_="points")
	assert len(grades) == 6, f"Missing grades: {len(grades)}"
	for single_grade in grades:
	grade = int(single_grade.get_text())
	final_grades.append(grade)
	assert final_grades[-1] == sum(
	final_grades[:-1]
	), "Grading sum is not making sense"
	else:
	grades = soup.find("div", class_="redacoes-corrigidas pg-bordercolor7")
	grades_sum = float(
	soup.find("th", class_="noBorder-left").get_text().replace(",", ".")
	)
	grades = grades.find_all("td")[:10]
	for idx in range(1, 10, 2):
	grade = float(grades[idx].get_text().replace(",", "."))
	final_grades.append(grade)
	assert grades_sum == sum(
	final_grades
	), "Grading sum is not making sense"
	final_grades.append(grades_sum)
	return final_grades
	elif self.sourceB:
	table = soup.find("table", {"id": "redacoes_corrigidas"})
	grades = table.find_all("td", class_="simple-td")
	grades = grades[3:]
	result = []
	for single_grade in grades:
	result.append(int(single_grade.get_text()))
	assert len(result) == 5, "We should have 5 Grades (one per concept) only"
	result.append(sum(result)) # Add sum as a sixt element to keep the same pattern
	return result

	def _get_general_comment(self, soup):
	if self.sourceA:

	def get_general_comment_aux(soup):
	result = soup.find("article", class_="list-item c")
	if result is not None:
	result = result.find("div", class_="description")
	return result.get_text()
	else:
	result = soup.find("p", style="margin: 0px 0px 11px;")
	if result is not None:
	return result.get_text()
	else:
	result = soup.find("p", style="margin: 0px;")
	if result is not None:
	return result.get_text()
	else:
	result = soup.find(
	"p", style="margin: 0px; text-align: justify;"
	)
	if result is not None:
	return result.get_text()
	else:
	return ""

	text = soup.find("div", class_="text")
	if text is not None:
	text = text.find("p")
	if (text is None) or (len(text.get_text()) < 2):
	return get_general_comment_aux(soup)
	return text.get_text()
	else:
	return get_general_comment_aux(soup)
	elif self.sourceB:
	return ""

	def _get_specific_comment(self, soup, general_comment):
	if self.sourceA:
	result = soup.find("div", class_="text")
	cms = []
	if result is not None:
	result = result.find_all("li")
	if result != []:
	for item in result:
	text = item.get_text()
	if text != "\xa0":
	cms.append(text)
	else:
	result = soup.find("div", class_="text").find_all("p")
	for item in result:
	text = item.get_text()
	if text != "\xa0":
	cms.append(text)
	else:
	result = soup.find_all("article", class_="list-item c")
	if len(result) < 2:
	return ["First if"]
	result = result[1].find_all("p")
	for item in result:
	text = item.get_text()
	if text != "\xa0":
	cms.append(text)
	specific_comment = cms.copy()
	if general_comment in specific_comment:
	specific_comment.remove(general_comment)
	if (len(specific_comment) > 1) and (len(specific_comment[0]) < 2):
	specific_comment = specific_comment[1:]
	return self._clean_list(specific_comment)
	elif self.sourceB:
	return ""

	def _get_essay(self, soup):
	if self.sourceA:
	essay = soup.find("div", class_="text-composition")
	result = []
	if essay is not None:
	essay = essay.find_all("p")
	for f in essay:
	while f.find("span", style="color:#00b050") is not None:
	f.find("span", style="color:#00b050").decompose()
	while f.find("span", class_="certo") is not None:
	f.find("span", class_="certo").decompose()
	for paragraph in essay:
	result.append(paragraph.get_text())
	else:
	essay = soup.find("div", {"id": "texto"})
	essay.find("section", class_="list-items").decompose()
	essay = essay.find_all("p")
	for f in essay:
	while f.find("span", class_="certo") is not None:
	f.find("span", class_="certo").decompose()
	for paragraph in essay:
	result.append(paragraph.get_text())
	return "\n".join(self._clean_list(result))
	elif self.sourceB:
	table = soup.find("article", class_="texto-conteudo entire")
	table = soup.find("div", class_="area-redacao-corrigida")
	if table is None:
	result = None
	else:
	for span in soup.find_all("span"):
	span.decompose()
	result = table.find_all("p")
	result = "\n".join(
	[paragraph.get_text().strip() for paragraph in result]
	)
	return result

	def _get_essay_year(self, soup):
	if self.sourceA:
	pattern = r"redações corrigidas - \w+/\d+"
	first_occurrence = re.search(pattern, soup.get_text().lower())
	matched_url = first_occurrence.group(0) if first_occurrence else None
	year_pattern = r"\d{4}"
	return re.search(year_pattern, matched_url).group(0)
	elif self.sourceB:
	pattern = r"Enviou seu texto em.*?(\d{4})"
	match = re.search(pattern, soup.get_text())
	return match.group(1) if match else -1

	def _clean_title(self, title):
	if self.sourceA:
	smaller_index = title.find("[")
	if smaller_index == -1:
	return title
	else:
	bigger_index = title.find("]")
	new_title = title[:smaller_index] + title[bigger_index + 1 :]
	return self._clean_title(new_title.replace(" ", " "))
	elif self.sourceB:
	return title

	def _clean_list(self, list):
	if list == []:
	return []
	else:
	new_list = []
	for phrase in list:
	phrase = (
	phrase.replace("\xa0", "").replace(" ,", ",").replace(" .", ".")
	)
	while phrase.find(" ") != -1:
	phrase = phrase.replace(" ", " ")
	if len(phrase) > 1:
	new_list.append(phrase)
	return new_list

	def parse(self, config_name):
	for key, filepath in self.paths_dict.items():
	if key != config_name:
	continue # TODO improve later, we will only support a single config at a time
	if "sourceA" in config_name:
	self.sourceA = f"{filepath}/sourceA/sourceA.csv"
	elif config_name == "sourceB":
	self.sourceB = f"{filepath}/sourceB/sourceB.csv"
	file = self.sourceA if self.sourceA else self.sourceB
	file_dir = "/".join((file).split("/")[:-1])
	sorted_files = sorted(os.listdir(file_dir))
	with open(file, "w", newline="", encoding="utf8") as final_file:
	writer = csv.writer(final_file)
	writer.writerow(CSV_HEADER)
	sub_folders = [
	name for name in sorted_files if not name.endswith(".csv")
	]
	essay_id = 0
	essay_title = None
	essay_text = None
	essay_grades = None
	general_comment = None
	specific_comment = None
	essay_year = None
	for prompt_folder in tqdm(
	sub_folders,
	desc=f"Parsing HTML files from: {key}",
	total=len(sub_folders),
	):
	if prompt_folder in PROMPTS_TO_IGNORE:
	continue
	prompt = os.path.join(file_dir, prompt_folder)
	sorted_prompts = sorted(os.listdir(prompt))
	prompt_essays = [name for name in sorted_prompts]
	essay_year = self._get_essay_year(
	self.apply_soup(prompt, "Prompt.html")
	)
	for essay in prompt_essays:
	soup_text = self.apply_soup(prompt, essay)
	if essay == "Prompt.html":
	continue
	essay_title = self._clean_title(self._get_title(soup_text))
	essay_grades = self._get_grades(soup_text)
	essay_text = self._get_essay(soup_text)
	general_comment = self._get_general_comment(soup_text).strip()
	specific_comment = self._get_specific_comment(
	soup_text, general_comment
	)
	writer.writerow(
	[
	essay,
	prompt_folder,
	essay_title,
	essay_text,
	essay_grades,
	general_comment,
	specific_comment,
	essay_year,
	]
	)
	essay_id += 1