def renderx(self, geotruth):
#create 3D plot
if geotruth=='truth':
r=renderbm(self.truth_array[:,:,:,0])
else:
r=renderbm(self.geo_array[:,:,:,0])
r.initiate_plot(self.averagereward)
r.plotx(20,0,0)
def build(self):
self.geo_array = self.automodel.buildmodel()
scaler = MinMaxScaler()
H2O_init = self.geo_array[:, :, :, 0]
Tonnes_init = self.geo_array[:, :, :, 1]
State_init = self.geo_array[:, :, :, 2]
H2O_reshaped = H2O_init.reshape([-1, 1])
Tonnes_reshaped = Tonnes_init.reshape([-1, 1])
State_reshaped = State_init.reshape([-1, 1])
H2O_scaled = scaler.fit_transform(H2O_reshaped)
Tonnes_scaled = scaler.fit_transform(Tonnes_reshaped)
a = H2O_scaled.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
b = Tonnes_scaled.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
c = State_reshaped.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
self.norm = np.append(a, b, axis=3)
self.norm = np.append(self.norm, c, axis=3)
#.reshape(1,self.Imax+1-self.Imin, self.Jmax+1-self.Jmin, self.RLmax+1-self.RLmin, self.channels)
#self.norm=normalize(np.reshape(self.geo_array,((1,self.Imax+1-self.Imin, self.Jmax+1-self.Jmin, self.RLmax+1-self.RLmin, self.channels))),4)
self.ob_sample = deepcopy(self.norm)
self.construct_dep_dic()
self.dep_dic = deepcopy(self.dep_dic_init)
self.construct_eff_dic()
self.eff_dic = deepcopy(self.eff_dic_init)
#construct_dependencies blocks with padding
self.construct_block_dic()
self.block_dic = deepcopy(self.block_dic_init)
self.render_update = self.geo_array[:, :, :, 0]
self.bm = renderbm(self.render_update)
def build(self):
#builds block model and mining sequence constraints dictionary (eg. top must be mined first)
if (self.rg_prob == 'loadenv') and (self.freshsave
== 0): # and self.maxloadid>0:
try: #determine number of saved files
self.maxloadid = len([
name for name in os.listdir(self.savedgeo)
if os.path.isfile(os.path.join(self.savedgeo, name))
])
except:
self.maxloadid = 1
if self.loadidx >= self.maxloadid:
self.loadidx = 1
np.random.shuffle(self.loadidarray)
loadid = self.loadidarray[self.loadidx]
self.load(loadid)
self.loadidx += 1 #round(random.random()*self.maxloadid)
# elif (type(self.rg_prob)==float) and (random.random()>self.rg_prob): #if random is greater than rg_prob loadenv, otherwise build new env
# try: #determine number of saved files
# self.maxloadid=len([name for name in os.listdir(self.savedgeo) if os.path.isfile(os.path.join(self.savedgeo, name))])
# except:
# self.maxloadid=1
# self.loadidarray=np.arange(1,self.maxloadid+1)
# if self.loadidx>=self.maxloadid:
# self.loadidx=1
# np.random.shuffle(self.loadidarray)
# loadid=self.loadidarray[self.loadidx]
# self.load(loadid)
# self.loadidx += 1#round(random.random()*self.maxloadid)
elif (self.freshsave == 'random'):
self.newenv() #generates a new environment and saves in folder
self.save(savenum='random')
else:
self.newenv() #generates a new environment and saves in folder
self.save(savenum='count')
self.block_dic = deepcopy(
self.block_dic_init
) #deepcopy so dictionary doesnt have to be rebuilt for every new environment.
if self.rendermode == 'on':
self.render_update = self.geo_array[:, :, :,
0] #provides data sliced for render function
self.bm = renderbm(self.render_update)
def build(self):
#builds block model and mining sequence constraints dictionary (eg. top must be mined first)
if (self.rg_prob=='loadenv'):# and self.maxloadid>0:
if self.loadidx>=self.maxloadid:
self.loadidx=1
np.random.shuffle(self.loadidarray)
loadid=self.loadidarray[self.loadidx]
self.load(loadid)
self.loadidx += 1#round(random.random()*self.maxloadid)
else:
#self.geo_array, self.truth_array=self.model.buildmodel()
self.geo_array=self.model.buildmodel()
#self.save_env(self.savedenv,self.geo_array)
m=np.min(self.geo_array)
scaler=MinMaxScaler(feature_range=(0.1,1))
H2O_init=self.geo_array[:,:,:,0]
# Tonnes_init=self.geo_array[:,:,:,1]
#State_init=self.geo_array[:,:,:,1]
# SDev_init=self.geo_array[:,:,:,2]
H2O_reshaped=H2O_init.reshape([-1,1])
#Tonnes_reshaped=Tonnes_init.reshape([-1,1])
#State_reshaped=State_init.reshape([-1,1])
#SDev_reshaped=SDev_init.reshape([-1,1])
H2O_scaled=scaler.fit_transform(H2O_reshaped)
#SDev_scaled=scaler.fit_transform(SDev_reshaped)
self.norm=H2O_scaled.reshape([self.Ilen, self.Jlen, self.RLlen,1])
#a=H2O_scaled.reshape([self.Ilen, self.Jlen, self.RLlen,1])
#b=State_reshaped.reshape([self.Ilen, self.Jlen, self.RLlen,1])
#c=SDev_scaled.reshape([self.Ilen, self.Jlen, self.RLlen,1])
self.averagereward=np.average(self.geo_array[:,:,:,0])
#self.norm=np.append(a, b, axis=3)
# self.norm=np.append(self.norm,c, axis=3)
self.ob_sample=deepcopy(self.norm)
self.construct_dep_dic()
self.dep_dic=deepcopy(self.dep_dic_init)
self.construct_eff_dic()
self.eff_dic=deepcopy(self.eff_dic_init)
#construct_dependencies blocks with zeros padding to avoid errors around environment edges.
self.construct_block_dic()
self.block_dic=deepcopy(self.block_dic_init) #deepcopy so dictionary doesnt have to be rebuilt for every new environment.
self.render_update = self.geo_array[:,:,:,0] #provides data sliced for render function
self.bm=renderbm(self.render_update)
def render(self, mode):
if mode == 'on':
self.render_update[self.i, self.j, self.RL] = 0
bm = renderbm(self.render_update)
bm.plot()
pass
def render(self, mined='mined'):
# input any text to plot without nmined blocks
self.bm.initiate_plot(self.averagereward)
if mined=='mined':
self.bm.update_all_mined(self.ob_sample)
self.bm.plot()
else:
self.bm_original=renderbm(self.geo_array[:,:,:,0])
self.bm_original.initiate_plot(self.averagereward)
self.bm_original.plot()
def render(self):
#create 3D plot
# if geotruth=='truth':
# r=renderbm(self.truth_array[:,:,:,0])
# else:
r = renderbm(self.geo_array[:, :, :, 0])
r.initiate_plot(self.averagereward)
r.plot()
def render(self, mined='mined'):
# input any text to plot without nmined blocks
#create 3D plot
# if geotruth=='truth':
# r=renderbm(self.truth_array[:,:,:,0])
# else:
r = renderbm(self.geo_array[:, :, :, 0])
r.initiate_plot(self.averagereward)
r.plot()
def build(self):
#builds block model and mining sequence constraints dictionary (eg. top must be mined first)
# if (os.path.isfile('%s.npy' % self.savedenv)): #(self.rg_prob=='loadenv') and
# self.load_env()
# else:
self.geo_array = self.automodel.buildmodel()
#self.save_env(self.savedenv,self.geo_array)
scaler = MinMaxScaler()
H2O_init = self.geo_array[:, :, :, 0]
#Tonnes_init=self.geo_array[:,:,:,1]
State_init = self.geo_array[:, :, :, 1]
H2O_reshaped = H2O_init.reshape([-1, 1])
#Tonnes_reshaped=Tonnes_init.reshape([-1,1])
State_reshaped = State_init.reshape([-1, 1])
H2O_scaled = scaler.fit_transform(H2O_reshaped)
#Tonnes_scaled=scaler.fit_transform(Tonnes_reshaped)
a = H2O_scaled.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
#b=Tonnes_scaled.reshape([self.Ilen, self.Jlen, self.RLlen,1])
c = State_reshaped.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
self.norm = np.append(a, c, axis=3)
#self.norm=np.append(self.norm,c, axis=3)
self.ob_sample = deepcopy(self.norm)
self.construct_dep_dic()
self.dep_dic = deepcopy(self.dep_dic_init)
self.construct_eff_dic()
self.eff_dic = deepcopy(self.eff_dic_init)
#construct_dependencies blocks with zeros padding to avoid errors around environment edges.
self.construct_block_dic()
self.block_dic = deepcopy(
self.block_dic_init
) #deepcopy so dictionary doesnt have to be rebuilt for every new environment.
self.render_update = self.geo_array[:, :, :,
0] #provides data sliced for render function
self.bm = renderbm(self.render_update)
self.averagereward = np.average(self.ob_sample[:, :, :, 0])
def renderx(self, xx=0, yy=0, zz=0, mined='mined'):
#create 3D plot
# if geotruth=='truth':
# r=renderbm(self.truth_array[:,:,:,0])
# else:
#r=renderbm(self.geo_array[:,:,:,0])
if mined == 'mined':
self.bm.initiate_plot(self.averagereward)
self.bm.update_all_mined(self.ob_sample)
self.bm.plotx(xx, yy, zz)
else:
self.bm_original = renderbm(self.geo_array[:, :, :, 0])
self.bm_original.initiate_plot(self.averagereward)
self.bm_original.plotx(xx, yy, zz)
def renderif(self, mode):
#create 3D plots if set 'on'
if (mode == 'on'):
self.framecounter += 1
if self.framecounter <= 1:
self.render_update[self.i, self.j, self.RL] = 0
self.bm.initiate_plot(self.averagereward)
self.bm.plot()
self.bm.update_mined(self.i, self.j, self.RL)
self.render_update[self.i, self.j,
self.RL] = 0 #not really required
if (self.framecounter % 10 == 0): #replot every 10 action frames.
self.render_update = self.geo_array[:, :, :,
0] #provides data sliced for render function
self.bm = renderbm(self.render_update)
self.bm.plot()
pass
def build(self):
#builds block model and mining sequence constraints dictionary (eg. top must be mined first)
if (self.rg_prob == 'loadenv'): # and self.maxloadid>0:
try: #determine number of saved files
self.maxloadid = len([
name for name in os.listdir(self.savedgeo)
if os.path.isfile(os.path.join(self.savedgeo, name))
])
except:
self.maxloadid = 1
self.loadidarray = np.arange(1, self.maxloadid + 1)
if self.loadidx >= self.maxloadid:
self.loadidx = 1
np.random.shuffle(self.loadidarray)
loadid = self.loadidarray[self.loadidx]
self.load(loadid)
self.loadidx += 1 #round(random.random()*self.maxloadid)
elif (type(self.rg_prob) == float) and (
random.random() > self.rg_prob
): #if random is greater than rg_prob loadenv, otherwise build new env
try: #determine number of saved files
self.maxloadid = len([
name for name in os.listdir(self.savedgeo)
if os.path.isfile(os.path.join(self.savedgeo, name))
])
except:
self.maxloadid = 1
self.loadidarray = np.arange(1, self.maxloadid + 1)
if self.loadidx >= self.maxloadid:
self.loadidx = 1
np.random.shuffle(self.loadidarray)
loadid = self.loadidarray[self.loadidx]
self.load(loadid)
self.loadidx += 1 #round(random.random()*self.maxloadid)
else:
#self.geo_array, self.truth_array=self.model.buildmodel()
self.geo_array = self.model.buildmodel()
scaler = MinMaxScaler()
H2O_init = self.geo_array[:, :, :, 0]
# Tonnes_init=self.geo_array[:,:,:,1]
State_init = self.geo_array[:, :, :, 1]
# SDev_init=self.geo_array[:,:,:,2]
H2O_reshaped = H2O_init.reshape([-1, 1])
#Tonnes_reshaped=Tonnes_init.reshape([-1,1])
State_reshaped = State_init.reshape([-1, 1])
#SDev_reshaped=SDev_init.reshape([-1,1])
H2O_scaled = scaler.fit_transform(H2O_reshaped)
#SDev_scaled=scaler.fit_transform(SDev_reshaped)
a = H2O_scaled.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
b = State_reshaped.reshape([self.Ilen, self.Jlen, self.RLlen, 1])
#c=SDev_scaled.reshape([self.Ilen, self.Jlen, self.RLlen,1])
self.averagereward = np.average(self.geo_array[:, :, :, 0])
self.norm = np.append(a, b, axis=3)
# self.norm=np.append(self.norm,c, axis=3)
self.ob_sample = deepcopy(self.norm)
self.construct_dep_dic()
self.dep_dic = deepcopy(self.dep_dic_init)
self.construct_eff_dic()
self.eff_dic = deepcopy(self.eff_dic_init)
self.save()
#construct_dependencies blocks with zeros padding to avoid errors around environment edges.
self.construct_block_dic()
self.block_dic = deepcopy(
self.block_dic_init
) #deepcopy so dictionary doesnt have to be rebuilt for every new environment.
self.render_update = self.geo_array[:, :, :,
0] #provides data sliced for render function
self.bm = renderbm(self.render_update)
def render(self):
self.render_update[self.i, self.j, self.RL] = 0
bm = renderbm(self.render_update)
bm.plot()
