Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Keeps track of the analysis results by storing the results in files.

 *

 * @package   core_analytics

 * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace core_analytics\local\analysis;

defined('MOODLE_INTERNAL') || die();

/**

 * Keeps track of the analysis results by storing the results in files.

 *

 * @package   core_analytics

 * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class result_file extends result {

    /**

     * Stores the analysis results by time-splitting method.

     * @var array

     */

    private $filesbytimesplitting = [];

    /**

     * Stores the analysis results.

     * @param  array $results

     * @return bool            True if anything was successfully analysed

     */

    public function add_analysable_results(array $results): bool {

        $any = false;

        // Process all provided time splitting methods.

        foreach ($results as $timesplittingid => $result) {

            if (!empty($result->result)) {

                $this->filesbytimesplitting[$timesplittingid][] = $result->result;

                $any = true;

            }

        }

        if (empty($any)) {

            return false;

        }

        return true;

    }

    /**

     * Retrieves cached results during evaluation.

     *

     * @param  \core_analytics\local\time_splitting\base $timesplitting

     * @param  \core_analytics\analysable                $analysable

     * @return mixed A \stored_file in this case.

     */

    public function retrieve_cached_result(\core_analytics\local\time_splitting\base $timesplitting,

        \core_analytics\analysable $analysable) {

        // For evaluation purposes we don't need to be that strict about how updated the data is,

        // if this analyser was analysed less that 1 week ago we skip generating a new one. This

        // helps scale the evaluation process as sites with tons of courses may need a lot of time to

        // complete an evaluation.

        if (!empty($this->options['evaluation']) && !empty($this->options['reuseprevanalysed'])) {

            $previousanalysis = \core_analytics\dataset_manager::get_evaluation_analysable_file($this->modelid,

                $analysable->get_id(), $timesplitting->get_id());

            // 1 week is a partly random time interval, no need to worry about DST.

            $boundary = time() - WEEKSECS;

            if ($previousanalysis && $previousanalysis->get_timecreated() > $boundary) {

                // Recover the previous analysed file and avoid generating a new one.

                return $previousanalysis;

            }

        }

        return false;

    }

    /**

     * Formats the result.

     *

     * @param  array                                     $data

     * @param  \core_analytics\local\target\base         $target

     * @param  \core_analytics\local\time_splitting\base $timesplitting

     * @param  \core_analytics\analysable                $analysable

     * @return mixed A \stored_file in this case

     */

    public function format_result(array $data, \core_analytics\local\target\base $target,

            \core_analytics\local\time_splitting\base $timesplitting, \core_analytics\analysable $analysable) {

        if (!empty($this->includetarget)) {

            $filearea = \core_analytics\dataset_manager::LABELLED_FILEAREA;

        } else {

            $filearea = \core_analytics\dataset_manager::UNLABELLED_FILEAREA;

        }

        $dataset = new \core_analytics\dataset_manager($this->modelid, $analysable->get_id(),

            $timesplitting->get_id(), $filearea, $this->options['evaluation']);

        // Add extra metadata.

        $this->add_model_metadata($data, $timesplitting, $target);

        // Write all calculated data to a file.

        if (!$result = $dataset->store($data)) {

            return false;

        }

        return $result;

    }

    /**

     * Returns the results of the analysis.

     * @return array

     */

    public function get(): array {

        if ($this->options['evaluation'] === false) {

            // Look for previous training and prediction files we generated and couldn't be used

            // by machine learning backends because they weren't big enough.

            $pendingfiles = \core_analytics\dataset_manager::get_pending_files($this->modelid, $this->includetarget,

                array_keys($this->filesbytimesplitting));

            foreach ($pendingfiles as $timesplittingid => $files) {

                foreach ($files as $file) {

                    $this->filesbytimesplitting[$timesplittingid][] = $file;

                }

            }

        }

        // We join the datasets by time splitting method.

        $timesplittingfiles = array();

        foreach ($this->filesbytimesplitting as $timesplittingid => $files) {

            if ($this->options['evaluation'] === true) {

                // Delete the previous copy. Only when evaluating.

                \core_analytics\dataset_manager::delete_previous_evaluation_file($this->modelid, $timesplittingid);

            }

            // Merge all course files into one.

            if ($this->includetarget) {

                $filearea = \core_analytics\dataset_manager::LABELLED_FILEAREA;

            } else {

                $filearea = \core_analytics\dataset_manager::UNLABELLED_FILEAREA;

            }

            $timesplittingfiles[$timesplittingid] = \core_analytics\dataset_manager::merge_datasets($files,

                $this->modelid, $timesplittingid, $filearea, $this->options['evaluation']);

        }

        if (!empty($pendingfiles)) {

            // We must remove them now as they are already part of another dataset.

            foreach ($pendingfiles as $timesplittingid => $files) {

                foreach ($files as $file) {

                    $file->delete();

                }

            }

        }

        return $timesplittingfiles;

    }

    /**

     * Adds target metadata to the dataset.

     *

     * The final dataset document will look like this:

     * ----------------------------------------------------

     * metadata1,metadata2,metadata3,.....

     * value1, value2, value3,.....

     *

     * header1,header2,header3,header4,.....

     * stud1value1,stud1value2,stud1value3,stud1value4,.....

     * stud2value1,stud2value2,stud2value3,stud2value4,.....

     * .....

     * ----------------------------------------------------

     *

     * @param array $data

     * @param \core_analytics\local\time_splitting\base $timesplitting

     * @param \core_analytics\local\target\base         $target

     * @return null

     */

    private function add_model_metadata(array &$data, \core_analytics\local\time_splitting\base $timesplitting,

            \core_analytics\local\target\base $target) {

        global $CFG;

        // If no target the first column is the sampleid, if target the last column is the target.

        // This will need to be updated when we support unsupervised learning models.

        $metadata = array(

            'timesplitting' => $timesplitting->get_id(),

            'nfeatures' => count(current($data)) - 1,

            'moodleversion' => $CFG->version,

            'targetcolumn' => $target->get_id()

        );

        if ($target->is_linear()) {

            $metadata['targettype'] = 'linear';

            $metadata['targetmin'] = $target::get_min_value();

            $metadata['targetmax'] = $target::get_max_value();

        } else {

            $metadata['targettype'] = 'discrete';

            $metadata['targetclasses'] = json_encode($target::get_classes());

        }

        // The first 2 samples will be used to store metadata about the dataset.

        $metadatacolumns = [];

        $metadatavalues = [];

        foreach ($metadata as $key => $value) {

            $metadatacolumns[] = $key;

            $metadatavalues[] = $value;

        }

        // This will also reset samples' dataset keys.

        array_unshift($data, $metadatacolumns, $metadatavalues);

    }

}