示例#1
0
        /// <summary>
        /// user-item 형태로 모델링된 bipartite graph를 사용하여 모든 test user에 대해 RWR 수행
        /// </summary>
        /// <param name="model_graph">user-item에 대한 bipartite graph</param>
        /// <param name="sw">추천 결과(사용자 id, 아이템 id, 점수)가 출력될 파일</param>
        public List <Score> PerformRWR(WeightedUndirectedGraph model_graph, int target)
        {
            // test user가 기존에 갖고 있는 이력 리스트를 저장
            HashSet <int> i_items = new HashSet <int>();

            if (model_graph.graph.ContainsKey(target))
            {
                HashSet <Weight> i_weight = model_graph.graph[target];
                foreach (Weight items in i_weight)
                {
                    i_items.Add(items.id);
                }
            }

            // RWR 수행
            RWR           ranker = new RWR(model_graph, damping_factor, target);
            List <Weight> score  = ranker.Calculate();

            // RWR 점수를 기준으로 타겟 사용자가 선호할 만한 TOP N개의 아이템 출력
            List <Score> recommend_items = new List <Score>();

            //Dictionary<int, double> recommend_items = new Dictionary<int, double>();
            foreach (Weight s in score)
            {
                // ID가 user ID 이거나, 추천 아이템이 타겟 사용자의 기존 이력에 포함되어 있으면 TOP N에 포함시키지 않음
                if (s.id < user_size || i_items.Contains(s.id))
                {
                    continue;
                }
                else if (recommend_items.Count < num_recommend)
                {
                    if (candidate_item == "Longtail_items")
                    {
                        if (Program.tophead_items.Contains(s.id))
                        {
                            continue;
                        }
                    }

                    Score user_score = new Score(s.id, s.w);
                    recommend_items.Add(user_score);
                }
                else
                {
                    break;
                }
            }

            return(recommend_items);
        }
        public Dictionary <int, double> PerformRWR(WeightedUndirectedGraph model_graph, int target)
        {
            HashSet <int> i_items = new HashSet <int>();

            if (model_graph.graph.ContainsKey(target))
            {
                SortedSet <Weight> i_weight = model_graph.graph[target];
                foreach (Weight items in i_weight)
                {
                    i_items.Add(items.id);
                }
            }

            RWR           ranker = new RWR(model_graph, damping_factor, target);
            List <Weight> score  = ranker.Calculate();

            double sum = 0d;
            Dictionary <int, double> recommend_items = new Dictionary <int, double>();

            foreach (Weight s in score)
            {
                if (s.id >= user_size)
                {
                    sum += s.w;
                }
            }

            foreach (Weight s in score)
            {
                if (s.id < user_size || i_items.Contains(s.id))
                {
                    continue;
                }

                if (candidate_item == "Longtail_items")
                {
                    if (Program.tophead_items.Contains(s.id))
                    {
                        continue;
                    }
                }

                recommend_items.Add(s.id, s.w / sum);
            }
            return(recommend_items);
        }