First Division Women stats & predictions

What is the structure of the Football First Division Women Malta?

How can I get involved as a volunteer or supporter?

Are there opportunities for young players?

<|repo_name|>gsmlab/KeplerNet<|file_sep|>/kepler_net/kepler_net/data.py # -*- coding: utf-8 -*- # Copyright (C) by Sascha Flennerhag # License: BSD-2-Clause import numpy as np from torch.utils.data import Dataset class KeplerDataset(Dataset): def __init__(self, time, flux, mask=None, transform=None, target_transform=None): """Dataset consisting of time series observations. Args: time (numpy.ndarray): Time values (shape: [n_obs]). flux (numpy.ndarray): Flux values (shape: [n_obs]). mask (numpy.ndarray): Boolean mask indicating which data points should be considered (shape: [n_obs]). If None all data points will be used (default). transform (callable): A function/transform that takes input sample as argument (sequence) and returns a transformed version (sequence). E.g., `transforms.RandomCrop`. target_transform (callable): A function/transform that takes target sample as argument (sequence) and returns a transformed version (sequence). E.g., `transforms.RandomCrop`. """ if not isinstance(time,np.ndarray): raise TypeError('time must be numpy array.') if not isinstance(flux,np.ndarray): raise TypeError('flux must be numpy array.') if time.shape != flux.shape: raise ValueError('time.shape != flux.shape.') self.time = time.astype(np.float32) self.flux = flux.astype(np.float32) if mask is None: self.mask = np.ones_like(self.time,dtype=np.bool) else: if not isinstance(mask,np.ndarray): raise TypeError('mask must be numpy array.') if mask.shape != self.time.shape: raise ValueError('mask.shape != time.shape') self.mask = mask.astype(np.bool) self.transform = transform self.target_transform = target_transform def __len__(self): return len(self.time) class KeplerDataModule(object): def __init__(self, train_data, val_data=None, test_data=None): """Module containing datasets. Args: train_data (KeplerDataset): Training dataset. val_data (KeplerDataset): Validation dataset. test_data (KeplerDataset): Test dataset. """ if not isinstance(train_data,Dataset): raise TypeError('train_data must be instance of torch.utils.data.Dataset') self.train_data = train_data self.val_data = val_data self.test_data = test_data <|repo_name|>gsmlab/KeplerNet<|file_sep|>/kepler_net/kepler_net/layers.py # -*- coding: utf-8 -*- # Copyright (C) by Sascha Flennerhag # License: BSD-2-Clause import torch import torch.nn as nn from . import util class CustomConv1d(nn.Module): def __init__(self, input_dim, output_dim, kernel_size=5, stride=1, dilation=1, bias=True): super(CustomConv1d,self).__init__() # Create convolution layer conv = nn.Conv1d(input_dim, output_dim, kernel_size=kernel_size, stride=stride, dilation=dilation, bias=bias) # Set weights according to Gaussian kernel n = torch.arange(kernel_size,dtype=torch.float32)-int((kernel_size-1)/2) # Gaussian weights using standard deviation sigma=0.25*(kernel_size-1) stdv = util.to_tensor(0.25*(kernel_size-1),dtype=torch.float32) weights_init = torch.exp(-0.5*n**2/stdv**2)/torch.sqrt(2*np.pi*stdv**2) # Repeat same weights across all input channels weights_init = weights_init.view(1,-1).repeat(input_dim,1) # Initialize convolution layer weights conv.weight.data.copy_(weights_init.view_as(conv.weight)) # Set bias terms to zero if bias was enabled if bias: conv.bias.data.fill_(0) # Store convolution layer as module attribute self.conv = conv class Flatten(nn.Module): def forward(self,x): return x.view(x.size(0),-1) class SoftmaxWithLoss(nn.Module): def forward(self,x,target,reduction='mean'): loss = nn.functional.cross_entropy(x,target,reduction=reduction) return loss class CenterLoss(nn.Module): def __init__(self,num_classes,alpha=0.5): super(CenterLoss,self).__init__() self.num_classes = num_classes # Register centers as module parameter; initialize randomly within range [-1,+1] self.centers = nn.Parameter(torch.empty(num_classes)) # Initialize centers using uniform distribution within range [-1,+1] nn.init.uniform_(self.centers,-1,+1) # Set learning rate multiplier alpha; alpha=0 means fixed centers; alpha=+inf means full learning rate multiplier self.alpha = alpha def forward(self,x,target,reduction='mean'): # Extract embeddings belonging to each class based on target labels; shape: [num_classes,num_embeddings_in_class,dim_embedding] embeddings_by_class_list = [x[target==c] for c in range(self.num_classes)] # Calculate mean embedding within each class; shape: [num_classes,dim_embedding] embeddings_by_class_mean_list = [emb.mean(dim=0) if len(emb)>0 else emb.new_zeros((x.size(-1),)) for emb in embeddings_by_class_list] # Stack mean embeddings into tensor; shape: [num_classes,dim_embedding] embeddings_by_class_mean_stack = torch.stack(embeddings_by_class_mean_list) # Calculate center loss as Euclidean distance between current centers # and mean embedding within each class; shape: [num_classes] center_loss_per_class = torch.norm(self.centers - embeddings_by_class_mean_stack,dim=-1)**2 # Reduce center loss per class according specified reduction method; # either 'mean' or 'sum' if reduction == 'mean': center_loss_per_class_mean = center_loss_per_class.mean() center_loss_per_class_summed = center_loss_per_class.sum() center_loss_per_class_reduced = center_loss_per_class_mean elif reduction == 'sum': center_loss_per_class_mean = center_loss_per_class.mean() center_loss_per_class_summed = center_loss_per_class.sum() center_loss_per_class_reduced = center_loss_per_class_summed else: raise ValueError("Reduction method must be either 'mean' or 'sum'.") # Update centers based on mean embedding within each class; # update rate depends on alpha parameter; alpha=0 means fixed centers; # alpha=+inf means full learning rate multiplier if self.training: if self.alpha == +float('inf'): self.centers.data.copy_(embeddings_by_class_mean_stack) elif self.alpha == float(0): pass else: updated_centers = self.alpha*self.centers.data + (1-self.alpha)*embeddings_by_class_mean_stack self.centers.data.copy_(updated_centers) return {'loss':center_loss_per_class_reduced, 'per-class-loss-mean':center_loss_per_class_mean, 'per-class-loss-summed':center_loss_per_class_summed} <|repo_name|>gsmlab/KeplerNet<|file_sep|>/examples/example01_dnn.py # -*- coding: utf-8 -*- # Copyright (C) by Sascha Flennerhag # License: BSD-2-Clause from sklearn.datasets import load_iris import matplotlib.pyplot as plt from kepler_net.kepler_net import KeplerNet np.random.seed(12345) # Load iris dataset X,y_true,CV_groups_true,CV_targets_true=load_iris(return_X_y=False) # Split into train/test sets using predefined cross-validation groups/targets X_train,y_train,X_test,y_test,CV_groups_train,CV_targets_train,CV_groups_test,CV_targets_test=KeplerNet.split_dataset(X,y_true,CV_groups_true,CV_targets_true) ############################################################################### ## Define model ############################################################################### model=KeplerNet.define_model( input_shape=(4,), hidden_layers=[16], activation_function='relu', output_activation_function='softmax', num_output_classes=CV_targets_train.max()+1) ############################################################################### ## Define training parameters ############################################################################### training_params={ 'learning_rate':5e-4, 'batch_size':16, 'num_epochs':10000, 'early_stopping_patience':10} ############################################################################### ## Train model ############################################################################### model.fit(X_train,y_train,**training_params) ############################################################################### ## Evaluate model performance on test set ############################################################################### test_acc=model.evaluate(X_test,y_test)[0] ############################################################################### ## Plot loss curves ############################################################################### train_val_losses=model.history['train_val_losses'] plt.plot(train_val_losses,label='train-val-loss') plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() plt.show() ############################################################################### ## Plot accuracy curves ############################################################################### train_val_accs=model.history['train_val_accs'] plt.plot(train_val_accs,label='train-val-acc') plt.xlabel('Epochs') plt.ylabel('Accuracy') plt.legend() plt.show() ############################################################################### ## Plot confusion matrix ############################################################################### y_pred=model.predict(X_test) confusion_matrix=model.confusion_matrix(y_test,y_pred) fig=plt.figure(figsize=(6,6)) ax=plt.gca() im=ax.imshow(confusion_matrix,cmap=plt.cm.Blues) ax.set_xticks(np.arange(confusion_matrix.shape[0])) ax.set_yticks(np.arange(confusion_matrix.shape[0])) ax.set_xticklabels(np.unique(CV_targets_true)) ax.set_yticklabels(np.unique(CV_targets_true)) ax.set_xlabel('True label') ax.set_ylabel('Predicted label') for i,j in itertools.product(range(confusion_matrix.shape[0]),range(confusion_matrix.shape[1])): ax.text(j,i,f'{confusion_matrix[i,j]}',horizontalalignment='center',color='white') fig.colorbar(im) plt.show() <|file_sep|># -*- coding: utf-8 -*- # Copyright (C) by Sascha Flennerhag # License: BSD-2-Clause from .model import KeplerNet __version__='0.6' __author__='Sascha Flennerhag' __email__='[email protected]' <|file_sep|># -*- coding: utf-8 -*- # Copyright (C) by Sascha Flennerhag # License: BSD-2-Clause import numpy as np def _to_tensor(x,dtype=None,**kwargs): return torch.tensor(x,dtype=dtype,**kwargs) def _to_numpy(x): return x.detach().cpu().numpy() def _to_device(x,dtype=None,**kwargs): return x.to(dtype=dtype