def rank(self, radius, input_name, element_names, beacon_radius_id,
robot_radius_id, sensor_radius):
radius_diff = robot_radius_id - beacon_radius_id
regions = []
regions.append([0.0, beacon_radius_id - radius_diff, beacon_radius_id])
regions.append([
beacon_radius_id - radius_diff, beacon_radius_id, robot_radius_id
])
regions.append(
[beacon_radius_id, robot_radius_id, robot_radius_id + radius_diff])
regions.append(
[robot_radius_id, robot_radius_id + radius_diff, sensor_radius])
fzi = fuzzySignal(input_name)
for i in range(len(element_names)):
fzi.addRegion(element_names[i], trimf(regions[i]))
f = fuzzy('Dupa')
f.addInSignal(fzi)
f.addOutSignal(fzi)
for i in range(len(element_names)):
f.addRule(rule({input_name: element_names[i]}, element_names[i]))
k = f.evaluate({input_name: radius})
return max(k, key=k.get)
def setfitness(self): fuzz = fuzzy(data_training,self.nilai) self.fitness = fuzz.akurasi + 1
radius_diff = robot_radius_id - beacon_radius_id
void = [0.0, beacon_radius_id - radius_diff, beacon_radius_id]
beacon = [beacon_radius_id - radius_diff, beacon_radius_id, robot_radius_id]
robot = [beacon_radius_id, robot_radius_id, robot_radius_id + radius_diff]
alien = [robot_radius_id, robot_radius_id + radius_diff, sensor_radius]
aa = fuzzySignal('radius')
aa.addRegion('Void', trimf(void))
aa.addRegion('Beacon', trimf(beacon))
aa.addRegion('Robot', trimf(robot))
aa.addRegion('Alien',
trimf([robot_radius_id, sensor_radius, 2 * sensor_radius]))
ff = fuzzy('Dupa')
ff.addInSignal(aa)
ff.addOutSignal(aa)
ff.addRule(rule({'radius': 'Void'}, 'Void'))
ff.addRule(rule({'radius': 'Beacon'}, 'Beacon'))
ff.addRule(rule({'radius': 'Robot'}, 'Robot'))
ff.addRule(rule({'radius': 'Alien'}, 'Alien'))
r = 0.0
print "Void", void
print "Beacon", beacon
print "Robot", robot
print "Alien", alien
while r < sensor_radius / 10:
def rankAvoidation(self, sensorRadius, obtainedRadiusToBeacon,
desiredRadiusToBeacon, obtainedDistanceToRobot,
minDistanceBetweenRobots,
obtainedDistanceFromBeaconToRobot):
sR = sensorRadius
oRtB = obtainedRadiusToBeacon
dRtB = desiredRadiusToBeacon
oDtR = obtainedDistanceToRobot
oDfBtR = obtainedDistanceFromBeaconToRobot
mDbR = minDistanceBetweenRobots
medDbR = mDbR + (sR - mDbR) / 2.0
minRtB = min(dRtB, oRtB) / 2.0 - mDbR
maxRtB = max(dRtB, oRtB) / 2.0 + mDbR
#INPUT 1
distance = 'distance'
fzi_d = fuzzySignal(distance)
fzi_d.addRegion('low', trimf([0.0, mDbR, medDbR]))
fzi_d.addRegion('middle', trimf([mDbR, medDbR, sR]))
fzi_d.addRegion('high', trimf([medDbR, sR, 2 * sR]))
#INPUT 2
localization = 'localization'
fzi_l = fuzzySignal(localization)
fzi_l.addRegion('left', trimf([0.0, minRtB, dRtB]))
fzi_l.addRegion('center', trimf([minRtB, dRtB, maxRtB]))
fzi_l.addRegion('right', trimf([dRtB, maxRtB, 2 * sR]))
#OUTPUT 1
fzo_d = fuzzySignal('avoidation')
fzo_d.addRegion('left', trimf([0.0, mDbR,
medDbR])) #trimf([-1.0, -0.5, 0.0]))
fzo_d.addRegion('center', trimf([mDbR, medDbR,
sR])) #trimf([-0.5, 0.0, 0.5]))
fzo_d.addRegion('right', trimf([medDbR, sR,
2 * sR])) #trimf([ 0.0, 0.5, 1.0]))
fav = fuzzy('av')
fav.addInSignal(fzi_d)
fav.addInSignal(fzi_l)
fav.addOutSignal(fzo_d)
fav.addRule(rule({'distance': 'low', 'localization': 'left'}, 'right'))
fav.addRule(
rule({
'distance': 'low',
'localization': 'center'
}, 'center'))
fav.addRule(rule({'distance': 'low', 'localization': 'right'}, 'left'))
fav.addRule(
rule({
'distance': 'middle',
'localization': 'left'
}, 'right'))
fav.addRule(
rule({
'distance': 'middle',
'localization': 'center'
}, 'center'))
fav.addRule(
rule({
'distance': 'middle',
'localization': 'right'
}, 'left'))
fav.addRule(
rule({
'distance': 'high',
'localization': 'left'
}, 'center'))
fav.addRule(
rule({
'distance': 'high',
'localization': 'center'
}, 'center'))
fav.addRule(
rule({
'distance': 'high',
'localization': 'right'
}, 'center'))
#EVALUATION
av = fav.evaluate({distance: oDtR, localization: oDfBtR})
return max(av, key=av.get)
sigbmkg3 = "III"
elif ((sensor3 >= 168) and (sensor3 <= 564)):
sigbmkg3 = "IV"
else:
sigbmkg3 = "V"
print(sensorPGA0, sigbmkg, long0, lat0, tanggal0, waktu0, sensor1)
print(sensorPGA1, sigbmkg2, long1, lat1, tanggal1, waktu1, sensor2)
print(sensorPGA2, sigbmkg3, long2, lat2, tanggal2, waktu2, sensor3)
if (hehe0 != waktu0) or (hehe1 != waktu1) or (hehe2 != waktu2):
pga1 = sensor1
pga2 = sensor2
pga3 = sensor3
hasil, tanggal, waktu = fuzzy(pga1, pga2, pga3)
#print("Fuzzy: ",hasil, tanggal, waktu)
akurasi, hasilknn, tanggalknn, waktuknn = knn(pga1, pga2, pga3)
#print("KNN: ", akurasi,"%",hasilknn,tanggalknn,waktuknn)
if (alat == 0):
data = {'h': hasil}
antares.setAccessKey('d2a4e28b0c316687:41fd4960fcee58c8')
antares.send(data, 'EarthquakeDetector', 'output')
else:
data = {'h': hasilknn}
antares.setAccessKey('d2a4e28b0c316687:41fd4960fcee58c8')
antares.send(data, 'EarthquakeDetector', 'output')
aa.addRegion('B',trimf([0,1,2]))
bb = fuzzySignal('x2')
bb.addRegion('S',trimf([-2,-1,0]))
bb.addRegion('C',trimf([-1,0,1]))
bb.addRegion('B',trimf([0,1,2]))
cc = fuzzySignal('y1')
cc.addRegion('S',trimf([-2,-1,0]))
cc.addRegion('C',trimf([-1,0,1]))
cc.addRegion('B',trimf([0,1,2]))
ff = fuzzy('Dupa')
ff.addInSignal(aa)
ff.addInSignal(bb)
ff.addOutSignal(cc)
ff.addRule(rule({'x1':'S','x2':'S'},'B'))
ff.addRule(rule({'x1':'S','x2':'C'},'B'))
ff.addRule(rule({'x1':'S','x2':'B'},'C'))
ff.addRule(rule({'x1':'C','x2':'S'},'B'))
ff.addRule(rule({'x1':'C','x2':'C'},'C'))
ff.addRule(rule({'x1':'C','x2':'B'},'S'))
ff.addRule(rule({'x1':'B','x2':'S'},'C'))
ff.addRule(rule({'x1':'B','x2':'C'},'S'))
from fuzzy import *
from svm import *
from dtree import *
from mlp import *
import timeit
import matplotlib.pyplot as plt
if __name__ == "__main__":
accuracy=[]
memory_used=[]
time=[]
algos=["SVM","MLP","DTree"]
fuzzy()
accuracy.append(svm_algo())
time.append(timeit.repeat(repeat=1))
memory_used.append(memory_usage_psutil())
accuracy.append(mlp())
time.append(timeit.repeat(repeat=1))
memory_used.append(memory_usage_psutil())
accuracy.append(dtree())
time.append(timeit.repeat(repeat=1))
memory_used.append(memory_usage_psutil())
fig=plt.figure()
plt.title("Execution Time Vs Algorithm")
plt.plot(algos,time)
plt.xlabel('Algorithm')