def __init__()

in graph.py [0:0]

• 46 lines of code
• 23 McCabe index (conditional complexity)

    def __init__(self, logpath, model_name, series_id, x_var, y_var, average, base=None, convert_to_epochs=False, legend=None):
        self.name = model_name
        if legend:
            self.name += ":" + legend
        with open(logpath, 'r') as f:
            lines = f.readlines()
        identifier = json.loads(lines[0])
        img_gen_repr_learn = False
        if 'code' in identifier:
            img_gen_repr_learn = True

        if img_gen_repr_learn:
            x_var = x_var_mapping[x_var]
            y_var = y_var_mapping[series_id][y_var]

        data = []
        epoch_length = None
        for l in lines[1:]:
            try:
                parse = json.loads(l)
                if epoch_length is None and 'n_updates_per_epoch' in parse:
                    epoch_length = float(parse['n_updates_per_epoch'])
                if img_gen_repr_learn:
                    data.append(parse)
                elif 'series' in parse and parse['series'] == series_id:
                    data.append(parse)
            except json.JSONDecodeError:
                pass

        data = [d for d in data if x_var in d and y_var in d]
        self.x = np.array([l[x_var] for l in data]).astype(np.float64)
        self.y = np.array([l[y_var] for l in data]).astype(np.float64)
        if convert_to_epochs and x_var not in EPOCH_VARS:
            self.x /= epoch_length
        if base is not None:
            self.y /= np.log(base)
        if average:
            out_y = []
            for j in range(1, len(self.y) + 1):
                mini = max(0, j - args.average)
                out_y.append(self.y[mini:j].mean())
            self.y = np.array(out_y)

        if len(self.x) > 0 and len(self.y) > 0:
            max_idx = np.argmax(self.y)
            min_idx = np.argmin(self.y)
            self.xmax = self.x[max_idx]
            self.ymax = self.y[max_idx]
            self.xmin = self.x[min_idx]
            self.ymin = self.y[min_idx]