diff --git a/analysis-master/analysis/__pycache__/__init__.cpython-37.pyc b/analysis-master/analysis/__pycache__/__init__.cpython-37.pyc deleted file mode 100644 index dd1607ef..00000000 Binary files a/analysis-master/analysis/__pycache__/__init__.cpython-37.pyc and /dev/null differ diff --git a/analysis-master/analysis/__pycache__/analysis.cpython-37.pyc b/analysis-master/analysis/__pycache__/analysis.cpython-37.pyc deleted file mode 100644 index 46f1441d..00000000 Binary files a/analysis-master/analysis/__pycache__/analysis.cpython-37.pyc and /dev/null differ diff --git a/analysis-master/build.sh b/analysis-master/build.sh old mode 100644 new mode 100755 diff --git a/analysis-master/build/lib/analysis/analysis.py b/analysis-master/build/lib/analysis/analysis.py index 03a1aa11..9297585b 100644 --- a/analysis-master/build/lib/analysis/analysis.py +++ b/analysis-master/build/lib/analysis/analysis.py @@ -278,7 +278,6 @@ import scipy from scipy import * import sklearn from sklearn import * -import torch try: from analysis import trueskill as Trueskill except: @@ -287,10 +286,6 @@ except: class error(ValueError): pass -def _init_device(): # initiates computation device for ANNs - device = 'cuda:0' if torch.cuda.is_available() else 'cpu' - return device - def load_csv(filepath): with open(filepath, newline='') as csvfile: file_array = np.array(list(csv.reader(csvfile))) @@ -700,225 +695,6 @@ def random_forest_regressor(data, outputs, test_size, n_estimators="warn", crite return kernel, RegressionMetrics(predictions, outputs_test) -class Regression: - - # Titan Robotics Team 2022: CUDA-based Regressions Module - # Written by Arthur Lu & Jacob Levine - # Notes: - # this module has been automatically inegrated into analysis.py, and should be callable as a class from the package - # this module is cuda-optimized and vectorized (except for one small part) - # setup: - - __version__ = "1.0.0.003" - - # changelog should be viewed using print(analysis.regression.__changelog__) - __changelog__ = """ - 1.0.0.003: - - bug fixes - 1.0.0.002: - -Added more parameters to log, exponential, polynomial - -Added SigmoidalRegKernelArthur, because Arthur apparently needs - to train the scaling and shifting of sigmoids - - 1.0.0.001: - -initial release, with linear, log, exponential, polynomial, and sigmoid kernels - -already vectorized (except for polynomial generation) and CUDA-optimized - """ - - __author__ = ( - "Jacob Levine ", - "Arthur Lu " - ) - - __all__ = [ - 'factorial', - 'take_all_pwrs', - 'num_poly_terms', - 'set_device', - 'LinearRegKernel', - 'SigmoidalRegKernel', - 'LogRegKernel', - 'PolyRegKernel', - 'ExpRegKernel', - 'SigmoidalRegKernelArthur', - 'SGDTrain', - 'CustomTrain' - ] - - global device - - device = "cuda:0" if torch.torch.cuda.is_available() else "cpu" - - #todo: document completely - - def set_device(self, new_device): - device=new_device - - class LinearRegKernel(): - parameters= [] - weights=None - bias=None - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.bias] - def forward(self,mtx): - long_bias=self.bias.repeat([1,mtx.size()[1]]) - return torch.matmul(self.weights,mtx)+long_bias - - class SigmoidalRegKernel(): - parameters= [] - weights=None - bias=None - sigmoid=torch.nn.Sigmoid() - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.bias] - def forward(self,mtx): - long_bias=self.bias.repeat([1,mtx.size()[1]]) - return self.sigmoid(torch.matmul(self.weights,mtx)+long_bias) - - class SigmoidalRegKernelArthur(): - parameters= [] - weights=None - in_bias=None - scal_mult=None - out_bias=None - sigmoid=torch.nn.Sigmoid() - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.in_bias=torch.rand(1, requires_grad=True, device=device) - self.scal_mult=torch.rand(1, requires_grad=True, device=device) - self.out_bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.in_bias, self.scal_mult, self.out_bias] - def forward(self,mtx): - long_in_bias=self.in_bias.repeat([1,mtx.size()[1]]) - long_out_bias=self.out_bias.repeat([1,mtx.size()[1]]) - return (self.scal_mult*self.sigmoid(torch.matmul(self.weights,mtx)+long_in_bias))+long_out_bias - - class LogRegKernel(): - parameters= [] - weights=None - in_bias=None - scal_mult=None - out_bias=None - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.in_bias=torch.rand(1, requires_grad=True, device=device) - self.scal_mult=torch.rand(1, requires_grad=True, device=device) - self.out_bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.in_bias, self.scal_mult, self.out_bias] - def forward(self,mtx): - long_in_bias=self.in_bias.repeat([1,mtx.size()[1]]) - long_out_bias=self.out_bias.repeat([1,mtx.size()[1]]) - return (self.scal_mult*torch.log(torch.matmul(self.weights,mtx)+long_in_bias))+long_out_bias - - class ExpRegKernel(): - parameters= [] - weights=None - in_bias=None - scal_mult=None - out_bias=None - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.in_bias=torch.rand(1, requires_grad=True, device=device) - self.scal_mult=torch.rand(1, requires_grad=True, device=device) - self.out_bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.in_bias, self.scal_mult, self.out_bias] - def forward(self,mtx): - long_in_bias=self.in_bias.repeat([1,mtx.size()[1]]) - long_out_bias=self.out_bias.repeat([1,mtx.size()[1]]) - return (self.scal_mult*torch.exp(torch.matmul(self.weights,mtx)+long_in_bias))+long_out_bias - - class PolyRegKernel(): - parameters= [] - weights=None - bias=None - power=None - def __init__(self, num_vars, power): - self.power=power - num_terms=self.num_poly_terms(num_vars, power) - self.weights=torch.rand(num_terms, requires_grad=True, device=device) - self.bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.bias] - def num_poly_terms(self,num_vars, power): - if power == 0: - return 0 - return int(self.factorial(num_vars+power-1) / self.factorial(power) / self.factorial(num_vars-1)) + self.num_poly_terms(num_vars, power-1) - def factorial(self,n): - if n==0: - return 1 - else: - return n*self.factorial(n-1) - def take_all_pwrs(self, vec, pwr): - #todo: vectorize (kinda) - combins=torch.combinations(vec, r=pwr, with_replacement=True) - out=torch.ones(combins.size()[0]).to(device).to(torch.float) - for i in torch.t(combins).to(device).to(torch.float): - out *= i - if pwr == 1: - return out - else: - return torch.cat((out,self.take_all_pwrs(vec, pwr-1))) - def forward(self,mtx): - #TODO: Vectorize the last part - cols=[] - for i in torch.t(mtx): - cols.append(self.take_all_pwrs(i,self.power)) - new_mtx=torch.t(torch.stack(cols)) - long_bias=self.bias.repeat([1,mtx.size()[1]]) - return torch.matmul(self.weights,new_mtx)+long_bias - - def SGDTrain(self, kernel, data, ground, loss=torch.nn.MSELoss(), iterations=1000, learning_rate=.1, return_losses=False): - optim=torch.optim.SGD(kernel.parameters, lr=learning_rate) - data_cuda=data.to(device) - ground_cuda=ground.to(device) - if (return_losses): - losses=[] - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data_cuda) - ls=loss(pred,ground_cuda) - losses.append(ls.item()) - ls.backward() - optim.step() - return [kernel,losses] - else: - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data_cuda) - ls=loss(pred,ground_cuda) - ls.backward() - optim.step() - return kernel - - def CustomTrain(self, kernel, optim, data, ground, loss=torch.nn.MSELoss(), iterations=1000, return_losses=False): - data_cuda=data.to(device) - ground_cuda=ground.to(device) - if (return_losses): - losses=[] - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data) - ls=loss(pred,ground) - losses.append(ls.item()) - ls.backward() - optim.step() - return [kernel,losses] - else: - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data_cuda) - ls=loss(pred,ground_cuda) - ls.backward() - optim.step() - return kernel - class Glicko2: _tau = 0.5 @@ -1016,4 +792,4 @@ class Glicko2: def did_not_compete(self): - self._preRatingRD() \ No newline at end of file + self._preRatingRD() diff --git a/analysis-master/dist/analysis-1.0.0.6-py3-none-any.whl b/analysis-master/dist/analysis-1.0.0.6-py3-none-any.whl index bc4762c9..46500f86 100644 Binary files a/analysis-master/dist/analysis-1.0.0.6-py3-none-any.whl and b/analysis-master/dist/analysis-1.0.0.6-py3-none-any.whl differ diff --git a/analysis-master/dist/analysis-1.0.0.6.tar.gz b/analysis-master/dist/analysis-1.0.0.6.tar.gz index 2a848dc8..570b4f71 100644 Binary files a/analysis-master/dist/analysis-1.0.0.6.tar.gz and b/analysis-master/dist/analysis-1.0.0.6.tar.gz differ diff --git a/data analysis/__pycache__/data.cpython-37.pyc b/data analysis/__pycache__/data.cpython-37.pyc index 6b91e2a6..6d3e92a8 100644 Binary files a/data analysis/__pycache__/data.cpython-37.pyc and b/data analysis/__pycache__/data.cpython-37.pyc differ diff --git a/analysis-master/analysis/__init__.py b/data analysis/analysis/__init__.py similarity index 100% rename from analysis-master/analysis/__init__.py rename to data analysis/analysis/__init__.py diff --git a/data analysis/analysis/__pycache__/__init__.cpython-37.pyc b/data analysis/analysis/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 00000000..fa1abb00 Binary files /dev/null and b/data analysis/analysis/__pycache__/__init__.cpython-37.pyc differ diff --git a/analysis-master/analysis/__pycache__/analysis.cpython-36.pyc b/data analysis/analysis/__pycache__/analysis.cpython-36.pyc similarity index 100% rename from analysis-master/analysis/__pycache__/analysis.cpython-36.pyc rename to data analysis/analysis/__pycache__/analysis.cpython-36.pyc diff --git a/data analysis/analysis/__pycache__/analysis.cpython-37.pyc b/data analysis/analysis/__pycache__/analysis.cpython-37.pyc new file mode 100644 index 00000000..b9d52e8e Binary files /dev/null and b/data analysis/analysis/__pycache__/analysis.cpython-37.pyc differ diff --git a/analysis-master/analysis/__pycache__/regression.cpython-37.pyc b/data analysis/analysis/__pycache__/regression.cpython-37.pyc similarity index 100% rename from analysis-master/analysis/__pycache__/regression.cpython-37.pyc rename to data analysis/analysis/__pycache__/regression.cpython-37.pyc diff --git a/analysis-master/analysis/__pycache__/titanlearn.cpython-37.pyc b/data analysis/analysis/__pycache__/titanlearn.cpython-37.pyc similarity index 100% rename from analysis-master/analysis/__pycache__/titanlearn.cpython-37.pyc rename to data analysis/analysis/__pycache__/titanlearn.cpython-37.pyc diff --git a/analysis-master/analysis/__pycache__/trueskill.cpython-37.pyc b/data analysis/analysis/__pycache__/trueskill.cpython-37.pyc similarity index 70% rename from analysis-master/analysis/__pycache__/trueskill.cpython-37.pyc rename to data analysis/analysis/__pycache__/trueskill.cpython-37.pyc index 1d5c8c7b..15c7554d 100644 Binary files a/analysis-master/analysis/__pycache__/trueskill.cpython-37.pyc and b/data analysis/analysis/__pycache__/trueskill.cpython-37.pyc differ diff --git a/analysis-master/analysis/analysis.py b/data analysis/analysis/analysis.py similarity index 74% rename from analysis-master/analysis/analysis.py rename to data analysis/analysis/analysis.py index 03a1aa11..7a840e89 100644 --- a/analysis-master/analysis/analysis.py +++ b/data analysis/analysis/analysis.py @@ -7,10 +7,18 @@ # current benchmark of optimization: 1.33 times faster # setup: -__version__ = "1.1.13.001" +__version__ = "1.1.13.005" # changelog should be viewed using print(analysis.__changelog__) __changelog__ = """changelog: + 1.1.13.005: + - cleaned up package + 1.1.13.004: + - small fixes to regression to improve performance + 1.1.13.003: + - filtered nans from regression + 1.1.13.002: + - removed torch requirement, and moved Regression back to regression.py 1.1.13.001: - bug fix with linear regression not returning a proper value - cleaned up regression @@ -239,7 +247,6 @@ __author__ = ( ) __all__ = [ - '_init_device', 'load_csv', 'basic_stats', 'z_score', @@ -260,7 +267,6 @@ __all__ = [ 'SVM', 'random_forest_classifier', 'random_forest_regressor', - 'Regression', 'Glicko2', # all statistics functions left out due to integration in other functions ] @@ -273,12 +279,10 @@ import csv import numba from numba import jit import numpy as np -import math import scipy from scipy import * import sklearn from sklearn import * -import torch try: from analysis import trueskill as Trueskill except: @@ -287,10 +291,6 @@ except: class error(ValueError): pass -def _init_device(): # initiates computation device for ANNs - device = 'cuda:0' if torch.cuda.is_available() else 'cpu' - return device - def load_csv(filepath): with open(filepath, newline='') as csvfile: file_array = np.array(list(csv.reader(csvfile))) @@ -349,15 +349,15 @@ def histo_analysis(hist_data): def regression(inputs, outputs, args): # inputs, outputs expects N-D array + X = np.array(inputs) + y = np.array(outputs) + regressions = [] if 'lin' in args: # formula: ax + b try: - X = np.array(inputs) - y = np.array(outputs) - def func(x, a, b): return a * x + b @@ -374,9 +374,6 @@ def regression(inputs, outputs, args): # inputs, outputs expects N-D array try: - X = np.array(inputs) - y = np.array(outputs) - def func(x, a, b, c, d): return a * np.log(b*(x + c)) + d @@ -391,10 +388,7 @@ def regression(inputs, outputs, args): # inputs, outputs expects N-D array if 'exp' in args: # formula: a e ^ (b(x + c)) + d - try: - - X = np.array(inputs) - y = np.array(outputs) + try: def func(x, a, b, c, d): @@ -410,8 +404,8 @@ def regression(inputs, outputs, args): # inputs, outputs expects N-D array if 'ply' in args: # formula: a + bx^1 + cx^2 + dx^3 + ... - inputs = [inputs] - outputs = [outputs] + inputs = np.array([inputs]) + outputs = np.array([outputs]) plys = [] limit = len(outputs[0]) @@ -433,10 +427,7 @@ def regression(inputs, outputs, args): # inputs, outputs expects N-D array if 'sig' in args: # formula: a tanh (b(x + c)) + d - try: - - X = np.array(inputs) - y = np.array(outputs) + try: def func(x, a, b, c, d): @@ -700,225 +691,6 @@ def random_forest_regressor(data, outputs, test_size, n_estimators="warn", crite return kernel, RegressionMetrics(predictions, outputs_test) -class Regression: - - # Titan Robotics Team 2022: CUDA-based Regressions Module - # Written by Arthur Lu & Jacob Levine - # Notes: - # this module has been automatically inegrated into analysis.py, and should be callable as a class from the package - # this module is cuda-optimized and vectorized (except for one small part) - # setup: - - __version__ = "1.0.0.003" - - # changelog should be viewed using print(analysis.regression.__changelog__) - __changelog__ = """ - 1.0.0.003: - - bug fixes - 1.0.0.002: - -Added more parameters to log, exponential, polynomial - -Added SigmoidalRegKernelArthur, because Arthur apparently needs - to train the scaling and shifting of sigmoids - - 1.0.0.001: - -initial release, with linear, log, exponential, polynomial, and sigmoid kernels - -already vectorized (except for polynomial generation) and CUDA-optimized - """ - - __author__ = ( - "Jacob Levine ", - "Arthur Lu " - ) - - __all__ = [ - 'factorial', - 'take_all_pwrs', - 'num_poly_terms', - 'set_device', - 'LinearRegKernel', - 'SigmoidalRegKernel', - 'LogRegKernel', - 'PolyRegKernel', - 'ExpRegKernel', - 'SigmoidalRegKernelArthur', - 'SGDTrain', - 'CustomTrain' - ] - - global device - - device = "cuda:0" if torch.torch.cuda.is_available() else "cpu" - - #todo: document completely - - def set_device(self, new_device): - device=new_device - - class LinearRegKernel(): - parameters= [] - weights=None - bias=None - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.bias] - def forward(self,mtx): - long_bias=self.bias.repeat([1,mtx.size()[1]]) - return torch.matmul(self.weights,mtx)+long_bias - - class SigmoidalRegKernel(): - parameters= [] - weights=None - bias=None - sigmoid=torch.nn.Sigmoid() - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.bias] - def forward(self,mtx): - long_bias=self.bias.repeat([1,mtx.size()[1]]) - return self.sigmoid(torch.matmul(self.weights,mtx)+long_bias) - - class SigmoidalRegKernelArthur(): - parameters= [] - weights=None - in_bias=None - scal_mult=None - out_bias=None - sigmoid=torch.nn.Sigmoid() - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.in_bias=torch.rand(1, requires_grad=True, device=device) - self.scal_mult=torch.rand(1, requires_grad=True, device=device) - self.out_bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.in_bias, self.scal_mult, self.out_bias] - def forward(self,mtx): - long_in_bias=self.in_bias.repeat([1,mtx.size()[1]]) - long_out_bias=self.out_bias.repeat([1,mtx.size()[1]]) - return (self.scal_mult*self.sigmoid(torch.matmul(self.weights,mtx)+long_in_bias))+long_out_bias - - class LogRegKernel(): - parameters= [] - weights=None - in_bias=None - scal_mult=None - out_bias=None - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.in_bias=torch.rand(1, requires_grad=True, device=device) - self.scal_mult=torch.rand(1, requires_grad=True, device=device) - self.out_bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.in_bias, self.scal_mult, self.out_bias] - def forward(self,mtx): - long_in_bias=self.in_bias.repeat([1,mtx.size()[1]]) - long_out_bias=self.out_bias.repeat([1,mtx.size()[1]]) - return (self.scal_mult*torch.log(torch.matmul(self.weights,mtx)+long_in_bias))+long_out_bias - - class ExpRegKernel(): - parameters= [] - weights=None - in_bias=None - scal_mult=None - out_bias=None - def __init__(self, num_vars): - self.weights=torch.rand(num_vars, requires_grad=True, device=device) - self.in_bias=torch.rand(1, requires_grad=True, device=device) - self.scal_mult=torch.rand(1, requires_grad=True, device=device) - self.out_bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.in_bias, self.scal_mult, self.out_bias] - def forward(self,mtx): - long_in_bias=self.in_bias.repeat([1,mtx.size()[1]]) - long_out_bias=self.out_bias.repeat([1,mtx.size()[1]]) - return (self.scal_mult*torch.exp(torch.matmul(self.weights,mtx)+long_in_bias))+long_out_bias - - class PolyRegKernel(): - parameters= [] - weights=None - bias=None - power=None - def __init__(self, num_vars, power): - self.power=power - num_terms=self.num_poly_terms(num_vars, power) - self.weights=torch.rand(num_terms, requires_grad=True, device=device) - self.bias=torch.rand(1, requires_grad=True, device=device) - self.parameters=[self.weights,self.bias] - def num_poly_terms(self,num_vars, power): - if power == 0: - return 0 - return int(self.factorial(num_vars+power-1) / self.factorial(power) / self.factorial(num_vars-1)) + self.num_poly_terms(num_vars, power-1) - def factorial(self,n): - if n==0: - return 1 - else: - return n*self.factorial(n-1) - def take_all_pwrs(self, vec, pwr): - #todo: vectorize (kinda) - combins=torch.combinations(vec, r=pwr, with_replacement=True) - out=torch.ones(combins.size()[0]).to(device).to(torch.float) - for i in torch.t(combins).to(device).to(torch.float): - out *= i - if pwr == 1: - return out - else: - return torch.cat((out,self.take_all_pwrs(vec, pwr-1))) - def forward(self,mtx): - #TODO: Vectorize the last part - cols=[] - for i in torch.t(mtx): - cols.append(self.take_all_pwrs(i,self.power)) - new_mtx=torch.t(torch.stack(cols)) - long_bias=self.bias.repeat([1,mtx.size()[1]]) - return torch.matmul(self.weights,new_mtx)+long_bias - - def SGDTrain(self, kernel, data, ground, loss=torch.nn.MSELoss(), iterations=1000, learning_rate=.1, return_losses=False): - optim=torch.optim.SGD(kernel.parameters, lr=learning_rate) - data_cuda=data.to(device) - ground_cuda=ground.to(device) - if (return_losses): - losses=[] - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data_cuda) - ls=loss(pred,ground_cuda) - losses.append(ls.item()) - ls.backward() - optim.step() - return [kernel,losses] - else: - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data_cuda) - ls=loss(pred,ground_cuda) - ls.backward() - optim.step() - return kernel - - def CustomTrain(self, kernel, optim, data, ground, loss=torch.nn.MSELoss(), iterations=1000, return_losses=False): - data_cuda=data.to(device) - ground_cuda=ground.to(device) - if (return_losses): - losses=[] - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data) - ls=loss(pred,ground) - losses.append(ls.item()) - ls.backward() - optim.step() - return [kernel,losses] - else: - for i in range(iterations): - with torch.set_grad_enabled(True): - optim.zero_grad() - pred=kernel.forward(data_cuda) - ls=loss(pred,ground_cuda) - ls.backward() - optim.step() - return kernel - class Glicko2: _tau = 0.5 @@ -1016,4 +788,4 @@ class Glicko2: def did_not_compete(self): - self._preRatingRD() \ No newline at end of file + self._preRatingRD() diff --git a/analysis-master/analysis/regression.py b/data analysis/analysis/regression.py similarity index 75% rename from analysis-master/analysis/regression.py rename to data analysis/analysis/regression.py index 6cbe7868..adf2a54e 100644 --- a/analysis-master/analysis/regression.py +++ b/data analysis/analysis/regression.py @@ -1,27 +1,28 @@ # Titan Robotics Team 2022: CUDA-based Regressions Module # Written by Arthur Lu & Jacob Levine # Notes: -# this should be imported as a python module using 'import regression' -# this should be included in the local directory or environment variable -# this module is cuda-optimized and vectorized (except for one small part) +# this module has been automatically inegrated into analysis.py, and should be callable as a class from the package +# this module is cuda-optimized and vectorized (except for one small part) # setup: -__version__ = "1.0.0.002" +__version__ = "1.0.0.003" -# changelog should be viewed using print(regression.__changelog__) +# changelog should be viewed using print(analysis.regression.__changelog__) __changelog__ = """ - 1.0.0.002: - -Added more parameters to log, exponential, polynomial - -Added SigmoidalRegKernelArthur, because Arthur apparently needs - to train the scaling and shifting of sigmoids - - 1.0.0.001: - -initial release, with linear, log, exponential, polynomial, and sigmoid kernels - -already vectorized (except for polynomial generation) and CUDA-optimized +1.0.0.003: + - bug fixes +1.0.0.002: + -Added more parameters to log, exponential, polynomial + -Added SigmoidalRegKernelArthur, because Arthur apparently needs + to train the scaling and shifting of sigmoids +1.0.0.001: + -initial release, with linear, log, exponential, polynomial, and sigmoid kernels + -already vectorized (except for polynomial generation) and CUDA-optimized """ __author__ = ( "Jacob Levine ", + "Arthur Lu " ) __all__ = [ @@ -39,35 +40,13 @@ __all__ = [ 'CustomTrain' ] - -# imports (just one for now): - -import torch +global device device = "cuda:0" if torch.torch.cuda.is_available() else "cpu" #todo: document completely -def factorial(n): - if n==0: - return 1 - else: - return n*factorial(n-1) -def num_poly_terms(num_vars, power): - if power == 0: - return 0 - return int(factorial(num_vars+power-1) / factorial(power) / factorial(num_vars-1)) + num_poly_terms(num_vars, power-1) - -def take_all_pwrs(vec,pwr): - #todo: vectorize (kinda) - combins=torch.combinations(vec, r=pwr, with_replacement=True) - out=torch.ones(combins.size()[0]) - for i in torch.t(combins): - out *= i - return torch.cat(out,take_all_pwrs(vec, pwr-1)) - -def set_device(new_device): - global device +def set_device(self, new_device): device=new_device class LinearRegKernel(): @@ -154,20 +133,39 @@ class PolyRegKernel(): power=None def __init__(self, num_vars, power): self.power=power - num_terms=num_poly_terms(num_vars, power) + num_terms=self.num_poly_terms(num_vars, power) self.weights=torch.rand(num_terms, requires_grad=True, device=device) self.bias=torch.rand(1, requires_grad=True, device=device) self.parameters=[self.weights,self.bias] + def num_poly_terms(self,num_vars, power): + if power == 0: + return 0 + return int(self.factorial(num_vars+power-1) / self.factorial(power) / self.factorial(num_vars-1)) + self.num_poly_terms(num_vars, power-1) + def factorial(self,n): + if n==0: + return 1 + else: + return n*self.factorial(n-1) + def take_all_pwrs(self, vec, pwr): + #todo: vectorize (kinda) + combins=torch.combinations(vec, r=pwr, with_replacement=True) + out=torch.ones(combins.size()[0]).to(device).to(torch.float) + for i in torch.t(combins).to(device).to(torch.float): + out *= i + if pwr == 1: + return out + else: + return torch.cat((out,self.take_all_pwrs(vec, pwr-1))) def forward(self,mtx): #TODO: Vectorize the last part cols=[] for i in torch.t(mtx): - cols.append(take_all_pwrs(i,self.power)) + cols.append(self.take_all_pwrs(i,self.power)) new_mtx=torch.t(torch.stack(cols)) long_bias=self.bias.repeat([1,mtx.size()[1]]) return torch.matmul(self.weights,new_mtx)+long_bias -def SGDTrain(kernel, data, ground, loss=torch.nn.MSELoss(), iterations=1000, learning_rate=.1, return_losses=False): +def SGDTrain(self, kernel, data, ground, loss=torch.nn.MSELoss(), iterations=1000, learning_rate=.1, return_losses=False): optim=torch.optim.SGD(kernel.parameters, lr=learning_rate) data_cuda=data.to(device) ground_cuda=ground.to(device) @@ -192,7 +190,7 @@ def SGDTrain(kernel, data, ground, loss=torch.nn.MSELoss(), iterations=1000, lea optim.step() return kernel -def CustomTrain(kernel, optim, data, ground, loss=torch.nn.MSELoss(), iterations=1000, return_losses=False): +def CustomTrain(self, kernel, optim, data, ground, loss=torch.nn.MSELoss(), iterations=1000, return_losses=False): data_cuda=data.to(device) ground_cuda=ground.to(device) if (return_losses): @@ -214,4 +212,4 @@ def CustomTrain(kernel, optim, data, ground, loss=torch.nn.MSELoss(), iterations ls=loss(pred,ground_cuda) ls.backward() optim.step() - return kernel + return kernel \ No newline at end of file diff --git a/analysis-master/analysis/titanlearn.py b/data analysis/analysis/titanlearn.py similarity index 100% rename from analysis-master/analysis/titanlearn.py rename to data analysis/analysis/titanlearn.py diff --git a/analysis-master/analysis/trueskill.py b/data analysis/analysis/trueskill.py similarity index 100% rename from analysis-master/analysis/trueskill.py rename to data analysis/analysis/trueskill.py diff --git a/analysis-master/analysis/visualization.py b/data analysis/analysis/visualization.py similarity index 100% rename from analysis-master/analysis/visualization.py rename to data analysis/analysis/visualization.py diff --git a/data analysis/config.csv b/data analysis/config.csv index d1975c6a..42e42922 100644 --- a/data analysis/config.csv +++ b/data analysis/config.csv @@ -1,9 +1,11 @@ 2020ilch balls-blocked,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal balls-collected,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal -balls-lower,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal +balls-lower-teleop,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal +balls-lower-auto,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal balls-started,basic_stats,historical_analyss,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal -balls-upper,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal +balls-upper-teleop,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal +balls-upper-auto,basic_stats,historical_analysis,regression_linear,regression_logarithmic,regression_exponential,regression_polynomial,regression_sigmoidal wheel-mechanism low-balls high-balls diff --git a/data analysis/superscript.py b/data analysis/superscript.py index 3a3c590c..70edaa92 100644 --- a/data analysis/superscript.py +++ b/data analysis/superscript.py @@ -3,11 +3,19 @@ # Notes: # setup: -__version__ = "0.0.3.000" +__version__ = "0.0.4.001" # changelog should be viewed using print(analysis.__changelog__) __changelog__ = """changelog: - 0.0.3.00: + 0.0.4.001: + - fixed bug where X range for regression was determined before sanitization + - better sanitized data + 0.0.4.000: + - fixed spelling issue in __changelog__ + - addressed nan bug in regression + - fixed errors on line 335 with metrics calling incorrect key "glicko2" + - fixed errors in metrics computing + 0.0.3.000: - added analysis to pit data 0.0.2.001: - minor stability patches @@ -71,6 +79,7 @@ __all__ = [ from analysis import analysis as an import data as d +import numpy as np import matplotlib.pyplot as plt import time import warnings @@ -114,7 +123,7 @@ def main(): print(" finished tests") print(" running metrics") - metrics = metricsloop(tbakey, apikey, competition, previous_time) + metricsloop(tbakey, apikey, competition, previous_time) print(" finished metrics") print(" running pit analysis") @@ -124,7 +133,7 @@ def main(): d.set_analysis_flags(apikey, "latest_update", {"latest_update":current_time}) print(" pushing to database") - push_to_database(apikey, competition, results, metrics, pit) + push_to_database(apikey, competition, results, pit) print(" pushed to database") def load_config(file): @@ -155,37 +164,37 @@ def simpleloop(data, tests): # expects 3D array with [Team][Variable][Match] def simplestats(data, test): + data = np.array(data) + data = data[np.isfinite(data)] + ranges = list(range(len(data))) + if(test == "basic_stats"): return an.basic_stats(data) if(test == "historical_analysis"): - return an.histo_analysis([list(range(len(data))), data]) + return an.histo_analysis([ranges, data]) if(test == "regression_linear"): - return an.regression(list(range(len(data))), data, ['lin']) + return an.regression(ranges, data, ['lin']) if(test == "regression_logarithmic"): - return an.regression(list(range(len(data))), data, ['log']) + return an.regression(ranges, data, ['log']) if(test == "regression_exponential"): - return an.regression(list(range(len(data))), data, ['exp']) + return an.regression(ranges, data, ['exp']) if(test == "regression_polynomial"): - return an.regression(list(range(len(data))), data, ['ply']) + return an.regression(ranges, data, ['ply']) if(test == "regression_sigmoidal"): - return an.regression(list(range(len(data))), data, ['sig']) + return an.regression(ranges, data, ['sig']) -def push_to_database(apikey, competition, results, metrics, pit): +def push_to_database(apikey, competition, results, pit): for team in results: d.push_team_tests_data(apikey, competition, team, results[team]) - for team in metrics: - - d.push_team_metrics_data(apikey, competition, team, metrics[team]) - for variable in pit: d.push_team_pit_data(apikey, competition, variable, pit[variable]) @@ -206,7 +215,7 @@ def metricsloop(tbakey, apikey, competition, timestamp): # listener based metric red = load_metrics(apikey, competition, match, "red") blu = load_metrics(apikey, competition, match, "blue") - + elo_red_total = 0 elo_blu_total = 0 @@ -279,6 +288,14 @@ def metricsloop(tbakey, apikey, competition, timestamp): # listener based metric blu[team]["gl2"]["rd"] = blu[team]["gl2"]["rd"] + blu_gl2_delta["rd"] blu[team]["gl2"]["vol"] = blu[team]["gl2"]["vol"] + blu_gl2_delta["vol"] + temp_vector = {} + temp_vector.update(red) + temp_vector.update(blu) + + for team in temp_vector: + + d.push_team_metrics_data(apikey, competition, team, temp_vector[team]) + """ not functional for now red_trueskill = [] blu_trueskill = [] @@ -305,11 +322,6 @@ def metricsloop(tbakey, apikey, competition, timestamp): # listener based metric """ - return_vector.update(red) - return_vector.update(blu) - - return return_vector - def load_metrics(apikey, competition, match, group_name): group = {} @@ -324,16 +336,17 @@ def load_metrics(apikey, competition, match, group_name): gl2 = {"score": 1500, "rd": 250, "vol": 0.06} ts = {"mu": 25, "sigma": 25/3} - d.push_team_metrics_data(apikey, competition, team, {"elo":elo, "gliko2":gl2,"trueskill":ts}) + #d.push_team_metrics_data(apikey, competition, team, {"elo":elo, "gl2":gl2,"trueskill":ts}) group[team] = {"elo": elo, "gl2": gl2, "ts": ts} else: metrics = db_data["metrics"] + elo = metrics["elo"] - gl2 = metrics["gliko2"] - ts = metrics["trueskill"] + gl2 = metrics["gl2"] + ts = metrics["ts"] group[team] = {"elo": elo, "gl2": gl2, "ts": ts} diff --git a/data analysis/visualize_pit.py b/data analysis/visualize_pit.py index 3305ee4d..afd10e20 100644 --- a/data analysis/visualize_pit.py +++ b/data analysis/visualize_pit.py @@ -34,7 +34,7 @@ import numpy as np # %% -fig, ax = plt.subplots(1, len(pit), sharey=True, figsize=(20,10)) +fig, ax = plt.subplots(1, len(pit), sharey=True, figsize=(80,15)) i = 0