NiaPy.runner.Runner.__export_to_latex() - Code Metrics - Inspection of "Upgrade runner" - NiaOrg/NiaPy - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#206)

by Grega

created 2019-04-26 04:47 UTC

NiaPy.runner.Runner.__export_to_latex() F

↳ Parent: NiaPy.runner

Complexity

Conditions

Size

Total Lines	69
Code Lines	55

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	55
nop	1
dl	0
loc	69
rs	3.6
c	0
b	0
f	0

How to fix Long Method Complexity

"""Implementation of Runner utility class."""

import datetime
import json
import os
import logging

import xlsxwriter
from numpy import (
    amin,
    median,
    amax,
    mean,
    std
)


from NiaPy.algorithms import AlgorithmUtility

logging.basicConfig()
logger = logging.getLogger('NiaPy.runner.Runner')
logger.setLevel('INFO')

__all__ = ["Runner"]


class Runner:
    r"""Runner utility feature.

    Feature which enables running multiple algorithms with multiple benchmarks.
    It also support exporting results in various formats (e.g. LaTeX, Excel, JSON)

    Attributes:
            D (int): Dimension of problem
            NP (int): Population size
            nFES (int): Number of function evaluations
            nRuns (int): Number of repetitions
            useAlgorithms (list of Algorithm): List of algorithms to run
            useBenchmarks (list of Benchmarks): List of benchmarks to run

    Returns:
            results (Dict[str, Dict]): Returns the results.

    """

    def __init__(self, D=10, nFES=1000000, nRuns=1, useAlgorithms='ArtificialBeeColonyAlgorithm', useBenchmarks='Ackley', **kwargs):
        r"""Initialize Runner.

        Args:
                D (int): Dimension of problem
                nFES (int): Number of function evaluations
                nRuns (int): Number of repetitions
                useAlgorithms (list of Algorithm): List of algorithms to run
                useBenchmarks (list of Benchmarks): List of benchmarks to run

        """

        self.D = D
        self.nFES = nFES
        self.nRuns = nRuns
        self.useAlgorithms = useAlgorithms
        self.useBenchmarks = useBenchmarks
        self.results = {}

    def benchmark_factory(self, name):
        r"""Create optimization task.

        Args:
                name (str): Benchmark name.

        Returns:
                Task: Optimization task to use.

        """

        from NiaPy.task import StoppingTask, OptimizationType
        return StoppingTask(D=self.D, nFES=self.nFES, optType=OptimizationType.MINIMIZATION, benchmark=name)

    @classmethod
    def __create_export_dir(cls):
        r"""Create export directory if not already createed."""
        if not os.path.exists("export"):
            os.makedirs("export")

    @classmethod
    def __generate_export_name(cls, extension):
        r"""Generate export file name.

        Args:
                extension (str): File format.

        Returns:

        """

        return "export/" + str(datetime.datetime.now()).replace(":", ".") + "." + extension

    def __export_to_log(self):
        r"""Print the results to terminal."""

        print(self.results)

    def __export_to_json(self):
        r"""Export the results in the JSON form.

        See Also:
                * :func:`NiaPy.Runner.__createExportDir`

        """

        self.__create_export_dir()
        with open(self.__generate_export_name("json"), "w") as outFile:
            json.dump(self.results, outFile)
            logger.info("Export to JSON completed!")

    def __export_to_xlsx(self):
        r"""Export the results in the xlsx form.

        See Also:
                :func:`NiaPy.Runner.__generateExportName`

        """

        self.__create_export_dir()
        workbook = xlsxwriter.Workbook(self.__generate_export_name("xlsx"))
        worksheet = workbook.add_worksheet()
        row, col, nRuns = 0, 0, 0

        for alg in self.results:
            _, col = worksheet.write(row, col, alg), col + 1
            for bench in self.results[alg]:
                worksheet.write(row, col, bench)
                nRuns = len(self.results[alg][bench])
                for i in range(len(self.results[alg][bench])):
                    _, row = worksheet.write(row, col, self.results[alg][bench][i]), row + 1
                row, col = row - len(self.results[alg][bench]), col + 1
            row, col = row + 1 + nRuns, col - 1 + len(self.results[alg])

        workbook.close()
        logger.info("Export to XLSX completed!")

    def __export_to_latex(self):
        r"""Export the results in the form of latex table.

        See Also:
                :func:`NiaPy.Runner.__createExportDir`
                :func:`NiaPy.Runner.__generateExportName`

        """

        self.__create_export_dir()

        metrics = ["Best", "Median", "Worst", "Mean", "Std."]

        def only_upper(s):
            return "".join(c for c in s if c.isupper())

        with open(self.__generate_export_name("tex"), "a") as outFile:
            outFile.write("\\documentclass{article}\n")
            outFile.write("\\usepackage[utf8]{inputenc}\n")
            outFile.write("\\usepackage{siunitx}\n")
            outFile.write("\\sisetup{\n")
            outFile.write("round-mode=places,round-precision=3}\n")
            outFile.write("\\begin{document}\n")
            outFile.write("\\begin{table}[h]\n")
            outFile.write("\\centering\n")
            begin_tabular = "\\begin{tabular}{cc"
            for alg in self.results:
                for _i in range(len(self.results[alg])):
                    begin_tabular += "S"
                firstLine = "   &"
                for benchmark in self.results[alg].keys():
                    firstLine += "  &   \\multicolumn{1}{c}{\\textbf{" + benchmark + "}}"
                firstLine += " \\\\"
                break
            begin_tabular += "}\n"
            outFile.write(begin_tabular)
            outFile.write("\\hline\n")
            outFile.write(firstLine + "\n")

            outFile.write("\\hline\n")
            for alg in self.results:
                for metric in metrics:
                    line = ""
                    if metric != "Worst":
                        line += "   &   " + metric
                    else:
                        shortAlg = ""
                        if alg.endswith("Algorithm"):
                            shortAlg = only_upper(alg[:-9])
                        else:
                            shortAlg = only_upper(alg)
                        line += "\\textbf{" + shortAlg + "} &   " + metric
                        for benchmark in self.results[alg]:
                            if metric == "Best":
                                line += "   &   " + str(amin(self.results[alg][benchmark]))
                            elif metric == "Median":
                                line += "   &   " + str(median(self.results[alg][benchmark]))
                            elif metric == "Worst":
                                line += "   &   " + str(amax(self.results[alg][benchmark]))
                            elif metric == "Mean":
                                line += "   &   " + str(mean(self.results[alg][benchmark]))
                            else:
                                line += "   &   " + str(std(self.results[alg][benchmark]))
                        line += "   \\\\"
                        outFile.write(line + "\n")
                    outFile.write("\\hline\n")
                outFile.write("\\end{tabular}\n")
                outFile.write("\\end{table}\n")
                outFile.write("\\end{document}")
        logger.info("Export to Latex completed!")

    def run(self, export="log", verbose=False):
        """Execute runner.

        Arguments:
                export (str): Takes export type (e.g. log, json, xlsx, latex) (default: "log")
                verbose (bool: Switch for verbose logging (default: {False})

        Raises:
                TypeError: Raises TypeError if export type is not supported

        Returns:
                dict: Returns dictionary of results

        See Also:
                * :func:`NiaPy.Runner.useAlgorithms`
                * :func:`NiaPy.Runner.useBenchmarks`
                * :func:`NiaPy.Runner.__algorithmFactory`

        """

        for alg in self.useAlgorithms:
            if not isinstance(alg, "".__class__):
                alg_name = str(type(alg).__name__)
            else:
                alg_name = alg

            self.results[alg_name] = {}

            if verbose:
                logger.info("Running %s...", alg_name)

            for bench in self.useBenchmarks:
                if not isinstance(bench, "".__class__):
                    bench_name = str(type(bench).__name__)
                else:
                    bench_name = bench

                if verbose:
                    logger.info("Running %s algorithm on %s benchmark...", alg_name, bench_name)

                benchmark_stopping_task = self.benchmark_factory(bench)
                self.results[alg_name][bench_name] = []
                for _ in range(self.nRuns):
                    algorithm = AlgorithmUtility().get_algorithm(alg)
                    self.results[alg_name][bench_name].append(algorithm.run(benchmark_stopping_task))
            if verbose:
                logger.info("---------------------------------------------------")
        if export == "log":
            self.__export_to_log()
        elif export == "json":
            self.__export_to_json()
        elif export == "xlsx":
            self.__export_to_xlsx()
        elif export == "latex":
            self.__export_to_latex()
        else:
            raise TypeError("Passed export type is not supported!")


1			"""Implementation of Runner utility class."""
2
3			import datetime
4			import json
5			import os
6			import logging
7
8			import xlsxwriter
9			from numpy import (
10			amin,
11			median,
12			amax,
13			mean,
14			std
15			)
16
17
18			from NiaPy.algorithms import AlgorithmUtility
19
20			logging.basicConfig()
21			logger = logging.getLogger('NiaPy.runner.Runner')
22			logger.setLevel('INFO')
23
24			__all__ = ["Runner"]
25
26
27			class Runner:
28			r"""Runner utility feature.
29
30			Feature which enables running multiple algorithms with multiple benchmarks.
31			It also support exporting results in various formats (e.g. LaTeX, Excel, JSON)
32
33			Attributes:
34			D (int): Dimension of problem
35			NP (int): Population size
36			nFES (int): Number of function evaluations
37			nRuns (int): Number of repetitions
38			useAlgorithms (list of Algorithm): List of algorithms to run
39			useBenchmarks (list of Benchmarks): List of benchmarks to run
40
41			Returns:
42			results (Dict[str, Dict]): Returns the results.
43
44			"""
45
46			def __init__(self, D=10, nFES=1000000, nRuns=1, useAlgorithms='ArtificialBeeColonyAlgorithm', useBenchmarks='Ackley', **kwargs):
47			r"""Initialize Runner.
48
49			Args:
50			D (int): Dimension of problem
51			nFES (int): Number of function evaluations
52			nRuns (int): Number of repetitions
53			useAlgorithms (list of Algorithm): List of algorithms to run
54			useBenchmarks (list of Benchmarks): List of benchmarks to run
55
56			"""
57
58			self.D = D
59			self.nFES = nFES
60			self.nRuns = nRuns
61			self.useAlgorithms = useAlgorithms
62			self.useBenchmarks = useBenchmarks
63			self.results = {}
64
65			def benchmark_factory(self, name):
66			r"""Create optimization task.
67
68			Args:
69			name (str): Benchmark name.
70
71			Returns:
72			Task: Optimization task to use.
73
74			"""
75
76			from NiaPy.task import StoppingTask, OptimizationType
77			return StoppingTask(D=self.D, nFES=self.nFES, optType=OptimizationType.MINIMIZATION, benchmark=name)
78
79			@classmethod
80			def __create_export_dir(cls):
81			r"""Create export directory if not already createed."""
82			if not os.path.exists("export"):
83			os.makedirs("export")
84
85			@classmethod
86			def __generate_export_name(cls, extension):
87			r"""Generate export file name.
88
89			Args:
90			extension (str): File format.
91
92			Returns:
93
94			"""
95
96			return "export/" + str(datetime.datetime.now()).replace(":", ".") + "." + extension
97
98			def __export_to_log(self):
99			r"""Print the results to terminal."""
100
101			print(self.results)
102
103			def __export_to_json(self):
104			r"""Export the results in the JSON form.
105
106			See Also:
107			* :func:`NiaPy.Runner.__createExportDir`
108
109			"""
110
111			self.__create_export_dir()
112			with open(self.__generate_export_name("json"), "w") as outFile:
113			json.dump(self.results, outFile)
114			logger.info("Export to JSON completed!")
115
116			def __export_to_xlsx(self):
117			r"""Export the results in the xlsx form.
118
119			See Also:
120			:func:`NiaPy.Runner.__generateExportName`
121
122			"""
123
124			self.__create_export_dir()
125			workbook = xlsxwriter.Workbook(self.__generate_export_name("xlsx"))
126			worksheet = workbook.add_worksheet()
127			row, col, nRuns = 0, 0, 0
128
129			for alg in self.results:
130			_, col = worksheet.write(row, col, alg), col + 1
131			for bench in self.results[alg]:
132			worksheet.write(row, col, bench)
133			nRuns = len(self.results[alg][bench])
134			for i in range(len(self.results[alg][bench])):
135			_, row = worksheet.write(row, col, self.results[alg][bench][i]), row + 1
136			row, col = row - len(self.results[alg][bench]), col + 1
137			row, col = row + 1 + nRuns, col - 1 + len(self.results[alg])
138
139			workbook.close()
140			logger.info("Export to XLSX completed!")
141
142			def __export_to_latex(self):
143			r"""Export the results in the form of latex table.
144
145			See Also:
146			:func:`NiaPy.Runner.__createExportDir`
147			:func:`NiaPy.Runner.__generateExportName`
148
149			"""
150
151			self.__create_export_dir()
152
153			metrics = ["Best", "Median", "Worst", "Mean", "Std."]
154
155			def only_upper(s):
156			return "".join(c for c in s if c.isupper())
157
158			with open(self.__generate_export_name("tex"), "a") as outFile:
159			outFile.write("\\documentclass{article}\n")
160			outFile.write("\\usepackage[utf8]{inputenc}\n")
161			outFile.write("\\usepackage{siunitx}\n")
162			outFile.write("\\sisetup{\n")
163			outFile.write("round-mode=places,round-precision=3}\n")
164			outFile.write("\\begin{document}\n")
165			outFile.write("\\begin{table}[h]\n")
166			outFile.write("\\centering\n")
167			begin_tabular = "\\begin{tabular}{cc"
168			for alg in self.results:
169			for _i in range(len(self.results[alg])):
170			begin_tabular += "S"
171			firstLine = " &"
172			for benchmark in self.results[alg].keys():
173			firstLine += " & \\multicolumn{1}{c}{\\textbf{" + benchmark + "}}"
174			firstLine += " \\\\"
175			break
176			begin_tabular += "}\n"
177			outFile.write(begin_tabular)
178			outFile.write("\\hline\n")
179			outFile.write(firstLine + "\n")
			0 ignored issues – show introduced 2019-04-15 10:29 UTC by Report Bug Copy Issue Report The variable `firstLine` does not seem to be defined for all execution paths. Loading history...
180			outFile.write("\\hline\n")
181			for alg in self.results:
182			for metric in metrics:
183			line = ""
184			if metric != "Worst":
185			line += " & " + metric
186			else:
187			shortAlg = ""
188			if alg.endswith("Algorithm"):
189			shortAlg = only_upper(alg[:-9])
190			else:
191			shortAlg = only_upper(alg)
192			line += "\\textbf{" + shortAlg + "} & " + metric
193			for benchmark in self.results[alg]:
194			if metric == "Best":
195			line += " & " + str(amin(self.results[alg][benchmark]))
196			elif metric == "Median":
197			line += " & " + str(median(self.results[alg][benchmark]))
198			elif metric == "Worst":
199			line += " & " + str(amax(self.results[alg][benchmark]))
200			elif metric == "Mean":
201			line += " & " + str(mean(self.results[alg][benchmark]))
202			else:
203			line += " & " + str(std(self.results[alg][benchmark]))
204			line += " \\\\"
205			outFile.write(line + "\n")
206			outFile.write("\\hline\n")
207			outFile.write("\\end{tabular}\n")
208			outFile.write("\\end{table}\n")
209			outFile.write("\\end{document}")
210			logger.info("Export to Latex completed!")
211
212			def run(self, export="log", verbose=False):
213			"""Execute runner.
214
215			Arguments:
216			export (str): Takes export type (e.g. log, json, xlsx, latex) (default: "log")
217			verbose (bool: Switch for verbose logging (default: {False})
218
219			Raises:
220			TypeError: Raises TypeError if export type is not supported
221
222			Returns:
223			dict: Returns dictionary of results
224
225			See Also:
226			* :func:`NiaPy.Runner.useAlgorithms`
227			* :func:`NiaPy.Runner.useBenchmarks`
228			* :func:`NiaPy.Runner.__algorithmFactory`
229
230			"""
231
232			for alg in self.useAlgorithms:
233			if not isinstance(alg, "".__class__):
234			alg_name = str(type(alg).__name__)
235			else:
236			alg_name = alg
237
238			self.results[alg_name] = {}
239
240			if verbose:
241			logger.info("Running %s...", alg_name)
242
243			for bench in self.useBenchmarks:
244			if not isinstance(bench, "".__class__):
245			bench_name = str(type(bench).__name__)
246			else:
247			bench_name = bench
248
249			if verbose:
250			logger.info("Running %s algorithm on %s benchmark...", alg_name, bench_name)
251
252			benchmark_stopping_task = self.benchmark_factory(bench)
253			self.results[alg_name][bench_name] = []
254			for _ in range(self.nRuns):
255			algorithm = AlgorithmUtility().get_algorithm(alg)
256			self.results[alg_name][bench_name].append(algorithm.run(benchmark_stopping_task))
257			if verbose:
258			logger.info("---------------------------------------------------")
259			if export == "log":
260			self.__export_to_log()
261			elif export == "json":
262			self.__export_to_json()
263			elif export == "xlsx":
264			self.__export_to_xlsx()
265			elif export == "latex":
266			self.__export_to_latex()
267			else:
268			raise TypeError("Passed export type is not supported!")
269

NiaOrg / NiaPy

Pull Request — master (#206)

NiaPy.runner.Runner.__export_to_latex() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like