def index(request):
if request.method == 'POST':
username = request.POST['username']
select = request.POST['select']
if select=='starcraft':
id = request.POST['id']
data = main.getData(username,select,id=id)
return profile_view(request,username,data,select)
if select=='wow':
realm = request.POST['realm']
data = main.getData(username,select,realm=realm)
return profile_view(request,username,data,select)
if select=='steam':
data = main.getData(username,select)
return profile_view(request,username,data,select)
if select=='crysis':
data = main.getData(username,select)
return profile_view(request,username,data,select)
return render_to_response("ggapi/index.html",context_instance=RequestContext(request))
def data():
if request.method == "POST":
global abc
global DP, Gr, CW
result = request.form
abc = result
Distress_time=result['Distress_time']
Distress_position=result['Distress_position']
if (Distress_position or Distress_time):
Datum_point,Grid,Cell_Width=main.getData(result)
if not(Distress_position and Distress_time):
Datum_point,Datum_line,Grid,Cell_Width=main.getData(result)
DP = Datum_point
Gr = Grid
CW = Cell_Width
print(Datum_point,Grid,Cell_Width)
return dash(result)
if request.method == "GET":
return render_template("dataCollect.html")
def test_pad_list_of_lists__same_size(self):
from main import get_rdf_data as getData
from main import pad_list_of_lists as testMethod
data = getData('rdfData/gfo-1.0.json')
list = testMethod(data['supports'])
for i in range(len(list)):
element = list[i]
for j in range(len(element)-1):
self.assertEqual(len(element[j]), len(element[j+1]))
def initialTrain():
state = main.getData()
main.startGame()
# If it's the first step
while not main.getDone():
# Random action
action = random.choice([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]])
# Get the rewards
reward = main.getReward(action)
# Look if the episode is finished
done = main.getDone()
# If we're dead
if done:
# We finished the episode
next_state = np.zeros([5])
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# First we need a state
state = main.getData()
# Stack the frames
else:
# Get the next state
next_state = main.getData()
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# Our state is now the next_state
state = next_state
main.initialize()
train()
def getGaitEvents(self):
# If negative minima is found,
# then first positive maxima is HS
# negative minima
if (not self.foundNegMinima and self.previousShankAngVelYDifference < 0
and self.shankAngVelYDifference > 0
and self.previousShankAngVelY < 0):
self.foundNegMinima = True
# positive maxima for shank ang vel X
if (not self.foundPosMaxima and self.previousShankAngVelXDifference > 0
and self.shankAngVelXDifference < 0
and self.previousShankAngVelX > 0):
self.foundPosMaxima = True
# positive maxima
if (self.foundNegMinima and self.foundPosMaxima
and self.previousShankAngVelYDifference > 0
and self.shankAngVelYDifference < 0
and self.previousShankAngVelY > 0):
self.gaitData['HS']['Row'].append(self.row)
self.gaitData['HS']['Shank Accel Z'].append(self.shankAccelZ)
self.foundNegMinima = False
self.foundPosMaxima = False
HSstartRow = self.row
while (self.row - HSstartRow < main.convertMilliSecToRow(
self.frequency, 300) and self.row < self.lastRow):
self.row += 1
main.getData(self)
main.setPreviousData(self)
else:
main.setPreviousData(self)
def map():
formData = {
"origin": None,
"destination": None,
"soc": None,
}
returnData = {}
if request.method == 'POST':
formData['origin'] = request.form.get(
'origin') # access the data inside
formData['destination'] = request.form.get('destination')
formData['soc'] = request.form.get('soc')
returnData = getData(formData['origin'], formData['destination'],
formData['soc'])
if returnData['energyA'] and returnData[
'energy'] and returnData['energyA'] < returnData['energy']:
returnData['waypoints'] = 'MH SH 79, Pali T. Waredi, Maharashtra'
return render_template('map.html',
active='map',
data=formData,
returnData=returnData)
def getGaitEventsWithThresholdAnd300MSPositive(self):
# If there are 5 HS events are already found, use 70% of the average to be the threshold to find the next positive maxima in ang velY
if (len(self.gaitData['HS']['Shank Ang Vel Y']) > 5):
if (len(self.gaitData['HS']['Shank Ang Vel Y']) == 6):
subArray = self.gaitData['HS']['Shank Ang Vel Y'][:5]
self.averageMax = sum(subArray) / 5
# print("ANG VEL Y VALUES = ", self.gaitData['HS']['Row'])
# print("ANG VEL Y VALUES = ", self.gaitData['HS']['Shank Ang Vel Y'])
# print("AVERAGE MAX = ", self.averageMax)
# negative minima
if (not self.foundNegMinima and self.previousShankAngVelYDifference < 0
and self.shankAngVelYDifference > 0
and self.previousShankAngVelY < 0):
self.foundNegMinima = True
# positive maxima
if (self.foundNegMinima and self.previousShankAngVelYDifference > 0
and self.shankAngVelYDifference < 0
and self.previousShankAngVelY > self.averageMax):
self.foundNegMinima = False
self.foundPosMaxima = False
HSstartRow = self.row
shankAngVelYPositive = True
# check if shankAngVelY is positive for 300 ms
while (shankAngVelYPositive
and self.row - HSstartRow < main.convertMilliSecToRow(
self.frequency, 300) and self.row < self.lastRow):
self.row += 1
main.getData(self)
main.setPreviousData(self)
if (self.shankAngVelY < 0):
shankAngVelYPositive = False
# if shankAngVelY stayed positive for 300 ms, then add HS event
if shankAngVelYPositive:
self.gaitData['HS']['Row'].append(self.row)
self.gaitData['HS']['Shank Ang Vel Y'].append(
self.previousShankAngVelY)
else:
main.setPreviousData(self)
else:
# negative minima
if (not self.foundNegMinima and self.previousShankAngVelYDifference < 0
and self.shankAngVelYDifference > 0
and self.previousShankAngVelY < 0):
self.foundNegMinima = True
# positive maxima for shank ang vel X
if (not self.foundPosMaxima and self.previousShankAngVelXDifference > 0
and self.shankAngVelXDifference < 0
and self.previousShankAngVelX > 0):
self.foundPosMaxima = True
# positive maxima
if (self.foundNegMinima and self.foundPosMaxima
and self.previousShankAngVelYDifference > 0
and self.shankAngVelYDifference < 0
and self.previousShankAngVelY > 0):
self.gaitData['HS']['Row'].append(self.row)
self.gaitData['HS']['Shank Ang Vel Y'].append(self.shankAngVelY)
self.foundNegMinima = False
self.foundPosMaxima = False
HSstartRow = self.row
while (self.row - HSstartRow < main.convertMilliSecToRow(
self.frequency, 300) and self.row < self.lastRow):
self.row += 1
main.getData(self)
main.setPreviousData(self)
else:
main.setPreviousData(self)
def searchBestForest(params, client):
c = client
print(c)
data = getDataForTraining(getData())
data.to_csv('../ignore/dataPrepared.csv')
data = dd.read_csv('../ignore/dataPrepared.csv').drop(columns='Unnamed: 0')
X_train, X_test, y_train, y_test = train_test_split(
data.drop(columns='price'), data.price, test_size=0.2)
[ele.compute() for ele in [X_train, X_test, y_train, y_test]]
with joblib.parallel_backend('dask'):
model = RandomForestRegressor(bootstrap=True,
criterion='mse',
max_depth=10,
max_features='auto',
max_leaf_nodes=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0.0,
n_estimators=200,
n_jobs=None,
oob_score=False,
random_state=None,
verbose=0,
warm_start=False)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
bestMod = {'model': model, 'R2_score': r2_score(y_test, y_pred)}
contador = 1
print(bestMod)
for estimators in params['n_estimators']:
for features in params['max_features']:
for dep in params['max_depth']:
for samples in params['min_samples_split']:
for samplesL in params['min_samples_leaf']:
for boot in params['bootstrap']:
model = RandomForestRegressor(
bootstrap=boot,
criterion='mse',
max_depth=dep,
max_features=features,
max_leaf_nodes=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=samplesL,
min_samples_split=samples,
min_weight_fraction_leaf=0.0,
n_estimators=estimators,
n_jobs=None,
oob_score=False,
random_state=None,
verbose=0,
warm_start=False)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
r2 = r2_score(y_test, y_pred)
if r2 > bestMod['R2_score']:
bestMod = {'model': model, 'R2_score': r2}
print(bestMod)
del model
import numpy as np
import matplotlib.pyplot as plt
import main as func
import pandas as pd
url1 = 'https://www.bps.go.id/dynamictable/2017/05/04/1243/indeks-kebahagiaan-menurut-provinsi-2014-2017.html'
soup1 = func.getData(url1)
# find results within table
result_wilayah = soup1.find('table', attrs={'id': 'tableLeftBottom'})
result_value = soup1.find('table', attrs={'id': 'tableRightBottom'})
rows_wilayah = result_wilayah.find_all('tr')
rows_value = result_value.find_all('tr')
data_ipm = {}
for id, r in enumerate(rows_wilayah[:-1]):
# find all columns per result
data_result = r.find_all('td', attrs={'id': 'th4'})
data_value = rows_value[id].find_all('td', attrs={'class': 'datas'})
# check that columns have data
if len(data_result) == 0:
continue
wilayah = data_result[0].getText()
wilayah = wilayah.replace('\n', '')
nilai = data_value[-1].getText()
# Remove decimal point
nilai = nilai.replace('.', '')
# Cast Data Type Integer
nilai = int(nilai)
# Import Libraries
import main as function
import numpy as np
import matplotlib.pyplot as plt
# Specify the URL
url = 'https://kawalpemilu.org/#pilpres:0'
soup = function.getData(url)
# Find results within table
results = soup.find('table', {'class': 'table'})
rows = results.find_all('tr', {'class': 'row'})
list_wilayah = []
jokowi = []
prabowo = []
# Print(rows)
for r in rows:
# Find columns per result
data = r.find_all('td')
# check that columns have data
if len(data) == 0:
continue
# Write columns to variables
wilayah = data[1].find('a').getText()
capres1 = data[2].find('span', attrs={'class': 'abs'}).getText()
capres2 = data[3].find('span', attrs={'class': 'abs'}).getText()
#Removing decimal point
capres1 = capres1.replace('.', '')
capres2 = capres2.replace('.', '')
from __future__ import print_function
import numpy as np
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import main
batch_size = 128
# num_classes = 10
epochs = 20
# the data, shuffled and split between train and test sets
X, y = main.getData()
X = np.array(X)
y = np.array(y)
l = len(X)
x_train = X[:int(0.6 * l)]
y_train = y[:int(0.6 * l)]
x_val = X[int(0.6 * l):int(0.8 * l)]
y_val = y[int(0.6 * l):int(0.8 * l)]
x_test = X[int(0.8 * l):]
y_test = y[int(0.8 * l):]
# x_train = x_train.reshape(l, 4)
# x_test = x_test.reshape(10000, 784)
# x_train = x_train.astype('float32')
# x_test = x_test.astype('float32')
# x_train /= 255
# x_test /= 255
def train():
global randomMoves, totalMoves, gamma
with tf.Session() as sess:
# Initialize the variables
sess.run(tf.global_variables_initializer())
# Initialize the decay rate (that will use to reduce epsilon)
decay_step = 0
if main.model != None:
print("oh no")
saver.restore(sess, main.model[0:-6])
decay_step = 1000000
# Init the game
instance = 0
while (training):
# Set step to 0
instance += 1
# Initialize the rewards of the episode
episode_rewards = []
# Make a new episode and observe the first state
main.startGame()
if main.getPlaying() == False:
main.setPlaying(True)
state = main.getData()
randomMoves = 0
totalMoves = 0
while main.getPlaying():
if main.ticks != 1000:
main.pygame.time.Clock().tick(main.ticks)
# Increase decay_step
decay_step += 1
# Predict the action to take and take it
action, explore_probability = predict_action(
explore_start, explore_stop, decay_rate, decay_step, state,
[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]],
sess)
# Do the action
reward = main.getReward(action)
# Look if the episode is finished
done = main.getPlaying()
# Add the reward to total reward
episode_rewards.append(reward)
# If the game is finished
if not done:
# the episode ends so no next state
next_state = np.zeros((5), dtype=np.int)
# Get the total reward of the episode
total_reward = np.sum(episode_rewards)
print('Episode: {}'.format(main.getGen()),
'Total reward: {:.4f}'.format(total_reward),
'Explore P: {:.4f}'.format(explore_probability),
'Moves: R:', randomMoves, ' T:', totalMoves)
memory.add((state, action, reward, next_state, done))
else:
# Get the next state
next_state = main.getData()
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# st+1 is now our current state
state = next_state
### LEARNING PART
# Obtain random mini-batch from memory
batch = memory.sample(batch_size)
states_mb = np.array([each[0] for each in batch], ndmin=2)
actions_mb = np.array([each[1] for each in batch])
rewards_mb = np.array([each[2] for each in batch])
next_states_mb = np.array([each[3] for each in batch], ndmin=2)
dones_mb = np.array([each[4] for each in batch])
target_Qs_batch = []
# Get Q values for next_state
Qs_next_state = sess.run(
DQNetwork.output,
feed_dict={DQNetwork.inputs_: next_states_mb})
# Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma*maxQ(s', a')
for i in range(0, len(batch)):
terminal = dones_mb[i]
# If we are in a terminal state, only equals reward
if terminal:
target_Qs_batch.append(rewards_mb[i])
else:
target = rewards_mb[i] + gamma * np.max(
Qs_next_state[i])
target_Qs_batch.append(target)
targets_mb = np.array([each for each in target_Qs_batch])
loss, _ = sess.run(
[DQNetwork.loss, DQNetwork.optimizer],
feed_dict={
DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb
})
# Write TF Summaries
summary = sess.run(write_op,
feed_dict={
DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb
})
writer.add_summary(summary, instance)
writer.flush()
# Save model every 10 episodes
if instance % 100 == 0:
save_path = saver.save(
sess, dir_path + "/models/model" + str(instance) + ".ckpt")
print("Model Saved")