def __setattr__(self, key, value):
if "java_fields" in self.__dict__ and key in self.__dict__["java_fields"]:
if isinstance(value, JavaConfig):
java_gateway.set_field(self.java_obj,key, value.java_obj)
else:
java_gateway.set_field(self.java_obj,key, value)
else:
self.__dict__[key] = value
def __setattr__(self, key, value):
if "java_fields" in self.__dict__ and key in self.__dict__[
"java_fields"]:
if isinstance(value, JavaConfig):
java_gateway.set_field(self.java_obj, key, value.java_obj)
else:
java_gateway.set_field(self.java_obj, key, value)
else:
self.__dict__[key] = value
def testSetField(self):
self.gateway = JavaGateway(auto_field=False)
ex = self.gateway.getNewExample()
set_field(ex, 'field10', 2334)
self.assertEquals(get_field(ex, 'field10'), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer('Hello World!')
set_field(ex, 'field21', sb)
self.assertEquals(get_field(ex, 'field21').toString(), 'Hello World!')
self.assertRaises(Exception, set_field, ex, 'field1', 123)
def testSetField(self):
self.gateway = JavaGateway(auto_field=False)
ex = self.gateway.getNewExample()
set_field(ex, 'field10', 2334)
self.assertEquals(get_field(ex, 'field10'), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer('Hello World!')
set_field(ex, 'field21', sb)
self.assertEquals(get_field(ex, 'field21').toString(), 'Hello World!')
self.assertRaises(Exception, set_field, ex, 'field1', 123)
def testSetField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=False))
ex = self.gateway.getNewExample()
set_field(ex, "field10", 2334)
self.assertEquals(get_field(ex, "field10"), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer("Hello World!")
set_field(ex, "field21", sb)
self.assertEquals(get_field(ex, "field21").toString(), "Hello World!")
self.assertRaises(Exception, set_field, ex, "field1", 123)
def testSetField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=False))
ex = self.gateway.getNewExample()
set_field(ex, "field10", 2334)
self.assertEquals(get_field(ex, "field10"), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer("Hello World!")
set_field(ex, "field21", sb)
self.assertEquals(get_field(ex, "field21").toString(), "Hello World!")
self.assertRaises(Exception, set_field, ex, "field1", 123)
def choose_action_epsilon_greedy(self, array_state, epsilon, netSnap):
### With probability epsilon choose a random action, otherwise choose
### the action with highest Q value
# unwrapping state
state = list(array_state)
state = np.asarray(state)
# print("SEG:", self.segmentCounter, "PrevQuality:", state[0], ", 2PrevCh:", state[1], ", PrevCh:", state[2], ", QualityIndex", state[3], ", Buffer:", state[4])
self.segmentCounter = self.segmentCounter + 1
if epsilon > 1 or epsilon < 0:
raise Exception('epsilon value between 0 and 1')
# Change state shape and datatype to match network input
if len(np.shape(state)) == 1:
state = np.array(state).reshape(-1, len(state))
# Evaluate output
out_layer = self.session.run(self.out_layer,
feed_dict={
self.x: state,
self.keep_prob: 1
})[0]
if np.random.rand() < (epsilon /
(self.n_classes - 1) * self.n_classes):
# Generate random action
action = np.random.randint(0, self.n_classes)
else:
# Choose the index of the max
action = np.argmax(out_layer)
# wrapping elements
# print(out_layer)
out_layer = out_layer.tolist()
# print("Q", out_layer, "Action: ", action)
double_class = gateway.jvm.double
double_out_layer = gateway.new_array(double_class, self.n_classes)
for i, val in enumerate(out_layer):
double_out_layer[i] = val
# setting netsnap object
set_field(netSnap, 'action', action)
set_field(netSnap, 'output', double_out_layer)
return
def choose_action_softmax(self, array_state, temperature, netSnap):
### Forward step on network and apply softmax sample on output
# unwrapping state
state = list(array_state)
state = np.asarray(state)
# print("SEG:" + self.segmentCounter + "PrevQuality:" +state[0] + ", 2PrevCh:" + state[1] + ", PrevCh:" + state[2] + ", QualityIndex" + state[3] + ", Buffer:" + state[4])
self.segmentCounter = self.segmentCounter + 1
if temperature == 0:
return self.choose_action_epsilon_greedy(state, temperature)
# Change state shape and datatype to match network input
if len(np.shape(state)) == 1:
state = np.array(state).reshape(-1, len(state))
# Evaluate softmax output
out_layer, softmax_output = self.session.run(
[self.out_layer, self.softmax_output],
feed_dict={
self.x: state,
self.softmax_temperature: temperature,
self.keep_prob: 1
})
softmax_output = softmax_output[0]
out_layer = out_layer[0]
# Sample the action using softmax output as mass pdf
action = np.random.choice(np.arange(0, np.size(softmax_output)),
p=softmax_output)
# wrapping elements
# print("Q"+ out_layer+"Action: " + action)
out_layer = out_layer.tolist()
double_class = gateway.jvm.double
double_out_layer = gateway.new_array(double_class, self.n_classes)
for i, val in enumerate(out_layer):
double_out_layer[i] = val
# setting netsnap object
set_field(netSnap, 'action', action)
set_field(netSnap, 'output', double_out_layer)
return
def testSetField(self):
self.gateway = JavaGateway(auto_field=False)
ex = self.gateway.getNewExample()
set_field(ex, "field10", 2334)
self.assertEquals(get_field(ex, "field10"), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer("Hello World!")
set_field(ex, "field21", sb)
self.assertEquals(get_field(ex, "field21").toString(), "Hello World!")
try:
set_field(ex, "field1", 123)
self.fail()
except Exception:
self.assertTrue(True)
def set_property(self, name, value):
return java_gateway.set_field(self.java_obj,name, value)
def processing(self):
try:
# initialize when game start (first processing call?)
if self.frameData.getEmptyFlag(
) or self.frameData.getRemainingTime() <= 0:
self.isGameJustStarted = True
del self.screens[:]
del self.actions[:]
del self.hps[:]
del self.energy[:]
del self.controllable[:]
del self.rewards[:]
self.frame_count = self.frames
return
# if self.cc.getSkillFlag():
# self.inputKey = self.cc.getSkillKey()
# return
# update state
displayBuffer = self.frameData.getDisplayByteBufferAsBytes(
resolution[1], resolution[0], True)
# rescaled to [-1, 1] and change data type np.float32
screen = np.frombuffer(displayBuffer, dtype=np.int8).reshape(
resolution[:2]) / 127.0
screen = screen.astype(np.float32)
# opponent always inverted
if self.player:
screen = -screen
self.screens.append(screen)
my_char = self.frameData.getMyCharacter(self.player)
opp_char = self.frameData.getOpponentCharacter(self.player)
self.hps.append((my_char.getHp(), opp_char.getHp()))
my_energy = my_char.getEnergy()
self.energy.append(my_energy / energy_scale) # energy scaled
# set action
action_continue = self.actions and self.actions[-1] is not None \
and self.frame_count < self.frames
# self.controllable.append(get_field(my_char, 'control'))
self.controllable.append(not self.cc.getskillFlag())
controllable = self.controllable[-1]
if get_field(my_char, 'front'):
actions = left_actions
else:
actions = right_actions
# if last action is set and running
if action_continue or not controllable:
# keep current action
self.actions.append(self.actions[-1])
else:
# take new action
self.cc.skillCancel()
stop_actions = [
a for a in range(len(actions))
if energy_cost[a] > my_energy
]
action_idx = self.act(self._get_recent_state(),
stop_actions=stop_actions)
self.actions.append(action_idx)
self.frames = len(actions[action_idx])
logger.debug('action_idx: {}'.format(action_idx))
self.frame_count = 0
# set key
if self.actions and self.actions[-1] is not None:
current_action = actions[self.actions[-1]]
if self.frame_count < len(current_action):
self.inputKey.empty()
action_keys = current_action[self.frame_count]
for key in action_keys:
if key in 'ABCDLRU':
set_field(self.inputKey, key, True)
else:
self.inputKey.empty()
if getattr(self, '_on_train', False):
# store new state action tuple and stream to monitor
self.save_transaction(actions)
self.frame_count += 1
except Exception as exc:
logger.error(traceback.format_exc())
def __setattr__(self, key, value):
if "java_fields" in self.__dict__ and key in self.__dict__[
"java_fields"]:
java_gateway.set_field(self.java_obj, key, value)
else:
self.__dict__[key] = value
# os.environ["JAVA_HOME"] = "/opt/miniconda3/envs/bet" # for pyjnius
os.environ[
"JAVA_HOME"] = "/usr/lib/jvm/java-8-oracle" # not working with pyjnius
os.environ['CLASSPATH'] = project_path + jar_path + jar_file
# %%
from py4j.java_gateway import JavaGateway, GatewayParameters, set_field
import sys
from datetime import datetime
gtw = JavaGateway.launch_gateway(
classpath=project_path + jar_path + jar_file,
redirect_stdout=sys.stdout,
redirect_stderr=sys.stderr,
die_on_exit=True) # auto_field=True changed within the library itself!
# gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True))
settings = gtw.jvm.settings.Settings()
set_field(settings, "neuralNetsPostProcessing", True)
set_field(settings, "pruneNetworks", True)
neuralogic = gtw.jvm
main = neuralogic.Main
print(main.testConnection(str(datetime.now())))
main.initLogging()
def set_property(self, name, value):
return java_gateway.set_field(self.java_obj, name, value)
"""
This script update rainfall data records in HEC-DSS database using ListSelection class.
Firstly, we create Main Window. Secondly, we open the DSS file Project.dss, and we read data from the specified record. Then, a new matrix
with actual rainfall data is generated. With set_field function, the data is updated. Finally, save function saves the data container in
the opened DSS file
"""
# modules importation
from py4j.java_gateway import JavaGateway, get_field, set_field
gateway = JavaGateway()
jhec = gateway.jvm.hec
# main script
mainWindow = jhec.dssgui.ListSelection.createMainWindow()
mainWindow.openDSSFile("C:/Project.dss")
record=mainWindow.read("//GAGE 1/PRECIP-INC/01JAN2000/30MIN/GAGE/")
temp=get_field(record,"values")
newTemp = [newTemp.rstrip('\n') for newTemp in open('C:/rainfall.txt')]
newTemp=[float(string) for string in newTemp]
# new matrix creation
for i in range(len(newTemp)):
temp[i]=newTemp[i]
set_field(record,"values",temp)
mainWindow.save(record)
