1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#ifndef OPTIMIZER_H
#define OPTIMIZER_H
#include <vector>
#include <string>
#include "FeatureData.h"
#include "Scorer.h"
#include "Types.h"
using namespace std;
typedef float featurescore;
class Point;
/**
* Abstract optimizer class.
*/
class Optimizer
{
protected:
Scorer *scorer; // no accessor for them only child can use them
FeatureData *FData; // no accessor for them only child can use them
unsigned int number_of_random_directions;
public:
Optimizer(unsigned Pd, vector<unsigned> i2O, vector<parameter_t> start, unsigned int nrandom);
void SetScorer(Scorer *_scorer);
void SetFData(FeatureData *_FData);
virtual ~Optimizer();
unsigned size() const {
return FData ? FData->size() : 0;
}
/**
* Generic wrapper around TrueRun to check a few things. Non virtual.
*/
statscore_t Run(Point&) const;
/**
* Main function that performs an optimization.
*/
virtual statscore_t TrueRun(Point&) const = 0;
/**
* Given a set of lambdas, get the nbest for each sentence.
*/
void Get1bests(const Point& param,vector<unsigned>& bests) const;
/**
* Given a set of nbests, get the Statistical score.
*/
statscore_t GetStatScore(const vector<unsigned>& nbests) const {
return scorer->score(nbests);
}
statscore_t GetStatScore(const Point& param) const;
vector<statscore_t> GetIncStatScore(vector<unsigned> ref, vector<vector<pair<unsigned,unsigned> > >) const;
/**
* Get the optimal Lambda and the best score in a particular direction from a given Point.
*/
statscore_t LineOptimize(const Point& start, const Point& direction, Point& best) const;
};
/**
* Default basic optimizer.
* This class implements Powell's method.
*/
class SimpleOptimizer : public Optimizer
{
private:
const float kEPS;
public:
SimpleOptimizer(unsigned dim, vector<unsigned> i2O, vector<parameter_t> start, unsigned int nrandom)
: Optimizer(dim, i2O, start,nrandom), kEPS(0.0001) {}
virtual statscore_t TrueRun(Point&) const;
};
/**
* An optimizer with random directions.
*/
class RandomDirectionOptimizer : public Optimizer
{
private:
const float kEPS;
public:
RandomDirectionOptimizer(unsigned dim, vector<unsigned> i2O, vector<parameter_t> start, unsigned int nrandom)
: Optimizer(dim, i2O, start, nrandom), kEPS(0.0001) {}
virtual statscore_t TrueRun(Point&) const;
};
/**
* Dumb baseline optimizer: just picks a random point and quits.
*/
class RandomOptimizer : public Optimizer
{
public:
RandomOptimizer(unsigned dim, vector<unsigned> i2O, vector<parameter_t> start, unsigned int nrandom)
: Optimizer(dim, i2O, start, nrandom) {}
virtual statscore_t TrueRun(Point&) const;
};
class OptimizerFactory
{
public:
static vector<string> GetTypeNames();
static Optimizer* BuildOptimizer(unsigned dim, vector<unsigned> tooptimize, vector<parameter_t> start, string type, unsigned int nrandom);
private:
OptimizerFactory() {}
~OptimizerFactory() {}
// Add new optimizer here BEFORE NOPTIMZER
enum OptType {
POWELL = 0,
RANDOM_DIRECTION = 1,
RANDOM,
NOPTIMIZER
};
static OptType GetOType(string);
static vector<string> typenames;
static void SetTypeNames();
};
#endif // OPTIMIZER_H
|
