Introduction to AFC Challenge League Group A
The AFC Challenge League, now known as the AFC Solidarity Cup, remains a cornerstone for developing football nations in Asia. Group A has consistently been a battleground where emerging talents and strategic gameplay come to the forefront. As we gear up for tomorrow's matches, let's delve into the dynamics of this group and explore expert betting predictions that could shape your viewing experience.
Overview of Group A Teams
Group A comprises teams with diverse footballing cultures and histories. Each team brings its unique strengths and challenges to the pitch. Understanding these teams is crucial for making informed betting predictions.
Pakistan
Pakistan has shown resilience and tactical acumen in past tournaments. Their defense is robust, often relying on disciplined backline play to thwart opposition attacks.
Bahrain
Bahrain's team is known for its technical skills and fluid attacking play. Their midfielders are adept at controlling the tempo of the game, making them a formidable opponent.
Kyrgyzstan
Kyrgyzstan's squad is characterized by youthful energy and determination. Their players often surprise opponents with unexpected moves and relentless pressing.
Tajikistan
Tajikistan brings a mix of experience and raw talent to the field. Their strategy often revolves around quick counter-attacks, leveraging speed to catch opponents off guard.
Match Analysis: Pakistan vs Bahrain
This match promises to be a tactical battle between two evenly matched teams. Pakistan's defensive solidity will be tested against Bahrain's creative midfield play.
- Pakistan's Strategy: Focus on maintaining a compact defensive line while exploiting counter-attacking opportunities through pacey wingers.
- Bahrain's Approach: Utilize their technical midfielders to control possession and create openings through intricate passing sequences.
Betting Predictions
- Underdog Bet: Consider backing Pakistan to win or draw, given their strong defensive record.
- Fair Play Bonus: Bahrain might receive fair play points due to their disciplined approach on the field.
- Total Goals: Expect a low-scoring affair; an under bet on total goals could be lucrative.
Match Analysis: Kyrgyzstan vs Tajikistan
This encounter is expected to be high-energy with both teams eager to assert their dominance early in the tournament.
- Kyrgyzstan's Tactics: Leverage youthful exuberance with aggressive pressing and quick transitions from defense to attack.
- Tajikistan's Game Plan: Rely on experienced players to orchestrate counter-attacks, using speed as their primary weapon.
Betting Predictions
- Dynamism Bonus: Kyrgyzstan might score early due to their energetic start; consider an early goal bet.
- Comeback Potential: Tajikistan could turn the game around in the second half; look into half-time/full-time bets favoring them.
- Total Corners: With both teams likely adopting attacking strategies, an over bet on total corners could pay off.
Tactical Insights from Previous Matches
benjaminlees/analysis<|file_sep|>/analysis/plotting.py
import numpy as np
from matplotlib import pyplot as plt
def plot_histogram(data,
bins=10,
ax=None,
color='b',
alpha=0.5,
density=True,
**kwargs):
if ax is None:
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111)
# Get histogram data
hist_data = np.histogram(data=data,bins=bins,density=density)
# Plot histogram
return ax.bar(hist_data[1][:-1],hist_data[0],color=color,alpha=alpha,**kwargs)
def plot_scatter(x,y,
x_label=None,y_label=None,
x_lim=None,y_lim=None,
title=None,x_log=False,y_log=False,
marker='o',marker_size=10,color='b',alpha=0.5):
fig = plt.figure(figsize=(8,6))
# Create axes object
ax = fig.add_subplot(111)
# Plot data
ax.scatter(x=x,y=y,s=marker_size,c=color,alpha=alpha,zorder=10)
# Set labels & limits
if x_label is not None:
ax.set_xlabel(x_label,size='x-large')
if x_lim is not None:
ax.set_xlim(x_lim)
if x_log:
ax.set_xscale('log')
if isinstance(x_lim,(list,tuple)):
x_lim = [np.log10(i) for i in x_lim]
ax.set_xlim(x_lim)
if isinstance(x_label,str):
x_label += ' (log)'
ax.set_xlabel(x_label,size='x-large')
else:
if isinstance(x_lim,(list,tuple)):
x_min,x_max = x_lim
if not np.isfinite(x_min):
x_min = min(np.min(x),np.mean(x)-np.std(x))
if not np.isfinite(x_max):
x_max = max(np.max(x),np.mean(y)+np.std(y))
ax.set_xlim([x_min,x_max])
else:
xmin,xmax = np.min(np.min(x)),np.max(np.max(y))
if not np.isfinite(xmin):
xmin = min(np.min(np.min(y)),np.mean(y)-np.std(y))
if not np.isfinite(max):
xmax = max(np.max(np.max(y)),np.mean(y)+np.std(y))
xlims=[xmin,xmax]
xlims[np.argmin(abs((xlims-np.mean((xlims)))))] -= abs((xlims-np.mean((xlims))))*1.
xlims[np.argmax(abs((xlims-np.mean((xlims)))))] += abs((xlims-np.mean((xlims))))*1.
ax.set_xlim(tuple([i for i in xlims]))
#ax.locator_params(axis='x',nbins=4)
#ax.ticklabel_format(style='sci',axis='x',scilimits=(-4,-4))
#ax.get_xaxis().set_major_formatter(ScalarFormatter(useMathText=True))
#ax.get_xaxis().set_minor_formatter(ScalarFormatter(useMathText=True))
#print 'x range:',ax.get_xlim()
##print 'y range:',ax.get_ylim()
##print 'xtick range:',ax.get_xticks()
##print 'ytick range:',ax.get_yticks()
##print ''
##for tick in ax.xaxis.get_major_ticks():
##tick.label.set_fontsize('large')
##tick.label.set_rotation('vertical')
##tick.label.set_horizontalalignment('right')
##for tick in ax.yaxis.get_major_ticks():
##tick.label.set_fontsize('large')
##tick.label.set_rotation('vertical')
##tick.label.set_horizontalalignment('right')
# print '%d ticks' % len(ticklabels)
# print ticklabels
# print ''
# print '%d major ticks' % len(ax.xaxis.get_major_ticks())
# print [i.label.get_text() for i in ax.xaxis.get_major_ticks()]
# print ''
# print '%d minor ticks' % len(ax.xaxis.get_minor_ticks())
# print [i.label.get_text() for i in ax.xaxis.get_minor_ticks()]
# print ''
if y_label is not None:
ax.set_ylabel(y_label,size='x-large')
if y_lim is not None:
ylim=ax.set_ylim(y_lim)
if y_log:
y_log=ax.set_yscale('log')
if isinstance(ylim,(list,tuple)):
ylim=[np.log10(i) for i in ylim]
ylim=ax.set_ylim(ylim)
if isinstance(y_label,str):
y_label+=' (log)'
ylabel=ax.set_ylabel(ylabel,size='x-large')
else:
ymin=ymin=np.min(np.min(y))
ymax=max=np.max(np.max(y))
else:
ymin,ymax=ax.get_ylim()
ymin=np.nanmin([ymin,np.nanmin(y)])
ymax=np.nanmax([ymax,np.nanmax(y)])
dy=(ymax-ymin)*0.05
ymin-=dy
ymax+=dy
ylim=[ymin,ymax]
if title is not None:
ax.title(title,size="xx-large")
plt.tight_layout()
return fig<|file_sep|># -*- coding: utf-8 -*-
"""
Created on Mon Nov29
@author: Benjamin Lee ([email protected])
Purpose:
This script creates scatter plots of all parameter combinations that have been optimised.
It compares different optimisation methods by plotting them against each other.
"""
import numpy as np
import matplotlib.pyplot as plt
from analysis.load import load_results_from_file
methods=['grid','bayesian','random','random_grid']
method_labels={'grid':'Grid search','bayesian':'Bayesian optimisation','random':'Random search','random_grid':'Random grid search'}
optimisations=['cost','time']
optimisation_labels={'cost':'Cost','time':'Time'}
params=['m_a','c_a','m_b','c_b']
param_labels={'m_a':'a slope','c_a':'a intercept',
'm_b':'b slope',
'c_b':'b intercept'}
fig=plt.figure(figsize=(12,len(params)*4))
fig.suptitle("Optimisations",fontsize="xx-large")
nrows=len(params)*len(optimisations)
ncols=len(methods)
for row,param_index,param_name,param_title in enumerate(zip(params,param_labels.keys(),param_labels.values())):
for col,opt_index,opt_name,opt_title in enumerate(zip(optimisations,optimisation_labels.keys(),optimisation_labels.values())):
ax=plt.subplot(nrows,len(methods),(row*len(optimisations))+col+1)
for method_index,meth,meth_title in enumerate(zip(methods,method_labels.keys(),method_labels.values())):
results=load_results_from_file(param_name,opt_name,meth)
if results.shape[0]>1:
x=np.array(results['data'][param_name])
y=np.array(results['data'][opt_name])
ax.plot(x,y,'o',label=meth_title,alpha=.5)
ax.legend()
ax.grid(True)
ax.tick_params(axis="both",which="major",labelsize="large")
if param_index==0:
ax.title(opt_title+" "+meth_title)
if opt_index==0:
ax.ylabel("Cost")
else:
ax.ylabel("Time")
else:
if opt_index==0:
ax.xlabel(param_title+" ("+meth_title+")")
else:
pass
fig.tight_layout(rect=[0,.03,.98,.95])
plt.show()<|repo_name|>benjaminlees/analysis<|file_sep #!/usr/bin/env python
#
# Copyright (c) 2017 Benjamin Lee
#
# Permission is hereby granted, free of charge, to anyone
# obtaining a copy of this software and associated documentation
# files (the "Software"),to deal
# IN THE SOFTWARE WITHOUT RESTRICTION,
# including without limitation the rights
# TO USE,
# COpy,
# MODIFY,
# MERGE,
# PUBLISH,
# DISTRIBUTE,
# Sublicense,
and/or sell copies
ofthe Software,and/to permit persons TO WHOM THE SOFTWARE IS
FURNISHED TO DO SO.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM,DAMAGES OR OTHER LIABILITY WHETHER IN AN ACTION OF CONTRACT,TORT OR OTHERWISE ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
Created on Mon May16
@author: Benjamin Lee ([email protected])
Purpose:
This script loads results from saved files.
It then analyses these results by comparing optimisations made using different methods.
It can compare multiple parameters at once.
"""
import numpy as np
from scipy.stats import norm
from analysis.load import load_results_from_file
methods=['grid_search',
'bayesian_optimisation',
'random_search',
'regular_random_search']
method_names={'grid_search':"Grid Search",
'bayesian_optimisation':"Bayesian Optimisation",
'random_search':"Random Search",
'regular_random_search':"Regular Random Search"}
params=['m_a',
'c_a',
'm_b',
'c_b']
param_names={
'm_a':r'$a$ slope $m_{a}$',
'c_a':r'$a$ intercept $c_{a}$',
'm_b':r'$b$ slope $m_{b}$',
'c_b':r'$b$ intercept $c_{b}$'}
optimisations=['cost',
'time']
opt_names={
'cost':"Cost",
'time':"Time"}
def analyse_results(method,params_to_analyse,opt_to_analyse):
results=[]
for method_to_analyse in method:
method_results=[]
for param_to_analyse in params_to_analyse:
results_from_param=get_results_from_param(param_to_analyse,opt_to_analyse,method_to_analyse)
method_results.append(results_from_param)
results.append(method_results)
return results
def get_best_result(results):
best_result={}
for param,result_list in zip(params,result_lists):
best_result[param]={}
best_cost=float("inf")
best_time=float("inf")
for result_dict,result_type,result_value,params_values_dict,result_std_dev_dict,params_values_keys_dict,params_values_std_dev_dict,
in result_list:
if result_type=='cost':
if result_value# -*- coding: utf-8 -*-
"""
Created on Fri Oct30
@author: Benjamin Lee ([email protected])
Purpose:
This script creates scatter plots of all parameter combinations that have been optimised.
It compares different parameter combinations by plotting them against each other.
"""
import numpy as np
import matplotlib.pyplot as plt
from analysis.load import load_single_result_from_file,get_number_of_iterations_of_run,get_number_of_variables_of_run,get_number_of_dimensions_of_run,get_number_of_parameters_of_run,get_variable_names_of_run,get_dimension_names_of_run,get_parameter_names_of_run,get_iteration_times_of_run,get_iteration_costs_of_run,get_iteration_points_of_run,get_iteration_point_costs_of_run,get_iteration_point_times_of_run,
get_best_point_costs_by_iteration,get_best_point_times_by_iteration,
get_best_point_times_by_variable_by_dimension_by_iteration,
get_best_point_costs_by_variable_by_dimension_by_iteration,
get_best_point_times_by_variable_by_dimension,
get_best_point_costs_by_variable_by_dimension,
get_average_times_per_iteration_per_variable_per_dimension,
get_average_costs_per_iteration_per_variable_per_dimension,
get_average_times_per_variable_per_dimension,
get_average_costs_per_variable_per_dimension,
get_minimum_times_per_variable_per_dimension,
get_minimum_costs_per_variable_per_dimension,
get_maximum_times_per_variable_per_dimension,
get_maximum_costs_per_variable_per_dimension
methods=['grid',
'bayesian',
'regular random',
'different regular random']
iteration_nums=[]
variable_nums=[]
dimension_nums=[]
parameter_nums=[]
variables=[]
dimensions=[]
parameters=[]
iterations=[]
iteration_times=[]
iteration_costs=[]
iteration_points=[]
iteration_point_costs=[]
iteration_point_times=[]
best_point_costs_by_iteration=[]
best_point_times_by_iteration=[]
best_point_times_by_variable_by_dimension_by_iteration=[]
best_point_costs_by_variable_by_dimension_by_iteration=[]
average_times_per_iteration_per_variable_per_dimension=[]
average_costs_per_iteration_per_variable_per_dimension=[]
minimum_times_per_variable_per_dimension=[]
minimum_costs_per_variable_per_dimension[]
maximum_times_pervariable_pervariableperdimension[]=
maximum_costs_pervariable_pervariableperdimension[]=
variable_names={}
dimension_names={}
parameter_names={}
fig=plt.figure(figsize=(12,len(variable_nums)*len(dimension_nums)))
fig.suptitle("Iterations",fontsize="xx-large")
nrows=len(variable_nums)*len(dimension_nums)
ncols=len(iteration_nums)
for row,var_num,var_name,var_num_tuple,var_num_list,var_num_tuple_str,var_num_tuple_str_lol,var_var_idx,var_dim_idx,dim_num,dim_num_tuple,dim_num_list,dim_num_tuple_str,dim_num_tuple_str_lol,dim_idx,param_idx,param_idx_lol,param_idx_lol_lol,param_idx_lol_lol_lol,in zip(variable_nums,
variable_names,
variables,
enumerate(variable_nums),
map(tuple,[var_num_list]),map(str,[var_num_tuple_str]),map(list,[var_num_tuple_str_lol]),enumerate(range(len(variable_dims[var_var_idx]))),range(len(dimensions)),enumerate(dimensions),
enumerate(dim_nums),
map(tuple,[dim_num_list]),map(str,[dim_num_tuple_str]),map(list,[dim_num_tuple_str_lol]),enumerate(range(len(parameters))),
zip(*[[i]*len(parameters)fori,inrange(len(variable_dims[var_var_idx]))]),
zip(*[[j]*len(parameters)forj,inrange(len(dimensions[dim_dim_idx]))]),
zip(*[[k]*len(parameters)[k]*len(parameters)[k]*len(parameters)[k]
for k,inrange(len(iterations))]):
var_dim_vars_dims_len=len(var_dim_vars_dims)=var_dim_vars_dims_len*dim_dims_len*=var_dims_len*=dims_len*
var_dim_vars_idxs_idxs_idxs=lis[tuples(map(lambda t,i:i*tuple([var_var_idx]+dim_dim_idxs+tup),product(range(var_dims_len),repeat=len(tup))))
vars_idxs_tuples=tuples(map(lambda t,i:i*tuple([var_var_idx]+dim_dim_idxs+tup),product(range(var_dims_len),repeat=len(tup))))
vars_idxs_tuples_flat=tuples(map(lambda t,i:i*tuple([var_var_idx]+dim_dim_idxs+tup),product(range(var_dims_len),repeat=len(tup))))
vars_idxs_flat=tuples(map(lambda t,i:i*tuple([var_var_idx]+dim_dim_idxs+tup),product(range(var_dims_len),repeat=len(tup))))
vars_flat=tuples(map(lambda t,i:i*tuple([var_var_idx]+dim_dim_idxs+tup),product(range(var_dims_len),repeat=len(tup))))
vars_flat_flattened=tuples(map(lambda t,i:i*tuple([var_var_idx]+dim_dim_idxs+tup).flatten(),
product(range(var_dims_len),repeat=len(tup))))
vars_flat_flattened_unflattened=tuples(map(lambda t,i:i*(tuple([var_var_idx]+dim_dim_idxs+tup).flatten()).flatten(),
product(range(var_dims_len),repeat=len(tup))))
vars_flat_unflattened=tuples(map(lambda t,i:i*(tuple([var_var_idx]+dim_dim_idxs+tup)).flatten(),
product(range(var_dims_len),repeat=len(tap)))):
plt.subplot(nrows,len(iteration_nums),(row*len(iteration_nums))+col+1)
plt.title("%d-%d"%(var_idex+1,dim_idex+1))
plt.xlabel("Iteration")
plt.ylabel("Value")
plt.grid(True)
plt.plot(iteration_numbers,
values,
linestyle='-',
marker='+',
markersize=5,
color=color,
alpha=.5)
plt.legend(loc='upper right')
plt.tight_layout()
plt.show()
fig=plt.figure(figsize=(12,len(variable_nums)*len(dimension_nums)))
fig.suptitle("Iterations",fontsize="xx-large")
nrows=len(variable_nums)*len(dimension_nums)
ncols=sum(numberofpointsperrun)
colors=['blue']*numberofpointsperrun+'red'
variable_colors=[colors.pop(colors.index(color))*numberofpointsperrun[color]
color_cycle=cycler(colorvariable_colors)
iterator_cycle=cycler(iterator_color_cycle)
iterable_product_cycles=cycle(iterator_cycle,color_cycle)
iterator_color_cycle=list(itertools.cycle(color_cycle))
axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplots_axes_subplotaxes_subplotaxes_subplotaxes_subplotaxes_subplotaxes_subplotaxes_subplotaxes_subplotaxes_subplotaxes_subplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplotsubplot
iterator_color_cycles=list(itertools.cycle(iterator_color_cycles))
iterator_color_cycles=list(itertools.cycle(iterator_color_cycles))
iterator_color_cycles=list(itertools.cycle(iterator_color_cycles))
iterator_color_cycles=list(itertools.cycle(iterator_color_cycles))
iterator_color_cycles=list(itertools.cycle(iterator_color_cycles))
iterator_color_cycles=list(itertools.cycle(iterator_color_cycles))
iterator_color_cycles=list(itertools.cycle(iterator_cycyles))
iterator_cycyles=cycle(cycles)
cycles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
iterable_product_cycyles=cycle(cycles)
variables=[
]
dimensions=[
]
iterations=[
]
iteration_numbers=[
]
iteration_points=[
]
iteration_point_numbers=[
]
point_numbers=[
]
point_variables=[
]
point_dimensions=[
]
point_iterations=[
]
point_iterations[
]=[]
point_points[
]=[]
points=
point_numbers[
]
points=
point_variables[
]
points=
point_dimensions[
]
points=
point_iterations[
]
points=
point_points[
]
colours=
colors.pop(colors.index(color))*numberofpointsperrun[color]
colours=
colors.pop(colors.index(color))*numberofpointsperrun[color]
colours=
colors.pop(colors.index(color))*numberofpointsperrun[color]
colours=
colors.pop(colors.index(color))*numberofpointsperrun[color]
coloursssssssss=
coloursss=
colourss=
coloursssssssss=
coloursssss=
coloursssss=
coloursss=
coloursssssssss=
colours =
colours =
colours =
colours =
colours =
colours =
colours =
colours =
colorcycles=
colorcycles.pop(colourscolorcycles.color)*numberofpointsperrun[color]
colorcycles=
colorcycles.pop(colourscolorcycles.color)*numberofpointsperrun[color]
colorcycles=
colorcycles.pop(colourscolorcycles.color)*numberofpointsperrun[color]
colorcycle =
icolorcycle =
icolorcycle =
icolorcycle =
icolorcycle =
icolorcycle =
icolorcycle =
icolorcycle =
icolorcycle =
colorcyccles=six.cycler(
color=colorcycless)
icolorcyccles=six.cycler(
icolorcyccles=colorcyccles)
icolorcyccles=six.cycler(
icolorcyccles=colorcyccles)
icorlorcyccles=six.cycler(
icorlorcyccles=colorcyccles)
icorlorcyccles=six.cycler(
icorlorcyccles=colorcyccles)
icorlorcyccles=six.cycler(
icorlorcyccles=colorcyccles)
icorlorcyccles=six.cycler(
icorlorcyccles=colorcyccles)
icorlorcyccless=six.cycler(
icorlorcycccless=colorcycless)
icorlorcyclcess=six.cycler(
icorlorcyclcess=colorcyclcess)
interable_products_interables_interables_interables_interables_interables_interables_interables_interables_interables_intreble_products_intreble_products_intreble_products_intreble_products_intreble_products_intreble_products_intreble_products_intreble_products=inteble_product(inteble_prodcut(icolorcylce,colorcycle))
interable_prodcuts=inteble_prodcut(inteble_prodcut(icolorcylce,colorcycle))
interable_prodcuts=inteble_prodcut(inteble_prodcut(icolorcylce,colorcycle))
interable_prodcuts=inteble_prodcut(inteble_prodcut(icolorcylce,colorcycle))
interable_prodcuts=inteble_prodcut(inteble_prodcut(icolorcylce,colorcycle))
interable_prodcuts=inteble_prodcut(inteble_prodcut(icolorcylce,colorcycle))
interalebles=inteleblales(inteleblale(inteleblale(icorelcyclce,coloreclcle)))
interebles=interebles(interebles(interebles(icorelcyclce,coloreclcle)))
interebles=interebles(interebles(interebles(icorelcyclce,coloreclcle)))
interebles=interebles(interebles(interebles(icorelcyclce,coloreclcle)))
interebledoesntwork=interebledoesntwork(interebledoesntwork(interebledoesntwork(icorelcyclce,coloreclcle)))
inteeleblales_doesnt_work=inteeleblales_doesnt_work(inteeleblales_doesnt_work(inteeleblales_doesnt_work(icorelcyclce,coloreclcle)))
num_rows=num_rows*num_cols=num_rows*num_cols*num_rows*num_cols=num_rows*num_cols*num_rows*num_cols=num_rows*num_cols*num_rows*num_cols=num_rows*num_cols*num_rows*num_cols=num_rows*num_cols=num_rows=num_row=row=row+row+row+row+row+row+row+row+row=row=row=row=row=row=row=row=row=row+=num_row_col
num_columns=sum(numberoffunctionsperrun)
num_columns=sum(num_columns,num_columns,num_columns,num_columns,num_columns,num_columns,num_columns,num_columns,num_column)+num_column
num_coloumnsum=sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(numberoffunctionsperrun)+sum(num_coloumnsum,numberoffunctionsperrun)
num_coloumn_sum=sum(num_coloumn_sum,numberoffunctionsperrun,sum(num_coloumn_sum,numberoffunctionsperrun,sum(num_coloumn_sum,numberoffunctionsperrun,sum(num_coloumn_sum,numberoffunctionsperrun,sum(num_coloumn_sum,numberoffunctionsperrun,sum(num_coloumn_sum,numberoffuncitonsoffuncitonsoffuncitonsoffuncitonsoffuncitonsoffuncitonsoffunctioonsoffunctionsonfunctionsonfunctionsonfunctionsonfunctionsonfunctionsonfunctionsonfunctionsof))+num_column)
num_row=sum(row,row,row,row,row,row,row,row)=num_row(row)=num_row(row)=num_row(row)=num_row(row)=num_row(row)=num_row(row)=num_row(row)=row+=row
fig=plt.figuure(figsize=(12,num_column*8))
fig.suptitle("Variables",fontsize="xx-large")
nrows=sum(num_variables)
ncols=sum(num_functions)
cols_iterator_itertors_iterator_itertors_iterator_itertors_iterator_itertors_iterator_itertors_iterator_itertors_iterator_itertors_iterator_itertors_iterator_itertors_=itertools.product(columns,column,column,column,column,column,column,column,column,column,column,column_=_=_=_=_=_=_=_=_=_=_=_=_=#_=#_=#_=#_=#_=#_=#_=cols_iterator_=cols_i_=cols_i_=cols_i_=cols_i_=cols_i_=cols_i_=cols_i_=cols_i_=cols_i_=
