project-codenet / model-experiments /token-based-similarity-classification /src /Verify /SimDsVerify.py
| """ | |
| Program for verification of downloaded classification datsets. | |
| """ | |
| import sys | |
| import os | |
| from os import path | |
| import argparse | |
| import csv | |
| class DsProblemStat: | |
| """ | |
| Statistics on problems usage in dataset | |
| """ | |
| def __init__(self): | |
| self.similar_left = set() | |
| self.similar_right = set() | |
| self.n_similar_left = 0 | |
| self.n_similar_right = 0 | |
| self.left = set() | |
| self.n_left = 0 | |
| self.right = set() | |
| self.n_right = 0 | |
| def update_similar(self, s1, s2): | |
| """ | |
| Update statistics for similarity sample | |
| Parameters: | |
| s1, s2 -- solutions used in similarity sample | |
| """ | |
| self.similar_left.add(s1) | |
| self.similar_right.add(s2) | |
| self.n_similar_right += 1 | |
| self.n_similar_left += 1 | |
| def update_left(self, s): | |
| """ | |
| Update statistics for dissimilarity sample | |
| """ | |
| self.left.add(s) | |
| self.n_left += 1 | |
| def update_right(self, s): | |
| """ | |
| Update statistics for dissimilarity sample | |
| """ | |
| self.right.add(s) | |
| self.n_right += 1 | |
| #-------End of class DsProblemStat ------------------------ | |
| class SamplePartStat: | |
| """ | |
| Statistics of the part of set of samples: | |
| similar, left or right | |
| """ | |
| def __init__(self): | |
| """ | |
| Initialize statistics of the part of sample: | |
| similar, left or right | |
| """ | |
| self.min_fract_sol_used = 1 | |
| self.max_fract_sol_used = 0 | |
| self.min_uniqueness = 1 | |
| self.max_uniqueness = 0 | |
| self.sols_used = 0 | |
| self.n_total = 0 | |
| def update(self, n_unique, n_used, n_total): | |
| """ | |
| Update statistics of the part of sample | |
| with data on solutions of one problem | |
| Parameters: | |
| - n_unique -- number of unique problem solutions used in samples | |
| - n_used -- number of total problem solutions used in samples | |
| - n_total -- number of all problem solutions existed | |
| """ | |
| #Fraction of all problem solutions used in samples | |
| _fract_used = float(n_unique) / float(n_total) | |
| self.min_fract_sol_used = min(self.min_fract_sol_used, _fract_used) | |
| self.max_fract_sol_used = max(self.max_fract_sol_used, _fract_used) | |
| #Ratio of number of problem solutions are used in sample to | |
| #number of cases where the problem is used in samples | |
| #Indicator how unique is usage of solution in the samples | |
| _uniqueness = float(n_unique) / float(n_used) | |
| self.min_uniqueness = min(self.min_uniqueness, _uniqueness) | |
| self.max_uniqueness = max(self.max_uniqueness, _uniqueness) | |
| #Number of cases where problem is used in the samples | |
| self.sols_used += n_unique | |
| self.n_total += n_total | |
| def report(self, title): | |
| """ | |
| Report statistics | |
| """ | |
| print(title) | |
| print(f"Total {self.sols_used} from all {self.n_total} " + | |
| "of problem solutions are used") | |
| print("Fraction of used problem solutions varies from " + | |
| f"{self.min_fract_sol_used:5.3f} to {self.max_fract_sol_used:5.3f} ") | |
| print("Uniqueness of used problem solutions varies from " + | |
| f"{self.min_uniqueness:7.5f} to {self.max_uniqueness:7.5f}") | |
| #-------End of class SamplePartStat ------------------------ | |
| class DsStat: | |
| """ | |
| Class defining statistics of dataset: test validation or training | |
| """ | |
| def __init__(self): | |
| self.simil_left_stat = SamplePartStat() | |
| self.simil_right_stat = SamplePartStat() | |
| self.left_stat = SamplePartStat() | |
| self.right_stat = SamplePartStat() | |
| self.total_sols = 0 | |
| self.min_sols = 999999999 | |
| self.min_problem = None | |
| self.max_sols = 0 | |
| self.max_problem = None | |
| self.n_problems = 0 | |
| def update(self, problem, problem_stat, n_total): | |
| """ | |
| Update statistics of problem solutions usage | |
| Parameters: | |
| - problem -- problem name | |
| - problem_stat -- Statistics of problem solutions | |
| in the form of DsProblemStat object | |
| - n_total -- Total number of solutions of the problem | |
| """ | |
| self.simil_left_stat.update(len(problem_stat.similar_left), | |
| problem_stat.n_similar_left, | |
| n_total) | |
| self.simil_right_stat.update(len(problem_stat.similar_right), | |
| problem_stat.n_similar_right, | |
| n_total) | |
| self.left_stat.update(len(problem_stat.left), | |
| problem_stat.n_left, | |
| n_total) | |
| self.right_stat.update(len(problem_stat.right), | |
| problem_stat.n_right, | |
| n_total) | |
| #Number of all problem solutions existed | |
| self.total_sols += n_total | |
| #Minimum number of problem solutions | |
| if n_total < self.min_sols: | |
| self.min_sols = n_total | |
| self.min_problem = problem | |
| #Maximum number of problem solutions | |
| if n_total > self.max_sols: | |
| self.max_sols = n_total | |
| self.max_problem = problem | |
| self.n_problems += 1 | |
| def update_solutions(self, n_total): | |
| """ | |
| Update statistics of dataset problem solutions | |
| with data on solutions of one problem | |
| - n_total -- number of all problem solutions existed | |
| """ | |
| #Number of all problem solutions existed | |
| self.total_sols += n_total | |
| #Minimum number of problem solutions | |
| self.min_sols = min(self.min_sols, n_total) | |
| #Maximum number of propblem solutions | |
| self.max_sols = max(self.max_sols, n_total) | |
| self.n_problems += 1 | |
| def report(self, title): | |
| """ | |
| Printing report of dataset statistics | |
| Parameters: | |
| - title -- title of the report | |
| """ | |
| print(title) | |
| print(f"Dataset uses {self.n_problems} problems " + | |
| f"having total {self.total_sols} solutions") | |
| print("Average number of problem solutions " + | |
| f"is {float(self.total_sols) / float(self.n_problems)}") | |
| print(f"Problem {self.min_problem} has lowest " + | |
| f"number {self.min_sols} of solutions") | |
| print(f"Problem {self.max_problem} has highest " + | |
| f"number {self.max_sols} of solutions") | |
| self.simil_left_stat.report("Statistics of left side of similarity samples:") | |
| self.simil_right_stat.report("Statistics of right side of similarity samples:") | |
| self.left_stat.report("Statistics of left side of dissimilarity samples:") | |
| self.right_stat.report("Statistics of right side of dissimilarity samples:") | |
| print("\n") | |
| #-------End of class DsStat ------------------------ | |
| def readDsProblems(fname): | |
| """ | |
| Read problems of the dataset | |
| Parameters: | |
| -fname -- file name | |
| Returns: | |
| - initialized dictionary | |
| * key - problem name | |
| * value - dictionary of number of problem used | |
| in similar and dissimilar samples as right and left one | |
| - number of errors found | |
| """ | |
| if not os.path.exists(fname): | |
| sys.exit(f"File {fname} of problems of datset is not found") | |
| _problem_dict = {} | |
| _n_errors = 0 | |
| with open(fname) as _f: | |
| for _p in _f: | |
| _p = _p.rstrip('\n') | |
| if _p in _problem_dict: | |
| print(f"Error: multiple occurrences of problem {_p} in file{fname}") | |
| _n_errors +=1 | |
| else: | |
| _problem_dict[_p] = DsProblemStat() | |
| return _problem_dict, _n_errors | |
| def readDsSamples(cvs_file, problems): | |
| """ | |
| Read samples of dataset | |
| Parameters; | |
| - cvs_file -- csv file defining dataset | |
| - problems -- dictionary of problems of the dataset | |
| key: problem name | |
| value: Statistics of problem usage | |
| in the form of DsProblemStat | |
| Fills in problems(dictionary of problems of the dataset) | |
| Returns: | |
| - number of samples in the loaded datasets | |
| - number of similar samples | |
| - number of dissimilar samples | |
| - number of errors found | |
| """ | |
| _n_errors = 0 | |
| if not os.path.exists(cvs_file): | |
| sys.exit(f"File {cvs_file} with datset is not found") | |
| _n_samples = 0 | |
| _n_similar = 0 | |
| _n_disssimilar = 0 | |
| with open(cvs_file, newline='') as _: | |
| _reader = csv.reader(_) | |
| next(_reader) | |
| for _p1, _s1, _p2, _s2 in _reader: | |
| _n_samples += 1 | |
| if _p1 not in problems: | |
| print(f"Error: problem {_p1} occurred in file {cvs_file} " + | |
| "is not among problems of that dataset") | |
| _n_errors +=1 | |
| if _p2 != _p1 and _p2 not in problems: | |
| print(f"Error: problem {_p2} occurred in file {cvs_file} " + | |
| "is not among problems of that dataset") | |
| _n_errors +=1 | |
| if _p1 == _p2: | |
| _n_similar += 1 | |
| problems[_p1].update_similar(_s1, _s2) | |
| else: | |
| _n_disssimilar += 1 | |
| problems[_p1].update_left(_s1) | |
| problems[_p2].update_right(_s2) | |
| return _n_samples, _n_similar, _n_disssimilar, _n_errors | |
| def checkNoCommonProblems(ds1, ds2, fname1, fname2): | |
| """ | |
| Check that no common problems in two datasets | |
| Parameters: | |
| - ds1 -- 1-st dataset as dictionary of its problems | |
| dictionary of problems of the dataset | |
| key: problem name | |
| value: Statistics of problem usage as DsProblemStat | |
| - ds2 -- 2-nd dataset as dictionary of its problems | |
| similar to ds1 | |
| - fname1 -- file name of 1-st dataset | |
| - fname2 -- file name of 2-nd dataset | |
| Returns number of errors found | |
| """ | |
| _n_errors = 0 | |
| _common_problems = frozenset(ds1.keys()).intersection(ds2.keys()) | |
| if _common_problems: | |
| _n_errors = len(_common_problems) | |
| print(f"Error datasets {fname1} and {fname2} " + | |
| "have following {_n_errors} common problems:") | |
| print(_common_problems) | |
| return _n_errors | |
| def checkDsSolVsDir(problem, solutions, ds_fn, ds_dir, fn_extension): | |
| """ | |
| Check that all solutiosn of a given problem are in dataset | |
| Parameters: | |
| - problem -- problem to check | |
| - solutions -- set of solutions to check | |
| - ds_fn -- file name of dataset whose problem | |
| and solutions are checked | |
| - ds_dir -- directory with source dataset | |
| - fn_extension -- extensions of source code files of problem solutions | |
| Returns number of errors | |
| """ | |
| _n_errors = 0 | |
| for _s in solutions: | |
| if not os.path.exists(f"{ds_dir}/{problem}/{_s}.{fn_extension}"): | |
| print(f"Solution {_s}.{fn_extension} occurring in file {ds_fn} " + | |
| f"is not in problem directory {ds_dir}/{problem}") | |
| _n_errors +=1 | |
| return _n_errors | |
| def checkDsVsDir(ds, ds_dir, ds_fn, fn_extension): | |
| """ | |
| Check loaded dataset with respect to source dataset directory | |
| Parameters: | |
| - ds -- dictionary defining dataset to be checked | |
| key: problem name | |
| value: Statistics of problem usage as DsProblemStat | |
| - ds_dir -- directory with source dataset | |
| - ds_fn -- file name of dataset whose problem | |
| and solutions are checked | |
| - fn_extension -- extensions of source code files of problem solutions | |
| Returns: | |
| - number of errors found | |
| """ | |
| _n_errors = 0 | |
| for _p, _samples in ds.items(): | |
| if not os.path.exists(f"{ds_dir}/{_p}"): | |
| print(f"Problem {_p} is not in dataset directory {ds_dir}") | |
| _n_errors +=1 | |
| _n_errors += checkDsSolVsDir( | |
| _p, _samples.similar_right, ds_fn, ds_dir, fn_extension) | |
| _n_errors += checkDsSolVsDir( | |
| _p, _samples.similar_left, ds_fn, ds_dir, fn_extension) | |
| _n_errors += checkDsSolVsDir( | |
| _p, _samples.right, ds_fn, ds_dir, fn_extension) | |
| _n_errors += checkDsSolVsDir( | |
| _p, _samples.left, ds_fn, ds_dir, fn_extension) | |
| return _n_errors | |
| def checkDirVsDatasets(source, train, val, test): | |
| """ | |
| Check that all problems from source dataset directory are in one | |
| of datasets | |
| Parameters: | |
| - source -- directory with source dataset | |
| - train -- dictionary defining training dataset to be checked | |
| key: problem name | |
| value: Statistics of problem usage as DsProblemStat | |
| - val -- dictionary defining validation dataset to be checked | |
| similar to train | |
| - test -- dictionary defining test dataset to be checked | |
| similar to train | |
| Returns: | |
| - number of problems in source dataset directory | |
| - number of solutions in source dataset directory | |
| - number of errors found | |
| """ | |
| _test_stat = DsStat() | |
| _val_stat = DsStat() | |
| _train_stat = DsStat() | |
| _problems = os.listdir(source) | |
| _n_total_solutions = 0 | |
| _n_errors = 0 | |
| if not _problems: | |
| sys.exit(f"Directory {source} of source code dataset is empty") | |
| for _p in _problems: | |
| _solutions = os.listdir(f"{source}/{_p}") | |
| _n_solutions = len(_solutions) | |
| if not _solutions: | |
| print(f"Error: Directory {source}/{_p} of source code dataset is empty") | |
| _n_errors += 1 | |
| continue | |
| _n_total_solutions += _n_solutions | |
| if _p in test: | |
| _test_stat.update(_p, test[_p], _n_solutions) | |
| elif _p in train: | |
| _train_stat.update(_p, train[_p], _n_solutions) | |
| elif _p in val: | |
| _val_stat.update(_p, val[_p], _n_solutions) | |
| else: | |
| print(f"Error: problem {_p} is not present in any datasets") | |
| _n_errors +=1 | |
| print("\n") | |
| _train_stat.report("Statistics of training dataset") | |
| _val_stat.report("Statistics of validation dataset") | |
| _test_stat.report("Statistics of test dataset") | |
| return len(_problems), _n_total_solutions, _n_errors | |
| #------------- End of functions ----------------------------- | |
| def main(args): | |
| """ | |
| Main function of program for verifying dataset | |
| Parameters: | |
| - args -- Parsed command line arguments | |
| as object returned by ArgumentParser | |
| """ | |
| if not os.path.exists(args.ds): | |
| sys.exit(f"Directory {args.source} of source code dataset is not found") | |
| n_total_errors = 0 | |
| train_problems, _n_errors = readDsProblems(args.train_problems) | |
| n_total_errors += _n_errors | |
| val_problems, _n_errors = readDsProblems(args.val_problems) | |
| n_total_errors += _n_errors | |
| test_problems, _n_errors = readDsProblems(args.test_problems) | |
| n_total_errors += _n_errors | |
| n_trains, n_train_similars, n_train_dissimilars, _n_errors = \ | |
| readDsSamples(args.train_samples, train_problems) | |
| n_total_errors += _n_errors | |
| n_vals, n_val_similars, n_val_dissimilars, _n_errors = \ | |
| readDsSamples(args.val_samples, val_problems) | |
| n_total_errors += _n_errors | |
| n_tests, n_test_similars, n_test_dissimilars, _n_errors = \ | |
| readDsSamples(args.test_samples, test_problems) | |
| n_total_errors += _n_errors | |
| n_total_errors += checkNoCommonProblems(train_problems, val_problems, | |
| args.train_problems, | |
| args.val_problems) | |
| n_total_errors += checkNoCommonProblems(train_problems, test_problems, | |
| args.train_problems, | |
| args.test_problems) | |
| n_total_errors += checkNoCommonProblems(test_problems, val_problems, | |
| args.test_problems, | |
| args.val_problems) | |
| n_total_errors += checkDsVsDir(train_problems, args.ds, | |
| args.train_samples, args.sol_ext) | |
| n_total_errors += checkDsVsDir(val_problems, args.ds, | |
| args.val_samples, args.sol_ext) | |
| n_total_errors += checkDsVsDir(test_problems, args.ds, | |
| args.test_samples, args.sol_ext) | |
| print(f"Training dataset has {n_trains} samples: " + | |
| f"{n_train_similars} similar and {n_train_dissimilars} " + | |
| f"dissimilar ones built on {len(train_problems)} problems") | |
| print(f"Validation dataset has {n_vals} samples: " + | |
| f"{n_val_similars} similar and {n_val_dissimilars} " + | |
| f"dissimilar ones built on {len(val_problems)} problems") | |
| print(f"Test dataset has {n_trains} samples: " + | |
| f"{n_test_similars} similar and {n_test_dissimilars} " + | |
| f"dissimilar ones built on {len(test_problems)} problems") | |
| n_source_problems, n_source_solutions, _n_errors = checkDirVsDatasets( | |
| args.ds, train_problems, val_problems, test_problems) | |
| print(f"Source dataset directory has {n_source_problems} problems " + | |
| f"with {n_source_solutions} total solutions") | |
| if n_total_errors: | |
| print(f"There were found {n_total_errors} errors in datasets") | |
| else: | |
| print("No errors were found in test and training datasets") | |
| #------------- End of function main ----------------------------- | |
| ################################################################################ | |
| # Command line arguments are described below | |
| ################################################################################ | |
| if __name__ == '__main__': | |
| print("\nVERIFYING CONSISTENCY OF TESTING, VALIDATION AND TRAINING SIMILARITY DATASETS") | |
| #Command-line arguments | |
| parser = argparse.ArgumentParser( | |
| description = "Verication of testing, validation and training datsets " + | |
| "of similarity analysis") | |
| parser.add_argument("ds", type=str, | |
| help="Directory with source dataset") | |
| parser.add_argument("--test_samples", type=str, | |
| help="file with samples of test dataset") | |
| parser.add_argument("--val_samples", type=str, required=True, | |
| help="file with samples of validation dataset") | |
| parser.add_argument("--train_samples", type=str, required=True, | |
| help="file with samples of training datset") | |
| parser.add_argument("--test_problems", type=str, required=True, | |
| help="file with problems of test dataset") | |
| parser.add_argument("--val_problems", type=str, required=True, | |
| help="file with problems of validation dataset") | |
| parser.add_argument("--train_problems", type=str, required=True, | |
| help="file with problems of training datset") | |
| parser.add_argument("--sol_ext", type=str, default="cpp", | |
| help="extentions of files with solutions") | |
| args = parser.parse_args() | |
| print("Parameter settings used:") | |
| for k,v in sorted(vars(args).items()): | |
| print("{}: {}".format(k,v)) | |
| main(args) | |