def test_Mask(self):
reference = Raster('../../examples/data.tif')
simulated = Raster('../../examples/data1.tif')
reference.resetMask([2])
simulated.resetMask([2])
eb = EBudget(reference, simulated)
W = eb.W
S1 = weightedSum(eb.Sj[1], W)
S3 = weightedSum(eb.Sj[3], W)
np.testing.assert_almost_equal(S1, 5.0 / 8)
np.testing.assert_almost_equal(S3, 3.0 / 8)
noNo = eb.NoNo()
np.testing.assert_almost_equal(noNo, 0.5)
noM = eb.NoMed()
np.testing.assert_almost_equal(noM, (5.0 * 5 / 8 + 3.0 * 3 / 8) / 8)
medM = eb.MedMed()
np.testing.assert_almost_equal(medM, 4.0 / 8)
medP = eb.MedPer()
np.testing.assert_almost_equal(medP, 1.0)
def setUp(self):
self.r1 = Raster('../../examples/multifact.tif')
# r1 -> r1 transition
self.r1r1 = [[
5,
5,
15,
], [
15,
10,
5,
], [
0,
15,
5,
]]
self.r2 = Raster('../../examples/multifact.tif')
self.r2.resetMask([0])
self.r2r2 = [[
0,
0,
8,
], [
8,
4,
0,
], [
100,
8,
0,
]]
self.r3 = Raster('../../examples/multifact.tif')
self.r3.resetMask([2])
def test_normalize(self):
multifact = [
[1, 1, 3],
[3, 2, 1],
[0, 3, 1],
]
# Normalize using std and mean
r1 = Raster('examples/multifact.tif')
r1.normalize()
r1.denormalize()
assert_array_equal(r1.getBand(1), multifact)
# Normalize using min and max
r1 = Raster('examples/multifact.tif')
r1.normalize(mode='maxmin')
r1.denormalize()
assert_array_equal(r1.getBand(1), multifact)
# Two normalization procedures
r1 = Raster('examples/multifact.tif')
r1.normalize()
r1.normalize(mode='maxmin')
r1.denormalize()
assert_array_equal(r1.getBand(1), multifact)
r1 = Raster('examples/multifact.tif')
r1.normalize(mode='maxmin')
r1.normalize()
r1.denormalize()
assert_array_equal(r1.getBand(1), multifact)
def test_getStat(self):
reference = Raster('../../examples/data.tif')
simulated = Raster('../../examples/data1.tif')
reference.resetMask([2])
simulated.resetMask([2])
eb = EBudget(reference, simulated)
stat = eb.getStat(nIter=3)
ans0 = {
'NoNo': 0.5,
'NoMed': (5.0 * 5 / 8 + 3.0 * 3 / 8) / 8,
'MedMed': 4.0 / 8,
'MedPer': 1.0,
'PerPer': 1.0
}
for k in stat[0].keys():
np.testing.assert_almost_equal(stat[0][k], ans0[k])
ans1 = {
'NoNo': 0.5,
'NoMed': (5.0 / 8 + 5.0 / 32 + 3.0 / 16 + 3.0 / 32) / 2,
'MedMed': 4.0 / 8,
'MedPer': 1.0,
'PerPer': 1.0
}
for k in stat[1].keys():
np.testing.assert_almost_equal(stat[0][k], ans1[k])
def _predict(self, state, calcTransitions=False):
'''
Predict the changes.
'''
try:
geodata = state.getGeodata()
rows, cols = geodata['ySize'], geodata['xSize']
self.transitionPotentials = None # Reset tr.potentials if they exist
# Get locations where self.initStateNum is occurs
band = state.getBand(1)
initStateMask = binaryzation(band, [self.initStateNum])
mask = band.mask
# Calculate summary map of factors weights
# Transition potentials:
# current implementation: potential and confidence are equal (two-class implementation)
# Confidence:
# confidence is summary map of factors scaled to 0-100, if current state = self.initState
# confidence is 0, if current state != self.initState
# Prediction:
# predicted value is a constant = areaAnalyst.encode(initStateNum, finalStateNum), if current state = self.initState
# predicted value is the transition code current_state -> current_state, if current state != self.initState
confidence = np.zeros((rows,cols), dtype=np.uint8)
weights = self.getWeights()
weightNum = 0 # Number of processed weights
for f in self.factors:
if not f.geoDataMatch(state):
raise MCEError('Geometries of the state and factor rasters are different!')
f.normalize(mode = 'maxmin')
for i in xrange(f.getBandsCount()):
band = f.getBand(i+1)
confidence = confidence + (band*weights[weightNum]*100).astype(np.uint8)
mask = np.ma.mask_or(mask, band.mask)
weightNum = weightNum + 1
confidence = confidence*initStateMask
prediction = np.copy(state.getBand(1))
for code in self.areaAnalyst.categories:
if code != self.initStateNum:
prediction[prediction==code] = self.areaAnalyst.encode(code, code)
else:
prediction[prediction==code] = self.areaAnalyst.encode(self.initStateNum, self.finalStateNum)
predicted_band = np.ma.array(data=prediction, mask=mask, dtype=np.uint8)
self.prediction = Raster()
self.prediction.create([predicted_band], geodata)
confidence_band = np.ma.array(data=confidence, mask=mask, dtype=np.uint8)
self.confidence = Raster()
self.confidence.create([confidence_band], geodata)
code = self.areaAnalyst.encode(self.initStateNum, self.finalStateNum)
self.transitionPotentials = {code: self.confidence}
except MemoryError:
self.errorReport.emit(self.tr("The system out of memory during MCE prediction"))
raise
except:
self.errorReport.emit(self.tr("An unknown error occurs during MCE prediction"))
raise
def setUp(self):
self.reference = Raster('../../examples/data.tif')
#~ [1,1,1,1],
#~ [1,1,2,2],
#~ [2,2,2,2],
#~ [3,3,3,3]
self.simulated = Raster('../../examples/data1.tif')
def main(initRaster, finalRaster, factors):
print 'Start Reading Init Data...', clock()
initRaster = Raster(initRaster)
finalRaster = Raster(finalRaster)
factors = [Raster(rasterName) for rasterName in factors]
print 'Finish Reading Init Data', clock(), '\n'
print "Start Making CrossTable...", clock()
crosstab = CrossTableManager(initRaster, finalRaster)
print "Finish Making CrossTable", clock(), '\n'
# Create and Train LR Model
model = LR(ns=1)
print 'Start Setting LR Trainig Data...', clock()
model.setTrainingData(initRaster,
factors,
finalRaster,
mode='Stratified',
samples=1000)
print 'Finish Setting Trainig Data', clock(), '\n'
print 'Start LR Training...', clock()
model.train()
print 'Finish Trainig', clock(), '\n'
print 'Start LR Prediction...', clock()
predict = model.getPrediction(initRaster, factors)
filename = 'lr_predict.tiff'
try:
predict.save(filename)
finally:
os.remove(filename)
print 'Finish LR Prediction...', clock(), '\n'
# simulation
print 'Start Simulation...', clock()
simulator = Simulator(initRaster, factors, model, crosstab)
# Make 1 cycle of simulation:
simulator.simN(1)
monteCarloSim = simulator.getState() # Result of MonteCarlo simulation
errors = simulator.errorMap(finalRaster) # Risk class validation
riskFunct = simulator.getConfidence() # Risk function
# Make K cycles of simulation:
# simulator.simN(K)
try:
monteCarloSim.save('simulation_result.tiff')
errors.save('risk_validation.tiff')
riskFunct.save('risk_func.tiff')
finally:
pass
os.remove('simulation_result.tiff')
os.remove('risk_validation.tiff')
os.remove('risk_func.tiff')
print 'Finish Simulation', clock(), '\n'
print 'Done', clock()
def _predict(self, state, calcTransitions=False):
'''
Predict the changes.
'''
try:
self.rangeChanged.emit(self.tr("Initialize model %p%"), 1)
rows, cols = self.geodata['ySize'], self.geodata['xSize']
if not self.changeMap.geoDataMatch(state):
raise WoeManagerError('Geometries of the state and changeMap rasters are different!')
prediction = np.zeros((rows,cols), dtype=np.uint8)
confidence = np.zeros((rows,cols), dtype=np.uint8)
mask = np.zeros((rows,cols), dtype=np.byte)
stateBand = state.getBand(1)
self.updateProgress.emit()
self.rangeChanged.emit(self.tr("Prediction %p%"), rows)
for r in xrange(rows):
for c in xrange(cols):
oldMax, currMax = -1000, -1000 # Small numbers
indexMax = -1 # Index of Max weight
initCat = stateBand[r,c] # Init category (state before transition)
try:
codes = self.analyst.codes(initCat) # Possible final states
for code in codes:
try: # If not all possible transitions are presented in the changeMap
map = self.woe[code] # Get WoE map of transition 'code'
except KeyError:
continue
w = map[r,c] # The weight in the (r,c)-pixel
if w > currMax:
indexMax, oldMax, currMax = code, currMax, w
prediction[r,c] = indexMax
confidence[r,c] = int(100*(sigmoid(currMax) - sigmoid(oldMax)))
except ValueError:
mask[r,c] = 1
self.updateProgress.emit()
predicted_band = np.ma.array(data=prediction, mask=mask, dtype=np.uint8)
self.prediction = Raster()
self.prediction.create([predicted_band], self.geodata)
confidence_band = np.ma.array(data=confidence, mask=mask, dtype=np.uint8)
self.confidence = Raster()
self.confidence.create([confidence_band], self.geodata)
except MemoryError:
self.errorReport.emit(self.tr("The system out of memory during WOE prediction"))
raise
except:
self.errorReport.emit(self.tr("An unknown error occurs during WoE prediction"))
raise
finally:
self.processFinished.emit()
def setUp(self):
self.factor = Raster('../../examples/multifact.tif')
#~ [1,1,3]
#~ [3,2,1]
#~ [0,3,1]
self.sites = Raster('../../examples/sites.tif')
#~ [1,2,1],
#~ [1,2,1],
#~ [0,1,2]
self.sites.resetMask(maskVals=[0])
self.mask = [[
False,
False,
False,
], [
False,
False,
False,
], [
True,
False,
False,
]]
fact = [[
1,
1,
3,
], [
3,
2,
1,
], [
0,
3,
1,
]]
site = [[
False,
True,
False,
], [
False,
True,
False,
], [
False,
False,
True,
]]
self.factraster = ma.array(data=fact, mask=self.mask, dtype=np.int)
self.sitesraster = ma.array(data=site, mask=self.mask, dtype=np.bool)
def setUp(self):
self.factor = Raster('../../examples/multifact.tif')
#~ [1,1,3]
#~ [3,2,1]
#~ [0,3,1]
self.state = Raster('../../examples/sites.tif')
self.state.resetMask(maskVals=[0])
#~ [1,2,1],
#~ [1,2,1],
#~ [0,1,2]
self.areaAnalyst = AreaAnalyst(self.state, second=None)
def setUp(self):
self.r1 = Raster('examples/multifact.tif')
self.r2 = Raster('examples/sites.tif')
self.r3 = Raster('examples/two_band.tif')
# r1
data1 = np.array([[1, 1, 3], [3, 2, 1], [0, 3, 1]])
# r2
data2 = np.array([[1, 2, 1], [1, 2, 1], [0, 1, 2]])
mask = [[False, False, False], [False, False, False],
[False, False, False]]
self.data1 = ma.array(data=data1, mask=mask)
self.data2 = ma.array(data=data2, mask=mask)
def test_get_state(self):
smp = Sampler(self.state, self.factors, self.output, ns=0)
assert_array_equal(smp.get_state(self.state, 1, 1), [0, 0])
assert_array_equal(smp.get_state(self.state, 0, 0), [0, 1])
smp = Sampler(self.state, self.factors, self.output, ns=1)
res = [
0,
1,
0,
0,
0,
1,
0,
1,
0,
0,
0,
1,
1,
0,
0,
1,
0,
0,
]
assert_array_equal(smp.get_state(self.state, 1, 1), res)
inputRast = Raster('../../examples/sites.tif')
inputRast.resetMask([0])
smp = Sampler(inputRast, self.factors, self.output, ns=0)
assert_array_equal(smp.get_state(self.state, 1, 1), [0])
assert_array_equal(smp.get_state(self.state, 0, 0), [1])
def test_roundBands(self):
rast = Raster('examples/multifact.tif')
rast.bands = rast.bands * 0.1
rast.roundBands()
answer = [[[
0,
0,
0,
], [0, 0, 0], [0, 0, 0]]]
assert_array_equal(answer, rast.bands)
rast = Raster('examples/multifact.tif')
rast.bands = rast.bands * 1.1
rast.roundBands(decimals=1)
answer = np.array([[[1.1, 1.1, 3.3], [3.3, 2.2, 1.1], [0.0, 3.3,
1.1]]])
assert_array_equal(answer, rast.bands)
def setUp(self):
self.output = Raster('../../examples/multifact.tif')
#~ [1,1,3]
#~ [3,2,1]
#~ [0,3,1]
self.output.resetMask([0])
self.state = self.output
self.factors = [
Raster('../../examples/sites.tif'),
Raster('../../examples/sites.tif')
]
#~ [1,2,1],
#~ [1,2,1],
#~ [0,1,2]
self.output1 = Raster('../../examples/data.tif')
self.state1 = self.output1
self.factors1 = [Raster('../../examples/fact16.tif')]
def setUp(self):
self.factors = [Raster('../../examples/multifact.tif')]
self.output = Raster('../../examples/sites.tif')
#~ sites.tif is 1-band 3x3 raster:
#~ [1,2,1],
#~ [1,2,1],
#~ [0,1,2]
self.factors2 = [Raster('../../examples/multifact.tif'), Raster('../../examples/multifact.tif')]
self.factors3 = [Raster('../../examples/two_band.tif')]
self.factors4 = [Raster('../../examples/two_band.tif'), Raster('../../examples/multifact.tif')]
self.output1 = Raster('../../examples/data.tif')
self.state1 = self.output1
self.factors1 = [Raster('../../examples/fact16.tif')]
def test_save(self):
try:
filename = 'temp.tiff'
self.r1.save(filename)
r2 = Raster(filename)
self.assertEqual(r2.get_dtype(), self.r1.get_dtype())
self.assertEqual(r2.getBandsCount(), self.r1.getBandsCount())
for i in range(r2.getBandsCount()):
assert_array_equal(r2.getBand(i + 1), self.r1.getBand(i + 1))
finally:
os.remove(filename)
def test_cat2vect(self):
smp = Sampler(self.state, self.factors, self.output, ns=0)
assert_array_equal(smp.cat2vect(0), [1, 0])
assert_array_equal(smp.cat2vect(1), [0, 1])
assert_array_equal(smp.cat2vect(2), [0, 0])
inputRast = Raster('../../examples/sites.tif')
inputRast.resetMask([0])
smp = Sampler(inputRast, self.factors, self.output, ns=0)
assert_array_equal(smp.cat2vect(1), [1])
assert_array_equal(smp.cat2vect(2), [0])
def errorMap(self, answer):
'''
Create map of correct and incorrect prediction.
This function compares the known answer and the result of predicting procedure,
correct pixel is marked as 0.
'''
state = self.getState()
b = state.getBand(1)
a = answer.getBand(1)
diff = (a - b).astype(np.int16)
result = Raster()
result.create([diff], state.getGeodata())
return result
def train(self):
'''
Train the model
'''
self.transitionPotentials = {}
try:
iterCount = len(self.codes)*len(self.factors)
self.rangeChanged.emit(self.tr("Training WoE... %p%"), iterCount)
changeMap = self.changeMap.getBand(1)
for code in self.codes:
sites = binaryzation(changeMap, [code])
# Reclass factors (continuous factor -> ordinal factor)
wMap = np.ma.zeros(changeMap.shape) # The map of summary weight of the all factors
self.weights[code] = {} # Dictionary for storing wheights of every raster's band
for k in xrange(len(self.factors)):
fact = self.factors[k]
self.weights[code][k] = {} # Weights of the factor
factorW = self.weights[code][k]
if self.bins: # Get bins of the factor
bin = self.bins[k]
if (bin != None) and fact.getBandsCount() != len(bin):
raise WoeManagerError("Count of bins list for multiband factor is't equal to band count!")
else: bin = None
for i in range(1, fact.getBandsCount()+1):
band = fact.getBand(i)
if bin and bin[i-1]: #
band = reclass(band, bin[i-1])
band, sites = masks_identity(band, sites, dtype=np.uint8) # Combine masks of the rasters
woeRes = woe(band, sites, self.unit_cell) # WoE for the 'code' (initState->finalState) transition and current 'factor'.
weights = woeRes['map']
wMap = wMap + weights
factorW[i] = woeRes['weights']
self.updateProgress.emit()
# Reclassification finished => set WoE coefficients
self.woe[code]=wMap # WoE for all factors and the transition code.
# Potentials are WoE map rescaled to 0--100 percents
band = (sigmoid(wMap)*100).astype(np.uint8)
p = Raster()
p.create([band], self.geodata)
self.transitionPotentials[code] = p
gc.collect()
except MemoryError:
self.errorReport.emit('The system out of memory during WoE trainig')
raise
except:
self.errorReport.emit(self.tr("An unknown error occurs during WoE trainig"))
raise
finally:
self.processFinished.emit()
def _predict(self, state, factors = None, calcTransitions=False):
geodata = state.getGeodata()
band = state.getBand(1)
rows, cols = geodata['ySize'], geodata['xSize']
# Let the new state is: 1 -> 2, 2- >3, 3 -> 1, then
# the prediction is 1->1, 2->5, 3->6
predicted_band = np.copy(band)
predicted_band[band == 1] = 1.0
predicted_band[band == 2] = 5.0
predicted_band[band == 3] = 6.0
# Let the confidence is 1/(1+row+col), where row is row number of the cell, col is column number of the cell.
confidence_band = np.zeros([rows, cols])
for i in xrange(cols):
for j in xrange(rows):
confidence_band[i,j] = 1.0/(1+i+j)
predicted_bands = [np.ma.array(data = predicted_band, mask = band.mask)]
confidence_bands = [np.ma.array(data = confidence_band, mask = band.mask)]
self.prediction = Raster()
self.prediction.create(predicted_bands, state.geodata)
self.confidence = Raster()
self.confidence.create(confidence_bands, state.geodata)
def setUp(self):
# Raster1:
#~ [1, 1, 3,],
#~ [3, 2, 1,],
#~ [0, 3, 1,]
self.raster1 = Raster('../../examples/multifact.tif')
self.raster1.resetMask([0])
self.X = np.array([
[1, 2, 3],
[3, 2, 1],
[0, 1, 1]
])
self.X = np.ma.array(self.X, mask=(self.X == 0))
self.raster2 = Raster()
self.raster2.create([self.X], self.raster1.getGeodata())
self.aa = AreaAnalyst(self.raster1, self.raster2)
self.crosstab = CrossTableManager(self.raster1, self.raster2)
# Simple model
self.model = Model(state=self.raster1)
def test_coarse(self):
reference = Raster('../../examples/data.tif')
simulated = Raster('../../examples/data1.tif')
reference.resetMask([2])
simulated.resetMask([2])
eb = EBudget(reference, simulated)
eb.coarse(2)
# W
answer = np.array([[1.0, 0.25], [0.5, 0.25]])
np.testing.assert_array_equal(eb.W, answer)
# Rj
answer1 = np.array([[1.0, 1.0], [0, 0]])
answer3 = np.array([[0, 0], [1.0, 1.0]])
ans = {1: answer1, 3: answer3}
np.testing.assert_equal(eb.Rj, ans)
# Sj
answer1 = np.array([[3.0 / 4, 0.0], [1.0, 0]])
answer3 = np.array([[1.0 / 4, 1.0], [0, 1.0]])
ans = {1: answer1, 3: answer3}
np.testing.assert_equal(eb.Sj, ans)
eb.coarse(2)
# W
answer = np.array([[0.5]])
np.testing.assert_array_equal(eb.W, answer)
# Rj
answer1 = np.array([[(1 + 1.0 / 4) / 2]])
answer3 = np.array([[(1.0 / 2 + 1.0 / 4) / 2]])
ans = {1: answer1, 3: answer3}
np.testing.assert_equal(eb.Rj, ans)
# Sj
answer1 = np.array([[(3.0 / 4 + 0.5) / 2]])
answer3 = np.array([[(1.0 / 4 + 1.0 / 4 + 1.0 / 4) / 2]])
ans = {1: answer1, 3: answer3}
np.testing.assert_equal(eb.Sj, ans)
def test_MCE(self):
data = [[1.0, 4.0, 6.0, 7.0], [1.0 / 4, 1.0, 3.0, 4.0],
[1.0 / 6, 1.0 / 3, 1.0, 2.0], [1.0 / 7, 1.0 / 4, 1.0 / 2, 1]]
# Multiband
factor = Raster('../../examples/two_band.tif')
mce = MCE([self.factor, factor, self.factor], data, 1, 2,
self.areaAnalyst)
w = mce.getWeights()
answer = [0.61682294, 0.22382863, 0.09723423, 0.06211421]
assert_almost_equal(w, answer)
# One-band
mce = MCE([self.factor, self.factor, self.factor, self.factor], data,
1, 2, self.areaAnalyst)
w = mce.getWeights()
answer = [0.61682294, 0.22382863, 0.09723423, 0.06211421]
assert_almost_equal(w, answer)
mask = [[False, False, False], [False, False, False],
[False, False, True]]
p = mce.getPrediction(self.state).getBand(1)
self.assertEquals(p.dtype, np.uint8)
answer = [ # The locations where the big numbers are stored must be masked (see mask and self.state)
[1, 3, 1], [1, 3, 1], [100, 1, 100]
]
answer = np.ma.array(data=answer, mask=mask)
assert_almost_equal(p, answer)
c = mce.getConfidence().getBand(1)
self.assertEquals(c.dtype, np.uint8)
answer = [ # The locations where the big numbers are stored must be masked (see mask and self.state)
[sum((w * 100).astype(int)) / 3, 0,
sum((w * 100).astype(int))],
[sum((w * 100).astype(int)), 0,
sum((w * 100).astype(int)) / 3],
[10000, sum((w * 100).astype(int)), 10000]
]
answer = np.ma.array(data=answer, mask=mask)
assert_almost_equal(c, answer)
def makeChangeMap(self):
rows, cols = self.geodata['ySize'], self.geodata['xSize']
band = np.zeros([rows, cols], dtype=np.int16)
f, s = self.first, self.second
if self.initRaster == None:
checkPersistent = False
else:
checkPersistent = True
t = self.initRaster.getBand(1)
raster = None
try:
self.rangeChanged.emit(self.tr("Creating change map %p%"), rows)
for i in xrange(rows):
for j in xrange(cols):
if (f.mask.shape == ()) or (not f.mask[i,j]):
r = f[i,j]
c = s[i,j]
# Percistent category is the category that is constant for all three rasters
if checkPersistent and (r==c) and (r==t[i,j]):
band[i, j] = self.persistentCategoryCode
else:
band[i, j] = self.encode(r, c)
self.updateProgress.emit()
bands = [np.ma.array(data = band, mask = f.mask, dtype=np.int16)]
raster = Raster()
raster.create(bands, self.geodata)
self.changeMap = raster
except MemoryError:
self.errorReport.emit(self.tr("The system out of memory during change map creating"))
raise
except:
self.errorReport.emit(self.tr("An unknown error occurs during change map creating"))
raise
finally:
self.processFinished.emit(raster)
def setUp(self):
self.init = Raster('../../examples/init.tif', maskVals={1: [255]})
self.final = Raster('../../examples/final.tif', maskVals={1: [255]})
def _predict(self, state, factors, calcTransitions=False):
'''
Calculate output and confidence rasters using LR model and input rasters
@param state Raster of the current state (categories) values.
@param factors List of the factor rasters (predicting variables).
'''
try:
self.rangeChanged.emit(self.tr("Initialize model %p%"), 1)
geodata = state.getGeodata()
rows, cols = geodata['ySize'], geodata['xSize']
for r in factors:
if not state.geoDataMatch(r):
raise LRError(
'Geometries of the input rasters are different!')
self.transitionPotentials = None # Reset tr.potentials if they exist
# Normalize factors before prediction:
for f in factors:
f.normalize(mode='mean')
predicted_band = np.zeros([rows, cols], dtype=np.uint8)
confidence_band = np.zeros([rows, cols], dtype=np.uint8)
if calcTransitions:
self.transitionPotentials = {}
for cat in self.catlist:
self.transitionPotentials[cat] = np.zeros([rows, cols],
dtype=np.uint8)
self.sampler = Sampler(state, factors, ns=self.ns)
mask = state.getBand(1).mask.copy()
if mask.shape == ():
mask = np.zeros([rows, cols], dtype=np.bool)
self.updateProgress.emit()
self.rangeChanged.emit(self.tr("Prediction %p%"), rows)
for i in xrange(rows):
for j in xrange(cols):
if not mask[i, j]:
input = self.sampler.get_inputs(state, i, j)
if input != None:
input = np.array([input])
out = self.logreg.predict(input)
predicted_band[i, j] = out
confidence = self._outputConfidence(input)
confidence_band[i, j] = confidence
if calcTransitions:
potentials = self.outputTransitions(input)
for cat in self.catlist:
map = self.transitionPotentials[cat]
map[i, j] = potentials[cat]
else: # Input sample is incomplete => mask this pixel
mask[i, j] = True
self.updateProgress.emit()
predicted_bands = [
np.ma.array(data=predicted_band, mask=mask, dtype=np.uint8)
]
confidence_bands = [
np.ma.array(data=confidence_band, mask=mask, dtype=np.uint8)
]
self.prediction = Raster()
self.prediction.create(predicted_bands, geodata)
self.confidence = Raster()
self.confidence.create(confidence_bands, geodata)
if calcTransitions:
for cat in self.catlist:
band = [
np.ma.array(data=self.transitionPotentials[cat],
mask=mask,
dtype=np.uint8)
]
self.transitionPotentials[cat] = Raster()
self.transitionPotentials[cat].create(band, geodata)
except MemoryError:
self.errorReport.emit(
self.tr("The system out of memory during LR prediction"))
raise
except:
self.errorReport.emit(
self.tr("An unknown error occurs during LR prediction"))
raise
finally:
self.processFinished.emit()
def test_WoeManager(self):
aa = AreaAnalyst(self.sites, self.sites)
w1 = WoeManager([self.factor], aa)
w1.train()
p = w1.getPrediction(self.sites).getBand(1)
answer = [[0, 3, 0], [0, 3, 0], [9, 0, 3]]
answer = ma.array(data=answer, mask=self.mask)
assert_array_equal(p, answer)
initState = Raster('../../examples/data.tif')
#~ [1,1,1,1],
#~ [1,1,2,2],
#~ [2,2,2,2],
#~ [3,3,3,3]
finalState = Raster('../../examples/data1.tif')
#~ [1,1,2,3],
#~ [3,1,2,3],
#~ [3,3,3,3],
#~ [1,1,3,2]
aa = AreaAnalyst(initState, finalState)
w = WoeManager([initState], aa)
w.train()
#print w.woe
p = w.getPrediction(initState).getBand(1)
self.assertEquals(p.dtype, np.uint8)
# Calculate by hands:
#1->1 transition raster:
r11 = [[1, 1, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
#1->2 raster:
r12 = [[0, 0, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
#1->3 raster:
r13 = [[0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
# 2->1
r21 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
# 2->2
r22 = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
# 2->3
r23 = [[0, 0, 0, 0], [0, 0, 0, 1], [1, 1, 1, 1], [0, 0, 0, 0]]
# 3->1
r31 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 1, 0, 0]]
# 3->2
r32 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1]]
# 3->3
r33 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]]
geodata = initState.getGeodata()
sites = {
'11': r11,
'12': r12,
'13': r13,
'21': r21,
'22': r22,
'23': r23,
'31': r31,
'32': r32,
'33': r33
}
woeDict = {} # WoE of transitions
for k in sites.keys(): #
if k != '21': # !!! r21 is zero
x = Raster()
x.create([np.ma.array(data=sites[k])], geodata)
sites[k] = x
woeDict[k] = woe(initState.getBand(1), x.getBand(1))
#w1max = np.maximum(woeDict['11'], woeDict['12'], woeDict['13'])
#w2max = np.maximum(woeDict['22'], woeDict['23'])
#w3max = np.maximum(woeDict['31'], woeDict['32'], woeDict['33'])
# Answer is a transition code with max weight
answer = [[0, 0, 0, 0], [0, 0, 5, 5], [5, 5, 5, 5], [6, 6, 6, 6]]
assert_array_equal(p, answer)
w = WoeManager([initState], aa, bins={
0: [
[2],
],
})
w.train()
p = w.getPrediction(initState).getBand(1)
self.assertEquals(p.dtype, np.uint8)
c = w.getConfidence().getBand(1)
self.assertEquals(c.dtype, np.uint8)
def test_create(self):
raster = Raster()
raster.create([self.data1], geodata=self.r1.getGeodata())
self.assertTrue(raster.geoDataMatch(self.r1))
self.assertEqual(raster.getBandsCount(), 1)
self.assertEqual(set(raster.getBandGradation(1)), set([0, 1, 2, 3]))
def main(initRaster, finalRaster, factors):
print 'Start Reading Init Data...', clock()
initRaster = Raster(initRaster)
finalRaster = Raster(finalRaster)
factors = [Raster(rasterName) for rasterName in factors]
print 'Finish Reading Init Data', clock(), '\n'
print "Start Making CrossTable...", clock()
crosstab = CrossTableManager(initRaster, finalRaster)
#print crosstab.getTransitionStat()
print "Finish Making CrossTable", clock(), '\n'
# Create and Train Analyst
print 'Start creating AreaAnalyst...', clock()
analyst = AreaAnalyst(initRaster, finalRaster)
print 'Finish creating AreaAnalyst ...', clock(), '\n'
print 'Start Making Change Map...', clock()
analyst = AreaAnalyst(initRaster, finalRaster)
changeMap = analyst.getChangeMap()
print 'Finish Making Change Map', clock(), '\n'
#~ # Create and Train ANN Model
model = MlpManager(ns=1)
model.createMlp(initRaster, factors, changeMap, [10])
print 'Start Setting MLP Trainig Data...', clock()
model.setTrainingData(initRaster,
factors,
changeMap,
mode='Stratified',
samples=1000)
print 'Finish Setting Trainig Data', clock(), '\n'
print 'Start MLP Training...', clock()
model.train(20, valPercent=20)
print 'Finish Trainig', clock(), '\n'
# print 'Start ANN Prediction...', clock()
# predict = model.getPrediction(initRaster, factors, calcTransitions=True)
# confidence = model.getConfidence()
# potentials = model.getTransitionPotentials()
#~ # Create and Train LR Model
#~ model = LR(ns=0)
#~ print 'Start Setting LR Trainig Data...', clock()
#~ model.setState(initRaster)
#~ model.setFactors(factors)
#~ model.setOutput(changeMap)
#~ model.setMode('Stratified')
#~ model.setSamples(100)
#~ model.setTrainingData()
#~ print 'Finish Setting Trainig Data', clock(), '\n'
#~ print 'Start LR Training...', clock()
#~ model.train()
#~ print 'Finish Trainig', clock(), '\n'
#~
#~ print 'Start LR Prediction...', clock()
#~ predict = model.getPrediction(initRaster, factors, calcTransitions=True)
#~ print 'Finish LR Prediction...', clock(), '\n'
# Create and Train WoE Model
# print 'Start creating AreaAnalyst...', clock()
# analyst = AreaAnalyst(initRaster, finalRaster)
# print 'Finish creating AreaAnalyst ...', clock(), '\n'
# print 'Start creating WoE model...', clock()
# bins = {0: [[1000, 3000]], 1: [[200, 500, 1500]]}
# model = WoeManager(factors, analyst, bins= bins)
# model.train()
# print 'Finish creating WoE model...', clock(), '\n'
#~ # Create and Train MCE Model
#~ print 'Start creating MCE model...', clock()
#~ matrix = [
#~ [1, 6],
#~ [1.0/6, 1]
#~ ]
#~ model = MCE(factors, matrix, 2, 3, analyst)
#~ print 'Finish creating MCE model...', clock(), '\n'
# predict = model.getPrediction(initRaster, factors, calcTransitions=True)
# confidence = model.getConfidence()
# potentials = model.getTransitionPotentials()
# filename = 'predict.tif'
# confname = 'confidence.tif'
# trans_prefix='trans_'
# try:
# predict.save(filename)
# confidence.save(confname)
# if potentials != None:
# for k,v in potentials.iteritems():
# map = v.save(trans_prefix+str(k) + '.tif')
# finally:
# os.remove(filename)
# #pass
# print 'Finish Saving...', clock(), '\n'
# simulation
print 'Start Simulation...', clock()
simulator = Simulator(initRaster, factors, model, crosstab)
# Make 1 cycle of simulation:
simulator.setIterationCount(1)
simulator.simN()
monteCarloSim = simulator.getState() # Result of MonteCarlo simulation
errors = simulator.errorMap(finalRaster) # Risk class validation
riskFunct = simulator.getConfidence() # Risk function
try:
monteCarloSim.save('simulation_result.tiff')
errors.save('risk_validation.tiff')
riskFunct.save('risk_func.tiff')
finally:
pass
# os.remove('simulation_result.tiff')
# os.remove('risk_validation.tiff')
# os.remove('risk_func.tiff')
print 'Finish Simulation', clock(), '\n'
print 'Done', clock()
def test_isContinues(self):
rast = Raster('examples/multifact.tif')
self.assertFalse(rast.isCountinues(bandNo=1))
rast = Raster('examples/dist_roads.tif')
self.assertTrue(rast.isCountinues(bandNo=1))
