W35 Trieste stats & predictions

Potrete seguire tutte le emozioni del torneo direttamente dal vivo o tramite piattaforme online dedicate. Ecco alcune opzioni disponibili per non perdervi nemmeno un punto delle partite domani a Trieste:

Nel Campo o Suggerimenti dal Vivo

• Ingresso Libero: Le prime due file dei posti a sedere sono generalmente riservate agli ospiti speciali o agli sponsor del torneo ma spesso rimangono libere fino all'inizio dell’evento.
  
• Pacchetti VIP: Se desiderate vivere l’atmosfera del torneo in prima persona con privilegi extra come accesso prioritario agli spogliatoi o postazioni esclusive, considerate l’acquisto di pacchetti VIP disponibili sul sito ufficiale del torneo.
  
• Balconcini Panoramici: I balconcini offrono una vista eccellente su tutto il campo consentendovi godervi lo spettacolo da una prospettiva privilegiata.
  DanteMansfield/harvardml2017<|file_sep|>/lab2/lab2.py from __future__ import print_function import numpy as np import pandas as pd from sklearn.linear_model import LogisticRegression from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score np.random.seed(42) def sigmoid(x): return np.exp(x) / (1 + np.exp(x)) def load_dataset(): # Load data from csv data = pd.read_csv('dataset.csv') X = data.iloc[:, :-1].values y = data.iloc[:, -1].values # Split into train and test sets X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) return X_train.astype(np.float), X_test.astype(np.float), y_train.astype(np.float), y_test.astype(np.float) def predict(features): """ Return the predicted values for the given features. Args: features: A numpy array of features. Returns: A numpy array of the predicted values. """ # Initialize weights and bias w = np.zeros(features.shape[1]) b = np.zeros(1) # Get predictions from sigmoid function predictions = sigmoid(np.dot(features,w)+b) # Convert to binary values (0 or 1) predictions[predictions >= .5] = 1 predictions[predictions< .5] = 0 return predictions def train(X_train,y_train,X_test,y_test): """ Train the logistic regression model. Args: X_train: Training features. y_train: Training labels. X_test: Test features. y_test: Test labels. """ # Initialize weights and bias w = np.zeros(X_train.shape[1]) b = np.zeros(1) # Set learning rate and number of epochs learning_rate = .01 n_epochs = int(100000) # Train the model for epoch in range(n_epochs): # Get predictions from sigmoid function prediction = sigmoid(np.dot(X_train,w)+b) # Compute gradient descent for weights and bias w_gradient_descent = (-1/X_train.shape[0])*np.dot(X_train.T,(y_train-prediction)) b_gradient_descent = (-1/X_train.shape[0])*np.sum(y_train-prediction) # Update weights and bias with new gradients w -= learning_rate*w_gradient_descent b -= learning_rate*b_gradient_descent if epoch%10000==0: print("Epoch:", epoch) X_test_prediction = predict(X_test) print("Accuracy:", accuracy_score(y_test,X_test_prediction)) if __name__ == '__main__': X_train,y_train,X_test,y_test = load_dataset() print("Training...") print("X_train shape:", X_train.shape) print("y_train shape:", y_train.shape) print("X_test shape:", X_test.shape) print("y_test shape:", y_test.shape) print("") print("Predicting...") y_pred = predict(X_test) print("Accuracy:", accuracy_score(y_test,y_pred)) print("") print("Training and Predicting...") train(X_train,y_train,X_test,y_test)<|repo_name|>DanteMansfield/harvardml2017<|file_sep|>/lab6/lab6.py import numpy as np np.random.seed(42) def get_activations(weights,bias,input_data): input_data=input_data.reshape((input_data.shape[0],input_data.shape[1],1)) features=input_data[:,0,:] labels=input_data[:,1,:] z=np.dot(weights.T,input_data)+bias output=np.tanh(z) return output,z def compute_cost(output,z,output_layer,input_data): m=output.shape[0] error=output-layer.reshape((m,output_layer.shape[0],1)) cost=error**2/2*m+np.sum(np.abs(weights))/2*m+np.sum(np.abs(bias))/2*m return cost def compute_gradients(weights,bias,output_layer,z,input_data,error): m=output_layer.shape[0] dz=doutput*derivative_tanh(z) dweights=np.dot(input_data,error.T)/m+np.sign(weights)/m dbias=np.sum(error,axis=0)/m+np.sign(bias)/m return dweights.T,dz def update_parameters(weights,bias,dweights,dz,dlearning_rate): return weights-dlearning_rate*dweights,bias-dlearning_rate*dz def initialize_weights(input_dim,output_dim): return np.random.randn(input_dim,output_dim),np.zeros((output_dim)) def derivative_tanh(z): return (np.cosh(z))**-2 if __name__ == '__main__': input_dim,output_dim=2,1 n_epochs=10000 input_data=np.array([[5.,5.,1],[5.,6.,0],[6.,5.,1],[6.,6.,0]]) output_layer=input_data[:,1].reshape((output_layer.shape[0],output_layer.shape[1],1)) dlearning_rate=.01 weights,bias=initialize_weights(input_dim,output_dim) for epoch in range(n_epochs): output,z=get_activations(weights,bias,input_data) error=output-layer.reshape((m,output_layer.shape[0],1)) cost=compute_cost(output,z,output_layer,input_data) dweights,dz=compute_gradients(weights,bias,output_layer,z,input_data,error) if epoch%1000==0: print(epoch,cost) new_weights,new_bias=update_parameters(weights,bias,dweights,dz,dlearning_rate) print(new_weights,new_bias)<|repo_name|>DanteMansfield/harvardml2017<|file_sep|>/lab5/lab5.py import numpy as np np.random.seed(42) def sigmoid(x): return np.exp(x) / (1 + np.exp(x)) def load_dataset(): data=np.loadtxt('dataset.csv',delimiter=',') X=data[:,:-1] y=data[:,-1] return X.astype(np.float),y.astype(np.float) def compute_cost(w,X,y,b): m=X.shape[0] h=sigmoid(np.dot(X,w)+b) cost=-np.sum(y*np.log(h)+(1-y)*np.log(1-h))/m return cost def compute_gradients(w,X,y,b): m=X.shape[0] h=sigmoid(np.dot(X,w)+b) dw=(np.dot(h-y,X.T))/m db=np.sum(h-y)/m return dw.T,db def update_parameters(w,b,dw,dz,dlearning_rate): return w-dlearning_rate*dw,b-dlearning_rate*dz if __name__ == '__main__': X