void
NdbapiDriver::initProperties() {
CrundDriver::initProperties();
cout << "setting ndb properties ..." << flush;
ostringstream msg;
mgmdConnect = toString(props[L"ndb.mgmdConnect"]);
if (mgmdConnect.empty()) {
mgmdConnect = string("localhost");
}
catalog = toString(props[L"ndb.catalog"]);
if (catalog.empty()) {
catalog = string("crunddb");
}
schema = toString(props[L"ndb.schema"]);
if (schema.empty()) {
schema = string("def");
}
//if (msg.tellp() == 0) {
if (msg.str().empty()) {
cout << " [ok]" << endl;
} else {
cout << endl << msg.str() << endl;
}
descr = "ndbapi(" + mgmdConnect + ")";
}
/**
* Common function for command service callbacks.
*
* NOTE: success is bool in messages, but has unsigned char type in C++
*/
bool send_command_long_and_wait(bool broadcast,
uint16_t command, uint8_t confirmation,
float param1, float param2,
float param3, float param4,
float param5, float param6,
float param7,
unsigned char &success, uint8_t &result)
{
using mavlink::common::MAV_RESULT;
unique_lock lock(mutex);
L_CommandTransaction::iterator ack_it;
/* check transactions */
for (const auto &tr : ack_waiting_list) {
if (tr.expected_command == command) {
ROS_WARN_THROTTLE_NAMED(10, "cmd", "CMD: Command %u already in progress", command);
return false;
}
}
/**
* @note APM & PX4 master always send COMMAND_ACK. Old PX4 never.
* Don't expect any ACK in broadcast mode.
*/
bool is_ack_required = (confirmation != 0 || m_uas->is_ardupilotmega() || m_uas->is_px4()) && !broadcast;
if (is_ack_required)
ack_it = ack_waiting_list.emplace(ack_waiting_list.end(), command);
command_long(broadcast,
command, confirmation,
param1, param2,
param3, param4,
param5, param6,
param7);
if (is_ack_required) {
lock.unlock();
bool is_not_timeout = wait_ack_for(*ack_it);
lock.lock();
success = is_not_timeout && ack_it->result == enum_value(MAV_RESULT::ACCEPTED);
result = ack_it->result;
ack_waiting_list.erase(ack_it);
}
else {
success = true;
result = enum_value(MAV_RESULT::ACCEPTED);
}
return true;
}
Conf& Conf::def_int(std::string name,
int lower_bound,
int upper_bound,
int default_value) {
assert2(lower_bound <= default_value && default_value <= upper_bound,
MS() << "Default value for " << name << "not in range.");
auto i = make_shared<Int>();
i->lower_bound = lower_bound;
i->upper_bound = upper_bound;
i->default_value = default_value;
i->value = default_value;
items[name] = i;
return *this;
}
Conf& Conf::def_float(std::string name,
double lower_bound,
double upper_bound,
double default_value) {
assert2(lower_bound <= default_value && default_value <= upper_bound,
MS() << "Default value for " << name << "not in range.");
auto f = make_shared<Float>();
f->lower_bound = lower_bound;
f->upper_bound = upper_bound;
f->default_value = default_value;
f->value = default_value;
items[name] = f;
return *this;
}
MAVConnTCPClient::MAVConnTCPClient(uint8_t system_id, uint8_t component_id,
std::string server_host, unsigned short server_port) :
MAVConnInterface(system_id, component_id),
tx_in_progress(false),
tx_q {},
rx_buf {},
io_service(),
io_work(new io_service::work(io_service)),
socket(io_service)
{
if (!resolve_address_tcp(io_service, conn_id, server_host, server_port, server_ep))
throw DeviceError("tcp: resolve", "Bind address resolve failed");
logInform(PFXd "Server address: %s", conn_id, to_string_ss(server_ep).c_str());
try {
socket.open(tcp::v4());
socket.connect(server_ep);
}
catch (boost::system::system_error &err) {
throw DeviceError("tcp", err);
}
// give some work to io_service before start
io_service.post(std::bind(&MAVConnTCPClient::do_recv, this));
// run io_service for async io
io_thread = std::thread([this] () {
utils::set_this_thread_name("mtcp%zu", conn_id);
io_service.run();
});
}
void command_int(bool broadcast,
uint8_t frame, uint16_t command,
uint8_t current, uint8_t autocontinue,
float param1, float param2,
float param3, float param4,
int32_t x, int32_t y,
float z)
{
using mavlink::common::MAV_COMPONENT;
const uint8_t tgt_sys_id = (broadcast) ? 0 : m_uas->get_tgt_system();
const uint8_t tgt_comp_id = (broadcast) ? 0 :
(use_comp_id_system_control) ?
enum_value(MAV_COMPONENT::COMP_ID_SYSTEM_CONTROL) : m_uas->get_tgt_component();
mavlink::common::msg::COMMAND_INT cmd;
cmd.target_system = tgt_sys_id;
cmd.target_component = tgt_comp_id;
cmd.frame = frame;
cmd.command = command;
cmd.current = current;
cmd.autocontinue = autocontinue;
cmd.param1 = param1;
cmd.param2 = param2;
cmd.param3 = param3;
cmd.param4 = param4;
cmd.x = x;
cmd.y = y;
cmd.z = z;
UAS_FCU(m_uas)->send_message_ignore_drop(cmd);
}
MAVConnTCPServer::MAVConnTCPServer(uint8_t system_id, uint8_t component_id,
std::string server_host, unsigned short server_port) :
MAVConnInterface(system_id, component_id),
io_service(),
acceptor(io_service)
{
if (!resolve_address_tcp(io_service, conn_id, server_host, server_port, bind_ep))
throw DeviceError("tcp-l: resolve", "Bind address resolve failed");
logInform(PFXd "Bind address: %s", conn_id, to_string_ss(bind_ep).c_str());
try {
acceptor.open(tcp::v4());
acceptor.set_option(tcp::acceptor::reuse_address(true));
acceptor.bind(bind_ep);
acceptor.listen();
}
catch (boost::system::system_error &err) {
throw DeviceError("tcp-l", err);
}
// give some work to io_service before start
io_service.post(std::bind(&MAVConnTCPServer::do_accept, this));
// run io_service for async io
io_thread = std::thread([this] () {
utils::set_this_thread_name("mtcps%zu", conn_id);
io_service.run();
});
}
Conf& Conf::def_choice(std::string name,
std::vector<std::string> choices,
std::string default_value) {
assert2(in_vector(choices, default_value),
MS() << default_value << " is not an option for " << name);
assert2(choices.size() >= 2,
MS() << "At least two choices are needed for " << name);
auto c = make_shared<Choice>();
c->choices = choices;
c->default_value = default_value;
c->value = default_value;
items[name] = c;
return *this;
}
void command_long(bool broadcast,
uint16_t command, uint8_t confirmation,
float param1, float param2,
float param3, float param4,
float param5, float param6,
float param7)
{
using mavlink::common::MAV_COMPONENT;
const uint8_t tgt_sys_id = (broadcast) ? 0 : m_uas->get_tgt_system();
const uint8_t tgt_comp_id = (broadcast) ? 0 :
(use_comp_id_system_control) ?
enum_value(MAV_COMPONENT::COMP_ID_SYSTEM_CONTROL) : m_uas->get_tgt_component();
const uint8_t confirmation_fixed = (broadcast) ? 0 : confirmation;
mavlink::common::msg::COMMAND_LONG cmd;
cmd.target_system = tgt_sys_id;
cmd.target_component = tgt_comp_id;
cmd.command = command;
cmd.confirmation = confirmation_fixed;
cmd.param1 = param1;
cmd.param2 = param2;
cmd.param3 = param3;
cmd.param4 = param4;
cmd.param5 = param5;
cmd.param6 = param6;
cmd.param7 = param7;
UAS_FCU(m_uas)->send_message_ignore_drop(cmd);
}
vector<BeamTreeResult<T>> best_trees(vector<Mat<T>> input, int beam_width) const {
auto leaves = convert_to_leaves(input);
vector<PartialTree> candidates = { PartialTree(leaves) };
while (candidates[0].nodes.size() > 1) {
vector<PartialTree> new_candidates;
for (auto& candidate: candidates) {
for (auto& new_candidate: cangen(candidate, beam_width)) {
new_candidates.emplace_back(new_candidate);
}
}
sort(new_candidates.begin(), new_candidates.end(),
[this](const PartialTree& c1, const PartialTree& c2) {
return candidate_log_probability(c1) > candidate_log_probability(c2);
});
candidates = vector<PartialTree>(
new_candidates.begin(),
new_candidates.begin() + min((size_t)beam_width, new_candidates.size())
);
for (size_t cidx = 0; cidx + 1 < candidates.size(); ++cidx) {
assert2(candidates[cidx].nodes.size() == candidates[cidx + 1].nodes.size(),
"Generated candidates of different sizes.");
}
}
vector<BeamTreeResult<T>> results;
for (auto& tree: candidates) {
results.emplace_back(tree.nodes[0], tree.derivation);
}
return results;
}
shared_ptr<visualizable::Tree> visualize_derivation(vector<uint> derivation, vector<string> words) {
using visualizable::Tree;
vector<shared_ptr<Tree>> result;
std::transform(words.begin(), words.end(), std::back_inserter(result),
[](const string& a) {
return make_shared<Tree>(a);
});
for (auto merge_idx : derivation) {
vector<shared_ptr<Tree>> new_result;
for(size_t ridx = 0; ridx < merge_idx; ++ridx) {
new_result.push_back(result[ridx]);
}
new_result.push_back(make_shared<Tree>(std::initializer_list<shared_ptr<Tree>> {
result[merge_idx],
result[merge_idx + 1]
}));
for(size_t ridx = merge_idx + 2; ridx < result.size(); ++ridx) {
new_result.push_back(result[ridx]);
}
result = new_result;
}
assert2(result.size() == 1, "Szymon messed up.");
return result[0];
}
void MAVConnTCPClient::client_connected(size_t server_channel)
{
logInform(PFXd "Got client, id: %zu, address: %s",
server_channel, conn_id, to_string_ss(server_ep).c_str());
// start recv
socket.get_io_service().post(std::bind(&MAVConnTCPClient::do_recv, this));
}
// Quantise a subband in in-place transform order
// This version of quantise_subbands assumes multiple quantisers per subband.
// It may be used for either quantising slices or for quantising subbands with codeblocks
const Array2D quantise_subbands(const Array2D& coefficients, const BlockVector& qIndices) {
const Index transformHeight = coefficients.shape()[0];
const Index transformWidth = coefficients.shape()[1];
// TO DO: Check numberOfSubbands=3n+1 ?
const int numberOfSubbands = qIndices.size();
const int waveletDepth = (numberOfSubbands-1)/3;
Index stride, offset; // stride is subsampling factor, offset is subsampling phase
Array2D result(coefficients.ranges());
// Create a view of the coefficients, representing the LL subband, quantise it,
// then assign the result a view of the results array. This puts the quantised
// LL subband into the result array in in-place transform order.
// ArrayIndices2D objects specify the subset of array elements within a view,
// that is they specify the subsampling factor and subsampling phase.
stride = pow(2, waveletDepth);
const ArrayIndices2D LLindices = // LLindices specifies the samples in the LL subband
indices[Range(0,transformHeight,stride)][Range(0,transformWidth,stride)];
result[LLindices] =
quantise_LLSubband(coefficients[LLindices], qIndices[0]);
// Next quantise the other subbands
// Note: Level numbers go from zero for the lowest ("DC") frequencies to depth for
// the high frequencies. This corresponds to the convention in the VC-2 specification.
// Subands go from zero ("DC") to numberOfSubbands-1 for HH at the highest level
for (char level=1, band=1; level<=waveletDepth; ++level) {
stride = pow(2, waveletDepth+1-level);
offset = stride/2;
// Create a view of coefficients corresponding to a subband, then quantise it
//Quantise HL subband
const ArrayIndices2D HLindices = // HLindices specifies the samples in the HL subband
indices[Range(0,transformHeight,stride)][Range(offset,transformWidth,stride)];
result[HLindices] = quantise_block(coefficients[HLindices], qIndices[band++]);
//Quantise LH subband
const ArrayIndices2D LHindices = // LHindices specifies the samples in the LH subband
indices[Range(offset,transformHeight,stride)][Range(0,transformWidth,stride)];
result[LHindices] = quantise_block(coefficients[LHindices], qIndices[band++]);
//Quantise HH subband
const ArrayIndices2D HHindices = // HHindices specifies the samples in the HH subband
indices[Range(offset,transformHeight,stride)][Range(offset,transformWidth,stride)];
result[HHindices] = quantise_block(coefficients[HHindices], qIndices[band++]);
}
return result;
}
bool arming_cb(mavros_msgs::CommandBool::Request &req,
mavros_msgs::CommandBool::Response &res)
{
using mavlink::common::MAV_CMD;
return send_command_long_and_wait(false,
enum_value(MAV_CMD::COMPONENT_ARM_DISARM), 1,
(req.value) ? 1.0 : 0.0,
0, 0, 0, 0, 0, 0,
res.success, res.result);
}
bool set_home_cb(mavros_msgs::CommandHome::Request &req,
mavros_msgs::CommandHome::Response &res)
{
using mavlink::common::MAV_CMD;
return send_command_long_and_wait(false,
enum_value(MAV_CMD::DO_SET_HOME), 1,
(req.current_gps) ? 1.0 : 0.0,
0, 0, 0, req.latitude, req.longitude, req.altitude,
res.success, res.result);
}
virtual void run(unsigned int generations,
unsigned int logFrequency = 100) {
// Generation: create the new members
for (auto i = 0U; i < PopSize; ++i) {
population.push_back(generator());
}
for (auto generation = 0U; generation < generations; ++generation) {
// Crossover: Add missing members
auto popSizePostSelection = population.size();
while (population.size() < PopSize) {
population.push_back(
crossover(population[random_uint(popSizePostSelection)],
population[random_uint(popSizePostSelection)]));
}
// Mutation: Mutate at least rate*popsize members
for (size_t i = 0; i < PopSize * mutationRate; ++i) {
auto index = random_uint(PopSize);
mutator(population[index]);
}
// Selection: Destroy the least fit members
selector(population, evaluator);
if (evaluator(population[0]) > bestScore) {
bestMember = population[0];
bestScore = evaluator(population[0]);
}
if (generation % logFrequency == 0) {
std::cout << "Generation(" << generation
<< ") - Fitness:" << bestScore << std::endl;
}
}
std::cout << "Best: ";
for (const auto& allele : bestMember) {
std::cout << allele << " ";
}
std::cout << std::endl << "Fitness: " << evaluator(bestMember)
<< std::endl;
}
bool trigger_control_cb(mavros_msgs::CommandTriggerControl::Request &req,
mavros_msgs::CommandTriggerControl::Response &res)
{
using mavlink::common::MAV_CMD;
return send_command_long_and_wait(false,
enum_value(MAV_CMD::DO_TRIGGER_CONTROL), 1,
(req.trigger_enable)? 1.0 : 0.0,
req.integration_time,
0, 0, 0, 0, 0,
res.success, res.result);
}
bool land_cb(mavros_msgs::CommandTOL::Request &req,
mavros_msgs::CommandTOL::Response &res)
{
using mavlink::common::MAV_CMD;
return send_command_long_and_wait(false,
enum_value(MAV_CMD::NAV_LAND), 1,
0, 0, 0,
req.yaw,
req.latitude, req.longitude, req.altitude,
res.success, res.result);
}
void MavRos::mavlink_pub_cb(const mavlink_message_t *mmsg, Framing framing)
{
auto rmsg = boost::make_shared<mavros_msgs::Mavlink>();
if (mavlink_pub.getNumSubscribers() == 0)
return;
rmsg->header.stamp = ros::Time::now();
mavros_msgs::mavlink::convert(*mmsg, *rmsg, enum_value(framing));
mavlink_pub.publish(rmsg);
}
inline void set_target(MsgT &cmd, bool broadcast)
{
using mavlink::common::MAV_COMPONENT;
const uint8_t tgt_sys_id = (broadcast) ? 0 : m_uas->get_tgt_system();
const uint8_t tgt_comp_id = (broadcast) ? 0 :
(use_comp_id_system_control) ?
enum_value(MAV_COMPONENT::COMP_ID_SYSTEM_CONTROL) : m_uas->get_tgt_component();
cmd.target_system = tgt_sys_id;
cmd.target_component = tgt_comp_id;
}
void MAVConnTCPServer::client_closed(std::weak_ptr<MAVConnTCPClient> weak_instp)
{
if (auto instp = weak_instp.lock()) {
bool locked = mutex.try_lock();
logInform(PFXd "Client connection closed, id: %p, address: %s",
conn_id, instp.get(), to_string_ss(instp->server_ep).c_str());
client_list.remove(instp);
if (locked)
mutex.unlock();
}
}
bool trigger_interval_cb(mavros_msgs::CommandTriggerInterval::Request &req,
mavros_msgs::CommandTriggerInterval::Response &res)
{
using mavlink::common::MAV_CMD;
// trigger interval can only be set when triggering is disabled
return send_command_long_and_wait(false,
enum_value(MAV_CMD::DO_SET_CAM_TRIGG_INTERVAL), 1,
req.cycle_time,
req.integration_time,
0, 0, 0, 0, 0,
res.success, res.result);
}
void Build() {
std::vector<utils::slice> key_slices;
for (size_t i = 0; i < keys_.size(); i++) {
key_slices.push_back(slice(keys_[i]));
}
filter_.clear();
policy_->create_filter(&key_slices[0], key_slices.size(), &filter_);
keys_.clear();
if (kVerbose >= 2) DumpFilter();
}
void player_right_clicked(int x, int y)
{
if (world_state != WORLDSTATE_NOLOAD) {return;}
if ((*global).active_screen != SCREEN_WORLD){return;}
if ((*global).game_pause) {return;}
if ( util.is_same_tile(x,y, (*global).player.player_at_x_int, (*global).player.player_at_y_int))
{
return;
}
t_o_interact.player_to_teleport_to(x,y);
}
/**
Given an ordered set of n nodes, find the best contiguous
pairs to join to form n-1 nodes. Return the `beam_width`
best set of nodes with the resulting join applied.
Inputs
------
vector<Node> states : nodes to join
int beam_width : number of joins to consider
Outputs
-------
vector<Candidate> new states : new sets with joined nodes
**/
vector<PartialTree> cangen(PartialTree candidate, int beam_width) const {
assert2(candidate.nodes.size() >= 2,
"Must at least have 2 states to join for candidate generation.");
int num_candidates = min((size_t)beam_width, candidate.nodes.size() - 1);
vector<Node> possible_joins;
vector<Mat<T>> scores;
for (size_t sidx = 0; sidx + 1 < candidate.nodes.size(); ++sidx) {
possible_joins.emplace_back(
Mat<T>(),
join_states(candidate.nodes[sidx], candidate.nodes[sidx + 1])
);
scores.emplace_back(prob_decoder.activate(possible_joins.back().state.hidden));
}
auto normalized_scores = MatOps<T>::softmax(scores);
for (size_t sidx = 0; sidx + 1 < candidate.nodes.size(); ++sidx) {
possible_joins[sidx].log_probability =
normalized_scores[sidx].log() +
candidate.nodes[sidx].log_probability +
candidate.nodes[sidx + 1].log_probability;
}
// initialize original index locations
vector<size_t> idx(possible_joins.size());
for (size_t i = 0; i < idx.size(); ++i)
idx[i] = i;
// sort indexes based on comparing values in v
sort(idx.begin(), idx.end(), [&possible_joins](size_t i1, size_t i2) {
return possible_joins[i1].log_probability.w(0) > possible_joins[i2].log_probability.w(0);
});
vector<PartialTree> results;
for (size_t cidx = 0; cidx < num_candidates; ++cidx) {
vector<Node> result;
size_t join_idx = idx[cidx];
for (size_t sidx = 0; sidx < join_idx; ++sidx)
result.emplace_back(candidate.nodes[sidx]);
result.emplace_back(possible_joins[join_idx]);
for (size_t sidx = join_idx + 2; sidx < candidate.nodes.size(); ++sidx) {
result.emplace_back(candidate.nodes[sidx]);
}
assert(result.size() == candidate.nodes.size() - 1);
auto new_derivation = candidate.derivation; // copy
// here cidx encodes the decision we made to join nodes cidx and cidx + 1.
new_derivation.push_back(cidx);
results.emplace_back(PartialTree(result, new_derivation));
}
return results;
}
/* ヤキトリマークの表示 */
void GameTableScreen::TrayReconst::ShowYakitori(const GameTable* gameStat) {
for (PlayerID i = 0; i < Players; ++i) {
if (!gameStat->Player[i].YakitoriFlag) continue;
switch (playerRelative(i, gameStat->PlayerID)) {
case sSelf:
{
RECT rect = {
(PlateWidthH + PlatePadding * 2) * (PlateID_Yakitori ) + PlatePadding, (PlateHeightH + PlatePadding * 2) * (0 ) + PlatePadding,
(PlateWidthH + PlatePadding * 2) * (PlateID_Yakitori + 1) - PlatePadding, (PlateHeightH + PlatePadding * 2) * (0 + 1) - PlatePadding,
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, YakitoriPosH, YakitoriPosV,
PlateWidthH, PlateHeightH, 0xffffffff, &rect, PlateWidthH / 2, PlateHeightH / 2);
}
break;
case sOpposite:
{
RECT rect = {
(PlateWidthH + PlatePadding * 2) * (PlateID_Yakitori ) + PlatePadding, (PlateHeightH + PlatePadding * 2) * (1 ) + PlatePadding,
(PlateWidthH + PlatePadding * 2) * (PlateID_Yakitori + 1) - PlatePadding, (PlateHeightH + PlatePadding * 2) * (1 + 1) - PlatePadding,
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, TableSize - YakitoriPosH, TableSize - YakitoriPosV,
PlateWidthH, PlateHeightH, 0xffffffff, &rect, PlateWidthH / 2, PlateHeightH / 2);
}
break;
case sRight:
{
RECT rect = {
(PlateWidthV + PlatePadding * 2) * (PlateID_Yakitori ) + PlatePadding, (PlateHeightV + PlatePadding * 2) * (0 ) + PlatePadding + (PlateHeightH + PlatePadding * 2) * 2,
(PlateWidthV + PlatePadding * 2) * (PlateID_Yakitori + 1) - PlatePadding, (PlateHeightV + PlatePadding * 2) * (0 + 1) - PlatePadding + (PlateHeightH + PlatePadding * 2) * 2,
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, YakitoriPosV, TableSize - YakitoriPosH,
PlateWidthV, PlateHeightV, 0xffffffff, &rect, PlateWidthV / 2, PlateHeightV / 2);
}
break;
case sLeft:
{
RECT rect = {
(PlateWidthV + PlatePadding * 2) * (PlateID_Yakitori ) + PlatePadding, (PlateHeightV + PlatePadding * 2) * (1 ) + PlatePadding + (PlateHeightH + PlatePadding * 2) * 2,
(PlateWidthV + PlatePadding * 2) * (PlateID_Yakitori + 1) - PlatePadding, (PlateHeightV + PlatePadding * 2) * (1 + 1) - PlatePadding + (PlateHeightH + PlatePadding * 2) * 2,
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, TableSize - YakitoriPosV, YakitoriPosH,
PlateWidthV, PlateHeightV, 0xffffffff, &rect, PlateWidthV / 2, PlateHeightV / 2);
}
break;
}
}
}
/* 起家マークの表示 */
void GameTableScreen::TrayReconst::ShowChiicha(const GameTable* gameStat) {
switch (playerRelative(0, gameStat->PlayerID)) {
case sSelf:
{
RECT rect = {
static_cast<int32_t>((PlateWidthH + PlatePadding * 2) * (gameStat->GameRound / Players ) + PlatePadding), static_cast<int32_t>((PlateHeightH + PlatePadding * 2) * (0 ) + PlatePadding),
static_cast<int32_t>((PlateWidthH + PlatePadding * 2) * (gameStat->GameRound / Players + 1) - PlatePadding), static_cast<int32_t>((PlateHeightH + PlatePadding * 2) * (0 + 1) - PlatePadding),
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, PlatePosH, PlatePosV,
PlateWidthH, PlateHeightH, 0xffffffff, &rect, PlateWidthH / 2, PlateHeightH / 2);
}
break;
case sOpposite:
{
RECT rect = {
static_cast<int32_t>((PlateWidthH + PlatePadding * 2) * (gameStat->GameRound / Players ) + PlatePadding), static_cast<int32_t>((PlateHeightH + PlatePadding * 2) * (1 ) + PlatePadding),
static_cast<int32_t>((PlateWidthH + PlatePadding * 2) * (gameStat->GameRound / Players + 1) - PlatePadding), static_cast<int32_t>((PlateHeightH + PlatePadding * 2) * (1 + 1) - PlatePadding),
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, TableSize - PlatePosH, TableSize - PlatePosV,
PlateWidthH, PlateHeightH, 0xffffffff, &rect, PlateWidthH / 2, PlateHeightH / 2);
}
break;
case sRight:
{
RECT rect = {
static_cast<int32_t>((PlateWidthV + PlatePadding * 2) * (gameStat->GameRound / Players ) + PlatePadding), static_cast<int32_t>((PlateHeightV + PlatePadding * 2) * (0 ) + PlatePadding + (PlateHeightH + PlatePadding * 2) * 2),
static_cast<int32_t>((PlateWidthV + PlatePadding * 2) * (gameStat->GameRound / Players + 1) - PlatePadding), static_cast<int32_t>((PlateHeightV + PlatePadding * 2) * (0 + 1) - PlatePadding + (PlateHeightH + PlatePadding * 2) * 2),
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, PlatePosV, TableSize - PlatePosH,
PlateWidthV, PlateHeightV, 0xffffffff, &rect, PlateWidthV / 2, PlateHeightV / 2);
}
break;
case sLeft:
{
RECT rect = {
static_cast<int32_t>((PlateWidthV + PlatePadding * 2) * (gameStat->GameRound / Players ) + PlatePadding), static_cast<int32_t>((PlateHeightV + PlatePadding * 2) * (1 ) + PlatePadding + (PlateHeightH + PlatePadding * 2) * 2),
static_cast<int32_t>((PlateWidthV + PlatePadding * 2) * (gameStat->GameRound / Players + 1) - PlatePadding), static_cast<int32_t>((PlateHeightV + PlatePadding * 2) * (1 + 1) - PlatePadding + (PlateHeightH + PlatePadding * 2) * 2),
};
SpriteRenderer::instantiate(caller->caller->getDevice())->ShowSprite(tChiicha, TableSize - PlatePosV, PlatePosH,
PlateWidthV, PlateHeightV, 0xffffffff, &rect, PlateWidthV / 2, PlateHeightV / 2);
}
break;
}
}
int main(int argc, char * argv[]) {
GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
cout << "dbpath = " << FLAGS_dbpath << endl;
// Open a database file
SQLite::Database db(FLAGS_dbpath);
// Load mapping from concepts to names
vector<string> index2concept;
if (!utils::file_exists(FLAGS_clean_index2target)) {
std::atomic<int> i(0);
auto concept_redirections = utils::load_redirection_list(FLAGS_redirections, [&i](std::string&& s)->std::string {
if (++i % 1000 == 0) {
std::cout << i << " cleaned redirection names \r" << std::flush;
}
return utils::join(
utils::xml_cleaner::split_punct_keep_brackets(s),
" ");
}, FLAGS_j);
index2concept = utils::load_list(FLAGS_index2target);
for (auto& concept : index2concept) {
if (concept_redirections.find(concept) != concept_redirections.end()) {
concept = utils::capitalize(concept_redirections.at(concept));
} else {
concept = utils::capitalize(concept);
}
}
utils::save_list(index2concept, FLAGS_clean_index2target);
} else {
index2concept = utils::load_list(FLAGS_clean_index2target);
}
// Load some examples from DB
SQLite::Statement query(db, "SELECT lines FROM articles");
// Convert protobuf -> vector<string>
auto els = load_protobuff_dataset(query, index2concept, 100);
cout << "got labeled examples" << endl;
for (auto& el : els) {
std::cout << utils::join(el[0], " ")
<< " (\033[4m" << utils::join(el[1], "\x1B[m, \033[4m") << "\x1B[m)" << std::endl;
}
}
static bool resolve_address_tcp(io_service &io, size_t chan, std::string host, unsigned short port, tcp::endpoint &ep)
{
bool result = false;
tcp::resolver resolver(io);
error_code ec;
tcp::resolver::query query(host, "");
std::for_each(resolver.resolve(query, ec), tcp::resolver::iterator(),
[&](const tcp::endpoint & q_ep) {
ep = q_ep;
ep.port(port);
result = true;
logDebug(PFXd "host %s resolved as %s", chan, host.c_str(), to_string_ss(ep).c_str());
});
if (ec) {
logWarn(PFXd "resolve error: %s", chan, ec.message().c_str());
result = false;
}
return result;
}
void training_loop(std::shared_ptr<Solver::AbstractSolver<REAL_t>> solver,
model_t& model,
std::function<vector<uint>(vector<uint>&)> pred_fun,
vector<numeric_example_t>& train,
vector<numeric_example_t>& validate) {
auto& vocab = arithmetic::vocabulary;
auto params = model.parameters();
int epoch = 0;
int difficulty_waiting = 0;
auto end_symbol_idx = vocab.word2index[utils::end_symbol];
int beam_width = FLAGS_beam_width;
if (beam_width < 1)
utils::exit_with_message(MS() << "Beam width must be strictly positive (got " << beam_width << ")");
Throttled throttled_examples;
Throttled throttled_validation;
bool target_accuracy_reached = false;
while (!target_accuracy_reached && epoch++ < FLAGS_graduation_time) {
auto indices = utils::random_arange(train.size());
auto indices_begin = indices.begin();
REAL_t minibatch_error = 0.0;
// one minibatch
for (auto indices_begin = indices.begin();
indices_begin < indices.begin() + std::min((size_t)FLAGS_minibatch, train.size());
indices_begin++) {
// <training>
auto& example = train[*indices_begin];
auto error = model.error(example, beam_width);
error.grad();
graph::backward();
minibatch_error += error.w(0);
// </training>
// // <reporting>
throttled_examples.maybe_run(seconds(10), [&]() {
graph::NoBackprop nb;
auto random_example_index = utils::randint(0, validate.size() -1);
auto& expression = validate[random_example_index].first;
auto predictions = model.predict(expression,
beam_width,
MAX_OUTPUT_LENGTH,
vocab.word2index.at(utils::end_symbol));
auto expression_string = arithmetic::vocabulary.decode(&expression);
if (expression_string.back() == utils::end_symbol)
expression_string.resize(expression_string.size() - 1);
std::cout << utils::join(expression_string) << std::endl;
vector<string> prediction_string;
vector<double> prediction_probability;
for (auto& prediction : predictions) {
if (validate[random_example_index].second == prediction.prediction) {
std::cout << utils::green;
}
prediction_probability.push_back(prediction.get_probability().w(0));
std::cout << "= (" << std::setprecision( 3 ) << prediction.get_probability().log().w(0) << ") ";
auto digits = vocab.decode(&prediction.prediction);
if (digits.back() == utils::end_symbol)
digits.pop_back();
auto joined_digits = utils::join(digits);
prediction_string.push_back(joined_digits);
std::cout << joined_digits << utils::reset_color << std::endl;
}
auto vgrid = make_shared<visualizable::GridLayout>();
assert2(predictions[0].derivations.size() == predictions[0].nodes.size(),
"Szymon messed up.");
for (int didx = 0;
didx < min((size_t)FLAGS_visualizer_trees, predictions[0].derivations.size());
++didx) {
auto visualization = visualize_derivation(
predictions[0].derivations[didx],
vocab.decode(&expression)
);
auto tree_prob = predictions[0].nodes[didx].log_probability.exp().w(0,0);
vgrid->add_in_column(0, make_shared<visualizable::Probability<double>>(tree_prob));
vgrid->add_in_column(0, visualization);
}
vgrid->add_in_column(1, make_shared<visualizable::Sentence<double>>(expression_string));
vgrid->add_in_column(1, make_shared<visualizable::FiniteDistribution<double>>(
prediction_probability,
prediction_string
));
if (visualizer)
visualizer->feed(vgrid->to_json());
});
double current_accuracy = -1;
throttled_validation.maybe_run(seconds(30), [&]() {
current_accuracy = arithmetic::average_recall(validate, pred_fun, FLAGS_j);
std::cout << "epoch: " << epoch << ", accuracy = " << std::setprecision( 3 )
<< 100.0 * current_accuracy << "%" << std::endl;
});
if (current_accuracy != -1 && current_accuracy > 0.9) {
std::cout << "Current accuracy is now " << current_accuracy << std::endl;
target_accuracy_reached = true;
break;
}
// </reporting>
}
solver->step(params); // One step of gradient descent
epoch++;
}
}
