C++ graphchi_vertex::num_edges方法代码示例

  /**
   *  Vertex update function - computes the least square step
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {
    vertex_data & vdata = latent_factors_inmem[vertex.id()];
    mat XtX = mat::Zero(D, D); 
    vec Xty = vec::Zero(D);

    bool compute_rmse = (vertex.num_outedges() > 0);
    // Compute XtX and Xty (NOTE: unweighted)
    for(int e=0; e < vertex.num_edges(); e++) {
      float observation = vertex.edge(e)->get_data();                
      vertex_data & nbr_latent = latent_factors_inmem[vertex.edge(e)->vertex_id()];
      Xty += nbr_latent.pvec * observation;
      XtX += nbr_latent.pvec * nbr_latent.pvec.transpose();
      if (compute_rmse) {
        double prediction;
        rmse_vec[omp_get_thread_num()] += sparse_als_predict(vdata, nbr_latent, observation, prediction);
      }
    }

    double regularization = lambda;
    if (regnormal)
      lambda *= vertex.num_edges();
    for(int i=0; i < D; i++) XtX(i,i) += regularization;


    bool isuser = vertex.id() < (uint)M;
    if (algorithm == SPARSE_BOTH_FACTORS || (algorithm == SPARSE_USR_FACTOR && isuser) || 
        (algorithm == SPARSE_ITM_FACTOR && !isuser)){ 
      double sparsity_level = 1.0;
      if (isuser)
        sparsity_level -= user_sparsity;
      else sparsity_level -= movie_sparsity;
      vdata.pvec = CoSaMP(XtX, Xty, (int)ceil(sparsity_level*(double)D), 10, 1e-4, D); 
    }
    else vdata.pvec = XtX.selfadjointView<Eigen::Upper>().ldlt().solve(Xty);
  }

  /**
   *  Vertex update function.
   *  On first iteration ,each vertex chooses a label = the vertex id.
   *  On subsequent iterations, each vertex chooses the minimum of the neighbor's
   *  label (and itself).
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {

    /* On subsequent iterations, find the minimum label of my neighbors */
    if (!edge_count){
      vid_t curmin = vertex_values[vertex.id()];
      if (gcontext.iteration == 0 && vertex.num_edges() > 0){
        mymutex.lock(); actual_vertices++; mymutex.unlock();
      }
      for(int i=0; i < vertex.num_edges(); i++) {
        vid_t nblabel = neighbor_value(vertex.edge(i));
        curmin = std::min(nblabel, curmin);
      }

      if (vertex_values[vertex.id()] > curmin) {
        changes++;
        set_data(vertex, curmin);
      }
    }
    else {
      vid_t curmin = vertex_values[vertex.id()];
      for(int i=0; i < vertex.num_edges(); i++) {
        vid_t nblabel = neighbor_value(vertex.edge(i));
        curmin = std::min(nblabel, curmin);
        if (vertex.edge(i)->vertex_id() > vertex.id()){
        mymutex.lock();
        state[curmin]++;
        mymutex.unlock();
        }
      }
    }
  }

  /**
   *  Vertex update function - computes the least square step
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {
    vertex_data & vdata = latent_factors_inmem[vertex.id()];
    bool isuser = vertex.id() < M;
    mat XtX = mat::Zero(D, D); 
    vec Xty = vec::Zero(D);

    bool compute_rmse = (vertex.num_outedges() > 0);
    // Compute XtX and Xty (NOTE: unweighted)
    for(int e=0; e < vertex.num_edges(); e++) {
      const edge_data & edge = vertex.edge(e)->get_data();
      float observation = edge.weight;                
      vertex_data & nbr_latent = latent_factors_inmem[vertex.edge(e)->vertex_id()];
      Xty += nbr_latent.pvec * observation;
      XtX.triangularView<Eigen::Upper>() += nbr_latent.pvec * nbr_latent.pvec.transpose();
      if (compute_rmse) {
        double prediction;
        rmse_vec[omp_get_thread_num()] += pmf_predict(vdata, nbr_latent, observation, prediction, (void*)&edge.avgprd);
        vertex.edge(e)->set_data(edge);
      }
    }

    double regularization = lambda;
    if (regnormal)
      lambda *= vertex.num_edges();
    for(int i=0; i < D; i++) XtX(i,i) += regularization;

    // Solve the least squares problem with eigen using Cholesky decomposition
    mat iAi_;
    bool ret =inv((isuser? A_U : A_V) + alpha *  XtX, iAi_);
    assert(ret);
    vec mui_ =  iAi_*((isuser? (A_U*mu_U) : (A_V*mu_V)) + alpha * Xty); 
    vdata.pvec = mvnrndex(mui_, iAi_, D, 0); 
    assert(vdata.pvec.size() == D);
 }

	void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {
		if(gcontext.iteration == 0){
			if(vertex.num_edges() == 0)	 return;
			VertexDataType vertexdata = vertex.get_data();
			if(!vertexdata.confirmed || !vertexdata.reconfirmed)
				return ;	
			//assert(vertex.num_inedges() * vertex.num_outedges() <= product);
			int ct = 0;		
			for(int i=0; i<vertex.num_edges(); i++){
				graphchi_edge<EdgeDataType>* edge = vertex.edge(i);
				bidirectional_label edgedata = edge->get_data();
				if(edgedata.is_equal()){		
					/*
					if(edgedata.smaller_one != 0)
						std::cout<<edgedata.smaller_one<<" \t"<<edgedata.larger_one<<"\t root="<<root<<std::endl;
					*/
					if(root == edgedata.my_label(vertex.id(), edge->vertexid)){
						ct++;	
					}
				}
				/*
				   lock.lock();
				   fprintf(fpout1, "%u\t%u\n", vertex.id(), vertex.outedge(i)->vertexid);
				   lock.unlock();
				   */
			}
			assert(ct > 1);
		}
	}

 /** 
   * Compute size of the relevant intersection of v and a pivot
   */
 int intersection_size(graphchi_vertex<uint32_t, uint32_t> &v, vid_t pivot, int start_i) {
     assert(is_pivot(pivot));
     int count = 0;
     if (pivot > v.id()) {
         dense_adj &dadj = adjs[pivot - pivot_st];
         int vc = v.num_edges();
          
         /**
           * If the adjacency list sizes are not too different, use
           * 'merge'-type of operation to compute size intersection.
           */
         if (dadj.count < 32 * (vc - start_i)) { // TODO: do real profiling to find best cutoff value
             // Do merge-style of check
             assert(v.edge(start_i)->vertex_id() == pivot);
             int i1 = 0;
             int i2 = start_i+1;
             int nedges = v.num_edges(); 
             
             while (i1 < dadj.count && i2 < nedges) {
                 vid_t dst = v.edge(i2)->vertexid;
                 vid_t a = dadj.adjlist[i1];
                 if (a == dst) {
                     /* Add one to edge between v and the match */
                     v.edge(i2)->set_data(v.edge(i2)->get_data() + 1);
                     count++;
                     i1++; i2++;
                     
                 } else {
                     i1 += a < dst;
                     i2 += a > dst;
                 }  
             }
         } else {
             /**
               * Otherwise, use linear/binary search.
               */
             vid_t lastvid = 0;
             for(int i=start_i+1; i < vc; i++) {
                 vid_t nb = v.edge(i)->vertexid;
                 if (nb > pivot && nb != lastvid) {
                     int match = findadj(dadj.adjlist, dadj.count, nb);
                     count += match;
                     if (match > 0) {
                         /* Add one to edge between v and the match */
                         v.edge(i)->set_data(v.edge(i)->get_data() + 1);
                     }
                 }
                 lastvid = nb;
             }
         }
     }        
     return count;
 }

 /**
   * Grab pivot's adjacency list into memory.
   */
 int grab_adj(graphchi_vertex<uint32_t, uint32_t> &v) {
     if(is_pivot(v.id())) {            
         int ncount = v.num_edges();
         // Count how many neighbors have larger id than v
         v.sort_edges_indirect();
  
         
         int actcount = 0;
         vid_t lastvid = 0;
         for(int i=0; i<ncount; i++) {
             if (v.edge(i)->vertexid > v.id() && v.edge(i)->vertexid != lastvid)  
                 actcount++;  // Need to store only ids larger than me
             lastvid = v.edge(i)->vertex_id();
         }
         
         // Allocate the in-memory adjacency list, using the
         // knowledge of the number of edges.
         dense_adj dadj = dense_adj(actcount, (vid_t*) calloc(sizeof(vid_t), actcount));
         actcount = 0;
         lastvid = 0;
         for(int i=0; i<ncount; i++) {
             if (v.edge(i)->vertexid > v.id() && v.edge(i)->vertexid != lastvid) {  // Need to store only ids larger than me
                 dadj.adjlist[actcount++] = v.edge(i)->vertex_id();
             }
             lastvid = v.edge(i)->vertex_id();
         }
         assert(dadj.count == actcount);
         adjs[v.id() - pivot_st] = dadj;
         assert(v.id() - pivot_st < adjs.size());
         __sync_add_and_fetch(&grabbed_edges, actcount);
         return actcount;
     }
     return 0;
 }

  /**
   *  Vertex update function.
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {
    //go over all user nodes
    if ( vertex.num_outedges() > 0){
      vertex_data & user = latent_factors_inmem[vertex.id()]; 
      //go over all ratings
      for(int e=0; e < vertex.num_edges(); e++) {
        float observation = vertex.edge(e)->get_data();                
        vertex_data & movie = latent_factors_inmem[vertex.edge(e)->vertex_id()];
        double estScore;
        rmse_vec[omp_get_thread_num()] += sgd_predict(user, movie, observation, estScore);
        double err = observation - estScore;
        if (std::isnan(err) || std::isinf(err))
          logstream(LOG_FATAL)<<"SGD got into numerical error. Please tune step size using --sgd_gamma and sgd_lambda" << std::endl;
        //NOTE: the following code is not thread safe, since potentially several
        //user nodes may updates this item gradient vector concurrently. However in practice it
        //did not matter in terms of accuracy on a multicore machine.
        //if you like to defend the code, you can define a global variable
        //mutex mymutex;
        //
        //and then do: mymutex.lock()
        movie.pvec += sgd_gamma*(err*user.pvec - sgd_lambda*movie.pvec);
        //and here add: mymutex.unlock();
        user.pvec += sgd_gamma*(err*movie.pvec - sgd_lambda*user.pvec);
      }
    }

  }

  /**
   *  Vertex update function - computes the least square step
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {
    vertex_data & vdata = latent_factors_inmem[vertex.id()];
    if (vertex.num_edges() == 0 || vdata.seed) //no edges, nothing to do here
      return;
    
    vec ret = zeros(D);
    double normalization = 0;
    for(int e=0; e < vertex.num_edges(); e++) {
      edge_data edge = vertex.edge(e)->get_data();                
      vertex_data & nbr_latent = latent_factors_inmem[vertex.edge(e)->vertex_id()];
      ret += edge.cooccurence_count * nbr_latent.pvec;
      normalization += edge.cooccurence_count;
    }

    ret /= normalization;
    vdata.pvec = alpha * vdata.pvec + (1-alpha)*ret;
  }

  /**
   *  Vertex update function - computes the least square step
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {

    if (gcontext.iteration == 0){
      if (vertex.num_outedges() == 0 && vertex.id() < M)
        logstream(LOG_FATAL)<<"NMF algorithm can not work when the row " << vertex.id() << " of the matrix contains all zeros" << std::endl;
      for(int e=0; e < vertex.num_edges(); e++) {
        float observation = vertex.edge(e)->get_data();                
        if (observation < 0 ){
          logstream(LOG_FATAL)<<"Found a negative entry in matirx row " << vertex.id() << " with value: " << observation << std::endl;
        }
      }
      return;   
    }

    bool isuser = (vertex.id() < M);
    if ((iter % 2 == 1 && !isuser) ||
        (iter % 2 == 0 && isuser))
      return;
    
    vec ret = zeros(D);

    vertex_data & vdata = latent_factors_inmem[vertex.id()];
    
    for(int e=0; e < vertex.num_edges(); e++) {
      float observation = vertex.edge(e)->get_data();                
      vertex_data & nbr_latent = latent_factors_inmem[vertex.edge(e)->vertex_id()];
      double prediction;
      rmse_vec[omp_get_thread_num()] += nmf_predict(vdata, nbr_latent, observation, prediction);
      if (prediction == 0)
        logstream(LOG_FATAL)<<"Got into numerical error! Please submit a bug report." << std::endl;
      ret += nbr_latent.pvec * (observation / prediction);
    }
    
    vec px;
    if (isuser)
      px = sum_of_item_latent_features;
    else 
      px = sum_of_user_latent_feautres;
    for (int i=0; i<D; i++){
      assert(px[i] != 0);
      vdata.pvec[i] *= ret[i] / px[i];
      if (vdata.pvec[i] < epsilon)
        vdata.pvec[i] = epsilon;
    }
  }

 // Helper
 virtual void set_latent_factor(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, latentvec_t &fact) {
     vertex.set_data(fact);
     for(int i=0; i < vertex.num_edges(); i++) {
         als_factor_and_weight factwght = vertex.edge(i)->get_data();
         factwght.factor = fact;
         vertex.edge(i)->set_data(factwght);   // Note that neighbors override the values they have written to edges.
                                               // This is ok, because vertices are always executed in same order.
     }
 }

    /**
      * Pagerank update function.
	  */
	void update(graphchi_vertex<VertexDataType, EdgeDataType> &v, graphchi_context &ginfo) {
		//array[v.id()]++;		
		if (ginfo.iteration == 0 && v.num_edges() > 0) {
			
			nbs.clear();
			for(int i=0; i<v.num_edges(); i++){
				nbs.insert(v.edge(i)->vertex_id());	
			}
			num_edges += nbs.size(); 
			/*
			if(v.num_inedges() > 0){
				//lock.lock();
				num_edges += v.num_inedges();
				//lock.unlock();
			}
			*/
		} else if(ginfo.iteration == 1){
			if(v.id() == 0){
				fprintf(fp_metis, "%u %u\n", num_vertices, num_edges/2);	
			}
			if(v.num_edges() > 0){	
				nbs.clear();
				for(int i=0; i<v.num_edges(); i++){
					nbs.insert(v.edge(i)->vertex_id());	
					/*
					graphchi_edge<EdgeDataType> * edge = v.edge(i);
					//EdgeDataType edata = edge->get_data();
					vid_t nb_id = edge->vertex_id();
					//lock.lock();
					fprintf(fp_metis, "%u ", nb_id+1);		
					//lock.unlock();
					//edge->set_data(edata);	
					*/
				}
				std::set<vid_t>::iterator it;
				for(it = nbs.begin(); it != nbs.end(); it++){
					fprintf(fp_metis, "%u ", (*it)+1);		
				}
				fprintf(fp_metis, "\n");
			}else{
				fprintf(fp_metis, "\n");
			}
		}
	}

    /**
     *  Vertex update function.
     *  On first iteration ,each vertex chooses a label = the vertex id.
     *  On subsequent iterations, each vertex chooses the minimum of the neighbor's
     *  label (and itself).
     */
    void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext)
    {
        /* This program requires selective scheduling. */
        assert(gcontext.scheduler != NULL);

        if(gcontext.iteration == 0)
        {
            set_data(vertex, vertex.id());
            /* Schedule neighbor for update */
            gcontext.scheduler->add_task(vertex.id());
            return;
        }
        else
        {
            vid_t curmin = vertex_values[vertex.id()];
            for(int i=0; i < vertex.num_edges(); i++)
            {
                vid_t nblabel = neighbor_value(vertex.edge(i));
                curmin = std::min(nblabel, curmin);

            }
            if ( curmin < vertex.get_data() )
            {
                for(int i=0; i < vertex.num_edges(); i++)
                {
                    if (curmin < neighbor_value(vertex.edge(i)))
                    {
                        /* Schedule neighbor for update */
                        gcontext.scheduler->add_task(vertex.edge(i)->vertex_id());
                    }
                }
                set_data(vertex, curmin);
            }
        }



        /* On subsequent iterations, find the minimum label of my neighbors */


        /* If my label changes, schedule neighbors */


    }

    /**
      * Pagerank update function.
	  */
	void update(graphchi_vertex<VType, EType> &v, graphchi_context &ginfo) {
		//array[v.id()]++;		
		if(v.num_edges() == 0)	return;
		if (ginfo.iteration == 0) {
			//int partid = getPId(v.id());	
			vid_t newid = getNewId(v.id()); 	
			v.set_data(newid);
			for(int i=0; i<v.num_edges(); i++){
				graphchi_edge<EType> * edge = v.edge(i);
				EType edata = edge->get_data();
				edata.my_label(v.id(), edge->vertex_id()) = newid;
				edge->set_data(edata);
			}	
		} else if(ginfo.iteration == 1){
			/*
			if(v.id() == 0){
				fprintf(fp_list, "%u %u\n", num_vertices, num_edges);	
			}
			*/
			if(v.num_outedges() > 0){	
				vid_t mylabel = v.get_data();
				for(int i=0; i<v.num_outedges(); i++){
					graphchi_edge<EType> * edge = v.outedge(i);
					EType edata = edge->get_data();
					vid_t nblabel = edata.nb_label(v.id(), edge->vertex_id());
					//vid_t nb_id = edge->vertex_id();
					assert(mylabel != nblabel);
					if(!flag_weight){
						lock.lock();
						fprintf(fp_list, "%u\t%u\n", mylabel, nblabel);		
						lock.unlock();
					}else{
						lock.lock();
						fprintf(fp_list, "%u\t%u\t%.3f\n", mylabel, nblabel, edata.weight);		
						lock.unlock();
					}
					//edge->set_data(edata);	
				}
			}/*else{
				fprintf(fp_list, "\n");
			}*/
		}
	}

    /**
     *  Vertex update function.
     */
    void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {        
        if (first_iteration) {
            vertex.set_data(SCCinfo(vertex.id()));
        }
        
        if (vertex.get_data().confirmed) {
            return;
        }   
        
        /* Vertices with only in or out edges cannot be part of a SCC (Trimming) */
        if (vertex.num_inedges() == 0 || vertex.num_outedges() == 0) {
            if (vertex.num_edges() > 0) {
                // TODO: check this logic!
                vertex.set_data(SCCinfo(vertex.id()));
            }
            vertex.remove_alledges();
            return;
        }
        remainingvertices = true;

        VertexDataType vertexdata = vertex.get_data();
        bool propagate = false;
        if (gcontext.iteration == 0) {
            vertexdata = vertex.id();
            propagate = true;
            /* Clean up in-edges. This would be nicer in the messaging abstraction... */
            for(int i=0; i < vertex.num_inedges(); i++) {
                bidirectional_label edgedata = vertex.inedge(i)->get_data();
                edgedata.my_label(vertex.id(), vertex.inedge(i)->vertexid) = vertex.id();
                vertex.inedge(i)->set_data(edgedata);
            }
        } else {
            
            /* Loop over in-edges and choose minimum color */
            vid_t minid = vertexdata.color;
            for(int i=0; i < vertex.num_inedges(); i++) {
                minid = std::min(minid, vertex.inedge(i)->get_data().neighbor_label(vertex.id(), vertex.inedge(i)->vertexid));
            }
            
            if (minid != vertexdata.color) {
                vertexdata.color = minid;
                propagate = true;
            }            
        }
        vertex.set_data(vertexdata);
        
        if (propagate) {
            for(int i=0; i < vertex.num_outedges(); i++) {
                bidirectional_label edgedata = vertex.outedge(i)->get_data();
                edgedata.my_label(vertex.id(), vertex.outedge(i)->vertexid) = vertexdata.color;
                vertex.outedge(i)->set_data(edgedata);
                gcontext.scheduler->add_task(vertex.outedge(i)->vertexid, true);
            }
        }
    }

  /**
   *  Vertex update function.
   */
  void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {
      if ( vertex.num_outedges() > 0){
        vertex_data & user = latent_factors_inmem[vertex.id()]; 

        memset(&user.weight[0], 0, sizeof(double)*D);
        for(int e=0; e < vertex.num_outedges(); e++) {
          vertex_data & movie = latent_factors_inmem[vertex.edge(e)->vertex_id()]; 
          user.weight += movie.weight;

        }
        // sqrt(|N(u)|) 
        float usrNorm = double(1.0/sqrt(vertex.num_outedges()));
        //sqrt(|N(u)| * sum_j y_j
        user.weight *= usrNorm;

        vec step = zeros(D);

        // main algorithm, see Koren's paper, just below below equation (16)
        for(int e=0; e < vertex.num_outedges(); e++) {
          vertex_data & movie = latent_factors_inmem[vertex.edge(e)->vertex_id()]; 
          float observation = vertex.edge(e)->get_data();                
          double estScore;
          rmse_vec[omp_get_thread_num()] += svdpp_predict(user, movie,observation, estScore); 
          // e_ui = r_ui - \hat{r_ui}
          float err = observation - estScore;
          assert(!std::isnan(rmse_vec[omp_get_thread_num()]));
          vec itmFctr = movie.pvec;
          vec usrFctr = user.pvec;

          //q_i = q_i + gamma2     *(e_ui*(p_u      +  sqrt(N(U))\sum_j y_j) - gamma7    *q_i)
          for (int j=0; j< D; j++)
            movie.pvec[j] += svdpp.itmFctrStep*(err*(usrFctr[j] +  user.weight[j])             - svdpp.itmFctrReg*itmFctr[j]);
          //p_u = p_u + gamma2    *(e_ui*q_i   -gamma7     *p_u)
          for (int j=0; j< D; j++)
            user.pvec[j] += svdpp.usrFctrStep*(err *itmFctr[j] - svdpp.usrFctrReg*usrFctr[j]);
          step += err*itmFctr;

          //b_i = b_i + gamma1*(e_ui - gmma6 * b_i) 
          movie.bias += svdpp.itmBiasStep*(err-svdpp.itmBiasReg* movie.bias);
          //b_u = b_u + gamma1*(e_ui - gamma6 * b_u)
          user.bias += svdpp.usrBiasStep*(err-svdpp.usrBiasReg* user.bias);
        }

        step *= float(svdpp.itmFctr2Step*usrNorm);
        //gamma7 
        double mult = svdpp.itmFctr2Step*svdpp.itmFctr2Reg;
        for(int e=0; e < vertex.num_edges(); e++) {
          vertex_data&  movie = latent_factors_inmem[vertex.edge(e)->vertex_id()];
          //y_j = y_j  +   gamma2*sqrt|N(u)| * q_i - gamma7 * y_j
          movie.weight +=  step                    -  mult  * movie.weight;
        }
      }
  }