Пример #1
0
    protected virtual void LoadData()
    {
        training_file = Path.Combine(data_dir, training_file);
        if (test_file != null)
        {
            test_file = Path.Combine(data_dir, test_file);
        }

        // user attributes
        if (user_attributes_file != null)
        {
            user_attributes = AttributeData.Read(Path.Combine(data_dir, user_attributes_file), user_mapping);
        }
        if (recommender is IUserAttributeAwareRecommender)
        {
            ((IUserAttributeAwareRecommender)recommender).UserAttributes = user_attributes;
        }

        // item attributes
        if (item_attributes_file != null)
        {
            item_attributes = AttributeData.Read(Path.Combine(data_dir, item_attributes_file), item_mapping);
        }
        if (recommender is IItemAttributeAwareRecommender)
        {
            ((IItemAttributeAwareRecommender)recommender).ItemAttributes = item_attributes;
        }

        // user relation
        if (recommender is IUserRelationAwareRecommender)
        {
            ((IUserRelationAwareRecommender)recommender).UserRelation = RelationData.Read(Path.Combine(data_dir, user_relations_file), user_mapping);
            Console.WriteLine("relation over {0} users", ((IUserRelationAwareRecommender)recommender).NumUsers);
        }

        // item relation
        if (recommender is IItemRelationAwareRecommender)
        {
            ((IItemRelationAwareRecommender)recommender).ItemRelation = RelationData.Read(Path.Combine(data_dir, item_relations_file), item_mapping);
            Console.WriteLine("relation over {0} items", ((IItemRelationAwareRecommender)recommender).NumItems);
        }
    }
Пример #2
0
    static void LoadData()
    {
        TimeSpan loading_time = Utils.MeasureTime(delegate() {
            // training data
            training_data = ItemRecommendation.Read(Path.Combine(data_dir, training_file), user_mapping, item_mapping);

            // relevant users and items
            if (relevant_users_file != null)
            {
                relevant_users = new HashSet <int>(user_mapping.ToInternalID(Utils.ReadIntegers(Path.Combine(data_dir, relevant_users_file))));
            }
            else
            {
                relevant_users = training_data.AllUsers;
            }
            if (relevant_items_file != null)
            {
                relevant_items = new HashSet <int>(item_mapping.ToInternalID(Utils.ReadIntegers(Path.Combine(data_dir, relevant_items_file))));
            }
            else
            {
                relevant_items = training_data.AllItems;
            }

            if (!(recommender is MyMediaLite.ItemRecommendation.Random))
            {
                ((ItemRecommender)recommender).Feedback = training_data;
            }

            // user attributes
            if (recommender is IUserAttributeAwareRecommender)
            {
                if (user_attributes_file == null)
                {
                    Usage("Recommender expects --user-attributes=FILE.");
                }
                else
                {
                    ((IUserAttributeAwareRecommender)recommender).UserAttributes = AttributeData.Read(Path.Combine(data_dir, user_attributes_file), user_mapping);
                }
            }

            // item attributes
            if (recommender is IItemAttributeAwareRecommender)
            {
                if (item_attributes_file == null)
                {
                    Usage("Recommender expects --item-attributes=FILE.");
                }
                else
                {
                    ((IItemAttributeAwareRecommender)recommender).ItemAttributes = AttributeData.Read(Path.Combine(data_dir, item_attributes_file), item_mapping);
                }
            }
            if (filtered_eval)
            {
                if (item_attributes_file == null)
                {
                    Usage("--filtered-evaluation expects --item-attributes=FILE.");
                }
                else
                {
                    item_attributes = AttributeData.Read(Path.Combine(data_dir, item_attributes_file), item_mapping);
                }
            }

            // user relation
            if (recommender is IUserRelationAwareRecommender)
            {
                if (user_relations_file == null)
                {
                    Usage("Recommender expects --user-relation=FILE.");
                }
                else
                {
                    ((IUserRelationAwareRecommender)recommender).UserRelation = RelationData.Read(Path.Combine(data_dir, user_relations_file), user_mapping);
                    Console.WriteLine("relation over {0} users", ((IUserRelationAwareRecommender)recommender).NumUsers);                     // TODO move to DisplayDataStats
                }
            }

            // item relation
            if (recommender is IItemRelationAwareRecommender)
            {
                if (user_relations_file == null)
                {
                    Usage("Recommender expects --item-relation=FILE.");
                }
                else
                {
                    ((IItemRelationAwareRecommender)recommender).ItemRelation = RelationData.Read(Path.Combine(data_dir, item_relations_file), item_mapping);
                    Console.WriteLine("relation over {0} items", ((IItemRelationAwareRecommender)recommender).NumItems);                     // TODO move to DisplayDataStats
                }
            }

            // test data
            if (test_ratio == 0)
            {
                if (test_file != null)
                {
                    test_data = ItemRecommendation.Read(Path.Combine(data_dir, test_file), user_mapping, item_mapping);
                }
            }
            else
            {
                var split     = new PosOnlyFeedbackSimpleSplit <PosOnlyFeedback <SparseBooleanMatrix> >(training_data, test_ratio);
                training_data = split.Train[0];
                test_data     = split.Test[0];
            }
        });

        Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "loading_time {0,0:0.##}", loading_time.TotalSeconds));
    }
    protected virtual void LoadData()
    {
        training_file = Path.Combine(data_dir, training_file);
        if (test_file != null)
        {
            test_file = Path.Combine(data_dir, test_file);
        }

        // user attributes
        if (user_attributes_file != null)
        {
            string[] files = user_attributes_file.Split(' ');
            foreach (string file in files)
            {
                if (file.Length > 0)
                {
                    user_attributes.Add(AttributeData.Read(Path.Combine(data_dir, file), user_mapping));
                }
            }
        }



        //Original

        for (int i = 0; i < recommenders.Count; i++)
        {
            if (recommenders[i] is IUserAttributeAwareRecommender)
            {
                ((IUserAttributeAwareRecommender)recommenders[i]).UserAttributes = user_attributes[0];
                if (user_attributes.Count > 1)
                {
                    ((IUserAttributeAwareRecommender)recommenders[i]).AdditionalUserAttributes = user_attributes.GetRange(1, user_attributes.Count - 1);
                }
                else
                {
                    ((IUserAttributeAwareRecommender)recommenders[i]).AdditionalUserAttributes = new List <IBooleanMatrix>();
                }
            }
        }

        // item attributes
        item_attributes = new List <IBooleanMatrix>();
        if (item_attributes_file != null)
        {
            string[] files = item_attributes_file.Split(' ');
            foreach (string file in files)
            {
                if (file.Length > 0)
                {
                    item_attributes.Add(AttributeData.Read(Path.Combine(data_dir, file), item_mapping));
                }
            }
        }


        //Cada um pega um metadado
        for (int i = 0; i < item_attributes.Count; i++)
        {
            if (recommenders[i] is IItemAttributeAwareRecommender)
            {
                ((IItemAttributeAwareRecommender)recommenders[i]).ItemAttributes           = item_attributes[i];
                ((IItemAttributeAwareRecommender)recommenders[i]).AdditionalItemAttributes = new List <IBooleanMatrix>();
            }
        }


        //Original

        /*
         * for (int i = 0; i < recommenders.Count; i++)
         * {
         *  if (recommenders[i] is IItemAttributeAwareRecommender)
         *  {
         *      ((IItemAttributeAwareRecommender)recommenders[i]).ItemAttributes = item_attributes[0];
         *      if (item_attributes.Count > 1)
         *          ((IItemAttributeAwareRecommender)recommenders[i]).AdditionalItemAttributes = item_attributes.GetRange(1, item_attributes.Count - 1);
         *      else
         *          ((IItemAttributeAwareRecommender)recommenders[i]).AdditionalItemAttributes = new List<IBooleanMatrix>();
         *  }
         *
         * }
         *
         */



        for (int i = 0; i < recommenders.Count; i++)
        {
            // user relation
            if (recommenders[i] is IUserRelationAwareRecommender)
            {
                ((IUserRelationAwareRecommender)recommenders[i]).UserRelation = RelationData.Read(Path.Combine(data_dir, user_relations_file), user_mapping);
                Console.WriteLine("relation over {0} users", ((IUserRelationAwareRecommender)recommenders[i]).NumUsers);
            }

            // item relation
            if (recommenders[i] is IItemRelationAwareRecommender)
            {
                ((IItemRelationAwareRecommender)recommenders[i]).ItemRelation = RelationData.Read(Path.Combine(data_dir, item_relations_file), item_mapping);
                Console.WriteLine("relation over {0} items", ((IItemRelationAwareRecommender)recommenders[i]).NumItems);
            }
        }
    }
Пример #4
0
    static void LoadData(string data_dir,
                         string user_attributes_file, string item_attributes_file,
                         string user_relation_file, string item_relation_file,
                         bool static_data)
    {
        if (training_file == null)
        {
            Usage("Program expects --training-file=FILE.");
        }

        TimeSpan loading_time = Utils.MeasureTime(delegate() {
            // read training data
            if (file_format == RatingFileFormat.DEFAULT)
            {
                training_data = static_data ? RatingPredictionStatic.Read(Path.Combine(data_dir, training_file), user_mapping, item_mapping, rating_type)
                                                                : MyMediaLite.IO.RatingPrediction.Read(Path.Combine(data_dir, training_file), user_mapping, item_mapping);
            }
            else if (file_format == RatingFileFormat.MOVIELENS_1M)
            {
                training_data = MovieLensRatingData.Read(Path.Combine(data_dir, training_file), user_mapping, item_mapping);
            }
            else if (file_format == RatingFileFormat.KDDCUP_2011)
            {
                training_data = MyMediaLite.IO.KDDCup2011.Ratings.Read(Path.Combine(data_dir, training_file));
            }

            recommender.Ratings = training_data;

            // user attributes
            if (recommender is IUserAttributeAwareRecommender)             // TODO also support the MovieLens format here
            {
                if (user_attributes_file == string.Empty)
                {
                    Usage("Recommender expects --user-attributes=FILE.");
                }
                else
                {
                    ((IUserAttributeAwareRecommender)recommender).UserAttributes = AttributeData.Read(Path.Combine(data_dir, user_attributes_file), user_mapping);
                }
            }

            // item attributes
            if (recommender is IItemAttributeAwareRecommender)
            {
                if (item_attributes_file == string.Empty)
                {
                    Usage("Recommender expects --item-attributes=FILE.");
                }
                else
                {
                    ((IItemAttributeAwareRecommender)recommender).ItemAttributes = AttributeData.Read(Path.Combine(data_dir, item_attributes_file), item_mapping);
                }
            }

            // user relation
            if (recommender is IUserRelationAwareRecommender)
            {
                if (user_relation_file == string.Empty)
                {
                    Usage("Recommender expects --user-relations=FILE.");
                }
                else
                {
                    ((IUserRelationAwareRecommender)recommender).UserRelation = RelationData.Read(Path.Combine(data_dir, user_relation_file), user_mapping);
                    Console.WriteLine("relation over {0} users", ((IUserRelationAwareRecommender)recommender).NumUsers);
                }
            }

            // item relation
            if (recommender is IItemRelationAwareRecommender)
            {
                if (user_relation_file == string.Empty)
                {
                    Usage("Recommender expects --item-relations=FILE.");
                }
                else
                {
                    ((IItemRelationAwareRecommender)recommender).ItemRelation = RelationData.Read(Path.Combine(data_dir, item_relation_file), item_mapping);
                    Console.WriteLine("relation over {0} items", ((IItemRelationAwareRecommender)recommender).NumItems);
                }
            }

            // read test data
            if (test_file != null)
            {
                if (file_format == RatingFileFormat.MOVIELENS_1M)
                {
                    test_data = MovieLensRatingData.Read(Path.Combine(data_dir, test_file), user_mapping, item_mapping);
                }
                else
                {
                    test_data = RatingPredictionStatic.Read(Path.Combine(data_dir, test_file), user_mapping, item_mapping, rating_type);
                }
                // TODO add KDD Cup
            }
        });

        Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "loading_time {0,0:0.##}", loading_time.TotalSeconds));
    }