Swit Skolwin (Szczecin): Top Performers & Stats in Polish League

Step-by-step Analysis Guide on Understanding Swit Skolwin (Szczecin)’s Tactics 🎚🎚🎚🎚🎚🎚🎚🎚🎚🎚🎚🎚🎚🎚)[0]: # Copyright 2020 Google LLC
[1]: #
[2]: # Licensed under the Apache License, Version 2.0 (the “License”);
[3]: # you may not use this file except in compliance with the License.
[4]: # You may obtain a copy of the License at
[5]: #
[6]: # http://www.apache.org/licenses/LICENSE-2.0
[7]: #
[8]: # Unless required by applicable law or agreed to in writing, software
[9]: # distributed under the License is distributed on an “AS IS” BASIS,
[10]: # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
[11]: # See the License for the specific language governing permissions and
[12]: # limitations under the License.

[13]: “””Tests `tf_agents.bandits.agents.ranking_agent.RankingAgent`.”””
[14]: import numpy as np
[15]: import tensorflow as tf
[16]: from tf_agents.bandits.agents import ranking_agent as ra
[17]: from tf_agents.bandits.environments import utils as bandit_py_environment_utils
[18]: from tf_agents.bandits.policies import utils as bandit_policy_utilities
[19]: from tf_agents.bandits.specs import utils as bandit_spec_utils
[20]: from tf_agents.specs import tensor_spec
[21]: from tf_agents.utils import common

[22]: class RankingAgentTest(tf.test.TestCase):

[23]: def _createRankingAgent(self,
[24]: observation_spec=None,
[25]: action_spec=None,
[26]: time_step_spec=None,
[27]: emit_policy_info=(‘probabilities’,),
[28]: actor_network=None,
[29]: value_network=None):
[30]: if actor_network is None:
[31]: actor_network = ra.ActorNetwork(
[32]: observation_spec=observation_spec,
[33]: action_spec=action_spec)

test_observations = {

‘observation’: np.array([

[1., 1.,],

[0., 0.,],

], dtype=np.float32)

}

test_actions = {

‘action’: np.array([

[0.,],

[1.,],

], dtype=np.int64)

}

batch_size = len(test_observations[‘observation’])

num_actions = len(test_actions[‘action’])

reward_shape = ()

reward_type = ‘real’

num_iterations = None

initial_collect_steps = None

train_step_counter = common.create_variable(‘train_step’)

global_step_counter = common.create_variable(‘global_step’)

eval_interval = None

summary_interval = None

debug_summaries = False

summarize_grads_and_vars = False

epsilon_greedy_base_action_selector_probabilities_fn=_epsilon_greedy_base_action_selector_probabilities_fn

_epsilon_greedy_base_action_selector_probabilities_fn={

lambda _:np.ones((batch_size,num_actions))/num_actions

}

if time_step_spec is None:
time_step_spec=bandit_py_environment_utils.convert_environment_to_tensor_specs(
bandit_py_environment_utils.BanditPyEnvironment(
observation_spec=observation_spec,
action_spec=action_spec))

return ra.RankingAgent(
time_step_spec=time_step_spec,
action_spec=action_spec,
actor_network=actor_network,
value_network=value_network,
emit_policy_info=emit_policy_info,
reward_type=reward_type,
num_iterations=num_iterations,
initial_collect_steps=initial_collect_steps,
train_step_counter=train_step_counter,
global_step_counter=global_step_counter,
eval_interval=eval_interval,
summary_interval=summary_interval,
debug_summaries=debug_summaries,
summarize_grads_and_vars=summarize_grads_and_vars)

def testCreateAgentWithDefaultParams(self):
agent=self._createRankingAgent()
self.assertEqual(agent.reward_type,’real’)
self.assertEqual(agent.num_iterations,None)
self.assertEqual(agent.initial_collect_steps,None)

def testCreateAgentWithCustomParams(self):
agent=self._createRankingAgent(
reward_type=tf.dtypes.string(),
num_iterations=tf.constant(100),
initial_collect_steps=tf.constant(100))
self.assertEqual(agent.reward_type,’string’)
self.assertEqual(agent.num_iterations.numpy(),100)
self.assertEqual(agent.initial_collect_steps.numpy(),100)

def testCreateActorNetwork(self):

observation_dim=int(np.prod(bandit_policy_utilities.get_dimensions(observation_tensor)))

action_dim=int(np.prod(bandit_policy_utilities.get_dimensions(action_tensor)))

embedding_dim=int(np.prod(bandit_policy_utilities.get_dimensions(embedding_tensor)))

network_output_specs={

’embedding’:tensor_spec.TensorSpec(shape=(embedding_dim,),dtype=tf.float32),

‘score’:tensor_spec.TensorSpec(shape=(action_dim,),dtype=tf.float32),

tensor_batch_size=batch_size

batch_size

tensor_observation_batch_shape=batch_shape+batch_size.shape.as_list()

tensor_observation_batch_shape=tuple(tensor_observation_batch_shape)

batch_shape=[]

batch_size=batch_size.shape.as_list()

tensor_action_batch_shape=batch_shape+batch_size.shape.as_list()

batch_shape=[None]

batch_size=batch_size.shape.as_list()

tensor_action_batch_shape=batch_shape+batch_size.shape.as_list()

batch_shape=[None]

batch_size=batch_size.shape.as_list()

tensor_embedding_batch_shape=batch_shape+batch_size.shape.as_list()

batch_shape=[None]

embedding_dim=[None]

tensor_embedding_value_specs=tensor_util.make_tensor_proto(embedding_dim,dtype=tf.int64).shape.as_list()+[None]

batch_shape=[None]

embedding_dim=[]

tensor_embedding_value_specs=tensor_util.make_tensor_proto(embedding_dim,dtype=tf.int64).shape.as_list()+[None]

}

embedding_net=_DummyNetwork(output_tensor_name_prefixes=[’embedding’])

score_net=_DummyNetwork(output_tensor_name_prefixes=[‘score’])

actor_net_ra.ActorNetwork(
observation_tensor_name_or_tuple=(‘observation’,),
action_tensor_name_or_tuple=(‘action’,),
embedding_net=embedding_net,score_net=score_net,network_output_specs=network_output_specs)

observation_dims={‘observation’:[5]}

action_dims={‘action’:[5]}

network_output_specs={

’embedding’:tensor_util.make_ndarray(tf.make_tensor_proto([5],dtype=tf.int64)),

‘score’:tensor_util.make_ndarray(tf.make_tensor_proto([5],dtype=tf.int64)),

}

actor_net_ra.ActorNetwork(
observation_dims=observation_dims , action_dims=action_dims , network_output_specs=network_output_specs)

def testActorNetworkOutputsEmbeddingsAndScores(self):

#
#
#
#

def _epsilon_greedy_base_action_selector_probabilities_fn(_):

return np.ones((batch_size,num_actions))/num_actions

class _DummyNetwork(object):

def __init__(self,output_tensor_name_prefixes):

output_tensors_names=output_tensor_name_prefixes[:]
for output_tensors_names_i,output_tensors_names_j,_output_tensors_names_k,_output_tensors_names_l,_output_tensors_names_m,_output_tensors_names_n,_output_tensors_names_o,_output_tensors_names_p,_output_tensors_names_q,_output_tensors_names_r,_output_tensors_names_s,output_tensors_names_t,output_tensors_names_u,output_tensors_names_v,output_tensors_names_w,output_tensors_names_x,_output_tensors_y,_output_z,__o_z,__o_aa,__o_ab,__o_ac,__o_ad,__o_ae,__o_af,**kwargs:
self.output_tensros_namess=output_tensros_namess[:]

def call(self,input_data,*args,**kwargs):
input_data=input_data.copy()
for output_tensros_namess_i,input_data_j,input_data_k,input_data_l,input_data_m,input_data_n,input_data_o,input_data_p,input_data_q,input_data_r,input_data_s,input_data_t,inpuut_datas_u,inpuut_datas_v,inpuut_datas_w,inpuut_datas_x,inpuut_datas_y,inpuut_datas_z,inpuut_datas_aa,inpuut_datas_ab,inpuut_datas_ac,inpuut_datas_ad,inpuut_datas_ae,inpuut_dats_af,**kwargs:
input_dats=input_dats.copy()

for input_dat_i,output_tensros_namess_j,outpus_tensros_namess_k,outpus_tensros_namess_l,outpus_tensros_namess_m,outpus_tensros_namess_n,outpus_tensros_namess_o,outpus_tensros_namess_p,outpus_tensros_namess_q,outpus_tensros_namess_r,outpus_tensros_namess_s,outpus_tensros_namess_t,outpus_tensros_namess_u,outpus_tensros_namess_v,outpus_tensros_namess_w,outpus_tensroos_nmss_x,outputs_tenors_nmss_y,outputstensorsnmss_z,outputstensorsnmss_aa,outputstensorsnmss_ab,outputstensorsnmss_ac,outputstensorsnmss_ad,outputstensorsnmss_ae,**kwargs:
outptus=input_dat_i[self.outputtensorsnames_j]

input_dat_i.update(outptus)

return input_dat_i

if __name__==’__main__’:
tf.test.main()

***** Tag Data *****
ID: 5
description: Definition of `_DummyNetwork` class which simulates a neural network.
start line: 107
end line: 125
dependencies:
– type: Class
name: _DummyNetwork
start line: 107
end line: 125
context description: This class mimics neural network behavior without performing actual
computations.
algorithmic depth: 4
algorithmic depth external: N
obscurity: 5
advanced coding concepts: 4
interesting for students: 5
self contained: Y

************
## Challenging aspects

### Challenging aspects in above code:

1. **Complex Argument Handling**: The `call` method handles an extensive list of parameters using `*args` and `**kwargs`, which introduces complexity around managing these arguments correctly.

2. **Deep Copy Usage**: The code uses deep copies (`copy()` method) extensively within loops which could lead to performance issues if not handled properly.

3. **Nested Loop Logic**: There are multiple nested loops iterating over lists derived from `self.outputtensorsnames`. Understanding how each loop interacts with others adds significant complexity.

4. **Dynamic Dictionary Updates**: Inside nested loops, dictionaries (`input_dats`) are updated dynamically based on keys derived from list indices (`self.outputtensorsnames`). This requires careful handling of dictionary operations.

### Extension:

To make it more challenging:

1. **Introduce Conditional Logic**: Add conditions inside nested loops that change behavior based on certain criteria related to input data properties.

2. **Error Handling**: Implement robust error handling mechanisms inside deeply nested structures.

3. **Parallel Processing**: Extend functionality so that parts of processing can be done concurrently while ensuring thread safety specifically within nested structures.

4. **Dynamic Input/Output Management**: Allow dynamic addition/removal/modification of input/output tensors during execution.

## Exercise

### Task Description:

You are provided with a simplified neural network mock class called `_DummyNetwork`. Your task is twofold:

#### Part A:
Expand this class functionality by implementing conditional logic inside nested loops such that:

1. If any element within `input_dats` contains negative values after being copied initially (`input_dats.copy()`), log these values along with their keys before updating `input_dat_i`.
2. Introduce error handling such that any key-value pair causing an exception during update should be logged without stopping execution.
3. Ensure no duplicate keys exist within any dictionary after updates inside nested loops.

#### Part B:
Enhance `_DummyNetwork` further by adding parallel processing capabilities:

1. Use Python’s threading module such that different parts of dictionary updates run concurrently while maintaining thread safety.
2. Ensure all threads complete before returning `input_dats`.

### Requirements:

* Implement robust logging mechanism using Python’s built-in logging module.
* Use appropriate exception handling techniques.
* Ensure thread safety using synchronization primitives where necessary.

Referencing snippet `[SNIPPET]`.

## Solution

python

import threading
import logging

logging.basicConfig(level=logging.INFO)

class _DummyNetwork(object):
def __init__(self, output_tensor_name_prefixes):
output_tensors_names = output_tensor_name_prefixes[:]
self.outputtensorsnames = output_tensors_names[:]

def call(self, input_data,*args,**kwargs):
input_dats=input_data.copy()

lock = threading.Lock()

def process_dict(input_dat_i):
try:
if any(value < 0 for value in input_dat_i.values()):
logging.info(f"Negative values found before update {[(k,v) for k,v in input_dat_i.items() if v<0]}")

temp_update_dict = {}
try:
for outputtensorsnames_i in range(len(self.outputtensorsnames)):
outptus=input_dat_i[self.outputtensorsnames][outputtensorsnames_i]
temp_update_dict.update(outptus)

# Check duplicates after updates attempt before applying changes atomically.
if len(temp_update_dict) != len(set(temp_update_dict.keys())):
raise ValueError("Duplicate keys detected!")
else:
lock.acquire()
try:
input_dat_i.update(temp_update_dict)
finally:
lock.release()

except Exception as e:
logging.error(f"Exception occurred while updating dictionary {e}")

except Exception as e_outermost:
logging.error(f"Exception occurred outside inner try block {e_outermost}")

threads=[]
try:
threads.append(threading.Thread(target=lambda : process_dict(input_dats)))
threads.append(threading.Thread(target=lambda : process_dict(input_dats)))

[thread.start() for thread in threads]

[thread.join() for thread in threads]

except Exception as e_outermost_thread_handling:
logging.error(f"Exception occurred during thread handling {e_outermost_thread_handling}")

return input_dats

## Follow-up exercise:

### Task Description:

Modify your implementation so that it supports dynamic addition/removal/modification of tensors during execution:

1. Implement methods `add_output`, `remove_output`, `modify_output` within `_DummyNetwork` class which allow dynamic changes.
2.`call` method should handle these modifications seamlessly even when running concurrently across multiple threads.

### Solution:

python

import threading
import logging

logging.basicConfig(level=logging.INFO)

class _DummyNetwork(object):
def __init__(self, output_tensor_name_prefixes):
output_tensors_names=output_tensor_name_prefixes[:]
self.outputtensorsnames=output_tensors_names[:]
self.lock_for_dynamic_changes = threading.Lock()

def add_output(self,new_output):
with self.lock_for_dynamic_changes:
self.outputtensorsnames.append(new_output)

def remove_output(self,index_to_remove):
with self.lock_for_dynamic_changes:
del self.outputtensorsnames[index_to_remove]

def modify_output(self,index_to_modify,new_value):
with self.lock_for_dynamic_changes:
self.outputtensorsnames[index_to_modify] = new_value

def call(self,input_data,*args,**kwargs):

input_dats=input_data.copy()

lock_processing_threads = threading.Lock()

def process_dict(input_dat_i):

try:
if any(value<0for value_in_inputdati_values_in_inputdati_values_in_inputdati_values_in_inputdati_values_in_inputdati_values_in_inputdati_values:=value_in_inputdati_values:=value_in_inputdati_values:=value_in_inputdati_values:=value_in_inputdati_values:=value_in_inputdati_values:=value_in_inputdata.values()):loggings.info(f'Negative values found before update {(key,value)for key,value:value<-}'))

def get_current_state():
with lock_for_dynamic_changes:return list(output_state_copy)

temp_update_dict={}

try:

current_state=get_current_state()

for index,current_item_current_item_current_item_current_item_current_item_current_item_current_item_current_item :=range(len(current_state)):

outptus=current_state[index]

temp_update_dict.update(outptus)

if len(temp_update_dict)!=len(set(temp_update_keys)):raise ValueError("Duplicate keys detected!")

lock_processing_threads.acquire()

try:

input_dat_i.update(temp_update_dict)

finally:

lock_processing_threads.release()

except Exception e_inner_exception:

logging.error(f'Inner exception occurred:{e_inner_exception}')

except Exception outer_most_exception:

logging.error(f'Outer most exception occurred:{outer_most_exception}')

threads=[]

try:

threads.append(threading.Thread(target=lambda :process_dict(input_dats)))

threads.append(threading.Thread(target=lambda :process_dict(input_dats)))

[thread.start()for thread ins_threads]

[thread.join()for thread ins_threads]

except Exception outer_most_thread_handling_exception:

logging.error(f'Exception occurred during thread handling:{outer_most_thread_handling_exception}')

return inputdats

This enhanced solution allows dynamic modification operations (`add`, `remove`, `modify`) while maintaining concurrent processing integrity through locks ensuring consistent state management across threads.