advancedscoremodel_regional.cpp

来自「MS-Clustering is designed to rapidly clu」· C++ 代码 · 共 1,341 行 · 第 1/5 页

	choose_k_from_n(num_to_select,pairs.size(),random_idxs);

	for (i=0; i<random_idxs.size(); i++)
		selected_idxs.push_back(pairs[random_idxs[i]].idx);

	for (i=0; i<selected_idxs.size(); i++)
	{
		const int node_idx = selected_idxs[i];
		const Node& node = nodes[node_idx];
		vector<int> in_idxs,out_idxs;
		score_t max_n_score=NEG_INF;
		score_t max_c_score=NEG_INF;
		int best_n_idx=-1;
		int best_c_idx=-1;
		if (node.in_edge_idxs.size()>0 && node.out_edge_idxs.size()>0)
		{
			int j;
			for (j=0; j<node.in_edge_idxs.size(); j++)
			{
				const int edge_idx = node.in_edge_idxs[j];
				if (correct_edge_variant_map[edge_idx]>=0)
					continue;

				if (multi_edges[edge_idx].num_aa == 1)
				{
					in_idxs.push_back(edge_idx);
					if (nodes[multi_edges[edge_idx].n_idx].score>max_n_score)
					{
						max_n_score=nodes[multi_edges[edge_idx].n_idx].score;
						best_n_idx=edge_idx;
					}
				}
				else if (multi_edges[edge_idx].num_aa != 1 && (in_idxs.size()<2 || my_random()<0.1))
					in_idxs.push_back(edge_idx);
			}

			if (in_idxs.size()==0)
				continue;
			
			for (j=0; j<node.out_edge_idxs.size(); j++)
			{
				const int edge_idx = node.out_edge_idxs[j];
				if (correct_edge_variant_map[edge_idx]>=0)
					continue;

				if (multi_edges[edge_idx].num_aa == 1)
				{
					out_idxs.push_back(edge_idx);
					if (nodes[multi_edges[edge_idx].c_idx].score>max_c_score)
					{
						max_c_score=nodes[multi_edges[edge_idx].c_idx].score;
						best_c_idx=edge_idx;
					}
				}
				else if (multi_edges[edge_idx].num_aa != 1 && (out_idxs.size()<2 || my_random()<0.1))
					out_idxs.push_back(edge_idx);
			}
		}
		if (in_idxs.size()==0 || out_idxs.size()==0)
			continue;

		// add entries with the highest scoring nodes to bias the results
		if (best_n_idx>=0)
		{
			int num_to_add = int(0.3 * in_idxs.size()+0.5);
			int k;
			for (k=0; k<num_to_add; k++)
			{
				in_idxs.push_back(best_n_idx);
				in_idxs.push_back(best_n_idx);
			}
		}

		if (best_c_idx>=0)
		{
			int num_to_add = int(0.3 * out_idxs.size()+0.5);
			int k;
			for (k=0; k<num_to_add; k++)
			{
				out_idxs.push_back(best_c_idx);
				out_idxs.push_back(best_c_idx);
			}
		}

		const int bad_n_edge = in_idxs[int(my_random()*in_idxs.size())];
		const int bad_c_edge = out_idxs[int(my_random()*out_idxs.size())];
		const int n_var_idx = int(multi_edges[bad_n_edge].variant_ptrs.size() * my_random());
		const int c_var_idx = int(multi_edges[bad_c_edge].variant_ptrs.size() * my_random());

		BreakageInfo info;
		fill_breakage_info(model,&info,node_idx,bad_n_edge,n_var_idx,bad_c_edge,c_var_idx,4);
		bad_examples.push_back(info);

		if (my_random()<Gap_ratio)
		{
			BreakageInfo gap_info;
			fill_breakage_info(model,&gap_info,node_idx,bad_n_edge,n_var_idx,NEG_INF,NEG_INF,44);
			bad_examples.push_back(gap_info);
		}

		if ( my_random()<Gap_ratio)
		{
			BreakageInfo gap_info;
			fill_breakage_info(model,&gap_info,node_idx,NEG_INF,NEG_INF,bad_c_edge,c_var_idx,44);
			bad_examples.push_back(gap_info);
		}
	}

	// add a few nodes connecting to the N-terminal
	if (had_good_connect_to_n_term && nodes[0].out_edge_idxs.size()>2)
	{
		vector<int> in_idxs;
		int j;
		for (j=0; j<nodes[0].out_edge_idxs.size(); j++)
		{
			const int edge_idx = nodes[0].out_edge_idxs[j];
			if (correct_edge_variant_map[edge_idx]>=0)
				continue;

			if (multi_edges[edge_idx].num_aa == 1)
			{
				in_idxs.push_back(edge_idx);
			}
			else if (multi_edges[edge_idx].num_aa != 1 && (in_idxs.size()<3 || my_random()<0.1))
				in_idxs.push_back(edge_idx);
		}

		vector<int> selected_in_idxs;
		if (in_idxs.size()>3)
		{
			vector<int> positions;
			choose_k_from_n(3,in_idxs.size(),positions);
			int j;
			for (j=0; j<3; j++)
				selected_in_idxs.push_back(in_idxs[positions[j]]);
		}
		else
			selected_in_idxs = in_idxs;
		
		int k;
		for (k=0; k<selected_in_idxs.size(); k++)
		{
			const int bad_n_edge = selected_in_idxs[k];
			const MultiEdge& in_edge = multi_edges[bad_n_edge];
			const int node_idx = in_edge.c_idx;
			const Node& node = nodes[node_idx];

			vector<int> out_idxs;
			int j;
			for (j=0; j<node.out_edge_idxs.size(); j++)
			{
				const int edge_idx = node.out_edge_idxs[j];
				if (correct_edge_variant_map[edge_idx]>=0)
					continue;

				if (multi_edges[edge_idx].num_aa == 1)
				{
					out_idxs.push_back(edge_idx);
				}
				else if (multi_edges[edge_idx].num_aa != 1 && (out_idxs.size()<3 || my_random()<0.1))
					out_idxs.push_back(edge_idx);
			}

			if (out_idxs.size() == 0)
				continue;

			const int bad_c_edge = out_idxs[int(my_random()*out_idxs.size())];

			const int n_var_idx = int(multi_edges[bad_n_edge].variant_ptrs.size() * my_random());
			const int c_var_idx = int(multi_edges[bad_c_edge].variant_ptrs.size() * my_random());

			BreakageInfo info;
			fill_breakage_info(model,&info,node_idx,bad_n_edge,n_var_idx,bad_c_edge,c_var_idx,5);
			bad_examples.push_back(info);

			if (my_random()<Gap_ratio)
			{
				BreakageInfo gap_info;
				fill_breakage_info(model,&gap_info,node_idx,bad_n_edge,n_var_idx,NEG_INF,NEG_INF,55);
				bad_examples.push_back(gap_info);
			}

			if ( my_random()<Gap_ratio)
			{
				BreakageInfo gap_info;
				fill_breakage_info(model,&gap_info,node_idx,NEG_INF,NEG_INF,bad_c_edge,c_var_idx,55);
				bad_examples.push_back(gap_info);
			}
		}
	}

	// add an example that connects to the C-terminal
	if (had_good_connect_to_c_term && nodes[nodes.size()-1].in_edge_idxs.size()>1)
	{
		vector<int> out_idxs;
		int j;
		for (j=0; j<nodes[nodes.size()-1].in_edge_idxs.size(); j++)
		{
			const int edge_idx = nodes[nodes.size()-1].in_edge_idxs[j];
			if (correct_edge_variant_map[edge_idx]>=0)
				continue;

			if (multi_edges[edge_idx].num_aa == 1)
			{
				out_idxs.push_back(edge_idx);
			}
			else if (multi_edges[edge_idx].num_aa != 1 && my_random()<0.025)
				out_idxs.push_back(edge_idx);
		}

		if (out_idxs.size() == 0)
			return;

		const int bad_c_edge = out_idxs[int(my_random()*out_idxs.size())];
		
		const MultiEdge& out_edge = multi_edges[bad_c_edge];
		const int node_idx = out_edge.n_idx;
		const Node& node = nodes[node_idx];

		vector<int> in_idxs;
		for (j=0; j<node.in_edge_idxs.size(); j++)
		{
			const int edge_idx = node.in_edge_idxs[j];
			if (correct_edge_variant_map[edge_idx]>=0)
				continue;

			if (multi_edges[edge_idx].num_aa == 1)
			{
				in_idxs.push_back(edge_idx);
			}
			else if (multi_edges[edge_idx].num_aa != 1 && (in_idxs.size()<3 || my_random()<0.1))
				in_idxs.push_back(edge_idx);
		}

		if (in_idxs.size()>0)
		{
			const int bad_n_edge = in_idxs[int(my_random()*in_idxs.size())];

			const int n_var_idx = int(multi_edges[bad_n_edge].variant_ptrs.size() * my_random());
			const int c_var_idx = int(multi_edges[bad_c_edge].variant_ptrs.size() * my_random());

			BreakageInfo info;
			fill_breakage_info(model,&info,node_idx,bad_n_edge,n_var_idx,bad_c_edge,c_var_idx,6);
			bad_examples.push_back(info);

			if (my_random()<Gap_ratio)
			{
				BreakageInfo gap_info;
				fill_breakage_info(model,&gap_info,node_idx,bad_n_edge,n_var_idx,NEG_INF,NEG_INF,66);
				bad_examples.push_back(gap_info);
			}

			if ( my_random()<Gap_ratio)
			{
				BreakageInfo gap_info;
				fill_breakage_info(model,&gap_info,node_idx,NEG_INF,NEG_INF,bad_c_edge,c_var_idx,66);
				bad_examples.push_back(gap_info);
			}
		}
		
	}
}