[EHN] Complete the package version

Author: xuyxu

.gitignore

@@ -1,2 +1,6 @@
 *.pyc
-*.swp
+*.swp
+
+build
+dist/
+Ensemble_PyTorch.egg-info

README.md

@@ -7,15 +7,25 @@ Implementation of scikit-learn like ensemble methods in Pytorch.
 * **BaggingClassifier** / **BaggingRegressor**
 * **GradientBoostingClassifier** / **GradientBoostingRegressor**
 
+## Installation
+
+Installing Ensemble-Pytorch package is simple. Just clone this repo and run the setup.
+
+```
+$ git clone https://github.com/AaronX121/Ensemble-Pytorch.git
+$ cd Ensemble-Pytorch
+$ python setup.py install
+```
+
 ## Minimal example on how to use
 ```python
 """
-  - Please see scripts in `script` for details on how to use
-  - Please see implementations in `ensemble` for details on ensemble methods
+  - Please see scripts in `examples` for details on how to use
+  - Please see implementations in `torchensemble` for details on ensemble methods
 """
 
 import base_estimator                               # import base estimator
-from ensemble.method_module import ensemble_method  # import ensemble method
+from torchensemble.method import ensemble_method    # import ensemble method
 
 model = ensemble_method(estimator=base_estimator,   # type of base estimator
                         n_estimators=10,            # number of base estimators
@@ -35,13 +45,13 @@ model.fit(train_loader)
 model.predict(test_loader)
 ```
 
-## Experiment results
+## Benchmarks
 
 * **Classification on CIFAR-10**
   * The table below presents the classification accuracy of different ensemble classifiers on the testing data of **CIFAR-10**
   * Each classifier uses **10** LeNet-5 model (with RELU activation and Dropout) as the base estimators
   * Each base estimator is trained over **100** epochs, with batch size **128**, learning rate **1e-3**, and weight decay **5e-4**
-  * Experiment results can be reproduced by running `./script/classification_cifar10_cnn.py`
+  * Experiment results can be reproduced by running `./examples/classification_cifar10_cnn.py`
 
 | Model Name | Params (MB) | Testing Acc (%) | Improvement (%) |
 | ------ | ------ | ------  | ------ |
@@ -55,7 +65,7 @@ model.predict(test_loader)
   * The table below presents the mean squared error (MSE) of different ensemble regressors on the testing data of **YearPredictionMSD**
   * Each regressor uses **10** multi-layered perceptron (MLP) model (with RELU activation and Dropout) as the base estimators, and the network architecture is fixed as `Input-128-128-Output`
   * Each base estimator is trained over **50** epochs, with batch size **256**, learning rate **1e-3**, and weight decay **5e-4**
-  * Experiment results can be reproduced by running `./script/regression_YearPredictionMSD_mlp.py`
+  * Experiment results can be reproduced by running `./examples/regression_YearPredictionMSD_mlp.py`
 
 | Model Name | Params (MB) | Testing MSE | Improvement |
 | ------ | ------ | ------  | ------ |
@@ -66,10 +76,7 @@ model.predict(test_loader)
 | **GradientBoostingRegressor** | 1.08 | 0.71 | - 0.12 |
 
 ## Package dependencies
+* joblib
 * pytorch
-* scikit-learn
 * torchvision
-
-## Reference
-* Zhou, Zhi-Hua. "Ensemble methods: foundations and algorithms." CRC press (2012).
-* Friedman, Jerome H. "Greedy function approximation: a gradient boosting machine." Annals of statistics (2001).
+* scikit-learn

script/classification_cifar10_cnn.py examples/classification_cifar10_cnn.pyscript/classification_cifar10_cnn.py renamed to examples/classification_cifar10_cnn.py

@@ -1,3 +1,5 @@
+""" Example on classification using CIFAR-10. """
+
 import sys
 sys.path.append('../')
 
@@ -6,11 +8,11 @@
 from torch.utils.data import DataLoader
 from torchvision import datasets, transforms
 
-from model.lenet5 import LeNet5
-from ensemble.fusion import FusionClassifier
-from ensemble.voting import VotingClassifier
-from ensemble.bagging import BaggingClassifier
-from ensemble.gradient_boosting import GradientBoostingClassifier
+from lenet5 import LeNet5
+from torchensemble.fusion import FusionClassifier
+from torchensemble.voting import VotingClassifier
+from torchensemble.bagging import BaggingClassifier
+from torchensemble.gradient_boosting import GradientBoostingClassifier
 
 
 def display_records(records):
@@ -79,11 +81,12 @@ def display_records(records):
 
     # VotingClassifier
     model = VotingClassifier(estimator=LeNet5,
-                              n_estimators=n_estimators,
-                              output_dim=output_dim,
-                              lr=lr,
-                              weight_decay=weight_decay,
-                              epochs=epochs)
+                             n_estimators=n_estimators,
+                             output_dim=output_dim,
+                             lr=lr,
+                             weight_decay=weight_decay,
+                             epochs=epochs,
+                             n_jobs=1)
 
     tic = time.time()
     model.fit(train_loader)
@@ -125,11 +128,11 @@ def display_records(records):
 
     # GradientBoostingClassifier
     model = GradientBoostingClassifier(estimator=LeNet5,
-                                        n_estimators=n_estimators,
-                                        output_dim=output_dim,
-                                        lr=lr,
-                                        weight_decay=weight_decay,
-                                        epochs=epochs)
+                                       n_estimators=n_estimators,
+                                       output_dim=output_dim,
+                                       lr=lr,
+                                       weight_decay=weight_decay,
+                                       epochs=epochs)
 
     tic = time.time()
     model.fit(train_loader)
@@ -146,4 +149,5 @@ def display_records(records):
                     evaluating_time, 
                     testing_acc))
 
+    # Print results on different ensemble methods
     display_records(records)

model/lenet5.py examples/lenet5.pymodel/lenet5.py renamed to examples/lenet5.py

@@ -4,14 +4,14 @@
 
 class LeNet5(nn.Module):
 
-    def __init__(self, output_dim=10):
+    def __init__(self):
         super(LeNet5, self).__init__()
 
         self.conv1 = nn.Conv2d(3, 6, 5, padding=2)
         self.conv2 = nn.Conv2d(6, 16, 5)
         self.fc1 = nn.Linear(576, 120)
         self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, output_dim)
+        self.fc3 = nn.Linear(84, 10)
 
     def forward(self, X):
 

model/MLP.py examples/mlp.pymodel/MLP.py renamed to examples/mlp.py

@@ -4,12 +4,12 @@
 
 class MLP(nn.Module):
 
-    def __init__(self, output_dim=1):
+    def __init__(self):
         super(MLP, self).__init__()
 
         self.linear1 = nn.Linear(90, 128)
         self.linear2 = nn.Linear(128, 128)
-        self.linear3 = nn.Linear(128, output_dim)
+        self.linear3 = nn.Linear(128, 1)
 
     def forward(self, X):
         X = X.view(X.size()[0], -1)

…ript/regression_YearPredictionMSD_mlp.py …ples/regression_YearPredictionMSD_mlp.pyscript/regression_YearPredictionMSD_mlp.py renamed to examples/regression_YearPredictionMSD_mlp.py script/regression_YearPredictionMSD_mlp.py renamed to examples/regression_YearPredictionMSD_mlp.py

@@ -1,29 +1,40 @@
+""" Example on univariate regression using YearPredictionMSD. """
+
 import sys
 sys.path.append('../')
 
 import time
 import torch
+import numbers
 from sklearn.preprocessing import scale
 from sklearn.datasets import load_svmlight_file
 from torch.utils.data import TensorDataset, DataLoader
 
-from model.mlp import MLP
-from ensemble.fusion import FusionRegressor
-from ensemble.voting import VotingRegressor
-from ensemble.bagging import BaggingRegressor
-from ensemble.gradient_boosting import GradientBoostingRegressor
+from mlp import MLP
+from torchensemble.fusion import FusionRegressor
+from torchensemble.voting import VotingRegressor
+from torchensemble.bagging import BaggingRegressor
+from torchensemble.gradient_boosting import GradientBoostingRegressor
 
 
 def load_data(batch_size):
-    
+
     # The dataset can be downloaded from: 
     #   https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/regression.html#YearPredictionMSD
 
-    train = load_svmlight_file('../../Dataset/LIBSVM/YearPredictionMSD.bz2')
-    test = load_svmlight_file('../../Dataset/LIBSVM/YearPredictionMSD.t.bz2')
+    if not isinstance(batch_size, numbers.Integral):
+        msg = '`batch_size` should be an integer, but got {} instead.'
+        raise ValueError(msg.format(batch_size))
+        
+    train_path = '../../Dataset/LIBSVM/YearPredictionMSD.bz2'
+    test_path = '../../Dataset/LIBSVM/YearPredictionMSD.t.bz2'
+
+    train = load_svmlight_file(train_path)
+    test = load_svmlight_file(test_path)
 
     X_train, X_test = (torch.FloatTensor(train[0].toarray()), 
                        torch.FloatTensor(test[0].toarray()))
+    
     y_train, y_test = (torch.FloatTensor(scale(train[1]).reshape(-1, 1)), 
                        torch.FloatTensor(scale(test[1]).reshape(-1, 1)))
 
@@ -111,11 +122,11 @@ def display_records(records):
 
     # BaggingRegressor
     model = BaggingRegressor(estimator=MLP,
-                              n_estimators=n_estimators,
-                              output_dim=output_dim,
-                              lr=lr,
-                              weight_decay=weight_decay,
-                              epochs=epochs)
+                             n_estimators=n_estimators,
+                             output_dim=output_dim,
+                             lr=lr,
+                             weight_decay=weight_decay,
+                             epochs=epochs)
 
     tic = time.time()
     model.fit(train_loader)
@@ -155,4 +166,5 @@ def display_records(records):
                     evaluating_time, 
                     testing_mse))
 
+    # Print results on different ensemble methods
     display_records(records)

model/__init__.py

@@ -0,0 +1,4 @@
+joblib
+torch
+torchvision
+scikit-learn

requirements.txt

@@ -0,0 +1,39 @@
+from setuptools import setup, find_packages
+from codecs import open
+from os import path
+
+here = path.abspath(path.dirname(__file__))
+
+# Get the long description from README.md
+with open(path.join(here, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+# get the dependencies and installs
+with open(path.join(here, 'requirements.txt'), encoding='utf-8') as f:
+    all_reqs = f.read().split('\n')
+
+install_requires = [x.strip() for x in all_reqs if 'git+' not in x]
+
+cmdclass = {}
+
+setup(
+    name='Ensemble-PyTorch',
+    version='0.0.1',
+    author='AaronX121',
+    
+    description=('Implementations of scikit-learn like ensemble methods in'
+                 ' Pytorch'),
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/AaronX121/Ensemble-Pytorch',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    keywords='Ensemble Learning',
+    
+    packages=find_packages(),
+    cmdclass=cmdclass,
+    install_requires=install_requires,
+)