示例#1
0
    def fit(self, X, Y, constraints=None):
        print("Training dual structural SVM")
        # we initialize with a small value so that loss-augmented inference
        # can give us something meaningful in the first iteration
        w = np.ones(self.problem.size_psi) * 1e-5
        n_samples = len(X)
        if constraints is None:
            constraints = [[] for i in xrange(n_samples)]
        loss_curve = []
        objective_curve = []
        primal_objective_curve = []
        self.ws = []
        self.alphas = []  # dual solutions
        for iteration in xrange(self.max_iter):
            if self.verbose > 0:
                print("iteration %d" % iteration)
            new_constraints = 0
            current_loss = 0.
            #for i, x, y in zip(np.arange(len(X)), X, Y):
                #y_hat, delta_psi, slack, loss = self._find_constraint(x, y, w)
            candidate_constraints = (Parallel(n_jobs=self.n_jobs)
                                     (delayed(find_constraint)
                                      (self.problem, x, y, w)
                                      for x, y in zip(X, Y)))
            for i, x, y, constraint in zip(np.arange(len(X)), X, Y,
                                           candidate_constraints):
                y_hat, delta_psi, slack, loss = constraint

                # check that the slack fits the loss-augmented inference
                x_loss_augmented = self.problem.loss_augment(x, y, w)
                dpsi_ = (GridCRF.psi(self.problem, x_loss_augmented, y)
                         - GridCRF.psi(self.problem, x_loss_augmented, y_hat))
                if np.abs(slack + min(0, np.dot(w, dpsi_))) > 0.01:
                    tracer()

                current_loss += loss

                if self.verbose > 1:
                    print("current slack: %f" % slack)
                y_hat_plain = unwrap_pairwise(y_hat)
                already_active = np.any([True for y__, _, _ in constraints[i]
                                         if (y_hat_plain ==
                                             unwrap_pairwise(y__)).all()])
                if already_active:
                    continue

                if self.check_constraints:
                    # "smart" stopping criterion
                    # check if most violated constraint is more violated
                    # than previous ones by more then eps.
                    # If it is less violated, inference was wrong/approximate
                    for con in constraints[i]:
                        # compute slack for old constraint
                        slack_tmp = max(con[2] - np.dot(w, con[1]), 0)
                        if self.verbose > 1:
                            print("slack old constraint: %f" % slack_tmp)
                        # if slack of new constraint is smaller or not
                        # significantly larger, don't add constraint.
                        # if smaller, complain about approximate inference.
                        if slack - slack_tmp < -1e-5:
                            print("bad inference: %f" % (slack_tmp - slack))
                            if self.break_on_bad:
                                tracer()
                            already_active = True
                            break

                # if significant slack and constraint not active
                # this is a weaker check than the "check_constraints" one.
                if not already_active and slack > 1e-5:
                    constraints[i].append([y_hat, delta_psi, loss])
                    new_constraints += 1
            current_loss /= len(X)
            loss_curve.append(current_loss)

            if new_constraints == 0:
                print("no additional constraints")
                #tracer()
                if iteration > 0:
                    break
            w, objective = self._solve_n_slack_qp(constraints, n_samples)

            # hack to make loss-augmented prediction working:
            w[:self.problem.n_states][w[:self.problem.n_states] == 0] = 1e-10
            slacks = [max(np.max([-np.dot(w, psi_) + loss_
                                  for _, psi_, loss_ in sample]), 0)
                      for sample in constraints]
            sum_of_slacks = np.sum(slacks)
            objective_p = self.C * sum_of_slacks / len(X) + np.sum(w ** 2) / 2.
            primal_objective_curve.append(objective_p)
            if (len(primal_objective_curve) > 2
                    and objective_p > primal_objective_curve[-2] + 1e8):
                print("primal loss became smaller. that shouldn't happen.")
                tracer()
            objective_curve.append(objective)
            if self.verbose > 0:
                print("current loss: %f  new constraints: %d, "
                      "primal objective: %f dual objective: %f" %
                      (current_loss, new_constraints,
                       primal_objective_curve[-1], objective))
            if (iteration > 1 and primal_objective_curve[-1] -
                    primal_objective_curve[-2] < 0.0001):
                print("objective converged.")
                break
            self.ws.append(w)
            if self.verbose > 1:
                print(w)
        self.w = w
        self.constraints_ = constraints
        print("calls to inference: %d" % self.problem.inference_calls)
        if self.plot:
            plt.figure()
            plt.subplot(131, title="loss")
            plt.plot(loss_curve)
            plt.subplot(132, title="objective")
            plt.plot(objective_curve)
            plt.subplot(133, title="primal objective")
            plt.plot(primal_objective_curve)
            plt.show()
            plt.close()