Superliga stats & predictions

Q: How can I follow daily match updates?

A: You can follow daily match updates through official league websites, sports news outlets dedicated to handball coverage, or mobile apps designed specifically for sports updates. <|repo_name|>renzho/renzho.github.io<|file_sep|>/_posts/2016-12-26-hello-world.md --- layout: post title: Hello World! --- I'm starting this blog because I want my notes to be searchable (and accessible) by other people. <|file_sep|># renzho.github.io <|file_sep|># Site settings title: Renzo Horta's blog email: [email protected] description: "Notes on machine learning." baseurl: "" url: "http://renzho.github.io" github_username: renzho # Build settings markdown: kramdown permalink: /blog/:year/:month/:day/:title/ exclude: - README.md - LICENSE.txt - Gemfile* - CNAME <|repo_name|>renzho/renzho.github.io<|file_sep|>/_posts/2016-12-27-convolutional-neural-networks.md --- layout: post title: Convolutional Neural Networks --- In this post I will be giving an overview of Convolutional Neural Networks (CNNs). CNNs are commonly used nowadays in applications such as object detection (Sermanet et al., 2014), image captioning (Karpathy & Fei-Fei 2015), human activity recognition (Simonyan & Zisserman 2014) among others. A CNN consists mainly of two components: 1. Convolutional layers which detect local patterns. 2. Pooling layers which reduce dimensionality. ## Convolutional Layer The convolution operation involves computing dot products between small regions in an image (called *filters* or *kernels*) and feature maps from previous layers. The figure above shows an example convolutional layer which receives three feature maps as input (from previous layers) where each feature map has $5times5$ pixels (this layer would have received images as input from previous layers). The filter $F$ has $5times5$ weights (plus one bias term $b$) which are applied across all three input feature maps at once using dot product operations. The number of output feature maps produced by this layer is equal to number of filters used ($k=2$). ## Pooling Layer The pooling operation consists of downsampling feature maps by aggregating neighbouring pixels using functions such as *max* or *mean*. The figure above shows an example pooling layer which uses *max* pooling with kernel size $2times2$ across two feature maps from previous layers. ## CNN Architecture A typical CNN architecture would consist of multiple convolutional layers followed by pooling layers interspersed at some points. In addition to convolutional layers there would be fully-connected layers towards the end before arriving at an output layer where you would get your predictions. ## Why CNNs? CNNs take advantage of spatial locality by having filters slide over images so that only local regions are computed at once instead computing dot products between whole images. This makes them computationally efficient when processing large images. <|repo_name|>renzho/renzho.github.io<|file_sep|>/_posts/2016-12-28-deep-learning.md --- layout: post title: Deep Learning Overview --- Deep Learning consists mainly of artificial neural networks which use multiple processing layers called *hidden layers* between inputs (features) $X$ and outputs (predictions) $hat{y}$. In general we have: $$hat{y} = f(XW + b)$$ where: - $f$ is an activation function. - $W$ are weights. - $b$ is bias. - $hat{y}$ are predicted outputs. ## Activation Function The activation function decides whether a neuron should be activated or not based on whether its weighted sum is above or below some threshold value. ### Sigmoid $$sigma(x) = frac{1}{1+e^{-x}}$$ ### ReLU $$f(x) = max(0,x)$$ ## Backpropagation Algorithm Backpropagation allows us compute gradients efficiently using chain rule. We want our neural network model parameters ($W$) to minimize loss ($L$). We start by computing loss derivatives: $$frac{partial L}{partial W} = frac{partial L}{partial hat{y}}cdotfrac{partial hat{y}}{partial W}$$ For multilayer networks we have: $$frac{partial L}{partial W^{[l]}} = frac{partial L}{partial z^{[l]}}cdotfrac{partial z^{[l]}}{partial W^{[l]}}$$ where $l$ denotes layer number. We propagate derivatives backwards so we need $frac{partial L}{partial z^{[l]}}$ which we obtain using chain rule: $$frac{partial L}{partial z^{[l]}} = frac{partial L}{partial z^{[l+1]}}cdotfrac{partial z^{[l+1]}}{partial a^{[l]}}cdotfrac{partial a^{[l]}}{partial z^{[l]}}$$ ## Gradient Descent Algorithm Gradient descent allows us update our model parameters ($W$) using derivatives computed via backpropagation algorithm. We start off by initializing parameters randomly: $$W = random(W)$$ Then we update them iteratively until convergence: $$W := W - alphanabla_W L(W)$$ where $alpha$ is learning rate. ## Stochastic Gradient Descent (SGD) In SGD we perform parameter updates after each training example instead after whole training set. <|repo_name|>jvargas94/Spectral-Mixture-Kernel-for-GP-GPR-Python<|file_sep|>/README.md # Spectral-Mixture-Kernel-for-GP-GPR-Python Spectral Mixture Kernel implemented using Python 2.7 / Numpy / Scipy libraries. For more details about Spectral Mixture Kernel see: J.C.Muller et al., "Gaussian Process Kernels for Pattern Discovery and Extrapolation", NIPS 2006. Implementation based on: https://github.com/mattjj/SMGP/blob/master/smkernel.py Dataset used: http://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html  <|repo_name|>jvargas94/Spectral-Mixture-Kernel-for-GP-GPR-Python<|file_sep|>/SM_kernel.py import numpy as np import scipy.stats as spstats import scipy.linalg as linalg class SM_kernel: def __init__(self): self.nmixes = None self.x_train = None self.y_train = None self.kernel_hyperparameters = None self.mean_function = None self.kernel_hyperparameters_bounds = None self.kernel_hyperparameters_bounds_nondiag = None def train(self,X,Y,nmixes): self.nmixes = nmixes self.x_train = X self.y_train = Y self.set_initial_hyperparameters() self.optimize_hyperparameters() def get_hyperparameters(self): return self.kernel_hyperparameters def optimize_hyperparameters(self): pass def set_initial_hyperparameters(self): self.kernel_hyperparameters_bounds_nondiag = [] for i in range(self.nmixes): self.kernel_hyperparameters_bounds_nondiag.append((0,None)) self.kernel_hyperparameters_bounds_nondiag.append((0,None)) self.kernel_hyperparameters_bounds_nondiag.append((0,None)) if i == 0: self.kernel_hyperparameters_bounds_nondiag.append((None,None)) else: self.kernel_hyperparameters_bounds_nondiag.append((0,None)) self.kernel_hyperparameters_bounds = [(0,None)] + self.kernel_hyperparameters_bounds_nondiag lb=np.zeros(len(self.kernel_hyperparameters_bounds)) for i in range(len(self.kernel_hyperparameters_bounds)): lb[i]=self.kernel_hyperparameters_bounds[i][0] kernel_param_shape=lb.shape u=spstats.uniform.rvs(size=kernel_param_shape) sigma_f_sq=10*u[kernel_param_shape[0]-1] lb[kernel_param_shape[0]-1]=sigma_f_sq kernel_param_shape=lb.shape mix_weights=np.zeros(nmixes) for i in range(nmixes): mix_weights[i]=u[kernel_param_shape[0]-nmixes+i] sum_weights=np.sum(mix_weights) mix_weights=mix_weights/sum_weights for i in range(nmixes): lb[kernel_param_shape[0]-nmixes+i]=mix_weights[i] if i == 0: lb[kernel_param_shape[0]-2*nmixes+i]=np.var(Y) else: lb[kernel_param_shape[0]-2*nmixes+i]=np.var(Y)/nmixes mu=spstats.uniform.rvs(size=X.shape) for i in range(nmixes): lb[kernel_param_shape[0]-2*nmixes-nmixes+i]=np.min(mu[:,i]) if i == 0: lb[kernel_param_shape[0]-3*nmixes+i]=np.max(mu[:,i]) else: lb[kernel_param_shape[0]-3*nmixes+i]=np.max(mu[:,i])/nmixes # print lb # u=spstats.uniform.rvs(size=(len(lb))) # x_init=u*(ub-lb)+lb # x_init[:len(lb)-len(lb)/self.nmixes]=u[:len(lb)-len(lb)/self.nmixes]*(ub[:len(lb)-len(lb)/self.nmixes]-lb[:len(lb)-len(lb)/self.nmixes])+lb[:len(lb)-len(lb)/self.nmixes] # x_init[len(l