St. Albans City FC: Squad, Achievements & Stats in the Combined Counties League

Overview of St. Albans City Football Team

St. Albans City Football Club, based in Hertfordshire, England, competes in the National League South, which is part of the English football league system. Known for their passionate fanbase and strong community ties, the club plays at Clarence Park. The team is currently managed by Steve King, who joined in 2020.

Team History and Achievements

Founded in 1934, St. Albans City has a rich history marked by significant achievements. They won the Southern League Premier Division twice and have consistently been competitive in their league. Notable seasons include reaching the FA Trophy semi-finals multiple times, showcasing their potential to compete at higher levels.

Current Squad and Key Players

The current squad boasts several standout players who contribute significantly to the team’s performance:

• Danny Wright – Striker known for his goal-scoring ability.
• Tom Garner – Midfielder with excellent playmaking skills.
• Nathan Thompson – Defender renowned for his defensive prowess.

Team Playing Style and Tactics

St. Albans City typically employs a 4-3-3 formation, focusing on quick transitions and maintaining possession. Their strengths lie in their solid defense and effective counter-attacks. However, they occasionally struggle with consistency in front of goal.

Interesting Facts and Unique Traits

The team is affectionately nicknamed “The Saints” by their fans. Known for their vibrant fanbase, St. Albans City has a long-standing rivalry with nearby teams such as Hemel Hempstead Town. Traditions include pre-match fan gatherings that create an electric atmosphere at Clarence Park.

Lists & Rankings of Players and Performance Metrics

• ✅ Danny Wright – Top scorer with 15 goals this season.
• ❌ Nathan Thompson – Recently recovering from injury but crucial to defense.
• 🎰 Tom Garner – Key playmaker with 8 assists so far.
• 💡 Team Ranking – Currently 5th in the league standings.

Comparisons with Other Teams in the League or Division

Compared to other teams like Basingstoke Town or Welling United, St. Albans City often excels defensively while sometimes lacking offensive firepower. Their tactical discipline sets them apart from many competitors within the division.

Case Studies or Notable Matches

A breakthrough game was their FA Trophy match against Sutton United where they secured a memorable victory through strategic gameplay and resilience under pressure.

Tables Summarizing Team Stats and Recent Form

Tips & Recommendations for Analyzing the Team or Betting Insights 💡

• Analyze recent form trends; St. Albans often performs well against lower-ranked teams due to tactical discipline.
• Carefully review head-to-head records against upcoming opponents for betting insights.
• Maintain awareness of key player injuries that may affect team dynamics and outcomes.

Frequently Asked Questions about Betting on St. Albans City 🤔

What are some key factors to consider when betting on St. Albans City?

Evaluate recent form, head-to-head statistics against upcoming opponents, and any player injuries that could impact performance.

How does St. Albans City perform away from home?

The team generally maintains a strong defensive record but can sometimes struggle to score away from home due to less support from traveling fans compared to home games.

In which types of matches do they usually perform best?

The Saints often excel in cup competitions where knockout formats favor teams playing strategically rather than relying solely on possession-based tactics seen in league matches.

Potential Pros & Cons of Current Form or Performance ✅❌

• ✅ Strong defensive record leading to consistent clean sheets across recent matches ✅


• ❌ Inconsistency in converting chances into goals ❌


• ✅ Effective counter-attacks resulting in unexpected victories ✅


• ❌ Occasional lapses leading to conceding late goals ❌


• ✅ Positive momentum building up after consecutive wins ✅


• ❌ Struggles when facing top-tier teams within division ❌


• ✅ Strong community support boosting morale during challenging fixtures ✅ </lKibetKipchumba/COMPSCI_311/A1/A1PartC.m function A1PartC() %function A1PartC() takes no arguments %This function solves problem C using only basic functions %Read data from file load(‘A1data.mat’) %Create matrix X X = zeros(20000,size(dataSet(:,1))); for i=1:size(dataSet(:,1)) X(i,:) = [ones(20000), dataSet(20000*(i-1)+[1:end],:)]; end %X = [ones(size(X(:,1))); dataSet]; %X = reshape(X,[size(X(:,1)),20000]); %Create matrix Y Y = zeros(20000,size(dataSet(:,1))); for i=0:size(dataSet(:,1))-1 Y(:,i+1) = dataSet((i*20000+[1:end]),end); end Y=Y’; %Initialize alpha vector alpha = ones(size(Y)); %solve normal equation using QR factorization method RtQ=X’*X; QtY=X’*Y; QRfactor=qr(RtQ); alpha=QRfactor’QtY; endKibetKipchumba/COMPSCI_311<|file_sep Mick Kibet Kipchumba CS311 Machine Learning Assignment 4 ================================== Assignment Details: ——————- The assignment was divided into three parts: **Part A:** The first part required us to implement a neural network with two hidden layers using gradient descent. **Part B:** The second part required us to use Matlab's built-in backpropagation algorithm. **Part C:** The third part required us implement stochastic gradient descent algorithm. Implementation: ————— For parts **A** & **B**, I implemented my own neural network class called `MyNeuralNetwork`. This class implements methods for training neural networks using both gradient descent (**A**) as well as backpropagation (**B**). For part **C**, I implemented my own version of stochastic gradient descent algorithm called `myStochasticGradientDescent`. This function uses backpropagation algorithm. The implementation details are outlined below: ### Part A: In this section I implemented my own version of gradient descent algorithm. I created an instance of `MyNeuralNetwork` class called `gradDescentNN`. I then trained this network using my implementation of gradient descent algorithm. I used sigmoid activation function since it is differentiable everywhere. The training process took about one hour on my laptop. ### Part B: In this section I used Matlab's built-in backpropagation algorithm. I created an instance of `MyNeuralNetwork` called `backPropNN`. I then trained this network using Matlab's built-in backpropagation algorithm. The training process took about one minute on my laptop. ### Part C: In this section I implemented my own version of stochastic gradient descent algorithm. I used Matlab's built-in backpropagation algorithm inside `myStochasticGradientDescent` function. I created an instance of `MyNeuralNetwork` called `stochasticGradDescentNN`. The training process took about one hour on my laptop. Results: ——– I tested all three implementations on test data set provided by professor. Here are results obtained: ### Part A: Average error over test set after training NN using Gradient Descent Algorithm : 0.109900265776081 Confusion Matrix after training NN using Gradient Descent Algorithm : Actual/Predicted 0 ~0 ——————————— Actual ~0 | 1879 | 221 ——————————— Actual ~0 | 206 | 1694 ### Part B: Average error over test set after training NN using Back Propogation Algorithm : 0.0932846702704268 Confusion Matrix after training NN using Back Propogation Algorithm : Actual/Predicted 0 ~0 ——————————— Actual ~0 | 1927 | 173 ——————————— Actual ~0 | 178 | 1722 ### Part C: Average error over test set after training NN using My Implementation Of SGD Algorithm : 0.100408865566101 Confusion Matrix after training NN using My Implementation Of SGD Algorithm : Actual/Predicted 0 ~0 ——————————— Actual ~0 | 1916 | 184 ——————————— Actual ~0 | 188 | 1712 Conclusion: ———– Based on results above we can see that Matlab's built-in backpropagation algorithm outperformed both implementations made by me.KibetKipchumba/COMPSCI_311 len(output_dims): raise ValueError(‘Number of blocks must be less than number of output dimensions.’) if num_of_filters_per_block is None: num_of_filters_per_block=num_of_filters_per_block*np.ones(len(output_dims)-num_of_blocks,dtype=int) if num_of_convs_per_block is None: num_of_convs_per_block=num_of_convs_per_block*np.ones(len(output_dims)-num_of_blocks,dtype=int) if stride is None: stride=stride*np.ones(len(output_dims)-num_of_blocks,dtype=int) if padding is None: padding=padding*np.ones(len(output_dims)-num_of_blocks,dtype=int) block_list=[] for block_index in range(num_of_blocks): block_list.append(nn.Sequential( *[ [ ( nn.BatchNormConvTransposed( input_channel_num=input_dims[block_index+index*num_of_convs_per_block[block_index]], output_channel_num=num_of_filters_per_block[block_index] , filter_size=output_dims[block_index+index*num_of_convs_per_block[block_index]+stride[block_index]], stride=stride[block_index], padding=padding[block_index] ) ) ]+[ [ ( ( ( ( ( ( ( ( # # # # # # # # # nn.ReLU() ) ) ) ) ) ) ) ) ]*(num_of_convs_per_block[block_index]-int(index!=num_convs_in_lastblock))+ [ ( ( ( ( ( ( ( ( ( #(output_shape_calculation here) ((input_shape-(filter_shape-padding*top_down_padding+bias))//stride)+top_down_padding+bias ) ) ) ) ) ) ) ) ) ] ] ] )) last_input_dimension=input_dimensions[-num_blocks:] last_output_dimension=output_dimensions[-num_blocks:] last_num_filters=num_filters[-num_blocks:] last_num_convs=num_convs[-num_blocks:] last_stride=strides[-num_blocks:] last_padding=paddings[-num_blocks:] last_list=[] index_range=np.arange(last_num_convs).tolist() index_range.pop() index_range.insert(-last_num_convs,last_num_convs-1) for index,last_filter_number,last_filter_stride,last_filter_padding,last_filter_output_dimension,last_filter_input_dimension,last_last_filter_number,in zip(index_range,last_num_filters,last_stride,last_padding,last_output_dimension,last_input_dimension,index_range): last_list.append(nn.Sequential( [ ( ( ( ( ( ( ( ( ( ( ( #(output_shape_calculation here) ((last_filter_input_dimension-(last_filter_number-last_last_filter_number-last_filter_stride+last_filter_padding))//last_filter_stride)+last_filter_padding ) ) ) ) ) ) ) ) ) ), *[ [ ( ( ( ( ( ( ( # # # # # # # # # ReLU() ) ) ) ) ) ) ]*(index!=last_num_convs-1)+ [ [ ( ( #(output_shape_calculation here) ((last_output_dimension[index]-((last_output_dimension[index]-index)-(last_output_dimension[index]-index)-last_stride[index]+last_padding[index]))//last_stride[index])+last_padding[index] ) ) ] ] ] ]) )) return block_list+list(reversed(last_list)) def calc_output_shape(input_shape,bias,top_down_padding,stride,padding,num_elements_to_pad_after_each_element,filtersize): shape=((input_shape-filtersize+(padding)*top_down_padding+bias)//stride)+top_down_padding+bias shape+=np.zeros(num_elements_to_pad_after_each_element,dtype=int)*(filtersize-shape%(filtersize-num_elements_to_pad_after_each_element)) return shape def calc_input_shape(output_shape,bias,top_down_padding,stride,padding,filtersize,num_elements_to_pad_after_each_element): shape=((output_shape-bias-top_down_padding)*(stride))+filtersize-(padding)*top_down_padding-bias shape-=np.zeros(num_elements_to_pad_after_each_element,dtype=int)*(shape%(filtersize-num_elements_to_pad_after_each_element)) return shape def calc_topdownpadding(padding,filtersize,num_elements_to_pad_after_each_element): top_down_pading=np.ceil(filtersize/(filtersize-num_elements_to_pad_after_each_element))*padding-filtersize+paddingsize def calc_bottomuppadding(top_down_pading,filtersize,num_elements_to_pad_after_each_element): bottom_up_pading=filtersize-np.floor(filtersize/(filtersize-num_elements_to_pad_after_each_element))*(filtersize-num_elements_to_pad_after_each_element) class BatchNormConvTransposed(nn.Module): def __init__(self,input_channel_num,output_channel_num,*args,**kwargs): if ‘filter_size’ not in kwargs.keys(): raise ValueError(‘Must specify filter size.’) if ‘stride’ not in kwargs.keys(): raise ValueError(‘Must specify strides.’) super(BatchNormConvTransposed,self).__init__() self.filter_width=args[kwargs[‘filter_size’]] self.filter_height=args[self.filter_width] self.stride_width=args[self.stride][self.filter_width] self.stride_height=args[self.stride][self.filter_height] self.padding_width=args[self.padding][self.filter_width] self.padding_height=args[self.padding][self.filter_height] assert(isinstance(filter_width,int)) assert(isinstance(filter_height,int)) assert(isinstance(stride_width,int)) assert(isinstance(stride_height,int)) assert(isinstance(padding_width,int)) assert(isinstance(padding_height,int)) assert(filter_width > max(stride_width,padding_width)) assert(filter_height > max(stride_height,padding_height)) assert(filter_width % max(stride_width,padding_width) == max(stride_width,padding_width)%filter_width) assert(filter_height % max(stride_height,padding_height) == max(stride_height,padding_height)%filter_height) input_depths=list(range(input_channel_num))+list(range(output_channel_num)) input_depths=np.array(input_depths).reshape([input_channel_num+len(output_channel_num)]) input_depths+=np.zeros([max(filter_width,max(filter_height))],’int’) input_depths[:,max(filter_weight,max(filter_heigh))] += np.array(list(range(max(filter_weight,max(filter_heigh)))),dtype=’int’) input_depths[:,max(filter_weight,max(filter_heigh))+np.arange(max(paddding_weight,padding_heigh))] += np.tile(np.array(list(range(max(padding_weight,paddding_heigh))),dtype=’int’),max(paddding_weight,paddding_heigh))[::-order] input_depths[:,max(filter_weight,max(filter_heigh))+np.arange(max(paddding_weight,paddding_heigh))+np.arange(max(paddding_weight,paddding_heigh))] -= np.tile(np.array(list(range(max(padding_weight,paddding_heigh))),dtype=’int’),max(paddding_weight,paddding_heigh))[::order] input_depths[:,max(filter_weight,max(filter_heigh))+np.arange(max(paddding_weight,paddding_heigh))*stride_factor+np.arange(max(paddding_weight,stridde_factor*paddding_height))] += np.tile(np.array(list(range(max(stridde_factor*padddding_weigth,stridde_factor*paddindg_hight))),dtype=’int’),stridde_factor)[::-order] input_depths[:,max(filter_weigth,max(filer_hieght))+np.arange(max(padding_weigth,stridde_factor*paddindg_hight))*stridde_factor] -= np.tile(np.array(list(range(max(stridde_factor*paddindg_hight))),dtype=’int’),stridde_factor)[::order] def forward(self,x): def backward(self,x_grad): class BatchNormConv(nn.Module): def __init__(self,*args,**kwargs): pass if __name__==’__main__’: labels=[‘cat’,’dog’] num_classes=len(set([‘cat’,’dog’])) num_labels=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) input_dimensions=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) output_dimensions=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) strides=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) padding=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) filt_sizes=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) num_filers=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) num_strides=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) num_paddings=np.zeros((len(set([‘cat’,’dog’])))).astype(int)+len(set([‘cat’,’dog’])) model=torch.nn.Sequential(*model.initalizer()) test_x=torch.randn(size=batchsize,dimensions=initalized_model.dimensions) test_y=torch.randint(low=min(model.num_classes),high=max(model.num_classes),(size=batchsize,),dtype=torch.int64) test_y=model(test_x) criterion=cross_entropy_loss() lr_scheduler=scheduler(lr_initiation_value=.001, lr_decay_value=.99, lr_decay_interval=.05, lr_increase_interval=.02, lr_increase_value=.02, epoch_interval_check=True, batch_interval_check=False) lr_optimizer=torch.optim.SGD(params=model.parameters(),lr=lrate,solver_momentum=.9) training_loop(model=model, train_loader=train_loader, criterion=criterion, optimizer=solver_optimizer, scheduler=scheduler_object, epochs=num_epochs) evaluation_loop(model=model, eval_loader=test_loader)KibetKipchumba/COMPSCI_311<|file_sep