def imagenet1000_classidx_to_label(self, class_idx: int) -> str: try: map = self.imagenet1000_classidx_label_dict() return map[str(class_idx)] except Exception as e: logger.exception(e) return "Class Not Found"
def classify_image(event, context): try: picture, filename = utils.get_image_from_event(event) img_net = ImageNetHelper("mobilenet_v2") img_net.load_model(S3_BUCKET) picture_tensor = img_net.transform_image(picture.content) prediction_idx = img_net.get_prediction(picture_tensor) prediction_label = img_net.imagenet1000_classidx_to_label( prediction_idx) return { "statusCode": 200, "headers": headers, "body": json.dumps({ "file": filename, "predicted": (prediction_idx, prediction_label), }), } except Exception as e: logger.exception(e) return { "statusCode": 500, "headers": headers, "body": json.dumps({"error": repr(e)}), }
def RecvFromSever(self) -> Tuple[Dict, int]: sockdata: str = "" try: sockdata = self.socket.recvfrom(UDP_MSGLEN)[0].decode("utf-8") if self.verbose: print("\nrecv", sockdata) except Exception as e: logger.exception(f"{e}") return dict(), SERVERCODE_TIMEOUT if "***restart***" in sockdata: logger.info(f"server restarted on port: {self.port}") return dict(), SERVERCODE_RESTART elif "***shutdown***" in sockdata: logger.info(f"server shutdown on port: {self.port}.") return dict(), SERVERCODE_SHUTDOWN elif not sockdata: logger.warning(f"server no response on port: {self.port}") return dict(), SERVERCODE_NORESPONSE elif "***identified***" in sockdata: logger.info(f"client identified connected on port: {self.port}") # * always delay few secs after starting round maybe ?? time.sleep(self.delay) return dict(), SERVERCODE_IDENTIFIED else: if self.verbose: logger.info(f"recv: {sockdata}") return ServerState.Deserialize(sockdata), SERVERCODE_OBSERVATION return True
def wrapper(*args, **kwargs): response = None try: response = function(*args, **kwargs) except exception: logger.exception(message) return response
def imagenet1000_classidx_label_dict(self) -> dict: try: with open("data/imagenet1000_clsidx_to_labels.json", "r") as f: map = json.loads(f.read()) return map except Exception as e: logger.exception(e) return None
def save_pretrained_model(self): try: model = self._model_func(pretrained=True) model.eval() # trace model with dummy input traced_model = torch.jit.trace(model, torch.randn(1, 3, 224, 224)) traced_model.save(f"./models/{self._model_name}.pt") except Exception as e: logger.exception(e)
def get_picture_filename(picture): try: filename = picture.headers[b"Content-Disposition"].decode().split( ":")[1].split("-")[1] if 4 > len(filename): filename = picture.headers[b"Content-Disposition"].decode().split( ":")[2].split("-")[1] except Exception as e: filename = "not-found" logger.exception(e) return filename
def transform_image(self, image_bytes): try: transformations = transforms.Compose([ transforms.Resize(255), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) image = Image.open(io.BytesIO(image_bytes)) return transformations(image).unsqueeze(0) except Exception as e: logger.exception(e) raise (e)
def decrypt(self): if encrypted: cipher = AES.new( getpass.getpass( 'Input decryption password (string will not show)')) try: self.api_key = ast.literal_eval(self.api_key) if type( self.api_key) == str else self.api_key self.api_secret = ast.literal_eval(self.api_secret) if type( self.api_secret) == str else self.api_secret except Exception: logger.exception(Exception) pass self.api_key = cipher.decrypt(self.api_key).decode() self.api_secret = cipher.decrypt(self.api_secret).decode() else: raise ImportError('"pycrypto" module has to be installed')
def load_model(self, s3_bucket: str): try: # s3 = boto3.session.Session(profile_name='eva4p2').client("s3") # noqa s3 = boto3.client("s3") model_path = os.path.join("artifacts/models", f"{self._model_name}.pt") obj = s3.get_object(Bucket=s3_bucket, Key=model_path) logger.info("Creating Byte Stream") bytestream = io.BytesIO(obj["Body"].read()) logger.info("Loading model") model = torch.jit.load(bytestream) logger.info("Model Loaded...") logger.info(model) logger.info(model.code) self._model = model except Exception as e: logger.exception(e) raise (e)
def job(query_hash): logger.debug('Starting to process %s' % query_hash) try: start_time = timeit.default_timer() events_pushed = push_data_from_query_hash(query_hash) logger.info( 'Done with the process of %s : %s events, after %1.2fs', query_hash, len(events_pushed), timeit.default_timer() - start_time, ) except: # noqa: E722 logger.exception( f'Threats for query hash {query_hash} failed to be retrieved and injected into misp' ) raise finally: jobs_running.remove(query_hash)
def get_historical_data(self, market, period, unit): """ Queries the historical data in the form of a list :param market: String literal for the market (ex: BTC-LTC) :type market: str :param period: Number of periods to query :type period: int :param unit: Ticker interval (one of: 'oneMin', 'fiveMin', 'thirtyMin', 'hour', 'week', 'day', and 'month') :type unit: str :return: List adapted from Bittrex JSON response :rtype : list """ request_url = 'https://bittrex.com/Api/v2.0/pub/market/GetTicks?marketName={}&tickInterval={}'.format( market, unit) try: historical_data = requests.get(request_url, headers={ "apisign": hmac.new( self.api_secret.encode(), request_url.encode(), hashlib.sha512).hexdigest() }).json() except json.decoder.JSONDecodeError as exception: logger.exception(exception) return [] if not historical_data['success']: if historical_data['message'] == 'INVALID_MARKET': logger.warning( 'The {} market is currently not available on Bittrex'. format(market)) return [] return historical_data['result'][-period:]
def get_message(text): global mood_value try: if len(text) > 0: text_sentiment = sentiment_from_text(text) if text_sentiment == None: return None total_sentiment = (sentiment_from_mood['sentiment'] * text_sentiment + sentiment_from_mood['mood'] * mood_value) / sentiment_from_mood['sum'] logger.debug(['total sentiment', total_sentiment]) result_sentiment = chose_message(total_sentiment) set_mood((mood_from_sentiment['sentiment'] * text_sentiment + mood_from_sentiment['mood'] * mood_value) / mood_from_sentiment['sum']) else: result_sentiment = chose_message(mood_value) except Exception as e: logger.exception(e) return None if len(messages) > 0: return random.choice(messages[result_sentiment]) else: return None
current_price = get_current_price(coin_pair) profit_margin = Database_List[strategy_index].get_simulated_profit_margin(coin_pair, current_price) if profit_margin >= 2.5: print(print_str.format(strategy_index, coin_pair, round(rsi), round(profit_margin), Messenger.generate_bittrex_URL(coin_pair))) Database_List[strategy_index].simulate_sell(coin_pair, current_price, rsi, day_volume) if __name__ == '__main__': def analyse_buys(): for strategy_index in range(number_of_strategies): if len(Database_List[strategy_index].simulated_trades['trackedCoinPairs']) < 1: for coin_pair in btc_coin_pairs: buy_strategy(coin_pair, strategy_index) def analyse_sells(): for strategy_index in range(number_of_strategies): for coin_pair in Database_List[strategy_index].simulated_trades['trackedCoinPairs']: sell_strategy(coin_pair, strategy_index) btc_coin_pairs = get_markets('BTC') print('Tracking {} Bittrex markets'.format(len(btc_coin_pairs))) while True: try: analyse_buys() analyse_sells() except Exception: logger.exception(Exception)
args['save_path_optimizer_encoder'], map_location="cpu") encoder_optimizer.load_state_dict(encoder_optimizer_state) encoder_optimizer = create_correct_state_dict(encoder_optimizer) decoder_optimizer = optim.Adam(decoder.parameters(), lr=learning_rate * decoder_learning_ratio) decoder_optimizer_state = torch.load( args['save_path_optimizer_decoder'], map_location="cpu") decoder_optimizer.load_state_dict(decoder_optimizer_state) decoder_optimizer = create_correct_state_dict(decoder_optimizer) from_scratch = False logger.info('Continue training') except Exception as e: logger.exception(e) logger.info('From scratch') pass if USE_CUDA: encoder = encoder.cuda() decoder = decoder.cuda() print_loss_total = 0 save_every = 500 batch_n = 0 epoch = 0 print_every = 125 print_every_val = 125 start = time.time()