use size_t for sizes

polarker · Dec 20, 2016 · 5dbda9e · 5dbda9e
1 parent 07ac9df
commit 5dbda9e
Show file tree

Hide file tree

Showing 35 changed files with 356 additions and 353 deletions.
diff --git a/example/charnn.cc b/example/charnn.cc
@@ -10,11 +10,11 @@ int main()
 
     chartxt::Article<T> article("./data/tinyshakespeare.txt");
 
-    int seq_length = 50;
-    int input_size = article.get_num_diff_chars();
-    int output_size = article.get_num_diff_chars();
-    auto hidden_sizes = {128, 128};
-    int batch_size = 100;
+    size_t seq_length = 50;
+    size_t input_size = article.get_num_diff_chars();
+    size_t output_size = article.get_num_diff_chars();
+    initializer_list<size_t> hidden_sizes {128, 128};
+    size_t batch_size = 100;
     int num_epoch = 10;
     T learning_rate = 0.01;
     bool use_embedding = true;

diff --git a/include/galois/base.h b/include/galois/base.h
@@ -55,39 +55,39 @@ namespace gs
         }
 
         // set dims for data (and grad)
-        void set_data_dims(int m)                        { set_data_dims({m}); }
-        void set_data_dims(int m, int n)                 { set_data_dims({m,n}); }
-        void set_data_dims(int m, int n, int o)          { set_data_dims({m,n,o}); }
-        void set_data_dims(int m, int n, int o, int k)   { set_data_dims({m,n,o,k}); }
-        void set_data_dims(initializer_list<int> nums) {
-            set_data_dims(vector<int>(nums));
+        void set_data_dims(size_t m)                                { set_data_dims({m}); }
+        void set_data_dims(size_t m, size_t n)                      { set_data_dims({m,n}); }
+        void set_data_dims(size_t m, size_t n, size_t o)            { set_data_dims({m,n,o}); }
+        void set_data_dims(size_t m, size_t n, size_t o, size_t k)  { set_data_dims({m,n,o,k}); }
+        void set_data_dims(initializer_list<size_t> nums) {
+            set_data_dims(vector<size_t>(nums));
         }
-        void set_data_dims(vector<int> nums) {
+        void set_data_dims(vector<size_t> nums) {
             CHECK(!data, "data should be nullptr before initialization");
             data = make_shared<NArray<T>>(nums);
             if (type == InnerSignal) {
                 CHECK(!grad, "grad should be nullptr before initialization");
                 grad = make_shared<NArray<T>>(nums);
             }
         }
-        vector<int> get_data_dims() {
+        vector<size_t> get_data_dims() {
             CHECK(data, "data should be non-empty");
             return data->get_dims();
         }
         // set dims for target
-        void set_target_dims(int m)                         { set_target_dims({m}); }
-        void set_target_dims(int m, int n)                  { set_target_dims({m,n}); }
-        void set_target_dims(int m, int n, int o)           { set_target_dims({m,n,o}); }
-        void set_target_dims(int m, int n, int o, int k)    { set_target_dims({m,n,o,k}); }
-        void set_target_dims(initializer_list<int> nums) {
-            set_target_dims(vector<int>(nums));
+        void set_target_dims(size_t m)                         { set_target_dims({m}); }
+        void set_target_dims(size_t m, size_t n)                  { set_target_dims({m,n}); }
+        void set_target_dims(size_t m, size_t n, size_t o)           { set_target_dims({m,n,o}); }
+        void set_target_dims(size_t m, size_t n, size_t o, size_t k)    { set_target_dims({m,n,o,k}); }
+        void set_target_dims(initializer_list<size_t> nums) {
+            set_target_dims(vector<size_t>(nums));
         }
-        void set_target_dims(vector<int> nums) {
+        void set_target_dims(vector<size_t> nums) {
             CHECK(type == OutputSignal, "only OutputSignal could set target");
             CHECK(!target, "target should be nullptr before initialization");
             target = make_shared<NArray<T>>(nums);
         }
-        vector<int> get_target_dims() {
+        vector<size_t> get_target_dims() {
             CHECK(target, "target should be non-empty");
             return target->get_dims();
         }
@@ -110,7 +110,7 @@ namespace gs
         virtual void forward() = 0;
         virtual void backward() = 0;
         virtual void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) = 0;
-        virtual void set_dims(int batch_size) = 0;
+        virtual void set_dims(size_t batch_size) = 0;
         virtual void reopaque() = 0;    // each filter only opaques its inner signal
         virtual shared_ptr<Filter<T>> share() = 0;  // return a SP_Filter<T>
         virtual shared_ptr<Filter<T>> clone() = 0;  // return a SP_Filter<T>

diff --git a/include/galois/filters/convolution.h b/include/galois/filters/convolution.h
@@ -11,15 +11,15 @@ namespace gs {
     private:
         SP_Signal<T> in_signal = nullptr;
         SP_Signal<T> out_signal = nullptr;
-        int num_rows = 0;
-        int num_columns = 0;
-        int in_channels = 0;
-        int out_channels = 0;
-        int kernel_rows = 0;
-        int kernel_columns = 0;
+        size_t num_rows = 0;
+        size_t num_columns = 0;
+        size_t in_channels = 0;
+        size_t out_channels = 0;
+        size_t kernel_rows = 0;
+        size_t kernel_columns = 0;
 
-        // int padding_w = 0;
-        // int padding_h = 0;
+        // size_t padding_w = 0;
+        // size_t padding_h = 0;
 
         SP_NArray<T> w = nullptr;
         SP_NArray<T> b = nullptr;
@@ -30,13 +30,13 @@ namespace gs {
         Convolution(const bool for_clone_or_share) {}
         Convolution(const Convolution&) = delete;
         Convolution& operator=(const Convolution&) = delete;
-        Convolution(int num_rows, int num_columns, int in_channels, int out_channels, int kernel_w, int kernel_h);
+        Convolution(size_t num_rows, size_t num_columns, size_t in_channels, size_t out_channels, size_t kernel_w, size_t kernel_h);
 
         SP_Filter<T> share() override;
         SP_Filter<T> clone() override;
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
         void reopaque() override;
 
         vector<SP_NArray<T>> get_params() override;

diff --git a/include/galois/filters/cross_entropy.h b/include/galois/filters/cross_entropy.h
@@ -22,7 +22,7 @@ namespace gs {
         void reopaque() override { softmax_output->reopaque(); }
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
 
         void forward() override;
         void backward() override;

diff --git a/include/galois/filters/embedding.h b/include/galois/filters/embedding.h
@@ -11,8 +11,8 @@ namespace gs {
     private:
         SP_Signal<T> in_signal = nullptr;
         SP_Signal<T> out_signal = nullptr;
-        int in_size = 0;
-        int out_size = 0;
+        size_t in_size = 0;
+        size_t out_size = 0;
 
         SP_NArray<T> w = nullptr;
         SP_NArray<T> dw = nullptr;
@@ -21,13 +21,13 @@ namespace gs {
         Embedding(const bool for_share_or_clone) {}
         Embedding(const Embedding&) = delete;
         Embedding& operator=(const Embedding&) = delete;
-        Embedding(int in_size, int out_size);
+        Embedding(size_t in_size, size_t out_size);
 
         SP_Filter<T> share() override;
         SP_Filter<T> clone() override;
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
         void reopaque() override;
 
         vector<SP_NArray<T>> get_params() override;

diff --git a/include/galois/filters/general_tanh.h b/include/galois/filters/general_tanh.h
@@ -19,7 +19,7 @@ namespace gs {
         void reopaque() override {}
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
 
         void forward() override;
         void backward() override;

diff --git a/include/galois/filters/linear.h b/include/galois/filters/linear.h
@@ -10,8 +10,8 @@ namespace gs {
     private:
         SP_Signal<T> in_signal = nullptr;
         SP_Signal<T> out_signal = nullptr;
-        int in_size = 0;
-        int out_size = 0;
+        size_t in_size = 0;
+        size_t out_size = 0;
 
         SP_NArray<T> w = nullptr;
         SP_NArray<T> b = nullptr;
@@ -22,13 +22,13 @@ namespace gs {
         Linear(const bool for_clone_or_share) {}
         Linear(const Linear&) = delete;
         Linear& operator=(const Linear&) = delete;
-        Linear(int in_size, int out_size);
+        Linear(size_t in_size, size_t out_size);
 
         SP_Filter<T> share() override;
         SP_Filter<T> clone() override;
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
         void reopaque() override;
 
         vector<SP_NArray<T>> get_params() override;

diff --git a/include/galois/filters/max_pooling.h b/include/galois/filters/max_pooling.h
@@ -11,26 +11,26 @@ namespace gs {
     private:
         SP_Signal<T> in_signal = nullptr;
         SP_Signal<T> out_signal = nullptr;
-        int kernel_rows = 0;
-        int kernel_columns = 0;
-        int stride_rows = 0;
-        int stride_columns = 0;
+        size_t kernel_rows = 0;
+        size_t kernel_columns = 0;
+        size_t stride_rows = 0;
+        size_t stride_columns = 0;
 
         // the following are set in set_dims
-        int num_rows = 0;
-        int num_columns = 0;
-        int channels = 0;
+        size_t num_rows = 0;
+        size_t num_columns = 0;
+        size_t channels = 0;
         SP_NArray<T> max_indexes = nullptr;
 
     public:
         MaxPooling(const MaxPooling&) = delete;
         MaxPooling& operator=(const MaxPooling) = delete;
-        MaxPooling(int kernel_rows, int kernel_columns, int stride_rows, int stride_columns);
+        MaxPooling(size_t kernel_rows, size_t kernel_columns, size_t stride_rows, size_t stride_columns);
 
         SP_Filter<T> share() override;
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
         void reopaque() override {}
 
         void forward() override;

diff --git a/include/galois/filters/tanh.h b/include/galois/filters/tanh.h
@@ -19,7 +19,7 @@ namespace gs {
         void reopaque() override {}
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
 
         void forward() override;
         void backward() override;

diff --git a/include/galois/gfilters/base_net.h b/include/galois/gfilters/base_net.h
@@ -53,7 +53,7 @@ namespace gs
         set<SP_PFilter<T>> get_pfilters() override;
 
         void install_signals(const vector<SP_Signal<T>> &in_signals, const vector<SP_Signal<T>> &out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
         void reopaque() override;
 
         void forward() override;
@@ -148,7 +148,7 @@ namespace gs
     }
 
     template<typename T>
-    void BaseNet<T>::set_dims(int batch_size) {
+    void BaseNet<T>::set_dims(size_t batch_size) {
         CHECK(fixed, "network should be fixed");
         CHECK(!fp_filters.empty(), "fp filters should have been set");
         for (auto filter : fp_filters) {

diff --git a/include/galois/gfilters/path.h b/include/galois/gfilters/path.h
@@ -33,7 +33,7 @@ namespace gs
         set<SP_PFilter<T>> get_pfilters() override;
 
         void install_signals(const vector<SP_Signal<T>>& in_signals, const vector<SP_Signal<T>>& out_signals) override;
-        void set_dims(int batch_size) override;
+        void set_dims(size_t batch_size) override;
         void reopaque() override;
 
         void forward() override;

diff --git a/include/galois/models/bi_seq_encoder_decoder.h b/include/galois/models/bi_seq_encoder_decoder.h
@@ -16,22 +16,23 @@ namespace gs
         static default_random_engine galois_rn_generator;
 
     protected:
-        int max_len_one;
-        int max_len_another;
-        int input_size_one;
-        int input_size_another;
-        vector<int> hidden_sizes;
+        size_t max_len_one;
+        size_t max_len_another;
+        size_t input_size_one;
+        size_t input_size_another;
+        vector<size_t> hidden_sizes;
 
-        int train_seq_count = 0;
+        size_t train_seq_count = 0;
         SP_NArray<T> train_one = nullptr;
         SP_NArray<T> train_another = nullptr;
     public:
-        BiSeqEncoderDecoder(int max_len_one,
-            int max_len_another,
-            int input_size_one,
-            int input_size_another,
-            initializer_list<int> hidden_sizes,
-            int batch_size,
+        BiSeqEncoderDecoder(
+            size_t max_len_one,
+            size_t max_len_another,
+            size_t input_size_one,
+            size_t input_size_another,
+            initializer_list<size_t> hidden_sizes,
+            size_t batch_size,
             int num_epoch,
             T learning_rate,
             string optimizer_name);

diff --git a/include/galois/models/mlp.h b/include/galois/models/mlp.h
@@ -26,20 +26,20 @@ namespace gs
         vector<SP_NArray<T>>  params = {};
         vector<SP_NArray<T>>  grads = {};
 
-        int batch_size;
+        size_t batch_size;
         int num_epoch;
         T learning_rate;
         SP_Optimizer<T> optimizer;
 
-        int train_count = 0;
+        size_t train_count = 0;
         SP_NArray<T> train_data = nullptr;
         SP_NArray<T> train_target = nullptr;
-        int test_count = 0;
+        size_t test_count = 0;
         SP_NArray<T> test_data = nullptr;
         SP_NArray<T> test_target = nullptr;
 
     public:
-        MLPModel(int batch_size, int num_epoch, T learning_rate, string optimizer_name);
+        MLPModel(size_t batch_size, int num_epoch, T learning_rate, string optimizer_name);
         MLPModel(const MLPModel& other) = delete;
         MLPModel& operator=(const MLPModel&) = delete;
 

diff --git a/include/galois/models/model.h b/include/galois/models/model.h
@@ -26,20 +26,20 @@ namespace gs
         vector<string>          output_ids = {};
         vector<SP_Signal<T>>    output_signals = {};
 
-        int batch_size;
+        size_t batch_size;
         int num_epoch;
         T learning_rate;
         SP_Optimizer<T> optimizer;
 
-        int train_count = 0;
+        size_t train_count = 0;
         vector<SP_NArray<T>> train_data = {};
         vector<SP_NArray<T>> train_target = {};
-        int test_count = 0;
+        size_t test_count = 0;
         vector<SP_NArray<T>> test_data = {};
         vector<SP_NArray<T>> test_target = {};
 
     public:
-        Model(int batch_size, int num_epoch, T learning_rate, string optimizer_name);
+        Model(size_t batch_size, int num_epoch, T learning_rate, string optimizer_name);
         Model(const Model& other) = delete;
         Model& operator=(const Model&) = delete;
 

diff --git a/include/galois/models/ordered_model.h b/include/galois/models/ordered_model.h
@@ -26,15 +26,15 @@ namespace gs
         vector<string>          output_ids = {};
         vector<SP_Signal<T>>    output_signals = {};
 
-        int batch_size;
+        size_t batch_size;
         int num_epoch;
         T learning_rate;
         SP_Optimizer<T> optimizer;
 
-        int train_count = 0;
+        size_t train_count = 0;
         vector<SP_NArray<T>> train_data = {};
         vector<SP_NArray<T>> train_target = {};
-        int test_count = 0;
+        size_t test_count = 0;
         vector<SP_NArray<T>> test_data = {};
         vector<SP_NArray<T>> test_target = {};