305 lines
9.5 KiB
C++
305 lines
9.5 KiB
C++
/*
|
|
* Scheduler.h
|
|
* @brief an example how inference can be used for scheduling qualifiers
|
|
* @date Mar 26, 2011
|
|
* @author Frank Dellaert
|
|
*/
|
|
|
|
#include <gtsam_unstable/discrete/Scheduler.h>
|
|
#include <gtsam/discrete/DiscreteFactorGraph.h>
|
|
#include <gtsam/base/debug.h>
|
|
#include <gtsam/base/timing.h>
|
|
|
|
#include <boost/tokenizer.hpp>
|
|
#include <boost/foreach.hpp>
|
|
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <cmath>
|
|
|
|
namespace gtsam {
|
|
|
|
using namespace std;
|
|
|
|
Scheduler::Scheduler(size_t maxNrStudents, const string& filename):
|
|
maxNrStudents_(maxNrStudents)
|
|
{
|
|
typedef boost::tokenizer<boost::escaped_list_separator<char> > Tokenizer;
|
|
|
|
// open file
|
|
ifstream is(filename.c_str());
|
|
if (!is) {
|
|
cerr << "Scheduler: could not open file " << filename << endl;
|
|
throw runtime_error("Scheduler: could not open file " + filename);
|
|
}
|
|
|
|
string line; // buffer
|
|
|
|
// process first line with faculty
|
|
if (getline(is, line, '\r')) {
|
|
Tokenizer tok(line);
|
|
Tokenizer::iterator it = tok.begin();
|
|
for (++it; it != tok.end(); ++it)
|
|
addFaculty(*it);
|
|
}
|
|
|
|
// for all remaining lines
|
|
size_t count = 0;
|
|
while (getline(is, line, '\r')) {
|
|
if (count++ > 100) throw runtime_error("reached 100 lines, exiting");
|
|
Tokenizer tok(line);
|
|
Tokenizer::iterator it = tok.begin();
|
|
addSlot(*it++); // add slot
|
|
// add availability
|
|
for (; it != tok.end(); ++it)
|
|
available_ += (it->empty()) ? "0 " : "1 ";
|
|
available_ += '\n';
|
|
}
|
|
} // constructor
|
|
|
|
/** addStudent has to be called after adding slots and faculty */
|
|
void Scheduler::addStudent(const string& studentName,
|
|
const string& area1, const string& area2,
|
|
const string& area3, const string& advisor) {
|
|
assert(nrStudents()<maxNrStudents_);
|
|
assert(facultyInArea_.count(area1));
|
|
assert(facultyInArea_.count(area2));
|
|
assert(facultyInArea_.count(area3));
|
|
size_t advisorIndex = facultyIndex_[advisor];
|
|
Student student(nrFaculty(), advisorIndex);
|
|
student.name_ = studentName;
|
|
// We fix the ordering by assigning a higher index to the student
|
|
// and numbering the areas lower
|
|
Key j = 3*maxNrStudents_ + nrStudents();
|
|
student.key_ = DiscreteKey(j, nrTimeSlots());
|
|
Key base = 3*nrStudents();
|
|
student.keys_[0] = DiscreteKey(base+0, nrFaculty());
|
|
student.keys_[1] = DiscreteKey(base+1, nrFaculty());
|
|
student.keys_[2] = DiscreteKey(base+2, nrFaculty());
|
|
student.areaName_[0] = area1;
|
|
student.areaName_[1] = area2;
|
|
student.areaName_[2] = area3;
|
|
students_.push_back(student);
|
|
}
|
|
|
|
/** get key for student and area, 0 is time slot itself */
|
|
const DiscreteKey& Scheduler::key(size_t s, boost::optional<size_t> area) const {
|
|
return area ? students_[s].keys_[*area] : students_[s].key_;
|
|
}
|
|
|
|
const string& Scheduler::studentName(size_t i) const {
|
|
assert(i<nrStudents());
|
|
return students_[i].name_;
|
|
}
|
|
|
|
const DiscreteKey& Scheduler::studentKey(size_t i) const {
|
|
assert(i<nrStudents());
|
|
return students_[i].key_;
|
|
}
|
|
|
|
const string& Scheduler::studentArea(size_t i, size_t area) const {
|
|
assert(i<nrStudents());
|
|
return students_[i].areaName_[area];
|
|
}
|
|
|
|
/** Add student-specific constraints to the graph */
|
|
void Scheduler::addStudentSpecificConstraints(size_t i, boost::optional<size_t> slot) {
|
|
bool debug = ISDEBUG("Scheduler::buildGraph");
|
|
|
|
assert(i<nrStudents());
|
|
const Student& s = students_[i];
|
|
|
|
if (!slot && !slotsAvailable_.empty()) {
|
|
if (debug) cout << "Adding availability of slots" << endl;
|
|
assert(slotsAvailable_.size()==s.key_.second);
|
|
CSP::add(s.key_, slotsAvailable_);
|
|
}
|
|
|
|
// For all areas
|
|
for (size_t area = 0; area < 3; area++) {
|
|
|
|
DiscreteKey areaKey = s.keys_[area];
|
|
const string& areaName = s.areaName_[area];
|
|
|
|
if (debug) cout << "Area constraints " << areaName << endl;
|
|
assert(facultyInArea_[areaName].size()==areaKey.second);
|
|
CSP::add(areaKey, facultyInArea_[areaName]);
|
|
|
|
if (debug) cout << "Advisor constraint " << areaName << endl;
|
|
assert(s.advisor_.size()==areaKey.second);
|
|
CSP::add(areaKey, s.advisor_);
|
|
|
|
if (debug) cout << "Availability of faculty " << areaName << endl;
|
|
if (slot) {
|
|
// get all constraints then specialize to slot
|
|
size_t dummyIndex = maxNrStudents_*3+maxNrStudents_;
|
|
DiscreteKey dummy(dummyIndex, nrTimeSlots());
|
|
Potentials::ADT p(dummy & areaKey, available_); // available_ is Doodle string
|
|
Potentials::ADT q = p.choose(dummyIndex, *slot);
|
|
DiscreteFactor::shared_ptr f(new DecisionTreeFactor(areaKey, q));
|
|
CSP::push_back(f);
|
|
} else {
|
|
CSP::add(s.key_, areaKey, available_); // available_ is Doodle string
|
|
}
|
|
}
|
|
|
|
// add mutex
|
|
if (debug) cout << "Mutex for faculty" << endl;
|
|
addAllDiff(s.keys_[0] & s.keys_[1] & s.keys_[2]);
|
|
}
|
|
|
|
|
|
/** Main routine that builds factor graph */
|
|
void Scheduler::buildGraph(size_t mutexBound) {
|
|
bool debug = ISDEBUG("Scheduler::buildGraph");
|
|
|
|
if (debug) cout << "Adding student-specific constraints" << endl;
|
|
for (size_t i = 0; i < nrStudents(); i++)
|
|
addStudentSpecificConstraints(i);
|
|
|
|
// special constraint for MN
|
|
if (studentName(0) == "Michael N") CSP::add(studentKey(0),
|
|
"0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1");
|
|
|
|
if (!mutexBound) {
|
|
DiscreteKeys dkeys;
|
|
BOOST_FOREACH(const Student& s, students_)
|
|
dkeys.push_back(s.key_);
|
|
addAllDiff(dkeys);
|
|
} else {
|
|
if (debug) cout << "Mutex for Students" << endl;
|
|
for (size_t i1 = 0; i1 < nrStudents(); i1++) {
|
|
// if mutexBound=1, we only mutex with next student
|
|
size_t bound = min((i1 + 1 + mutexBound), nrStudents());
|
|
for (size_t i2 = i1 + 1; i2 < bound; i2++) {
|
|
addAllDiff(studentKey(i1), studentKey(i2));
|
|
}
|
|
}
|
|
}
|
|
} // buildGraph
|
|
|
|
/** print */
|
|
void Scheduler::print(const string& s) const {
|
|
|
|
cout << s << " Faculty:" << endl;
|
|
BOOST_FOREACH(const string& name, facultyName_)
|
|
cout << name << '\n';
|
|
cout << endl;
|
|
|
|
cout << s << " Slots:\n";
|
|
size_t i = 0;
|
|
BOOST_FOREACH(const string& name, slotName_)
|
|
cout << i++ << " " << name << endl;
|
|
cout << endl;
|
|
|
|
cout << "Availability:\n" << available_ << '\n';
|
|
|
|
cout << s << " Area constraints:\n";
|
|
BOOST_FOREACH(const FacultyInArea::value_type& it, facultyInArea_)
|
|
{
|
|
cout << setw(12) << it.first << ": ";
|
|
BOOST_FOREACH(double v, it.second)
|
|
cout << v << " ";
|
|
cout << '\n';
|
|
}
|
|
cout << endl;
|
|
|
|
cout << s << " Students:\n";
|
|
BOOST_FOREACH (const Student& student, students_)
|
|
student.print();
|
|
cout << endl;
|
|
|
|
CSP::print(s + " Factor graph");
|
|
cout << endl;
|
|
} // print
|
|
|
|
/** Print readable form of assignment */
|
|
void Scheduler::printAssignment(sharedValues assignment) const {
|
|
// Not intended to be general! Assumes very particular ordering !
|
|
cout << endl;
|
|
for (size_t s = 0; s < nrStudents(); s++) {
|
|
Key j = 3*maxNrStudents_ + s;
|
|
size_t slot = assignment->at(j);
|
|
cout << studentName(s) << " slot: " << slotName_[slot] << endl;
|
|
Key base = 3*s;
|
|
for (size_t area = 0; area < 3; area++) {
|
|
size_t faculty = assignment->at(base+area);
|
|
cout << setw(12) << studentArea(s,area) << ": " << facultyName_[faculty]
|
|
<< endl;
|
|
}
|
|
cout << endl;
|
|
}
|
|
}
|
|
|
|
/** Special print for single-student case */
|
|
void Scheduler::printSpecial(sharedValues assignment) const {
|
|
Values::const_iterator it = assignment->begin();
|
|
for (size_t area = 0; area < 3; area++, it++) {
|
|
size_t f = it->second;
|
|
cout << setw(12) << studentArea(0,area) << ": " << facultyName_[f] << endl;
|
|
}
|
|
cout << endl;
|
|
}
|
|
|
|
/** Accumulate faculty stats */
|
|
void Scheduler::accumulateStats(sharedValues assignment, vector<
|
|
size_t>& stats) const {
|
|
for (size_t s = 0; s < nrStudents(); s++) {
|
|
Key base = 3*s;
|
|
for (size_t area = 0; area < 3; area++) {
|
|
size_t f = assignment->at(base+area);
|
|
assert(f<stats.size());
|
|
stats[f]++;
|
|
} // area
|
|
} // s
|
|
}
|
|
|
|
/** Eliminate, return a Bayes net */
|
|
DiscreteBayesNet::shared_ptr Scheduler::eliminate() const {
|
|
gttic(my_eliminate);
|
|
// TODO: fix this!!
|
|
size_t maxKey = keys().size();
|
|
Ordering defaultKeyOrdering;
|
|
for (size_t i = 0; i<maxKey; ++i)
|
|
defaultKeyOrdering += Key(i);
|
|
DiscreteBayesNet::shared_ptr chordal = this->eliminateSequential(defaultKeyOrdering);
|
|
gttoc(my_eliminate);
|
|
return chordal;
|
|
}
|
|
|
|
/** Find the best total assignment - can be expensive */
|
|
Scheduler::sharedValues Scheduler::optimalAssignment() const {
|
|
DiscreteBayesNet::shared_ptr chordal = eliminate();
|
|
|
|
if (ISDEBUG("Scheduler::optimalAssignment")) {
|
|
DiscreteBayesNet::const_iterator it = chordal->end()-1;
|
|
const Student & student = students_.front();
|
|
cout << endl;
|
|
(*it)->print(student.name_);
|
|
}
|
|
|
|
gttic(my_optimize);
|
|
sharedValues mpe = chordal->optimize();
|
|
gttoc(my_optimize);
|
|
return mpe;
|
|
}
|
|
|
|
/** find the assignment of students to slots with most possible committees */
|
|
Scheduler::sharedValues Scheduler::bestSchedule() const {
|
|
sharedValues best;
|
|
throw runtime_error("bestSchedule not implemented");
|
|
return best;
|
|
}
|
|
|
|
/** find the corresponding most desirable committee assignment */
|
|
Scheduler::sharedValues Scheduler::bestAssignment(
|
|
sharedValues bestSchedule) const {
|
|
sharedValues best;
|
|
throw runtime_error("bestAssignment not implemented");
|
|
return best;
|
|
}
|
|
|
|
} // gtsam
|
|
|
|
|