Landesliga Tirol stats & predictions

Ressources Supplémentaires pour les Fans du Football Tirolais

• Calendrier des Matchs: Consultez les dates et horaires des prochains matchs dans la Landesliga Tirol!
• Résultats en Direct: Restez à jour avec les scores en temps réel et les mises à jour des matchs!
• Forums Communautaires: Participez aux discussions avec d'autres fans et partagez vos prédictions!
• Articles d'Analyses Approfondies: Découvrez des analyses détaillées des performances des équipes et des joueurs!
• Podcasts sur le Football Tirolais: Écoutez les experts discuter des dernières nouvelles et tendances!
• Calendrier des Transferts: Restez informé sur les mouvements récents au sein des clubs!
• Vidéos d'Highlights: Revivez les moments forts et les buts incroyables!
• Interviews Exclusives: Lisez les entretiens avec les entraîneurs et les joueurs!
• Statistiques Avancées: Explorez les données approfondies pour affiner vos prédictions d'apostes!
• Guides pour Débutants en Apôtres Sportifs: Obtenez des conseils pour débuter vos paris avec succès!
• Rétrospectives Historiques: Plongez dans l'histoire riche et passionnante de la Landesliga Tirol!
• Applications Mobiles Dédiées: Téléchargez nos apps pour ne jamais manquer une mise à jour ou un match en direct!XueLiangWang/CPM2<|file_sep|>/src/CPM2.py #!/usr/bin/env python import numpy as np from numpy import sqrt import scipy.linalg as sl import scipy.sparse.linalg as ssl import matplotlib.pyplot as plt from functools import partial from .utils import * class CPM2: """ CPM2 is an implementation of the CPM2 algorithm. Attributes: ndim (int): Dimensionality of the problem. nb (int): Number of basis functions. ntrain (int): Number of training points. nalpha (int): Number of alpha vectors in the solution. alpha (np.ndarray): Alpha vectors in the solution. QR (np.ndarray): QR decomposition of the training set. basis_norm (np.ndarray): Norms of basis functions in the training set. basis_evaluator (callable): Function that evaluates basis functions. dual_vars (np.ndarray): Dual variables in the solution. support_vectors (np.ndarray): Support vectors in the solution. Input arguments: basis_set (callable or list(callable)): List of functions or callable that returns basis function values when called with x. X_train (np.ndarray): Training set. y_train (np.ndarray): Target values for training set. nalpha0 (int): Initial number of alpha vectors. tol_factor (float): Tolerance factor used in computation. max_iter (int): Maximum number of iterations allowed in CPM2 algorithm. Raises: ValueError if dimensionality cannot be inferred from input arguments. ValueError if type of basis_set is not callable or list(callable). ValueError if shape of X_train is not [ntrain, ndim]. ValueError if shape of y_train is not [ntrain]. ValueError if nalpha0 is not positive integer. ValueError if tol_factor is not positive real number. ValueError if max_iter is not positive integer. Returns: None """ def __init__(self, basis_set, X_train, y_train, nalpha0=1, tol_factor=1e-12, max_iter=100): self.ndim = None self.nb = None self.ntrain = None self.nalpha = None self.alpha = None self.QR = None self.basis_norm = None self.basis_evaluator = None self.dual_vars = None self.support_vectors = None def _compute_tolerance(self): # Compute tolerance based on maximum norm among training points and norm of target values. return np.max(np.abs(self.y_train)) * self.tol_factor def _init_basis(self): # Initialize basis function evaluator based on type of basis_set input argument. if isinstance(self.basis_set, list): # If list was provided then we assume it contains callable objects. self.basis_evaluator = partial(evaluate_basis_list, basis_functions=self.basis_set) self.nb = len(self.basis_set) self.ndim = len(self.basis_set[0](np.zeros((1,self.ndim)))) elif callable(self.basis_set): # If single callable object was provided then we assume it returns all basis function evaluations. self.basis_evaluator = self.basis_set # Evaluate on zero vector to determine number of basis functions and dimensionality. self.ndim = len(self.X_train[0]) self.nb = len(self.basis_evaluator(np.zeros((1,self.ndim)))[0]) else: raise ValueError('Invalid type for argument "basis_set".') def _init_training_data(self): # Initialize training data attributes. self.ntrain = len(self.X_train) if len(self.X_train[0]) != self.ndim: raise ValueError('Shape of X_train must be [ntrain x ndim]') if len(self.y_train) != self.ntrain: raise ValueError('Shape of y_train must be [ntrain]') def _init_dual_vars(self): # Initialize dual variables and support vectors attributes. # Initialize dual variables array with zeros and support vectors array with empty array. self.dual_vars = np.zeros((self.nalpha,self.ntrain)) self.support_vectors = np.empty((0,self.ndim)) def _init_QR_decomposition(self): # Compute QR decomposition for matrix with basis function evaluations on training points. self.QR = sl.qr(evaluate_basis_list(X=self.X_train, basis_functions=self.basis_set), mode='economic') def _update_tolerance(self): # Update tolerance based on new norm among training points and norm of target values. new_tol = np.max(np.abs(self.y_train)) * self.tol_factor if new_tol > self.tol: self.tol = new_tol def _update_alpha_and_dual_vars(self): # Update alpha and dual variables based on current support vectors. # Construct design matrix with only support vectors. Phi_support_vectors = evaluate_basis_list(X=self.support_vectors, basis_functions=self.basis_set) # Solve least squares problem to update alpha values. soln,_ = ssl.lsmr(Phi_support_vectors.T @ Phi_support_vectors, Phi_support_vectors.T @ self.y_train) # Update alpha values. self.alpha[:self.nalpha_support,:] = soln.reshape(-1,self.nalpha_support) # Update dual variables based on new alpha values and support vectors. Q,R,Piv = sl.qr(Phi_support_vectors.T @ Phi_support_vectors, mode='economic') ytilde = Q.T @ Phi_support_vectors.T @ self.y_train # Solve least squares problem to get dual variables for support vectors only. soln,_ = ssl.lsmr(R,ytilde[:self.nalpha_support]) # Update dual variables based on solution to least squares problem. self.dual_vars[:self.nalpha_support,:] = sl.solve_triangular(R,soln).reshape(-1,self.nalpha_support)[:,Piv] def _update_support_vectors_and_nalpha_support(self): # Compute current residuals for each point in training set and update support vectors attribute based on residuals greater than tolerance. resids_current,_ = compute_resids(Phi=self.QR[0], y=self.y_train, alpha=self.alpha, tol=self.tol) nresids_large_current = np.sum(np.abs(resids_current) > self.tol) if nresids_large_current > self.nalpha_support: # Find indices corresponding to large residuals and use these indices to select corresponding points from training set to be added to support vector set. indices_large_resids_current = np.where(np.abs(resids_current) > self.tol)[0] new_points_to_add_to_SV_set=np.array([self.X_train[i] for i in indices_large_resids_current]) # Concatenate new points to existing support vector set to update attribute value for support vectors. self.support_vectors=np.concatenate((self.support_vectors,new_points_to_add_to_SV_set),axis=0) # Update value for nalpha_support based on current size of support vector set and number of basis functions.