def _set_configuration(args):
"""
This method using for set configurations of program and logger
:param args: arguments from user console input
:return: exit code
"""
conf_type_obj = args.pop(ParserArgs.CONFIG_TYPE.name)
if conf_type_obj == ParserArgs.SETTINGS.name:
storage_path = args.pop(ParserArgs.STORAGE_PATH.dest)
try:
Configuration.edit_settings(storage_path)
except Exception as e:
sys.stderr.write(str(e))
return ERROR_CODE
print('Program settings edited...')
elif conf_type_obj == ParserArgs.LOGGER.name:
level = args.pop(ParserArgs.LOGGER_LEVEL.dest)
enabled = args.pop(ParserArgs.ENABLED_LOGGER.dest)
log_file_path = args.pop(ParserArgs.LOG_FILE_PATH.dest)
Configuration.edit_logger_configs(Files.LOG_CONFIG, level, enabled,
log_file_path)
print('Logger configs edited...')
return 0
def start_ai():
global running
keyboard = Controller()
running = True
keys = File.read_keys(Configuration.get_selected_game())
labels = File.read_labels(Configuration.get_selected_game())
model = create_model()
dir = os.path.dirname(
File.get_checkpoint_file(Configuration.get_selected_game()))
latest = tf.train.latest_checkpoint(dir)
model.load_weights(latest)
class_amount = len(File.read_labels(Configuration.get_selected_game()))
yolo_model = File.get_yolo_cfg_file_fullpath(class_amount)
label_path = File.get_yolo_label_textfile_fullpath(
Configuration.get_selected_game())
options = {
'model': yolo_model,
'load': latest_checkpoint(),
'threshold': 0.2,
'gpu': 0.8,
'labels': label_path
}
tfnet = TFNet(options)
while running:
img = ImageGrab.grab()
img_np = np.array(img)
frame = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)
results = tfnet.return_predict(frame)
reset_label_dict(labels)
shorten_list(results)
tensor = []
for label in label_data_dict:
tensor.append(int(label_data_dict[label][0]))
tensor.append(int(label_data_dict[label][1]))
tensor.append(int(label_data_dict[label][2]))
tensor.append(int(label_data_dict[label][3]))
#print(tensor)
single_row = np.expand_dims(tensor, axis=0)
retval = model.predict(single_row)[0]
for index, val in enumerate(retval):
mapped_key = get_key_code(keys[index])
print(val)
if (val < 0.5):
keyboard.release(mapped_key)
print('released: ' + str(mapped_key))
if (val > 0.5):
keyboard.press(mapped_key)
print('pressed: ' + str(mapped_key))
print(keys)
print(retval)
return
def _reset_configuration(conf_type_obj):
if (conf_type_obj == ParserArgs.LOGGER.name
and os.path.exists(Files.LOG_CONFIG)):
os.remove(Files.LOG_CONFIG)
print('Logger configs reset...')
if (conf_type_obj == ParserArgs.SETTINGS.name
and os.path.exists(Files.SETTINGS)):
Files.set_default()
Configuration.reset_settings()
os.remove(Files.SETTINGS)
print('Program settings reset...')
return 0
def __init__(self, config: Configuration):
self.WIDGET_SPACING = 8
# self.configuration = config
config.widgets['settings-window-box'] = self
print(config.widgets)
self.setup_ui()
def register_participant(self, routing_identifier: str) -> None:
if not self.__client.is_connected:
self._error("NATS.IO CLIENT NOT CONNECTED")
return None
try:
node: str = Configuration.get_instance().node()
request: ParticipantJoined = ParticipantJoined(
identifier=routing_identifier, node=node)
response = self.__client.request(
subject="{}/{}".format(ADDRESS_SERVICE, "/register"),
payload=request.SerializeToString())
result: Result = Result()
result.ParseFromString(response.data)
if result.status == Result.Status.SUCCESS:
self._info("REGISTERED TO NODE: {} TO NODE: {} \n {}".format(
routing_identifier, node, result.message))
elif result.status == Result.Status.SUCCESS:
self._error(
"FAILED TO REGISTER :{} TO NODE: {} TO NONE: {} \n {}".
format(routing_identifier, node, result.message))
except ErrConnectionClosed as e:
self._error("Connection closed prematurely. {}", e)
return None
except ErrTimeout as e:
self._error("Timeout occurred when publishing msg :{}".format(e))
return None
async def test_subscription(self):
payload = ParticipantPassOver()
payload.sender_identifier = "XXXXXX"
payload.target_identifier = "YYYYYY"
payload.originating_node = "saber-fox"
payload.payload = "guniowevw".encode()
await self.__client.publish(
subject="v1/node/{}/participants/pass-over".format(
Configuration.get_instance().node()),
payload=payload.SerializeToString())
def migrate() -> None:
configuration: Configuration = Configuration.get_instance()
click.echo("DATABASE URL: {}\n".format(configuration.database_uri()))
click.echo("MIGRATIONS FOLDER: {}\n".format(MIGRATIONS_FOLDER))
handler = SQLMigrationHandler(
database_url=configuration.database_uri(),
migration_folder=MIGRATIONS_FOLDER
)
handler.migrate()
def run_build_cli(dry_run: bool, branch: str, commit_id: str):
from app.build import Build
from app.configuration import Configuration
from app.runner import Runner
conf = Configuration.from_file('config.yml', branch, commit_id)
conf.dry_run = dry_run
build = Build.from_configuration(conf)
runner = Runner.from_build(build)
runner.run()
def lstm_prediction(indicator_file_name, data_input):
modelh5_path = Configuration.get_file_model_file(indicator_file_name)
# initialize the Recurrent Neural Network
# Solving pattern with sequence of data
regressor = keras.models.load_model(modelh5_path)
predicted_price = regressor.predict(data_input)
result = {
'summary': str(regressor.summary()),
'predicted_price': predicted_price
}
return result
def setUp(self) -> None:
configuration: Configuration = Configuration.get_instance(testing=True)
self.migration_handler = SQLMigrationHandler(
database_url=configuration.database_uri(),
migration_folder=MIGRATIONS_FOLDER)
self.migration_handler.migrate()
self.__debug = True
engine = create_engine(configuration.database_uri(), echo=self.__debug)
session_factory = sessionmaker(bind=engine)
self.session = scoped_session(session_factory)
BaseModel.set_session(session=self.session)
BaseModel.prepare(engine, reflect=True)
def get():
"""RNN Learning [get] method
Returns:
Response: The response
"""
indicator_files = []
indicator_files = Configuration.get_files()
message = json.dumps({
"api_version": "1.0.0",
"indicator_files": indicator_files
})
response = Response(
message,
status=200, # Status OK
mimetype='application/json')
return response
def run_build(res):
branch = res['ref'].rsplit('/', maxsplit=1)[1]
tag = None
if res['ref'].startswith('refs/heads/'):
branch = res['ref'][len('refs/heads/'):]
elif res['ref'].startswith('refs/tags/') and 'base_ref' in res:
branch = res['base_ref'][len('refs/heads/'):]
tag = res['ref'][len('refs/tags/'):]
else:
return
commit_id = res['head_commit']['id']
conf = Configuration.from_file('config.yml', branch, commit_id)
if conf is None:
return
build = Build.from_configuration(conf)
runner = Runner.from_build(build)
runner.run()
def run() -> int:
"""
Start program
:return: int - exit code
"""
# check settings
Configuration.apply_settings()
set_logger_enabled(Configuration.is_logger_enabled())
# check for files and create it if they missed
check_program_data_files(Files.FOLDER, Files.FILES)
# set logging configuration
if os.path.exists(Files.LOG_CONFIG):
set_logger_config_file(Files.LOG_CONFIG)
else:
set_logger_config_file(Files.DEFAULT_LOG_CONFIG_FILE)
# create loggers and
cli_logger = get_logger()
cli_logger.info('Start program.')
# load data from storage and create entities controllers
users_wrapper_storage = UserWrapperStorage(Files.AUTH_FILE, Files.ONLINE)
queue_storage = JsonQueueStorage(Files.QUEUES_FILE)
queue_controller = QueueController(queue_storage)
task_storage = JsonTaskStorage(Files.TASKS_FILE)
task_controller = TaskController(task_storage)
user_storage = JsonUserStorage(Files.USERS_FILE)
user_controller = UserController(user_storage)
plan_storage = JsonPlanStorage(Files.PLANS_FILE)
plan_controller = PlanController(plan_storage)
# init library interface
library = Interface(users_wrapper_storage.online_user, queue_controller,
user_controller, task_controller, plan_controller)
# update reminders deadlines queue and other
library.update_all()
_show_new_messages(library)
parser = get_parsers()
args = vars(parser.parse_args())
cli_logger.debug('Console args: {}'.format(args))
# check that target is defined
target = args.pop(ParserArgs.TARGET.name)
if target is None:
parser.error('target is required', need_to_exit=False)
return ERROR_CODE
if target == ParserArgs.UPDATE.name:
return 0
# check that action is defined
action = args.pop(ParserArgs.ACTION)
if action is None:
FormattedParser.active_sub_parser.error('action is required',
need_to_exit=False)
return ERROR_CODE
# check that target is config and do action with it
if target == ParserArgs.CONFIG.name:
if action == ParserArgs.SET:
return _set_configuration(args)
if action == ParserArgs.RESET:
conf_type_obj = args.pop(ParserArgs.CONFIG_TYPE.name)
return _reset_configuration(conf_type_obj)
# check that target is user and do action with it
if target == ParserArgs.USER.name:
if action == ParserArgs.ADD:
return _add_user(nick=args.pop(ParserArgs.NICKNAME.name),
password=args.pop(ParserArgs.PASSWORD.name),
users_storage=users_wrapper_storage,
library=library)
if action == ParserArgs.LOGIN.name:
return _login(nick=args.pop(ParserArgs.NICKNAME.name),
password=args.pop(ParserArgs.PASSWORD.name),
users_storage=users_wrapper_storage,
library=library)
if action == ParserArgs.LOGOUT.name:
return _logout(users_wrapper_storage)
if action == ParserArgs.SHOW:
long = args.pop(ParserArgs.LONG.dest)
sortby = args.pop(ParserArgs.SORT_BY.dest)
return _show_user_tasks(library, long, sortby)
# check that target is queue and do action with it
if target == ParserArgs.QUEUE.name:
if action == ParserArgs.ADD:
return _add_queue(name=args.pop(
ParserArgs.QUEUE_NAME.name).strip(' '),
library=library)
if action == ParserArgs.DELETE:
return _del_queue(key=args.pop(
ParserArgs.QUEUE_NAME.name).strip(' '),
recursive=args.pop(ParserArgs.RECURSIVE.dest),
library=library)
if action == ParserArgs.SET:
key = args.pop(ParserArgs.KEY.name)
new_name = args.pop(ParserArgs.NEW_NAME.dest)
if new_name is None:
parser.active_sub_parser.help()
return 0
return _edit_queue(key=key, new_name=new_name, library=library)
if action == ParserArgs.SHOW:
return _show_queue_tasks(
key=args.pop(ParserArgs.KEY.name),
opened=args.pop(ParserArgs.OPEN_TASKS.dest),
archive=args.pop(ParserArgs.SOLVED_TASKS.dest),
failed=args.pop(ParserArgs.FAILED_TASKS.dest),
long=args.pop(ParserArgs.LONG.dest),
library=library,
sortby=args.pop(ParserArgs.SORT_BY.dest))
if action == ParserArgs.FIND:
name = args.pop(ParserArgs.QUEUE_NAME.name)
return _find_queues(name, library)
# check that target is task and do action with it
if target == ParserArgs.TASK.name:
if action == ParserArgs.ADD:
return _add_task(args, library)
if action == ParserArgs.SET:
return _edit_task(args, library)
if action == ParserArgs.DELETE:
return _del_task(args, library)
if action == ParserArgs.SHOW:
return _show_task(args.pop(ParserArgs.KEY.name), library,
args.pop(ParserArgs.LONG.dest))
if action == ParserArgs.FIND:
return _find_task(args, library)
if action == ParserArgs.ACTIVATE:
key = args.pop(ParserArgs.KEY.name)
return _activate_task(key, library)
# check that target is plan and do action with it
if target == ParserArgs.PLAN.name:
if action == ParserArgs.ADD:
name = args.pop(ParserArgs.PLAN_NAME.name)
period = args.pop(ParserArgs.PLAN_PERIOD.name)
activation_time = args.pop(ParserArgs.PLAN_ACTIVATION_TIME.name)
reminder = args.pop(ParserArgs.TASK_REMINDER.dest)
return _add_plan(name, activation_time, period, reminder, library)
if action == ParserArgs.SET:
key = args.pop(ParserArgs.KEY.name)
new_name = args.pop(ParserArgs.PLAN_NAME_OPTIONAL.dest)
period = args.pop(ParserArgs.PLAN_PERIOD_OPTIONAL.dest)
activation_time = args.pop(
ParserArgs.PLAN_ACTIVATION_TIME_OPTIONAL.dest)
reminder = args.pop(ParserArgs.TASK_REMINDER.dest)
return _edit_plan(key, new_name, period, activation_time, reminder,
library)
if action == ParserArgs.SHOW:
return _show_plans(library)
if action == ParserArgs.DELETE:
key = args.pop(ParserArgs.KEY.name)
return _delete_plan(key, library)
if target == ParserArgs.NOTIFICATIONS.name:
if action == ParserArgs.SHOW:
notifications = library.online_user.notifications
print('Notifications for user "{}":'.format(
library.online_user.nick))
if _show_messages(notifications):
print('Notifications not found!')
library.clear_new_messages()
if action == ParserArgs.DELETE:
_del_notifications(library,
_all=args.pop(ParserArgs.ALL.dest),
old=args.pop(ParserArgs.OLD.dest))
from flask import Flask from app.configuration import Configuration from flask_bootstrap import Bootstrap from flask_login import LoginManager configuration = Configuration().load() app = Flask(__name__) app.config.update(configuration) bootstrap = Bootstrap(app) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'login' from app import views, login_manager
class ParticipantService(LoggerMixin):
def __init__(self, configuration: Configuration, command_bus: CommandBus,
participant_repository: ParticipantRepository,
message_repository: MessageRepository) -> None:
self.__configuration = configuration
self.__online_participants: Dict[Participant] = {}
self.__contact_pairing: Dict[str] = {}
self.__route_pairing: Dict[str] = {}
self.__command_bus: CommandBus = command_bus
self.__participant_repository: ParticipantRepository = participant_repository
self.__message_repository: MessageRepository = message_repository
def fetch(self, identifier) -> Participant:
if identifier != self.__online_participants:
self.__fetch_details(identifier=identifier)
return self.__online_participants[identifier]
@EventListener(subject="v1/node/{}/participants/pass-over".format(
Configuration.get_instance().node()),
event_type=ParticipantPassOver)
def on_external_participant_event(self,
event: ParticipantPassOver) -> None:
self._info("SENDER : {0}".format(event.sender_identifier))
self._info("TARGET : {0}".format(event.target_identifier))
self._info("ORIGINATING NODE : {0}".format(event.originating_node))
self._info("MARKER : {0}".format(event.marker))
if event.target_identifier in self.__route_pairing:
target_identifier = self.__route_pairing[event.target_identifier]
self.__command_bus.handle(
MessageDispatchCommand(
participant_identifier=target_identifier,
payload=event.payload,
response_type=ResponseType.RECEIVE_DIRECT_MESSAGE))
self.__save_direct_message(
sender_identifier=event.sender_identifier,
target_identifier=target_identifier,
message=event.payload,
marker=event.marker)
def resolve_contacts(self, content: bytearray) -> bytearray:
contact_batch_request = BatchContactMatchRequest()
contact_batch_request.ParseFromString(content)
resolved_contact_batch = self.__resolve_contacts(
contact_batch_request=contact_batch_request)
return resolved_contact_batch.SerializeToString()
def __resolve_contacts(
self, contact_batch_request: BatchContactMatchRequest
) -> BatchContactMatchResponse:
response = BatchContactMatchResponse()
for contact_request in contact_batch_request.requests:
if contact_request.type is ContactRequest.ContactType.EMAIL and \
contact_request.value in self.__contact_pairing:
participant: Participant = self.__online_participants[
self.__contact_pairing[contact_request.value]]
response.contacts.append(
Contact(profile_picture_url=participant.photo_url,
nickname=participant.nickname,
identifier=participant.routing_identity))
return response
def __fetch_details(self, identifier: str) -> None:
url: str = "{0}/{1}/{2}".format(
self.__configuration.account_service_url(),
"/api/v1/account-service/users/details",
)
response: requests.Response = requests.get(url=url)
if response.status_code is not 200:
self._error("FAILED TO FETCH USER: {}".format(response.text))
else:
content_map: Dict = response.json()
if not self.is_identity_known(
participant_identifier=content_map['identifier']):
self.create_routing_identity(
participant_identifier=content_map['identifier'])
routing_identifier = self.fetch_routing_identity(
participant_identifier=content_map['identifier'])
self.__online_participants[identifier] = Participant(
routing_identity=routing_identifier,
content_map=response.json())
self.__route_pairing[routing_identifier] = content_map['identity']
self.__contact_pairing[response.json()["email"]] = identifier
self._info("ADDED PARTICIPANT ENTRY FOR: {}".format(identifier))
get_client().register_participant(
routing_identifier=routing_identifier)
def is_identity_known(self, participant_identifier: str) -> bool:
return self.__participant_repository.has_identity(
participant_identifier=participant_identifier)
def fetch_routing_identity(self, participant_identifier: str) -> str:
identity: Identity = self.__participant_repository.fetch_identity(
participant_identifier=participant_identifier)
return identity.routing_identity
def create_routing_identity(self, participant_identifier: str) -> None:
routing_identifier = str(uuid.uuid4())
self.__participant_repository.create_identity(
participant_identifier=participant_identifier,
routing_identifier=routing_identifier)
def relay_direct_message(self, sender_identifier: str,
payload: bytearray) -> None:
direct_message = DirectMessage()
direct_message.ParseFromString(payload)
marker = str(uuid.uuid4())
if direct_message.target_identifier in self.__route_pairing:
target_identifier = self.__route_pairing[
direct_message.target_identifier]
self.__command_bus.handle(
MessageDispatchCommand(
participant_identifier=target_identifier,
payload=payload,
response_type=ResponseType.RECEIVE_DIRECT_MESSAGE))
self.__save_direct_message(sender_identifier=sender_identifier,
target_identifier=target_identifier,
message=payload,
marker=marker)
self.__report_delivery_success(
sender_identifier=sender_identifier,
target_identifier=direct_message.target_identifier,
marker=marker)
else:
node: str = self.__resolve_last_known_node(
target_identifier=direct_message.target_identifier)
if node is None:
self.__report_delivery_failure(
sender_identifier=sender_identifier,
target_identifier=direct_message.target_identifier,
delivery_failed_at=direct_message.sent_at)
else:
self.__send_direct_message_to_node(
node=node,
sender_identifier=sender_identifier,
target_identifier=direct_message.target_identifier,
marker=marker,
payload=payload)
def save_device_information(self, participant_identifier: str,
device_information: DeviceDetails) -> None:
self.__participant_repository.add_device(
participant_identifier=participant_identifier,
device=device_information)
def __save_direct_message(self, sender_identifier: str,
target_identifier: str, message: bytearray,
marker: str) -> None:
current_time = datetime.utcnow()
self.__message_repository.save(sender=sender_identifier,
target=target_identifier,
payload=message,
marker=marker,
received_at=current_time)
def __report_delivery_success(self, sender_identifier: str,
target_identifier: str, marker: str) -> None:
utc_now = datetime.utcnow()
current_time = Timestamp()
current_time.FromDatetime(utc_now)
self.__send_delivery_status(sender_identifier=sender_identifier,
target_identifier=target_identifier,
message="Successfully delivered message",
marker=marker,
status=Delivery.State.FAILED,
sent_at=current_time)
def __report_message_read(self, sender_identifier: str,
target_identifier: str, marker: str) -> None:
utc_now = datetime.utcnow()
current_time = Timestamp()
current_time.FromDatetime(utc_now)
self.__send_delivery_status(sender_identifier=sender_identifier,
target_identifier=target_identifier,
message="Successfully delivered message",
marker=marker,
status=Delivery.State.READ,
sent_at=current_time)
def __report_delivery_failure(self, sender_identifier: str,
target_identifier: str,
sender_timestamp: Timestamp) -> None:
self.__send_delivery_status(sender_identifier=sender_identifier,
target_identifier=target_identifier,
message="Failed to deliver the message :(",
marker="",
status=Delivery.State.FAILED,
sent_at=sender_timestamp)
def __send_delivery_status(self, sender_identifier: str,
target_identifier: str, message: str,
marker: str, status: Delivery.State,
sender_timestamp: Timestamp) -> None:
delivery_note: Delivery = Delivery(message=message,
state=status,
marker=marker,
target_identifier=target_identifier,
sent_at=sender_timestamp)
self.__command_bus.handle(
MessageDispatchCommand(
participant_identifier=self.__route_pairing[sender_identifier],
payload=delivery_note.SerializeToString(),
response_type=ResponseType.DELIVERY_STATE,
sent_at=sender_timestamp))
@staticmethod
def __resolve_last_known_node(target_identifier: str) -> Optional[str]:
client: ParticipantClient = get_client()
return client.fetch_last_known_node(
target_identifier=target_identifier)
@staticmethod
def __send_direct_message_to_node(node: str, sender_identifier: str,
target_identifier: str,
payload: bytearray) -> None:
client: ParticipantClient = get_client()
passover: ParticipantPassOver = ParticipantPassOver(
originating_node=node,
sender_identifier=sender_identifier,
target_identifier=target_identifier,
payload=payload)
client.passover_direct_message_to(passover=passover)
def run() -> falcon.App:
application = ServerApplication(configuration=Configuration.get_instance())
return application.run()
"""Main Entrypoint"""
from flask_restful import Api
from flask import Flask
from flask_cors import CORS
from app.configuration import Configuration
from app.views.predict import Predict
from app.views.task_status import TaskStatus
from app.views.recurrent_neural_network import RecurrentNeuralNetwork
if __name__ == '__main__':
configuration = Configuration()
application = Flask(__name__, static_url_path='/static')
# allow CORS for all domains on all routes
cors = CORS(application, resources={r"/api/v1/*": {"origins": "*"}})
api = Api(application)
# route initialization
rnn_routes = [
'/',
'/api/v1/rnn/',
]
api.add_resource(RecurrentNeuralNetwork,
*rnn_routes,
resource_class_kwargs={'configuration': configuration})
api.add_resource(TaskStatus,
'/api/v1/taskstatus/',
resource_class_kwargs={'configuration': configuration})
api.add_resource(Predict,
'/api/v1/predict/',
resource_class_kwargs={'configuration': configuration})
configuration.mi_logger.info('Machine Learning Service Starting')
# application initialization
def __init__(self):
self.__configuration = NATSConfiguration(
content_map=Configuration.get_instance().nats_configuration())
self.__client: Client = Client()
'Key.f19': Key.f19,
'Key.f20': Key.f20,
'Key.f2': Key.f2,
'Key.f3': Key.f3,
'Key.f4': Key.f4,
'Key.f5': Key.f5,
'Key.f6': Key.f6,
'Key.f7': Key.f7,
'Key.f8': Key.f8,
'Key.f9': Key.f9,
'Key.home': Key.home,
'Key.insert': Key.insert,
'Key.left': Key.left,
'Key.menu': Key.menu,
'Key.num_lock': Key.num_lock,
'Key.page_down': Key.page_down,
'Key.page_up': Key.page_up,
'Key.pause': Key.pause,
'Key.print_screen': Key.print_screen,
'Key.right': Key.right,
'Key.scroll_lock': Key.scroll_lock,
'Key.shift': Key.shift,
'Key.shift_l': Key.shift_l,
'Key.shift_r': Key.shift_r
}.get(key, key)
if __name__ == "__main__":
Configuration.set_selected_game('pong')
start_ai()
def get_client() -> ParticipantClient:
configuration: Configuration = Configuration.get_instance()
if configuration.is_in_test_mode():
return FakeParticipantClient.instance()
return NATSParticipantClient.instance()
def configuration():
return Configuration.get_instance(testing=True)
# This is a sample Python script.
# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
# Press the green button in the gutter to run the script.
from app.application import Application
from app.configuration import Configuration
if __name__ == '__main__':
application: Application = Application(configuration=Configuration.get_instance())
application.run()
def initialise_model_lstm(indicator_file_name, timesteps, test_set_input,
test_set_output, train_set_input, train_set_output,
epochs):
"""[summary]
Args:
indicator_file_name ([type]): [description]
timesteps ([type]): [description]
test_set_input ([type]): [description]
test_set_output ([type]): [description]
train_set_input ([type]): [description]
train_set_output ([type]): [description]
epochs ([type]): [description]
Returns:
[type]: [description]
"""
keras_model_directory = Configuration.get_directory(indicator_file_name)
modelh5_path = Configuration.get_file_model_file(indicator_file_name)
# define the RNN input shape
lstm_input_shape = (timesteps, 1)
# initialize the Recurrent Neural Network
# Solving pattern with sequence of data
regressor = keras.models.Sequential()
training.update_state(state="PROGRESS", meta={'progress': 70})
neurons = 50
batch_size = 32
# Long Short Term Memory model -
# supervised Deep Neural Network that is very good at doing time-series prediction.
# adding the first LSTM Layer and some Dropout regularisation
#
# Dropout: Makes sure that network can never rely on any given activation
# to be present because at any moment they could become squashed i.e. value = 0
# forced to learn a redunant representation for everything
#
# return sequences: We want output after every layer in which will be
# passed to the next layer
regressor.add(
keras.layers.LSTM(units=neurons,
return_sequences=True,
input_shape=lstm_input_shape))
regressor.add(keras.layers.Dropout(0.2))
# adding a second LSTM Layer and some Dropout regularisation
regressor.add(keras.layers.LSTM(units=neurons, return_sequences=True))
regressor.add(keras.layers.Dropout(0.2))
# adding a third LSTM Layer and some Dropout regularisation
regressor.add(keras.layers.LSTM(units=neurons, return_sequences=True))
regressor.add(keras.layers.Dropout(0.2))
# adding a fourth LSTM Layer and some Dropout regularisation
regressor.add(keras.layers.LSTM(units=neurons))
regressor.add(keras.layers.Dropout(0.2))
# adding the output layer
# Dense format output layer
regressor.add(keras.layers.Dense(units=1)) # prediction
# compile network
# find the global minimal point
regressor.compile(optimizer='adam', loss='mean_absolute_error')
regressor.summary()
accuracy = regressor.evaluate(test_set_input, test_set_output)
print('Restored model, accuracy: {:5.2f}%'.format(100 * accuracy))
# fitting the RNN to the training set
# giving input in batch sizes of 5
# loss should decrease on each an every epochs
history = regressor.fit(train_set_input,
train_set_output,
batch_size=batch_size,
epochs=epochs,
steps_per_epoch=5,
validation_data=(test_set_input, test_set_output),
verbose=0,
callbacks=[KerasFitCallback(training, epochs)])
# save the model for javascript format readable
tfjs.converters.save_keras_model(regressor, keras_model_directory)
# save the model for python format readable
regressor.save(modelh5_path)
predicted_price = regressor.predict(test_set_input)
result = {
'summary': str(regressor.summary()),
'history': str(history),
'predicted_price': predicted_price
}
return result
